Lines Matching defs:device
22 static bool drbd_may_do_local_read(struct drbd_device *device, sector_t sector, int size);
24 static struct drbd_request *drbd_req_new(struct drbd_device *device, struct bio *bio_src)
38 req->device = device;
63 struct drbd_device *device = req->device;
70 wake_up(&device->misc_wait);
76 struct drbd_device *device = req->device;
83 drbd_err(device, "drbd_req_destroy: Logic BUG rq_state = 0x%x, completion_ref = %d\n",
104 root = &device->write_requests;
106 root = &device->read_requests;
109 drbd_err(device, "drbd_req_destroy: Logic BUG: interval empty, but: rq_state=0x%x, sect=%llu, size=%u\n",
129 drbd_set_out_of_sync(device, req->i.sector, req->i.size);
132 drbd_set_in_sync(device, req->i.sector, req->i.size);
146 if (get_ldev_if_state(device, D_FAILED)) {
147 drbd_al_complete_io(device, &req->i);
148 put_ldev(device);
150 drbd_warn(device, "Should have called drbd_al_complete_io(, %llu, %u), "
177 void complete_master_bio(struct drbd_device *device,
183 dec_ap_bio(device);
197 struct drbd_device *device = req->device;
212 drbd_err(device, "drbd_req_complete: Logic BUG rq_state = 0x%x\n", s);
217 drbd_err(device, "drbd_req_complete: Logic BUG, master_bio == NULL!\n");
245 req->epoch == atomic_read(&first_peer_device(device)->connection->current_tle_nr))
246 start_new_tl_epoch(first_peer_device(device)->connection);
283 wake_up(&device->misc_wait);
295 struct drbd_device *device = req->device;
296 D_ASSERT(device, m || (req->rq_state & RQ_POSTPONED));
404 struct drbd_device *device = req->device;
405 struct drbd_peer_device *peer_device = first_peer_device(device);
409 if (drbd_suspended(device) && !((s | clear) & RQ_COMPLETION_SUSP))
429 inc_ap_pending(device);
444 atomic_add(req->i.size >> 9, &device->ap_in_flight);
460 D_ASSERT(device, req->rq_state & RQ_LOCAL_PENDING);
473 dec_ap_pending(device);
486 atomic_sub(req->i.size >> 9, &device->ap_in_flight);
503 wake_up(&device->misc_wait);
509 static void drbd_report_io_error(struct drbd_device *device, struct drbd_request *req)
516 drbd_warn(device, "local %s IO error sector %llu+%u on %s\n",
520 bdevname(device->ldev->backing_bdev, b));
551 struct drbd_device *const device = req->device;
552 struct drbd_peer_device *const peer_device = first_peer_device(device);
562 drbd_err(device, "LOGIC BUG in %s:%u\n", __FILE__ , __LINE__);
574 D_ASSERT(device, !(req->rq_state & RQ_NET_MASK));
587 D_ASSERT(device, !(req->rq_state & RQ_LOCAL_MASK));
593 device->writ_cnt += req->i.size >> 9;
595 device->read_cnt += req->i.size >> 9;
606 drbd_report_io_error(device, req);
607 __drbd_chk_io_error(device, DRBD_WRITE_ERROR);
612 drbd_set_out_of_sync(device, req->i.sector, req->i.size);
613 drbd_report_io_error(device, req);
614 __drbd_chk_io_error(device, DRBD_READ_ERROR);
639 D_ASSERT(device, drbd_interval_empty(&req->i));
640 drbd_insert_interval(&device->read_requests, &req->i);
642 set_bit(UNPLUG_REMOTE, &device->flags);
644 D_ASSERT(device, req->rq_state & RQ_NET_PENDING);
645 D_ASSERT(device, (req->rq_state & RQ_LOCAL_MASK) == 0);
658 D_ASSERT(device, drbd_interval_empty(&req->i));
659 drbd_insert_interval(&device->write_requests, &req->i);
678 set_bit(UNPLUG_REMOTE, &device->flags);
681 D_ASSERT(device, req->rq_state & RQ_NET_PENDING);
747 D_ASSERT(device, req->rq_state & RQ_NET_PENDING);
748 D_ASSERT(device, req->rq_state & RQ_EXP_WRITE_ACK);
764 D_ASSERT(device, req->rq_state & RQ_EXP_RECEIVE_ACK);
773 D_ASSERT(device, req->rq_state & RQ_EXP_WRITE_ACK);
778 D_ASSERT(device, req->rq_state & RQ_NET_PENDING);
781 wake_up(&device->misc_wait);
809 get_ldev(device); /* always succeeds in this call path */
851 drbd_err(device, "FIXME (BARRIER_ACKED but pending)\n");
862 D_ASSERT(device, req->rq_state & RQ_NET_PENDING);
882 static bool drbd_may_do_local_read(struct drbd_device *device, sector_t sector, int size)
887 if (device->state.disk == D_UP_TO_DATE)
889 if (device->state.disk != D_INCONSISTENT)
892 nr_sectors = get_capacity(device->vdisk);
893 D_ASSERT(device, sector < nr_sectors);
894 D_ASSERT(device, esector < nr_sectors);
899 return drbd_bm_count_bits(device, sbnr, ebnr) == 0;
902 static bool remote_due_to_read_balancing(struct drbd_device *device, sector_t sector,
910 bdi = device->ldev->backing_bdev->bd_disk->queue->backing_dev_info;
913 return atomic_read(&device->local_cnt) >
914 atomic_read(&device->ap_pending_cnt) + atomic_read(&device->rs_pending_cnt);
924 return test_and_change_bit(READ_BALANCE_RR, &device->flags);
945 struct drbd_device *device = req->device;
951 drbd_for_each_overlap(i, &device->write_requests, sector, size) {
962 /* Indicate to wake up device->misc_wait on progress. */
963 prepare_to_wait(&device->misc_wait, &wait, TASK_UNINTERRUPTIBLE);
965 spin_unlock_irq(&device->resource->req_lock);
967 spin_lock_irq(&device->resource->req_lock);
969 finish_wait(&device->misc_wait, &wait);
973 static void maybe_pull_ahead(struct drbd_device *device)
975 struct drbd_connection *connection = first_peer_device(device)->connection;
988 if (on_congestion == OC_PULL_AHEAD && device->state.conn == C_AHEAD)
993 * sure device->act_log is there.
995 if (!get_ldev_if_state(device, D_UP_TO_DATE))
999 atomic_read(&device->ap_in_flight) >= nc->cong_fill) {
1000 drbd_info(device, "Congestion-fill threshold reached\n");
1004 if (device->act_log->used >= nc->cong_extents) {
1005 drbd_info(device, "Congestion-extents threshold reached\n");
1011 start_new_tl_epoch(first_peer_device(device)->connection);
1014 _drbd_set_state(_NS(device, conn, C_AHEAD), 0, NULL);
1016 _drbd_set_state(_NS(device, conn, C_DISCONNECTING), 0, NULL);
1018 put_ldev(device);
1032 struct drbd_device *device = req->device;
1036 if (!drbd_may_do_local_read(device,
1040 put_ldev(device);
1044 if (device->state.pdsk != D_UP_TO_DATE)
1054 rbm = rcu_dereference(device->ldev->disk_conf)->read_balancing;
1060 if (remote_due_to_read_balancing(device, req->i.sector, rbm)) {
1064 put_ldev(device);
1095 struct drbd_device *device = req->device;
1098 remote = drbd_should_do_remote(device->state);
1099 send_oos = drbd_should_send_out_of_sync(device->state);
1109 D_ASSERT(device, req->master_bio->bi_opf & REQ_PREFLUSH);
1118 D_ASSERT(device, !(remote && send_oos));
1123 } else if (drbd_set_out_of_sync(device, req->i.sector, req->i.size))
1131 int err = drbd_issue_discard_or_zero_out(req->device,
1141 struct drbd_device *device = req->device;
1152 bio_set_dev(bio, device->ldev->backing_bdev);
1159 if (get_ldev(device)) {
1160 if (drbd_insert_fault(device, type))
1169 put_ldev(device);
1174 static void drbd_queue_write(struct drbd_device *device, struct drbd_request *req)
1176 spin_lock_irq(&device->resource->req_lock);
1177 list_add_tail(&req->tl_requests, &device->submit.writes);
1179 &device->pending_master_completion[1 /* WRITE */]);
1180 spin_unlock_irq(&device->resource->req_lock);
1181 queue_work(device->submit.wq, &device->submit.worker);
1183 wake_up(&device->al_wait);
1192 drbd_request_prepare(struct drbd_device *device, struct bio *bio, unsigned long start_jif)
1198 req = drbd_req_new(device, bio);
1200 dec_ap_bio(device);
1203 drbd_err(device, "could not kmalloc() req\n");
1212 if (!get_ldev(device)) {
1223 && !test_bit(AL_SUSPENDED, &device->flags)) {
1224 if (!drbd_al_begin_io_fastpath(device, &req->i))
1232 atomic_inc(&device->ap_actlog_cnt);
1233 drbd_queue_write(device, req);
1247 static bool may_do_writes(struct drbd_device *device)
1249 const union drbd_dev_state s = device->state;
1274 drbd_queue_unplug(req->device);
1304 static void drbd_send_and_submit(struct drbd_device *device, struct drbd_request *req)
1306 struct drbd_resource *resource = device->resource;
1322 maybe_pull_ahead(device);
1326 if (drbd_suspended(device)) {
1332 put_ldev(device);
1346 req->epoch = atomic_read(&first_peer_device(device)->connection->current_tle_nr);
1352 first_peer_device(device)->connection->current_tle_writes++;
1354 list_add_tail(&req->tl_requests, &first_peer_device(device)->connection->transfer_log);
1358 if (req->private_bio && !may_do_writes(device)) {
1361 put_ldev(device);
1386 &device->pending_master_completion[rw == WRITE]);
1391 &device->pending_completion[rw == WRITE]);
1398 drbd_err(device, "IO ERROR: neither local nor remote data, sector %llu+%u\n",
1417 complete_master_bio(device, &m);
1420 void __drbd_make_request(struct drbd_device *device, struct bio *bio, unsigned long start_jif)
1422 struct drbd_request *req = drbd_request_prepare(device, bio, start_jif);
1425 drbd_send_and_submit(device, req);
1428 static void submit_fast_path(struct drbd_device *device, struct list_head *incoming)
1439 && !test_bit(AL_SUSPENDED, &device->flags)) {
1440 if (!drbd_al_begin_io_fastpath(device, &req->i))
1445 atomic_dec(&device->ap_actlog_cnt);
1449 drbd_send_and_submit(device, req);
1454 static bool prepare_al_transaction_nonblock(struct drbd_device *device,
1463 spin_lock_irq(&device->al_lock);
1465 err = drbd_al_begin_io_nonblock(device, &req->i);
1475 spin_unlock_irq(&device->al_lock);
1477 wake_up(&device->al_wait);
1481 static void send_and_submit_pending(struct drbd_device *device, struct list_head *pending)
1490 atomic_dec(&device->ap_actlog_cnt);
1492 drbd_send_and_submit(device, req);
1499 struct drbd_device *device = container_of(ws, struct drbd_device, submit.worker);
1505 spin_lock_irq(&device->resource->req_lock);
1506 list_splice_tail_init(&device->submit.writes, &incoming);
1507 spin_unlock_irq(&device->resource->req_lock);
1514 submit_fast_path(device, &incoming);
1519 prepare_to_wait(&device->al_wait, &wait, TASK_UNINTERRUPTIBLE);
1522 prepare_al_transaction_nonblock(device, &incoming, &pending, &busy);
1545 spin_lock_irq(&device->resource->req_lock);
1546 list_splice_tail_init(&device->submit.writes, &incoming);
1547 spin_unlock_irq(&device->resource->req_lock);
1549 finish_wait(&device->al_wait, &wait);
1574 if (list_empty(&device->submit.writes))
1577 spin_lock_irq(&device->resource->req_lock);
1578 list_splice_tail_init(&device->submit.writes, &more_incoming);
1579 spin_unlock_irq(&device->resource->req_lock);
1584 made_progress = prepare_al_transaction_nonblock(device, &more_incoming, &more_pending, &busy);
1592 drbd_al_begin_io_commit(device);
1593 send_and_submit_pending(device, &pending);
1599 struct drbd_device *device = bio->bi_disk->private_data;
1609 D_ASSERT(device, IS_ALIGNED(bio->bi_iter.bi_size, 512));
1611 inc_ap_bio(device);
1612 __drbd_make_request(device, bio, start_jif);
1621 struct drbd_device *device = net_req->device;
1630 drbd_warn(device, "Remote failed to finish a request within %ums > ko-count (%u) * timeout (%u * 0.1s)\n",
1640 drbd_warn(device,
1663 drbd_warn(device, "Remote failed to answer a P_BARRIER (sent at %lu jif; now=%lu jif) within %ums > ko-count (%u) * timeout (%u * 0.1s)\n",
1690 struct drbd_device *device = from_timer(device, t, request_timer);
1691 struct drbd_connection *connection = first_peer_device(device)->connection;
1701 if (nc && device->state.conn >= C_WF_REPORT_PARAMS) {
1706 if (get_ldev(device)) { /* implicit state.disk >= D_INCONSISTENT */
1707 dt = rcu_dereference(device->ldev->disk_conf)->disk_timeout * HZ / 10;
1708 put_ldev(device);
1722 spin_lock_irq(&device->resource->req_lock);
1723 req_read = list_first_entry_or_null(&device->pending_completion[0], struct drbd_request, req_pending_local);
1724 req_write = list_first_entry_or_null(&device->pending_completion[1], struct drbd_request, req_pending_local);
1743 if (req_peer && req_peer->device != device)
1762 !time_in_range(now, device->last_reattach_jif, device->last_reattach_jif + dt)) {
1763 drbd_warn(device, "Local backing device failed to meet the disk-timeout\n");
1764 __drbd_chk_io_error(device, DRBD_FORCE_DETACH);
1775 spin_unlock_irq(&device->resource->req_lock);
1776 mod_timer(&device->request_timer, nt);