Lines Matching defs:device
24 struct drbd_device *device;
45 struct drbd_device *device;
52 idr_for_each_entry(&resource->devices, device, vnr)
77 state_change->devices[n].device = NULL;
86 struct drbd_device *device;
97 * No state, no device IDR, no connections lists can change. */
124 idr_for_each_entry(&resource->devices, device, vnr) {
125 kref_get(&device->kref);
126 device_state_change->device = device;
127 device_state_change->disk_state[OLD] = device->state.disk;
129 /* The peer_devices for each device have to be enumerated in
134 peer_device = conn_peer_device(connection, device->vnr);
137 device->state.pdsk;
140 C_WF_REPORT_PARAMS, device->state.conn);
142 device->state.user_isp;
144 device->state.peer_isp;
146 device->state.aftr_isp;
176 struct drbd_device *device = device_state_change->device;
178 device_state_change->disk_state[NEW] = device->state.disk;
195 struct drbd_device *device =
196 peer_device_state_change->peer_device->device;
197 union drbd_dev_state state = device->state;
264 struct drbd_device *device = state_change->devices[n].device;
266 if (device)
267 kref_put(&device->kref, drbd_destroy_device);
280 static void after_state_ch(struct drbd_device *device, union drbd_state os,
286 static union drbd_state sanitize_state(struct drbd_device *device, union drbd_state os,
302 struct drbd_device *device = peer_device->device;
303 if (device->state.disk != D_DISKLESS ||
304 device->state.conn != C_STANDALONE ||
305 device->state.role != R_SECONDARY) {
343 struct drbd_device *device = peer_device->device;
344 role = max_role(role, device->state.role);
359 struct drbd_device *device = peer_device->device;
360 peer = max_role(peer, device->state.peer);
375 struct drbd_device *device = peer_device->device;
376 disk_state = max_t(enum drbd_disk_state, disk_state, device->state.disk);
391 struct drbd_device *device = peer_device->device;
392 disk_state = min_t(enum drbd_disk_state, disk_state, device->state.disk);
407 struct drbd_device *device = peer_device->device;
408 disk_state = max_t(enum drbd_disk_state, disk_state, device->state.pdsk);
423 struct drbd_device *device = peer_device->device;
424 conn = min_t(enum drbd_conns, conn, device->state.conn);
439 if (peer_device->device->state.conn == C_WF_REPORT_PARAMS) {
455 wake_up(&peer_device->device->state_wait);
463 * @device: DRBD device.
467 static int cl_wide_st_chg(struct drbd_device *device,
489 drbd_change_state(struct drbd_device *device, enum chg_state_flags f,
496 spin_lock_irqsave(&device->resource->req_lock, flags);
497 ns = apply_mask_val(drbd_read_state(device), mask, val);
498 rv = _drbd_set_state(device, ns, f, NULL);
499 spin_unlock_irqrestore(&device->resource->req_lock, flags);
506 * @device: DRBD device.
510 void drbd_force_state(struct drbd_device *device,
513 drbd_change_state(device, CS_HARD, mask, val);
517 _req_st_cond(struct drbd_device *device, union drbd_state mask,
524 if (test_and_clear_bit(CL_ST_CHG_SUCCESS, &device->flags))
527 if (test_and_clear_bit(CL_ST_CHG_FAIL, &device->flags))
530 spin_lock_irqsave(&device->resource->req_lock, flags);
531 os = drbd_read_state(device);
532 ns = sanitize_state(device, os, apply_mask_val(os, mask, val), NULL);
537 if (!cl_wide_st_chg(device, os, ns))
540 rv = is_valid_state(device, ns);
542 rv = is_valid_soft_transition(os, ns, first_peer_device(device)->connection);
547 spin_unlock_irqrestore(&device->resource->req_lock, flags);
554 * @device: DRBD device.
563 drbd_req_state(struct drbd_device *device, union drbd_state mask,
575 mutex_lock(device->state_mutex);
577 buffer = drbd_md_get_buffer(device, __func__);
579 spin_lock_irqsave(&device->resource->req_lock, flags);
580 os = drbd_read_state(device);
581 ns = sanitize_state(device, os, apply_mask_val(os, mask, val), NULL);
584 spin_unlock_irqrestore(&device->resource->req_lock, flags);
588 if (cl_wide_st_chg(device, os, ns)) {
589 rv = is_valid_state(device, ns);
591 rv = is_valid_soft_transition(os, ns, first_peer_device(device)->connection);
592 spin_unlock_irqrestore(&device->resource->req_lock, flags);
596 print_st_err(device, os, ns, rv);
600 if (drbd_send_state_req(first_peer_device(device), mask, val)) {
603 print_st_err(device, os, ns, rv);
607 wait_event(device->state_wait,
608 (rv = _req_st_cond(device, mask, val)));
612 print_st_err(device, os, ns, rv);
615 spin_lock_irqsave(&device->resource->req_lock, flags);
616 ns = apply_mask_val(drbd_read_state(device), mask, val);
617 rv = _drbd_set_state(device, ns, f, &done);
619 rv = _drbd_set_state(device, ns, f, &done);
622 spin_unlock_irqrestore(&device->resource->req_lock, flags);
625 D_ASSERT(device, current != first_peer_device(device)->connection->worker.task);
631 drbd_md_put_buffer(device);
633 mutex_unlock(device->state_mutex);
640 * @device: DRBD device.
649 _drbd_request_state(struct drbd_device *device, union drbd_state mask,
654 wait_event(device->state_wait,
655 (rv = drbd_req_state(device, mask, val, f)) != SS_IN_TRANSIENT_STATE);
673 request_detach(struct drbd_device *device)
675 return drbd_req_state(device, NS(disk, D_FAILED),
679 int drbd_request_detach_interruptible(struct drbd_device *device)
683 drbd_suspend_io(device); /* so no-one is stuck in drbd_al_begin_io */
684 wait_event_interruptible(device->state_wait,
685 (rv = request_detach(device)) != SS_IN_TRANSIENT_STATE);
686 drbd_resume_io(device);
688 ret = wait_event_interruptible(device->misc_wait,
689 device->state.disk != D_FAILED);
700 _drbd_request_state_holding_state_mutex(struct drbd_device *device, union drbd_state mask,
707 wait_event_cmd(device->state_wait,
708 (rv = drbd_req_state(device, mask, val, f)) != SS_IN_TRANSIENT_STATE,
709 mutex_unlock(device->state_mutex),
710 mutex_lock(device->state_mutex));
715 static void print_st(struct drbd_device *device, const char *name, union drbd_state ns)
717 drbd_err(device, " %s = { cs:%s ro:%s/%s ds:%s/%s %c%c%c%c%c%c }\n",
733 void print_st_err(struct drbd_device *device, union drbd_state os,
738 drbd_err(device, "State change failed: %s\n", drbd_set_st_err_str(err));
739 print_st(device, " state", os);
740 print_st(device, "wanted", ns);
774 static void drbd_pr_state_change(struct drbd_device *device, union drbd_state os, union drbd_state ns,
796 drbd_info(device, "%s\n", pb);
819 * @device: DRBD device.
823 is_valid_state(struct drbd_device *device, union drbd_state ns)
833 if (get_ldev(device)) {
834 fp = rcu_dereference(device->ldev->disk_conf)->fencing;
835 put_ldev(device);
838 nc = rcu_dereference(first_peer_device(device)->connection->net_conf);
843 else if (conn_highest_peer(first_peer_device(device)->connection) == R_PRIMARY)
850 else if (ns.role == R_SECONDARY && device->open_cnt)
884 first_peer_device(device)->connection->agreed_pro_version < 88)
907 * @device: DRBD device.
1027 static void print_sanitize_warnings(struct drbd_device *device, enum sanitize_state_warnings warn)
1039 drbd_warn(device, "%s\n", msg_table[warn]);
1044 * @device: DRBD device.
1052 static union drbd_state sanitize_state(struct drbd_device *device, union drbd_state os,
1062 if (get_ldev(device)) {
1064 fp = rcu_dereference(device->ldev->disk_conf)->fencing;
1066 put_ldev(device);
1092 get_ldev_if_state(device, D_NEGOTIATING)) {
1093 if (device->ed_uuid == device->ldev->md.uuid[UI_CURRENT]) {
1094 ns.disk = device->new_state_tmp.disk;
1095 ns.pdsk = device->new_state_tmp.pdsk;
1102 put_ldev(device);
1198 if (device->resource->res_opts.on_no_data == OND_SUSPEND_IO &&
1218 void drbd_resume_al(struct drbd_device *device)
1220 if (test_and_clear_bit(AL_SUSPENDED, &device->flags))
1221 drbd_info(device, "Resumed AL updates\n");
1225 static void set_ov_position(struct drbd_device *device, enum drbd_conns cs)
1227 if (first_peer_device(device)->connection->agreed_pro_version < 90)
1228 device->ov_start_sector = 0;
1229 device->rs_total = drbd_bm_bits(device);
1230 device->ov_position = 0;
1237 device->ov_start_sector = ~(sector_t)0;
1239 unsigned long bit = BM_SECT_TO_BIT(device->ov_start_sector);
1240 if (bit >= device->rs_total) {
1241 device->ov_start_sector =
1242 BM_BIT_TO_SECT(device->rs_total - 1);
1243 device->rs_total = 1;
1245 device->rs_total -= bit;
1246 device->ov_position = device->ov_start_sector;
1248 device->ov_left = device->rs_total;
1253 * @device: DRBD device.
1261 _drbd_set_state(struct drbd_device *device, union drbd_state ns,
1264 struct drbd_peer_device *peer_device = first_peer_device(device);
1272 os = drbd_read_state(device);
1274 ns = sanitize_state(device, os, ns, &ssw);
1286 rv = is_valid_state(device, ns);
1291 if (is_valid_state(device, os) == rv)
1299 print_st_err(device, os, ns, rv);
1303 print_sanitize_warnings(device, ssw);
1305 drbd_pr_state_change(device, os, ns, flags);
1320 atomic_inc(&device->local_cnt);
1323 clear_bit(RS_DONE, &device->flags);
1326 state_change = remember_old_state(device->resource, GFP_ATOMIC);
1328 /* changes to local_cnt and device flags should be visible before
1332 device->state.i = ns.i;
1333 device->resource->susp = ns.susp;
1334 device->resource->susp_nod = ns.susp_nod;
1335 device->resource->susp_fen = ns.susp_fen;
1346 drbd_print_uuids(device, "attached to UUIDs");
1355 wake_up(&device->misc_wait);
1356 wake_up(&device->state_wait);
1360 * Log the last position, unless end-of-device. */
1363 device->ov_start_sector =
1364 BM_BIT_TO_SECT(drbd_bm_bits(device) - device->ov_left);
1365 if (device->ov_left)
1366 drbd_info(device, "Online Verify reached sector %llu\n",
1367 (unsigned long long)device->ov_start_sector);
1372 drbd_info(device, "Syncer continues.\n");
1373 device->rs_paused += (long)jiffies
1374 -(long)device->rs_mark_time[device->rs_last_mark];
1376 mod_timer(&device->resync_timer, jiffies);
1381 drbd_info(device, "Resync suspended\n");
1382 device->rs_mark_time[device->rs_last_mark] = jiffies;
1390 set_ov_position(device, ns.conn);
1391 device->rs_start = now;
1392 device->rs_last_sect_ev = 0;
1393 device->ov_last_oos_size = 0;
1394 device->ov_last_oos_start = 0;
1397 device->rs_mark_left[i] = device->ov_left;
1398 device->rs_mark_time[i] = now;
1401 drbd_rs_controller_reset(device);
1404 drbd_info(device, "Starting Online Verify from sector %llu\n",
1405 (unsigned long long)device->ov_position);
1406 mod_timer(&device->resync_timer, jiffies);
1410 if (get_ldev(device)) {
1411 u32 mdf = device->ldev->md.flags & ~(MDF_CONSISTENT|MDF_PRIMARY_IND|
1416 if (test_bit(CRASHED_PRIMARY, &device->flags))
1418 if (device->state.role == R_PRIMARY ||
1419 (device->state.pdsk < D_INCONSISTENT && device->state.peer == R_PRIMARY))
1421 if (device->state.conn > C_WF_REPORT_PARAMS)
1423 if (device->state.disk > D_INCONSISTENT)
1425 if (device->state.disk > D_OUTDATED)
1427 if (device->state.pdsk <= D_OUTDATED && device->state.pdsk >= D_INCONSISTENT)
1429 if (mdf != device->ldev->md.flags) {
1430 device->ldev->md.flags = mdf;
1431 drbd_md_mark_dirty(device);
1434 drbd_set_ed_uuid(device, device->ldev->md.uuid[UI_CURRENT]);
1435 put_ldev(device);
1441 set_bit(CONSIDER_RESYNC, &device->flags);
1458 drbd_resume_al(device);
1467 device->last_reattach_jif = jiffies;
1475 ascw->device = device;
1481 drbd_err(device, "Could not kmalloc an ascw\n");
1491 struct drbd_device *device = ascw->device;
1493 after_state_ch(device, ascw->os, ascw->ns, ascw->flags, ascw->state_change);
1502 static void abw_start_sync(struct drbd_device *device, int rv)
1505 drbd_err(device, "Writing the bitmap failed not starting resync.\n");
1506 _drbd_request_state(device, NS(conn, C_CONNECTED), CS_VERBOSE);
1510 switch (device->state.conn) {
1512 _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
1515 drbd_start_resync(device, C_SYNC_SOURCE);
1520 int drbd_bitmap_io_from_worker(struct drbd_device *device,
1526 D_ASSERT(device, current == first_peer_device(device)->connection->worker.task);
1528 /* open coded non-blocking drbd_suspend_io(device); */
1529 atomic_inc(&device->suspend_cnt);
1531 drbd_bm_lock(device, why, flags);
1532 rv = io_fn(device);
1533 drbd_bm_unlock(device);
1535 drbd_resume_io(device);
1575 struct drbd_device *device = device_state_change->device;
1580 return notify_device_state(skb, seq, device, &device_info, type);
1695 * @device: DRBD device.
1700 static void after_state_ch(struct drbd_device *device, union drbd_state os,
1704 struct drbd_resource *resource = device->resource;
1705 struct drbd_peer_device *peer_device = first_peer_device(device);
1717 clear_bit(CRASHED_PRIMARY, &device->flags);
1718 if (device->p_uuid)
1719 device->p_uuid[UI_FLAGS] &= ~((u64)2);
1723 drbd_bcast_event(device, &sib);
1727 drbd_khelper(device, "pri-on-incon-degr");
1735 spin_lock_irq(&device->resource->req_lock);
1750 spin_unlock_irq(&device->resource->req_lock);
1754 spin_lock_irq(&device->resource->req_lock);
1762 clear_bit(NEW_CUR_UUID, &peer_device->device->flags);
1777 spin_unlock_irq(&device->resource->req_lock);
1786 connection->agreed_pro_version >= 96 && get_ldev(device)) {
1788 put_ldev(device);
1796 device->rs_total = 0;
1797 device->rs_failed = 0;
1798 atomic_set(&device->rs_pending_cnt, 0);
1799 drbd_rs_cancel_all(device);
1808 device->state.conn == C_WF_BITMAP_S)
1809 drbd_queue_bitmap_io(device, &drbd_send_bitmap, NULL,
1815 if (get_ldev(device)) {
1817 device->ldev->md.uuid[UI_BITMAP] == 0 && ns.disk >= D_UP_TO_DATE) {
1818 if (drbd_suspended(device)) {
1819 set_bit(NEW_CUR_UUID, &device->flags);
1821 drbd_uuid_new_current(device);
1825 put_ldev(device);
1829 if (ns.pdsk < D_INCONSISTENT && get_ldev(device)) {
1831 device->ldev->md.uuid[UI_BITMAP] == 0 && ns.disk >= D_UP_TO_DATE) {
1832 drbd_uuid_new_current(device);
1840 drbd_bitmap_io_from_worker(device, &drbd_bm_write,
1842 put_ldev(device);
1849 device->state.conn <= C_CONNECTED && get_ldev(device)) {
1852 drbd_bitmap_io_from_worker(device, &drbd_bm_write,
1854 put_ldev(device);
1874 suspend_other_sg(device);
1888 drbd_queue_bitmap_io(device,
1901 if (device->ldev) {
1903 eh = rcu_dereference(device->ldev->disk_conf)->on_io_error;
1906 was_io_error = test_and_clear_bit(WAS_IO_ERROR, &device->flags);
1913 drbd_khelper(device, "local-io-error");
1928 if (test_and_clear_bit(FORCE_DETACH, &device->flags))
1929 tl_abort_disk_io(device);
1934 if (device->state.disk != D_FAILED)
1935 drbd_err(device,
1937 drbd_disk_str(device->state.disk));
1942 drbd_rs_cancel_all(device);
1947 drbd_md_sync(device);
1949 put_ldev(device);
1958 if (device->state.disk != D_DISKLESS)
1959 drbd_err(device,
1961 drbd_disk_str(device->state.disk));
1967 put_ldev(device);
1976 test_and_clear_bit(RESYNC_AFTER_NEG, &device->flags)) {
1978 resync_after_online_grow(device);
1985 resume_next_sg(device);
1996 && verify_can_do_stop_sector(device))
2011 (ns.conn == C_CONNECTED || ns.conn >= C_AHEAD) && get_ldev(device)) {
2012 drbd_queue_bitmap_io(device, &drbd_bm_write_copy_pages, NULL,
2014 put_ldev(device);
2021 resume_next_sg(device);
2024 drbd_md_sync(device);
2082 struct drbd_device *device = peer_device->device;
2083 if (test_bit(NEW_CUR_UUID, &device->flags)) {
2084 drbd_uuid_new_current(device);
2085 clear_bit(NEW_CUR_UUID, &device->flags);
2119 struct drbd_device *device = peer_device->device;
2120 os = device->state;
2161 struct drbd_device *device = peer_device->device;
2162 os = drbd_read_state(device);
2163 ns = sanitize_state(device, os, apply_mask_val(os, mask, val), NULL);
2174 rv = is_valid_state(device, ns);
2176 if (is_valid_state(device, os) == rv)
2184 print_st_err(device, os, ns, rv);
2221 struct drbd_device *device = peer_device->device;
2223 os = drbd_read_state(device);
2225 ns = sanitize_state(device, os, ns, NULL);
2230 rv = _drbd_set_state(device, ns, flags, NULL);
2232 ns.i = device->state.i;