Lines Matching refs:device
52 struct drbd_device *device;
54 device = bio->bi_private;
55 device->md_io.error = blk_status_to_errno(bio->bi_status);
58 if (device->ldev)
59 put_ldev(device);
63 * to timeout on the lower level device, and eventually detach from it.
71 * ASSERT(atomic_read(&device->md_io_in_use) == 1) there.
73 drbd_md_put_buffer(device);
74 device->md_io.done = 1;
75 wake_up(&device->misc_wait);
85 struct drbd_device *device = peer_device->device;
87 spin_lock_irqsave(&device->resource->req_lock, flags);
88 device->read_cnt += peer_req->i.size >> 9;
90 if (list_empty(&device->read_ee))
91 wake_up(&device->ee_wait);
93 __drbd_chk_io_error(device, DRBD_READ_ERROR);
94 spin_unlock_irqrestore(&device->resource->req_lock, flags);
97 put_ldev(device);
106 struct drbd_device *device = peer_device->device;
126 inc_unacked(device);
130 spin_lock_irqsave(&device->resource->req_lock, flags);
131 device->writ_cnt += peer_req->i.size >> 9;
132 list_move_tail(&peer_req->w.list, &device->done_ee);
142 do_wake = list_empty(block_id == ID_SYNCER ? &device->sync_ee : &device->active_ee);
147 __drbd_chk_io_error(device, DRBD_WRITE_ERROR);
150 kref_get(&device->kref); /* put is in drbd_send_acks_wf() */
152 kref_put(&device->kref, drbd_destroy_device);
154 spin_unlock_irqrestore(&device->resource->req_lock, flags);
157 drbd_rs_complete_io(device, i.sector);
160 wake_up(&device->ee_wait);
163 drbd_al_complete_io(device, &i);
165 put_ldev(device);
174 struct drbd_device *device = peer_req->peer_device->device;
180 drbd_warn(device, "%s: error=%d s=%llus\n",
198 drbd_panic_after_delayed_completion_of_aborted_request(struct drbd_device *device)
201 device->minor, device->resource->name, device->vnr);
210 struct drbd_device *device = req->device;
230 * If later the local backing device "recovers", and now DMAs some data
244 drbd_emerg(device, "delayed completion of aborted local request; disk-timeout may be too aggressive\n");
247 drbd_panic_after_delayed_completion_of_aborted_request(device);
278 spin_lock_irqsave(&device->resource->req_lock, flags);
280 spin_unlock_irqrestore(&device->resource->req_lock, flags);
281 put_ldev(device);
284 complete_master_bio(device, &m);
342 struct drbd_device *device = peer_device->device;
364 drbd_free_peer_req(device, peer_req);
372 drbd_err(device, "kmalloc() of digest failed.\n");
378 drbd_free_peer_req(device, peer_req);
381 drbd_err(device, "drbd_send_drequest(..., csum) failed\n");
389 struct drbd_device *device = peer_device->device;
392 if (!get_ldev(device))
404 spin_lock_irq(&device->resource->req_lock);
405 list_add_tail(&peer_req->w.list, &device->read_ee);
406 spin_unlock_irq(&device->resource->req_lock);
408 atomic_add(size >> 9, &device->rs_sect_ev);
416 spin_lock_irq(&device->resource->req_lock);
418 spin_unlock_irq(&device->resource->req_lock);
420 drbd_free_peer_req(device, peer_req);
422 put_ldev(device);
428 struct drbd_device *device =
431 switch (device->state.conn) {
433 make_ov_request(first_peer_device(device), cancel);
436 make_resync_request(first_peer_device(device), cancel);
445 struct drbd_device *device = from_timer(device, t, resync_timer);
448 &first_peer_device(device)->connection->sender_work,
449 &device->resync_work);
498 struct drbd_device *device = peer_device->device;
509 dc = rcu_dereference(device->ldev->disk_conf);
510 plan = rcu_dereference(device->rs_plan_s);
514 if (device->rs_in_flight + sect_in == 0) { /* At start of resync */
521 correction = want - device->rs_in_flight - plan->total;
541 drbd_warn(device, "si=%u if=%d wa=%u co=%d st=%d cps=%d pl=%d cc=%d rs=%d\n",
542 sect_in, device->rs_in_flight, want, correction,
543 steps, cps, device->rs_planed, curr_corr, req_sect);
551 struct drbd_device *device = peer_device->device;
555 sect_in = atomic_xchg(&device->rs_sect_in, 0);
556 device->rs_in_flight -= sect_in;
559 mxb = drbd_get_max_buffers(device) / 2;
560 if (rcu_dereference(device->rs_plan_s)->size) {
562 device->c_sync_rate = number * HZ * (BM_BLOCK_SIZE / 1024) / SLEEP_TIME;
564 device->c_sync_rate = rcu_dereference(device->ldev->disk_conf)->resync_rate;
565 number = SLEEP_TIME * device->c_sync_rate / ((BM_BLOCK_SIZE / 1024) * HZ);
579 if (mxb - device->rs_in_flight/8 < number)
580 number = mxb - device->rs_in_flight/8;
587 struct drbd_device *const device = peer_device->device;
591 const sector_t capacity = get_capacity(device->vdisk);
601 if (device->rs_total == 0) {
607 if (!get_ldev(device)) {
608 /* Since we only need to access device->rsync a
609 get_ldev_if_state(device,D_FAILED) would be sufficient, but
612 drbd_err(device, "Disk broke down during resync!\n");
618 discard_granularity = rcu_dereference(device->ldev->disk_conf)->rs_discard_granularity;
622 max_bio_size = queue_max_hw_sectors(device->rq_queue) << 9;
648 bit = drbd_bm_find_next(device, device->bm_resync_fo);
651 device->bm_resync_fo = drbd_bm_bits(device);
652 put_ldev(device);
659 device->bm_resync_fo = bit;
662 device->bm_resync_fo = bit + 1;
664 if (unlikely(drbd_bm_test_bit(device, bit) == 0)) {
665 drbd_rs_complete_io(device, sector);
697 if (drbd_bm_test_bit(device, bit+1) != 1)
708 device->bm_resync_fo = bit + 1;
715 if (device->use_csums) {
718 put_ldev(device);
721 drbd_rs_complete_io(device, sector);
722 device->bm_resync_fo = BM_SECT_TO_BIT(sector);
739 drbd_err(device, "drbd_send_drequest() failed, aborting...\n");
741 put_ldev(device);
747 if (device->bm_resync_fo >= drbd_bm_bits(device)) {
754 put_ldev(device);
759 device->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9));
760 mod_timer(&device->resync_timer, jiffies + SLEEP_TIME);
761 put_ldev(device);
767 struct drbd_device *device = peer_device->device;
770 const sector_t capacity = get_capacity(device->vdisk);
778 sector = device->ov_position;
787 && verify_can_do_stop_sector(device)
788 && sector >= device->ov_stop_sector;
795 device->ov_position = sector;
803 if (drbd_send_ov_request(first_peer_device(device), sector, size)) {
809 device->ov_position = sector;
812 device->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9));
814 mod_timer(&device->resync_timer, jiffies + SLEEP_TIME);
822 struct drbd_device *device = dw->device;
824 ov_out_of_sync_print(first_peer_device(device));
825 drbd_resync_finished(first_peer_device(device));
834 struct drbd_device *device = dw->device;
837 drbd_resync_finished(first_peer_device(device));
842 static void ping_peer(struct drbd_device *device)
844 struct drbd_connection *connection = first_peer_device(device)->connection;
849 test_bit(GOT_PING_ACK, &connection->flags) || device->state.conn < C_CONNECTED);
854 struct drbd_device *device = peer_device->device;
866 if (drbd_rs_del_all(device)) {
876 dw->device = device;
880 drbd_err(device, "Warn failed to drbd_rs_del_all() and to kmalloc(dw).\n");
883 dt = (jiffies - device->rs_start - device->rs_paused) / HZ;
887 db = device->rs_total;
889 if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T)
890 db -= device->ov_left;
893 device->rs_paused /= HZ;
895 if (!get_ldev(device))
898 ping_peer(device);
900 spin_lock_irq(&device->resource->req_lock);
901 os = drbd_read_state(device);
913 drbd_info(device, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n",
915 dt + device->rs_paused, device->rs_paused, dbdt);
917 n_oos = drbd_bm_total_weight(device);
921 drbd_alert(device, "Online verify found %lu %dk block out of sync!\n",
926 D_ASSERT(device, (n_oos - device->rs_failed) == 0);
931 if (device->use_csums && device->rs_total) {
932 const unsigned long s = device->rs_same_csum;
933 const unsigned long t = device->rs_total;
937 drbd_info(device, "%u %% had equal checksums, eliminated: %luK; "
940 Bit2KB(device->rs_same_csum),
941 Bit2KB(device->rs_total - device->rs_same_csum),
942 Bit2KB(device->rs_total));
946 if (device->rs_failed) {
947 drbd_info(device, " %lu failed blocks\n", device->rs_failed);
961 if (device->p_uuid) {
964 _drbd_uuid_set(device, i, device->p_uuid[i]);
965 drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_CURRENT]);
966 _drbd_uuid_set(device, UI_CURRENT, device->p_uuid[UI_CURRENT]);
968 drbd_err(device, "device->p_uuid is NULL! BUG\n");
975 drbd_uuid_set_bm(device, 0UL);
976 drbd_print_uuids(device, "updated UUIDs");
977 if (device->p_uuid) {
982 device->p_uuid[i] = device->ldev->md.uuid[i];
987 _drbd_set_state(device, ns, CS_VERBOSE, NULL);
989 spin_unlock_irq(&device->resource->req_lock);
999 fp = rcu_dereference(device->ldev->disk_conf)->fencing;
1004 struct drbd_device *device = peer_device->device;
1005 disk_state = min_t(enum drbd_disk_state, disk_state, device->state.disk);
1006 pdsk_state = min_t(enum drbd_disk_state, pdsk_state, device->state.pdsk);
1014 put_ldev(device);
1016 device->rs_total = 0;
1017 device->rs_failed = 0;
1018 device->rs_paused = 0;
1020 /* reset start sector, if we reached end of device */
1021 if (verify_done && device->ov_left == 0)
1022 device->ov_start_sector = 0;
1024 drbd_md_sync(device);
1027 drbd_khelper(device, khelper_cmd);
1033 static void move_to_net_ee_or_free(struct drbd_device *device, struct drbd_peer_request *peer_req)
1038 atomic_add(i, &device->pp_in_use_by_net);
1039 atomic_sub(i, &device->pp_in_use);
1040 spin_lock_irq(&device->resource->req_lock);
1041 list_add_tail(&peer_req->w.list, &device->net_ee);
1042 spin_unlock_irq(&device->resource->req_lock);
1045 drbd_free_peer_req(device, peer_req);
1057 struct drbd_device *device = peer_device->device;
1061 drbd_free_peer_req(device, peer_req);
1062 dec_unacked(device);
1070 drbd_err(device, "Sending NegDReply. sector=%llus.\n",
1076 dec_unacked(device);
1078 move_to_net_ee_or_free(device, peer_req);
1081 drbd_err(device, "drbd_send_block() failed\n");
1118 struct drbd_device *device = peer_device->device;
1122 drbd_free_peer_req(device, peer_req);
1123 dec_unacked(device);
1127 if (get_ldev_if_state(device, D_FAILED)) {
1128 drbd_rs_complete_io(device, peer_req->i.sector);
1129 put_ldev(device);
1132 if (device->state.conn == C_AHEAD) {
1135 if (likely(device->state.pdsk >= D_INCONSISTENT)) {
1143 drbd_err(device, "Not sending RSDataReply, "
1149 drbd_err(device, "Sending NegRSDReply. sector %llus.\n",
1158 dec_unacked(device);
1160 move_to_net_ee_or_free(device, peer_req);
1163 drbd_err(device, "drbd_send_block() failed\n");
1171 struct drbd_device *device = peer_device->device;
1178 drbd_free_peer_req(device, peer_req);
1179 dec_unacked(device);
1183 if (get_ldev(device)) {
1184 drbd_rs_complete_io(device, peer_req->i.sector);
1185 put_ldev(device);
1196 D_ASSERT(device, digest_size == di->digest_size);
1208 device->rs_same_csum += peer_req->i.size >> BM_BLOCK_SHIFT;
1220 drbd_err(device, "Sending NegDReply. I guess it gets messy.\n");
1223 dec_unacked(device);
1224 move_to_net_ee_or_free(device, peer_req);
1227 drbd_err(device, "drbd_send_block/ack() failed\n");
1235 struct drbd_device *device = peer_device->device;
1262 drbd_free_peer_req(device, peer_req);
1272 drbd_free_peer_req(device, peer_req);
1273 dec_unacked(device);
1279 struct drbd_device *device = peer_device->device;
1280 if (device->ov_last_oos_start + device->ov_last_oos_size == sector) {
1281 device->ov_last_oos_size += size>>9;
1283 device->ov_last_oos_start = sector;
1284 device->ov_last_oos_size = size>>9;
1293 struct drbd_device *device = peer_device->device;
1303 drbd_free_peer_req(device, peer_req);
1304 dec_unacked(device);
1310 if (get_ldev(device)) {
1311 drbd_rs_complete_io(device, peer_req->i.sector);
1312 put_ldev(device);
1323 D_ASSERT(device, digest_size == di->digest_size);
1334 drbd_free_peer_req(device, peer_req);
1343 dec_unacked(device);
1345 --device->ov_left;
1348 if ((device->ov_left & 0x200) == 0x200)
1349 drbd_advance_rs_marks(peer_device, device->ov_left);
1351 stop_sector_reached = verify_can_do_stop_sector(device) &&
1352 (sector + (size>>9)) >= device->ov_stop_sector;
1354 if (device->ov_left == 0 || stop_sector_reached) {
1394 struct drbd_device *device =
1399 return pd_send_unplug_remote(first_peer_device(device));
1427 struct drbd_device *device = req->device;
1428 struct drbd_peer_device *const peer_device = first_peer_device(device);
1458 struct drbd_device *device = req->device;
1459 struct drbd_peer_device *const peer_device = first_peer_device(device);
1491 struct drbd_device *device = req->device;
1492 struct drbd_peer_device *const peer_device = first_peer_device(device);
1521 struct drbd_device *device = req->device;
1524 drbd_al_begin_io(device, &req->i);
1526 req->private_bio = bio_alloc_clone(device->ldev->backing_bdev,
1536 static int _drbd_may_sync_now(struct drbd_device *device)
1538 struct drbd_device *odev = device;
1562 * @device: DRBD device.
1566 static bool drbd_pause_after(struct drbd_device *device)
1588 * @device: DRBD device.
1592 static bool drbd_resume_next(struct drbd_device *device)
1613 void resume_next_sg(struct drbd_device *device)
1616 drbd_resume_next(device);
1620 void suspend_other_sg(struct drbd_device *device)
1623 drbd_pause_after(device);
1628 enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor)
1641 if (odev == device)
1666 void drbd_resync_after_changed(struct drbd_device *device)
1671 changed = drbd_pause_after(device);
1672 changed |= drbd_resume_next(device);
1678 struct drbd_device *device = peer_device->device;
1679 struct gendisk *disk = device->ldev->backing_bdev->bd_disk;
1682 atomic_set(&device->rs_sect_in, 0);
1683 atomic_set(&device->rs_sect_ev, 0);
1684 device->rs_in_flight = 0;
1685 device->rs_last_events =
1693 plan = rcu_dereference(device->rs_plan_s);
1701 struct drbd_device *device = from_timer(device, t, start_resync_timer);
1702 drbd_device_post_work(device, RS_START);
1705 static void do_start_resync(struct drbd_device *device)
1707 if (atomic_read(&device->unacked_cnt) || atomic_read(&device->rs_pending_cnt)) {
1708 drbd_warn(device, "postponing start_resync ...\n");
1709 device->start_resync_timer.expires = jiffies + HZ/10;
1710 add_timer(&device->start_resync_timer);
1714 drbd_start_resync(device, C_SYNC_SOURCE);
1715 clear_bit(AHEAD_TO_SYNC_SOURCE, &device->flags);
1718 static bool use_checksum_based_resync(struct drbd_connection *connection, struct drbd_device *device)
1727 || test_bit(CRASHED_PRIMARY, &device->flags)); /* or only after Primary crash? */
1732 * @device: DRBD device.
1738 void drbd_start_resync(struct drbd_device *device, enum drbd_conns side)
1740 struct drbd_peer_device *peer_device = first_peer_device(device);
1745 if (device->state.conn >= C_SYNC_SOURCE && device->state.conn < C_AHEAD) {
1746 drbd_err(device, "Resync already running!\n");
1751 drbd_err(device, "No connection to peer, aborting!\n");
1755 if (!test_bit(B_RS_H_DONE, &device->flags)) {
1760 r = drbd_khelper(device, "before-resync-target");
1763 drbd_info(device, "before-resync-target handler returned %d, "
1769 r = drbd_khelper(device, "before-resync-source");
1773 drbd_info(device, "before-resync-source handler returned %d, "
1776 drbd_info(device, "before-resync-source handler returned %d, "
1789 if (!mutex_trylock(device->state_mutex)) {
1790 set_bit(B_RS_H_DONE, &device->flags);
1791 device->start_resync_timer.expires = jiffies + HZ/5;
1792 add_timer(&device->start_resync_timer);
1796 mutex_lock(device->state_mutex);
1800 clear_bit(B_RS_H_DONE, &device->flags);
1802 if (device->state.conn < C_CONNECTED
1803 || !get_ldev_if_state(device, D_NEGOTIATING)) {
1808 ns = drbd_read_state(device);
1810 ns.aftr_isp = !_drbd_may_sync_now(device);
1819 r = _drbd_set_state(device, ns, CS_VERBOSE, NULL);
1820 ns = drbd_read_state(device);
1826 unsigned long tw = drbd_bm_total_weight(device);
1830 device->rs_failed = 0;
1831 device->rs_paused = 0;
1832 device->rs_same_csum = 0;
1833 device->rs_last_sect_ev = 0;
1834 device->rs_total = tw;
1835 device->rs_start = now;
1837 device->rs_mark_left[i] = tw;
1838 device->rs_mark_time[i] = now;
1840 drbd_pause_after(device);
1842 * Open coded drbd_rs_cancel_all(device), we already have IRQs
1844 spin_lock(&device->al_lock);
1845 lc_reset(device->resync);
1846 device->resync_locked = 0;
1847 device->resync_wenr = LC_FREE;
1848 spin_unlock(&device->al_lock);
1853 wake_up(&device->al_wait); /* for lc_reset() above */
1856 device->rs_last_bcast = jiffies - HZ;
1858 drbd_info(device, "Began resync as %s (will sync %lu KB [%lu bits set]).\n",
1860 (unsigned long) device->rs_total << (BM_BLOCK_SHIFT-10),
1861 (unsigned long) device->rs_total);
1863 device->bm_resync_fo = 0;
1864 device->use_csums = use_checksum_based_resync(connection, device);
1866 device->use_csums = false;
1879 if (connection->agreed_pro_version < 95 && device->rs_total == 0) {
1904 /* ns.conn may already be != device->state.conn,
1909 mod_timer(&device->resync_timer, jiffies);
1911 drbd_md_sync(device);
1913 put_ldev(device);
1915 mutex_unlock(device->state_mutex);
1920 struct drbd_device *device = peer_device->device;
1922 device->rs_last_bcast = jiffies;
1924 if (!get_ldev(device))
1927 drbd_bm_write_lazy(device, 0);
1928 if (resync_done && is_sync_state(device->state.conn))
1931 drbd_bcast_event(device, &sib);
1933 device->rs_last_bcast = jiffies;
1934 put_ldev(device);
1937 static void drbd_ldev_destroy(struct drbd_device *device)
1939 lc_destroy(device->resync);
1940 device->resync = NULL;
1941 lc_destroy(device->act_log);
1942 device->act_log = NULL;
1945 drbd_backing_dev_free(device, device->ldev);
1946 device->ldev = NULL;
1949 clear_bit(GOING_DISKLESS, &device->flags);
1950 wake_up(&device->misc_wait);
1953 static void go_diskless(struct drbd_device *device)
1955 struct drbd_peer_device *peer_device = first_peer_device(device);
1956 D_ASSERT(device, device->state.disk == D_FAILED);
1975 if (device->bitmap && device->ldev) {
1980 if (drbd_bitmap_io_from_worker(device, drbd_bm_write,
1982 if (test_bit(WAS_READ_ERROR, &device->flags)) {
1983 drbd_md_set_flag(device, MDF_FULL_SYNC);
1984 drbd_md_sync(device);
1989 drbd_force_state(device, NS(disk, D_DISKLESS));
1992 static int do_md_sync(struct drbd_device *device)
1994 drbd_warn(device, "md_sync_timer expired! Worker calls drbd_md_sync().\n");
1995 drbd_md_sync(device);
2022 static void do_device_work(struct drbd_device *device, const unsigned long todo)
2025 do_md_sync(device);
2028 update_on_disk_bitmap(first_peer_device(device), test_bit(RS_DONE, &todo));
2030 go_diskless(device);
2032 drbd_ldev_destroy(device);
2034 do_start_resync(device);
2063 struct drbd_device *device = peer_device->device;
2064 unsigned long todo = get_work_bits(&device->flags);
2068 kref_get(&device->kref);
2070 do_device_work(device, todo);
2071 kref_put(&device->kref, drbd_destroy_device);
2230 struct drbd_device *device = peer_device->device;
2231 D_ASSERT(device, device->state.disk == D_DISKLESS && device->state.conn == C_STANDALONE);
2232 kref_get(&device->kref);
2234 drbd_device_cleanup(device);
2235 kref_put(&device->kref, drbd_destroy_device);