1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_worker.c 3b411b363SPhilipp Reisner 4b411b363SPhilipp Reisner This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5b411b363SPhilipp Reisner 6b411b363SPhilipp Reisner Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7b411b363SPhilipp Reisner Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8b411b363SPhilipp Reisner Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9b411b363SPhilipp Reisner 10b411b363SPhilipp Reisner drbd is free software; you can redistribute it and/or modify 11b411b363SPhilipp Reisner it under the terms of the GNU General Public License as published by 12b411b363SPhilipp Reisner the Free Software Foundation; either version 2, or (at your option) 13b411b363SPhilipp Reisner any later version. 14b411b363SPhilipp Reisner 15b411b363SPhilipp Reisner drbd is distributed in the hope that it will be useful, 16b411b363SPhilipp Reisner but WITHOUT ANY WARRANTY; without even the implied warranty of 17b411b363SPhilipp Reisner MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18b411b363SPhilipp Reisner GNU General Public License for more details. 19b411b363SPhilipp Reisner 20b411b363SPhilipp Reisner You should have received a copy of the GNU General Public License 21b411b363SPhilipp Reisner along with drbd; see the file COPYING. If not, write to 22b411b363SPhilipp Reisner the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23b411b363SPhilipp Reisner 24b411b363SPhilipp Reisner */ 25b411b363SPhilipp Reisner 26b411b363SPhilipp Reisner #include <linux/module.h> 27b411b363SPhilipp Reisner #include <linux/drbd.h> 28b411b363SPhilipp Reisner #include <linux/sched.h> 29b411b363SPhilipp Reisner #include <linux/wait.h> 30b411b363SPhilipp Reisner #include <linux/mm.h> 31b411b363SPhilipp Reisner #include <linux/memcontrol.h> 32b411b363SPhilipp Reisner #include <linux/mm_inline.h> 33b411b363SPhilipp Reisner #include <linux/slab.h> 34b411b363SPhilipp Reisner #include <linux/random.h> 35b411b363SPhilipp Reisner #include <linux/string.h> 36b411b363SPhilipp Reisner #include <linux/scatterlist.h> 37b411b363SPhilipp Reisner 38b411b363SPhilipp Reisner #include "drbd_int.h" 39b411b363SPhilipp Reisner #include "drbd_req.h" 40b411b363SPhilipp Reisner 4100d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel); 42b411b363SPhilipp Reisner 43b411b363SPhilipp Reisner 44c5a91619SAndreas Gruenbacher /* endio handlers: 45c5a91619SAndreas Gruenbacher * drbd_md_io_complete (defined here) 46fcefa62eSAndreas Gruenbacher * drbd_request_endio (defined here) 47fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio (defined here) 48c5a91619SAndreas Gruenbacher * bm_async_io_complete (defined in drbd_bitmap.c) 49c5a91619SAndreas Gruenbacher * 50b411b363SPhilipp Reisner * For all these callbacks, note the following: 51b411b363SPhilipp Reisner * The callbacks will be called in irq context by the IDE drivers, 52b411b363SPhilipp Reisner * and in Softirqs/Tasklets/BH context by the SCSI drivers. 53b411b363SPhilipp Reisner * Try to get the locking right :) 54b411b363SPhilipp Reisner * 55b411b363SPhilipp Reisner */ 56b411b363SPhilipp Reisner 57b411b363SPhilipp Reisner 58b411b363SPhilipp Reisner /* About the global_state_lock 59b411b363SPhilipp Reisner Each state transition on an device holds a read lock. In case we have 6095f8efd0SAndreas Gruenbacher to evaluate the resync after dependencies, we grab a write lock, because 61b411b363SPhilipp Reisner we need stable states on all devices for that. */ 62b411b363SPhilipp Reisner rwlock_t global_state_lock; 63b411b363SPhilipp Reisner 64b411b363SPhilipp Reisner /* used for synchronous meta data and bitmap IO 65b411b363SPhilipp Reisner * submitted by drbd_md_sync_page_io() 66b411b363SPhilipp Reisner */ 67b411b363SPhilipp Reisner void drbd_md_io_complete(struct bio *bio, int error) 68b411b363SPhilipp Reisner { 69b411b363SPhilipp Reisner struct drbd_md_io *md_io; 70cdfda633SPhilipp Reisner struct drbd_conf *mdev; 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner md_io = (struct drbd_md_io *)bio->bi_private; 73cdfda633SPhilipp Reisner mdev = container_of(md_io, struct drbd_conf, md_io); 74cdfda633SPhilipp Reisner 75b411b363SPhilipp Reisner md_io->error = error; 76b411b363SPhilipp Reisner 770cfac5ddSPhilipp Reisner /* We grabbed an extra reference in _drbd_md_sync_page_io() to be able 780cfac5ddSPhilipp Reisner * to timeout on the lower level device, and eventually detach from it. 790cfac5ddSPhilipp Reisner * If this io completion runs after that timeout expired, this 800cfac5ddSPhilipp Reisner * drbd_md_put_buffer() may allow us to finally try and re-attach. 810cfac5ddSPhilipp Reisner * During normal operation, this only puts that extra reference 820cfac5ddSPhilipp Reisner * down to 1 again. 830cfac5ddSPhilipp Reisner * Make sure we first drop the reference, and only then signal 840cfac5ddSPhilipp Reisner * completion, or we may (in drbd_al_read_log()) cycle so fast into the 850cfac5ddSPhilipp Reisner * next drbd_md_sync_page_io(), that we trigger the 860cfac5ddSPhilipp Reisner * ASSERT(atomic_read(&mdev->md_io_in_use) == 1) there. 870cfac5ddSPhilipp Reisner */ 880cfac5ddSPhilipp Reisner drbd_md_put_buffer(mdev); 89cdfda633SPhilipp Reisner md_io->done = 1; 90cdfda633SPhilipp Reisner wake_up(&mdev->misc_wait); 91cdfda633SPhilipp Reisner bio_put(bio); 92cdfda633SPhilipp Reisner put_ldev(mdev); 93b411b363SPhilipp Reisner } 94b411b363SPhilipp Reisner 95b411b363SPhilipp Reisner /* reads on behalf of the partner, 96b411b363SPhilipp Reisner * "submitted" by the receiver 97b411b363SPhilipp Reisner */ 98db830c46SAndreas Gruenbacher void drbd_endio_read_sec_final(struct drbd_peer_request *peer_req) __releases(local) 99b411b363SPhilipp Reisner { 100b411b363SPhilipp Reisner unsigned long flags = 0; 101a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 102b411b363SPhilipp Reisner 10387eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 104db830c46SAndreas Gruenbacher mdev->read_cnt += peer_req->i.size >> 9; 105db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 106b411b363SPhilipp Reisner if (list_empty(&mdev->read_ee)) 107b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 108db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 10981e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 11087eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 111b411b363SPhilipp Reisner 112db830c46SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &peer_req->w); 113b411b363SPhilipp Reisner put_ldev(mdev); 114b411b363SPhilipp Reisner } 115b411b363SPhilipp Reisner 116b411b363SPhilipp Reisner /* writes on behalf of the partner, or resync writes, 11745bb912bSLars Ellenberg * "submitted" by the receiver, final stage. */ 118db830c46SAndreas Gruenbacher static void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(local) 119b411b363SPhilipp Reisner { 120b411b363SPhilipp Reisner unsigned long flags = 0; 121a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 122181286adSLars Ellenberg struct drbd_interval i; 123b411b363SPhilipp Reisner int do_wake; 124579b57edSAndreas Gruenbacher u64 block_id; 125b411b363SPhilipp Reisner int do_al_complete_io; 126b411b363SPhilipp Reisner 127db830c46SAndreas Gruenbacher /* after we moved peer_req to done_ee, 128b411b363SPhilipp Reisner * we may no longer access it, 129b411b363SPhilipp Reisner * it may be freed/reused already! 130b411b363SPhilipp Reisner * (as soon as we release the req_lock) */ 131181286adSLars Ellenberg i = peer_req->i; 132db830c46SAndreas Gruenbacher do_al_complete_io = peer_req->flags & EE_CALL_AL_COMPLETE_IO; 133db830c46SAndreas Gruenbacher block_id = peer_req->block_id; 134b411b363SPhilipp Reisner 13587eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 136db830c46SAndreas Gruenbacher mdev->writ_cnt += peer_req->i.size >> 9; 137db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); /* has been on active_ee or sync_ee */ 138db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 139b411b363SPhilipp Reisner 140bb3bfe96SAndreas Gruenbacher /* 1415e472264SAndreas Gruenbacher * Do not remove from the write_requests tree here: we did not send the 142bb3bfe96SAndreas Gruenbacher * Ack yet and did not wake possibly waiting conflicting requests. 143bb3bfe96SAndreas Gruenbacher * Removed from the tree from "drbd_process_done_ee" within the 144bb3bfe96SAndreas Gruenbacher * appropriate w.cb (e_end_block/e_end_resync_block) or from 145bb3bfe96SAndreas Gruenbacher * _drbd_clear_done_ee. 146bb3bfe96SAndreas Gruenbacher */ 147b411b363SPhilipp Reisner 148579b57edSAndreas Gruenbacher do_wake = list_empty(block_id == ID_SYNCER ? &mdev->sync_ee : &mdev->active_ee); 149b411b363SPhilipp Reisner 150db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 15181e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 15287eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 153b411b363SPhilipp Reisner 154579b57edSAndreas Gruenbacher if (block_id == ID_SYNCER) 155181286adSLars Ellenberg drbd_rs_complete_io(mdev, i.sector); 156b411b363SPhilipp Reisner 157b411b363SPhilipp Reisner if (do_wake) 158b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 159b411b363SPhilipp Reisner 160b411b363SPhilipp Reisner if (do_al_complete_io) 161181286adSLars Ellenberg drbd_al_complete_io(mdev, &i); 162b411b363SPhilipp Reisner 1630625ac19SPhilipp Reisner wake_asender(mdev->tconn); 164b411b363SPhilipp Reisner put_ldev(mdev); 16545bb912bSLars Ellenberg } 166b411b363SPhilipp Reisner 16745bb912bSLars Ellenberg /* writes on behalf of the partner, or resync writes, 16845bb912bSLars Ellenberg * "submitted" by the receiver. 16945bb912bSLars Ellenberg */ 170fcefa62eSAndreas Gruenbacher void drbd_peer_request_endio(struct bio *bio, int error) 17145bb912bSLars Ellenberg { 172db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = bio->bi_private; 173a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 17445bb912bSLars Ellenberg int uptodate = bio_flagged(bio, BIO_UPTODATE); 17545bb912bSLars Ellenberg int is_write = bio_data_dir(bio) == WRITE; 17645bb912bSLars Ellenberg 17707194272SLars Ellenberg if (error && __ratelimit(&drbd_ratelimit_state)) 17845bb912bSLars Ellenberg dev_warn(DEV, "%s: error=%d s=%llus\n", 17945bb912bSLars Ellenberg is_write ? "write" : "read", error, 180db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 18145bb912bSLars Ellenberg if (!error && !uptodate) { 18207194272SLars Ellenberg if (__ratelimit(&drbd_ratelimit_state)) 18345bb912bSLars Ellenberg dev_warn(DEV, "%s: setting error to -EIO s=%llus\n", 18445bb912bSLars Ellenberg is_write ? "write" : "read", 185db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 18645bb912bSLars Ellenberg /* strange behavior of some lower level drivers... 18745bb912bSLars Ellenberg * fail the request by clearing the uptodate flag, 18845bb912bSLars Ellenberg * but do not return any error?! */ 18945bb912bSLars Ellenberg error = -EIO; 19045bb912bSLars Ellenberg } 19145bb912bSLars Ellenberg 19245bb912bSLars Ellenberg if (error) 193db830c46SAndreas Gruenbacher set_bit(__EE_WAS_ERROR, &peer_req->flags); 19445bb912bSLars Ellenberg 19545bb912bSLars Ellenberg bio_put(bio); /* no need for the bio anymore */ 196db830c46SAndreas Gruenbacher if (atomic_dec_and_test(&peer_req->pending_bios)) { 19745bb912bSLars Ellenberg if (is_write) 198db830c46SAndreas Gruenbacher drbd_endio_write_sec_final(peer_req); 19945bb912bSLars Ellenberg else 200db830c46SAndreas Gruenbacher drbd_endio_read_sec_final(peer_req); 20145bb912bSLars Ellenberg } 202b411b363SPhilipp Reisner } 203b411b363SPhilipp Reisner 204b411b363SPhilipp Reisner /* read, readA or write requests on R_PRIMARY coming from drbd_make_request 205b411b363SPhilipp Reisner */ 206fcefa62eSAndreas Gruenbacher void drbd_request_endio(struct bio *bio, int error) 207b411b363SPhilipp Reisner { 208a115413dSLars Ellenberg unsigned long flags; 209b411b363SPhilipp Reisner struct drbd_request *req = bio->bi_private; 210a21e9298SPhilipp Reisner struct drbd_conf *mdev = req->w.mdev; 211a115413dSLars Ellenberg struct bio_and_error m; 212b411b363SPhilipp Reisner enum drbd_req_event what; 213b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 214b411b363SPhilipp Reisner 215b411b363SPhilipp Reisner if (!error && !uptodate) { 216b411b363SPhilipp Reisner dev_warn(DEV, "p %s: setting error to -EIO\n", 217b411b363SPhilipp Reisner bio_data_dir(bio) == WRITE ? "write" : "read"); 218b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 219b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 220b411b363SPhilipp Reisner * but do not return any error?! */ 221b411b363SPhilipp Reisner error = -EIO; 222b411b363SPhilipp Reisner } 223b411b363SPhilipp Reisner 224b411b363SPhilipp Reisner /* to avoid recursion in __req_mod */ 225b411b363SPhilipp Reisner if (unlikely(error)) { 226b411b363SPhilipp Reisner what = (bio_data_dir(bio) == WRITE) 2278554df1cSAndreas Gruenbacher ? WRITE_COMPLETED_WITH_ERROR 2285c3c7e64SLars Ellenberg : (bio_rw(bio) == READ) 2298554df1cSAndreas Gruenbacher ? READ_COMPLETED_WITH_ERROR 2308554df1cSAndreas Gruenbacher : READ_AHEAD_COMPLETED_WITH_ERROR; 231b411b363SPhilipp Reisner } else 2328554df1cSAndreas Gruenbacher what = COMPLETED_OK; 233b411b363SPhilipp Reisner 234b411b363SPhilipp Reisner bio_put(req->private_bio); 235b411b363SPhilipp Reisner req->private_bio = ERR_PTR(error); 236b411b363SPhilipp Reisner 237a115413dSLars Ellenberg /* not req_mod(), we need irqsave here! */ 23887eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 239a115413dSLars Ellenberg __req_mod(req, what, &m); 24087eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 2412415308eSLars Ellenberg put_ldev(mdev); 242a115413dSLars Ellenberg 243a115413dSLars Ellenberg if (m.bio) 244a115413dSLars Ellenberg complete_master_bio(mdev, &m); 245b411b363SPhilipp Reisner } 246b411b363SPhilipp Reisner 24799920dc5SAndreas Gruenbacher int w_read_retry_remote(struct drbd_work *w, int cancel) 248b411b363SPhilipp Reisner { 249b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 25000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 251b411b363SPhilipp Reisner 252b411b363SPhilipp Reisner /* We should not detach for read io-error, 253b411b363SPhilipp Reisner * but try to WRITE the P_DATA_REPLY to the failed location, 254b411b363SPhilipp Reisner * to give the disk the chance to relocate that block */ 255b411b363SPhilipp Reisner 25687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 257d255e5ffSLars Ellenberg if (cancel || mdev->state.pdsk != D_UP_TO_DATE) { 2588554df1cSAndreas Gruenbacher _req_mod(req, READ_RETRY_REMOTE_CANCELED); 25987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 26099920dc5SAndreas Gruenbacher return 0; 261b411b363SPhilipp Reisner } 26287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 263b411b363SPhilipp Reisner 26400d56944SPhilipp Reisner return w_send_read_req(w, 0); 265b411b363SPhilipp Reisner } 266b411b363SPhilipp Reisner 267f6ffca9fSAndreas Gruenbacher void drbd_csum_ee(struct drbd_conf *mdev, struct crypto_hash *tfm, 268db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, void *digest) 26945bb912bSLars Ellenberg { 27045bb912bSLars Ellenberg struct hash_desc desc; 27145bb912bSLars Ellenberg struct scatterlist sg; 272db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 27345bb912bSLars Ellenberg struct page *tmp; 27445bb912bSLars Ellenberg unsigned len; 27545bb912bSLars Ellenberg 27645bb912bSLars Ellenberg desc.tfm = tfm; 27745bb912bSLars Ellenberg desc.flags = 0; 27845bb912bSLars Ellenberg 27945bb912bSLars Ellenberg sg_init_table(&sg, 1); 28045bb912bSLars Ellenberg crypto_hash_init(&desc); 28145bb912bSLars Ellenberg 28245bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) { 28345bb912bSLars Ellenberg /* all but the last page will be fully used */ 28445bb912bSLars Ellenberg sg_set_page(&sg, page, PAGE_SIZE, 0); 28545bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 28645bb912bSLars Ellenberg page = tmp; 28745bb912bSLars Ellenberg } 28845bb912bSLars Ellenberg /* and now the last, possibly only partially used page */ 289db830c46SAndreas Gruenbacher len = peer_req->i.size & (PAGE_SIZE - 1); 29045bb912bSLars Ellenberg sg_set_page(&sg, page, len ?: PAGE_SIZE, 0); 29145bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 29245bb912bSLars Ellenberg crypto_hash_final(&desc, digest); 29345bb912bSLars Ellenberg } 29445bb912bSLars Ellenberg 29545bb912bSLars Ellenberg void drbd_csum_bio(struct drbd_conf *mdev, struct crypto_hash *tfm, struct bio *bio, void *digest) 296b411b363SPhilipp Reisner { 297b411b363SPhilipp Reisner struct hash_desc desc; 298b411b363SPhilipp Reisner struct scatterlist sg; 299b411b363SPhilipp Reisner struct bio_vec *bvec; 300b411b363SPhilipp Reisner int i; 301b411b363SPhilipp Reisner 302b411b363SPhilipp Reisner desc.tfm = tfm; 303b411b363SPhilipp Reisner desc.flags = 0; 304b411b363SPhilipp Reisner 305b411b363SPhilipp Reisner sg_init_table(&sg, 1); 306b411b363SPhilipp Reisner crypto_hash_init(&desc); 307b411b363SPhilipp Reisner 3084b8514eeSLars Ellenberg bio_for_each_segment(bvec, bio, i) { 309b411b363SPhilipp Reisner sg_set_page(&sg, bvec->bv_page, bvec->bv_len, bvec->bv_offset); 310b411b363SPhilipp Reisner crypto_hash_update(&desc, &sg, sg.length); 311b411b363SPhilipp Reisner } 312b411b363SPhilipp Reisner crypto_hash_final(&desc, digest); 313b411b363SPhilipp Reisner } 314b411b363SPhilipp Reisner 3159676c760SLars Ellenberg /* MAYBE merge common code with w_e_end_ov_req */ 31699920dc5SAndreas Gruenbacher static int w_e_send_csum(struct drbd_work *w, int cancel) 317b411b363SPhilipp Reisner { 31800d56944SPhilipp Reisner struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 31900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 320b411b363SPhilipp Reisner int digest_size; 321b411b363SPhilipp Reisner void *digest; 32299920dc5SAndreas Gruenbacher int err = 0; 323b411b363SPhilipp Reisner 32453ea4331SLars Ellenberg if (unlikely(cancel)) 32553ea4331SLars Ellenberg goto out; 326b411b363SPhilipp Reisner 3279676c760SLars Ellenberg if (unlikely((peer_req->flags & EE_WAS_ERROR) != 0)) 32853ea4331SLars Ellenberg goto out; 32953ea4331SLars Ellenberg 330f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 331b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 332b411b363SPhilipp Reisner if (digest) { 333db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 334db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 335f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 3369676c760SLars Ellenberg /* Free peer_req and pages before send. 33753ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 33853ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 33953ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 340c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 3413967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 342db830c46SAndreas Gruenbacher peer_req = NULL; 343b411b363SPhilipp Reisner inc_rs_pending(mdev); 34499920dc5SAndreas Gruenbacher err = drbd_send_drequest_csum(mdev, sector, size, 34553ea4331SLars Ellenberg digest, digest_size, 346b411b363SPhilipp Reisner P_CSUM_RS_REQUEST); 347b411b363SPhilipp Reisner kfree(digest); 348b411b363SPhilipp Reisner } else { 349b411b363SPhilipp Reisner dev_err(DEV, "kmalloc() of digest failed.\n"); 35099920dc5SAndreas Gruenbacher err = -ENOMEM; 351b411b363SPhilipp Reisner } 352b411b363SPhilipp Reisner 35353ea4331SLars Ellenberg out: 354db830c46SAndreas Gruenbacher if (peer_req) 3553967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 356b411b363SPhilipp Reisner 35799920dc5SAndreas Gruenbacher if (unlikely(err)) 358b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest(..., csum) failed\n"); 35999920dc5SAndreas Gruenbacher return err; 360b411b363SPhilipp Reisner } 361b411b363SPhilipp Reisner 362b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 363b411b363SPhilipp Reisner 364b411b363SPhilipp Reisner static int read_for_csum(struct drbd_conf *mdev, sector_t sector, int size) 365b411b363SPhilipp Reisner { 366db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 367b411b363SPhilipp Reisner 368b411b363SPhilipp Reisner if (!get_ldev(mdev)) 36980a40e43SLars Ellenberg return -EIO; 370b411b363SPhilipp Reisner 371e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector)) 3720f0601f4SLars Ellenberg goto defer; 3730f0601f4SLars Ellenberg 374b411b363SPhilipp Reisner /* GFP_TRY, because if there is no memory available right now, this may 375b411b363SPhilipp Reisner * be rescheduled for later. It is "only" background resync, after all. */ 3760db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, ID_SYNCER /* unused */, sector, 3770db55363SAndreas Gruenbacher size, GFP_TRY); 378db830c46SAndreas Gruenbacher if (!peer_req) 37980a40e43SLars Ellenberg goto defer; 380b411b363SPhilipp Reisner 381db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_send_csum; 38287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 383db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->read_ee); 38487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 385b411b363SPhilipp Reisner 3860f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 387fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, DRBD_FAULT_RS_RD) == 0) 38880a40e43SLars Ellenberg return 0; 38945bb912bSLars Ellenberg 39010f6d992SLars Ellenberg /* If it failed because of ENOMEM, retry should help. If it failed 39110f6d992SLars Ellenberg * because bio_add_page failed (probably broken lower level driver), 39210f6d992SLars Ellenberg * retry may or may not help. 39310f6d992SLars Ellenberg * If it does not, you may need to force disconnect. */ 39487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 395db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 39687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 39722cc37a9SLars Ellenberg 3983967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 39980a40e43SLars Ellenberg defer: 40045bb912bSLars Ellenberg put_ldev(mdev); 40180a40e43SLars Ellenberg return -EAGAIN; 402b411b363SPhilipp Reisner } 403b411b363SPhilipp Reisner 40499920dc5SAndreas Gruenbacher int w_resync_timer(struct drbd_work *w, int cancel) 405794abb75SPhilipp Reisner { 40600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 407794abb75SPhilipp Reisner switch (mdev->state.conn) { 408794abb75SPhilipp Reisner case C_VERIFY_S: 40900d56944SPhilipp Reisner w_make_ov_request(w, cancel); 410794abb75SPhilipp Reisner break; 411794abb75SPhilipp Reisner case C_SYNC_TARGET: 41200d56944SPhilipp Reisner w_make_resync_request(w, cancel); 413794abb75SPhilipp Reisner break; 414794abb75SPhilipp Reisner } 415794abb75SPhilipp Reisner 41699920dc5SAndreas Gruenbacher return 0; 417794abb75SPhilipp Reisner } 418794abb75SPhilipp Reisner 419b411b363SPhilipp Reisner void resync_timer_fn(unsigned long data) 420b411b363SPhilipp Reisner { 421b411b363SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 422b411b363SPhilipp Reisner 423794abb75SPhilipp Reisner if (list_empty(&mdev->resync_work.list)) 424e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->resync_work); 425b411b363SPhilipp Reisner } 426b411b363SPhilipp Reisner 427778f271dSPhilipp Reisner static void fifo_set(struct fifo_buffer *fb, int value) 428778f271dSPhilipp Reisner { 429778f271dSPhilipp Reisner int i; 430778f271dSPhilipp Reisner 431778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 432f10f2623SPhilipp Reisner fb->values[i] = value; 433778f271dSPhilipp Reisner } 434778f271dSPhilipp Reisner 435778f271dSPhilipp Reisner static int fifo_push(struct fifo_buffer *fb, int value) 436778f271dSPhilipp Reisner { 437778f271dSPhilipp Reisner int ov; 438778f271dSPhilipp Reisner 439778f271dSPhilipp Reisner ov = fb->values[fb->head_index]; 440778f271dSPhilipp Reisner fb->values[fb->head_index++] = value; 441778f271dSPhilipp Reisner 442778f271dSPhilipp Reisner if (fb->head_index >= fb->size) 443778f271dSPhilipp Reisner fb->head_index = 0; 444778f271dSPhilipp Reisner 445778f271dSPhilipp Reisner return ov; 446778f271dSPhilipp Reisner } 447778f271dSPhilipp Reisner 448778f271dSPhilipp Reisner static void fifo_add_val(struct fifo_buffer *fb, int value) 449778f271dSPhilipp Reisner { 450778f271dSPhilipp Reisner int i; 451778f271dSPhilipp Reisner 452778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 453778f271dSPhilipp Reisner fb->values[i] += value; 454778f271dSPhilipp Reisner } 455778f271dSPhilipp Reisner 4569958c857SPhilipp Reisner struct fifo_buffer *fifo_alloc(int fifo_size) 4579958c857SPhilipp Reisner { 4589958c857SPhilipp Reisner struct fifo_buffer *fb; 4599958c857SPhilipp Reisner 4609958c857SPhilipp Reisner fb = kzalloc(sizeof(struct fifo_buffer) + sizeof(int) * fifo_size, GFP_KERNEL); 4619958c857SPhilipp Reisner if (!fb) 4629958c857SPhilipp Reisner return NULL; 4639958c857SPhilipp Reisner 4649958c857SPhilipp Reisner fb->head_index = 0; 4659958c857SPhilipp Reisner fb->size = fifo_size; 4669958c857SPhilipp Reisner fb->total = 0; 4679958c857SPhilipp Reisner 4689958c857SPhilipp Reisner return fb; 4699958c857SPhilipp Reisner } 4709958c857SPhilipp Reisner 4719d77a5feSPhilipp Reisner static int drbd_rs_controller(struct drbd_conf *mdev) 472778f271dSPhilipp Reisner { 473daeda1ccSPhilipp Reisner struct disk_conf *dc; 474778f271dSPhilipp Reisner unsigned int sect_in; /* Number of sectors that came in since the last turn */ 475778f271dSPhilipp Reisner unsigned int want; /* The number of sectors we want in the proxy */ 476778f271dSPhilipp Reisner int req_sect; /* Number of sectors to request in this turn */ 477778f271dSPhilipp Reisner int correction; /* Number of sectors more we need in the proxy*/ 478778f271dSPhilipp Reisner int cps; /* correction per invocation of drbd_rs_controller() */ 479778f271dSPhilipp Reisner int steps; /* Number of time steps to plan ahead */ 480778f271dSPhilipp Reisner int curr_corr; 481778f271dSPhilipp Reisner int max_sect; 482813472ceSPhilipp Reisner struct fifo_buffer *plan; 483778f271dSPhilipp Reisner 484778f271dSPhilipp Reisner sect_in = atomic_xchg(&mdev->rs_sect_in, 0); /* Number of sectors that came in */ 485778f271dSPhilipp Reisner mdev->rs_in_flight -= sect_in; 486778f271dSPhilipp Reisner 487daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 488813472ceSPhilipp Reisner plan = rcu_dereference(mdev->rs_plan_s); 489778f271dSPhilipp Reisner 490813472ceSPhilipp Reisner steps = plan->size; /* (dc->c_plan_ahead * 10 * SLEEP_TIME) / HZ; */ 491778f271dSPhilipp Reisner 492778f271dSPhilipp Reisner if (mdev->rs_in_flight + sect_in == 0) { /* At start of resync */ 493daeda1ccSPhilipp Reisner want = ((dc->resync_rate * 2 * SLEEP_TIME) / HZ) * steps; 494778f271dSPhilipp Reisner } else { /* normal path */ 495daeda1ccSPhilipp Reisner want = dc->c_fill_target ? dc->c_fill_target : 496daeda1ccSPhilipp Reisner sect_in * dc->c_delay_target * HZ / (SLEEP_TIME * 10); 497778f271dSPhilipp Reisner } 498778f271dSPhilipp Reisner 499813472ceSPhilipp Reisner correction = want - mdev->rs_in_flight - plan->total; 500778f271dSPhilipp Reisner 501778f271dSPhilipp Reisner /* Plan ahead */ 502778f271dSPhilipp Reisner cps = correction / steps; 503813472ceSPhilipp Reisner fifo_add_val(plan, cps); 504813472ceSPhilipp Reisner plan->total += cps * steps; 505778f271dSPhilipp Reisner 506778f271dSPhilipp Reisner /* What we do in this step */ 507813472ceSPhilipp Reisner curr_corr = fifo_push(plan, 0); 508813472ceSPhilipp Reisner plan->total -= curr_corr; 509778f271dSPhilipp Reisner 510778f271dSPhilipp Reisner req_sect = sect_in + curr_corr; 511778f271dSPhilipp Reisner if (req_sect < 0) 512778f271dSPhilipp Reisner req_sect = 0; 513778f271dSPhilipp Reisner 514daeda1ccSPhilipp Reisner max_sect = (dc->c_max_rate * 2 * SLEEP_TIME) / HZ; 515778f271dSPhilipp Reisner if (req_sect > max_sect) 516778f271dSPhilipp Reisner req_sect = max_sect; 517778f271dSPhilipp Reisner 518778f271dSPhilipp Reisner /* 519778f271dSPhilipp Reisner dev_warn(DEV, "si=%u if=%d wa=%u co=%d st=%d cps=%d pl=%d cc=%d rs=%d\n", 520778f271dSPhilipp Reisner sect_in, mdev->rs_in_flight, want, correction, 521778f271dSPhilipp Reisner steps, cps, mdev->rs_planed, curr_corr, req_sect); 522778f271dSPhilipp Reisner */ 523778f271dSPhilipp Reisner 524778f271dSPhilipp Reisner return req_sect; 525778f271dSPhilipp Reisner } 526778f271dSPhilipp Reisner 5279d77a5feSPhilipp Reisner static int drbd_rs_number_requests(struct drbd_conf *mdev) 528e65f440dSLars Ellenberg { 529e65f440dSLars Ellenberg int number; 530813472ceSPhilipp Reisner 531813472ceSPhilipp Reisner rcu_read_lock(); 532813472ceSPhilipp Reisner if (rcu_dereference(mdev->rs_plan_s)->size) { 533e65f440dSLars Ellenberg number = drbd_rs_controller(mdev) >> (BM_BLOCK_SHIFT - 9); 534e65f440dSLars Ellenberg mdev->c_sync_rate = number * HZ * (BM_BLOCK_SIZE / 1024) / SLEEP_TIME; 535e65f440dSLars Ellenberg } else { 536daeda1ccSPhilipp Reisner mdev->c_sync_rate = rcu_dereference(mdev->ldev->disk_conf)->resync_rate; 537e65f440dSLars Ellenberg number = SLEEP_TIME * mdev->c_sync_rate / ((BM_BLOCK_SIZE / 1024) * HZ); 538e65f440dSLars Ellenberg } 539813472ceSPhilipp Reisner rcu_read_unlock(); 540e65f440dSLars Ellenberg 541e65f440dSLars Ellenberg /* ignore the amount of pending requests, the resync controller should 542e65f440dSLars Ellenberg * throttle down to incoming reply rate soon enough anyways. */ 543e65f440dSLars Ellenberg return number; 544e65f440dSLars Ellenberg } 545e65f440dSLars Ellenberg 54699920dc5SAndreas Gruenbacher int w_make_resync_request(struct drbd_work *w, int cancel) 547b411b363SPhilipp Reisner { 54800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 549b411b363SPhilipp Reisner unsigned long bit; 550b411b363SPhilipp Reisner sector_t sector; 551b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 5521816a2b4SLars Ellenberg int max_bio_size; 553e65f440dSLars Ellenberg int number, rollback_i, size; 554b411b363SPhilipp Reisner int align, queued, sndbuf; 5550f0601f4SLars Ellenberg int i = 0; 556b411b363SPhilipp Reisner 557b411b363SPhilipp Reisner if (unlikely(cancel)) 55899920dc5SAndreas Gruenbacher return 0; 559b411b363SPhilipp Reisner 560af85e8e8SLars Ellenberg if (mdev->rs_total == 0) { 561af85e8e8SLars Ellenberg /* empty resync? */ 562af85e8e8SLars Ellenberg drbd_resync_finished(mdev); 56399920dc5SAndreas Gruenbacher return 0; 564af85e8e8SLars Ellenberg } 565af85e8e8SLars Ellenberg 566b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 567b411b363SPhilipp Reisner /* Since we only need to access mdev->rsync a 568b411b363SPhilipp Reisner get_ldev_if_state(mdev,D_FAILED) would be sufficient, but 569b411b363SPhilipp Reisner to continue resync with a broken disk makes no sense at 570b411b363SPhilipp Reisner all */ 571b411b363SPhilipp Reisner dev_err(DEV, "Disk broke down during resync!\n"); 57299920dc5SAndreas Gruenbacher return 0; 573b411b363SPhilipp Reisner } 574b411b363SPhilipp Reisner 5750cfdd247SPhilipp Reisner max_bio_size = queue_max_hw_sectors(mdev->rq_queue) << 9; 576e65f440dSLars Ellenberg number = drbd_rs_number_requests(mdev); 577e65f440dSLars Ellenberg if (number == 0) 5780f0601f4SLars Ellenberg goto requeue; 579b411b363SPhilipp Reisner 580b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 581b411b363SPhilipp Reisner /* Stop generating RS requests, when half of the send buffer is filled */ 582e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 583e42325a5SPhilipp Reisner if (mdev->tconn->data.socket) { 584e42325a5SPhilipp Reisner queued = mdev->tconn->data.socket->sk->sk_wmem_queued; 585e42325a5SPhilipp Reisner sndbuf = mdev->tconn->data.socket->sk->sk_sndbuf; 586b411b363SPhilipp Reisner } else { 587b411b363SPhilipp Reisner queued = 1; 588b411b363SPhilipp Reisner sndbuf = 0; 589b411b363SPhilipp Reisner } 590e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 591b411b363SPhilipp Reisner if (queued > sndbuf / 2) 592b411b363SPhilipp Reisner goto requeue; 593b411b363SPhilipp Reisner 594b411b363SPhilipp Reisner next_sector: 595b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 596b411b363SPhilipp Reisner bit = drbd_bm_find_next(mdev, mdev->bm_resync_fo); 597b411b363SPhilipp Reisner 5984b0715f0SLars Ellenberg if (bit == DRBD_END_OF_BITMAP) { 599b411b363SPhilipp Reisner mdev->bm_resync_fo = drbd_bm_bits(mdev); 600b411b363SPhilipp Reisner put_ldev(mdev); 60199920dc5SAndreas Gruenbacher return 0; 602b411b363SPhilipp Reisner } 603b411b363SPhilipp Reisner 604b411b363SPhilipp Reisner sector = BM_BIT_TO_SECT(bit); 605b411b363SPhilipp Reisner 606e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 607e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 608b411b363SPhilipp Reisner mdev->bm_resync_fo = bit; 609b411b363SPhilipp Reisner goto requeue; 610b411b363SPhilipp Reisner } 611b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 612b411b363SPhilipp Reisner 613b411b363SPhilipp Reisner if (unlikely(drbd_bm_test_bit(mdev, bit) == 0)) { 614b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 615b411b363SPhilipp Reisner goto next_sector; 616b411b363SPhilipp Reisner } 617b411b363SPhilipp Reisner 6181816a2b4SLars Ellenberg #if DRBD_MAX_BIO_SIZE > BM_BLOCK_SIZE 619b411b363SPhilipp Reisner /* try to find some adjacent bits. 620b411b363SPhilipp Reisner * we stop if we have already the maximum req size. 621b411b363SPhilipp Reisner * 622b411b363SPhilipp Reisner * Additionally always align bigger requests, in order to 623b411b363SPhilipp Reisner * be prepared for all stripe sizes of software RAIDs. 624b411b363SPhilipp Reisner */ 625b411b363SPhilipp Reisner align = 1; 626d207450cSPhilipp Reisner rollback_i = i; 627b411b363SPhilipp Reisner for (;;) { 6281816a2b4SLars Ellenberg if (size + BM_BLOCK_SIZE > max_bio_size) 629b411b363SPhilipp Reisner break; 630b411b363SPhilipp Reisner 631b411b363SPhilipp Reisner /* Be always aligned */ 632b411b363SPhilipp Reisner if (sector & ((1<<(align+3))-1)) 633b411b363SPhilipp Reisner break; 634b411b363SPhilipp Reisner 635b411b363SPhilipp Reisner /* do not cross extent boundaries */ 636b411b363SPhilipp Reisner if (((bit+1) & BM_BLOCKS_PER_BM_EXT_MASK) == 0) 637b411b363SPhilipp Reisner break; 638b411b363SPhilipp Reisner /* now, is it actually dirty, after all? 639b411b363SPhilipp Reisner * caution, drbd_bm_test_bit is tri-state for some 640b411b363SPhilipp Reisner * obscure reason; ( b == 0 ) would get the out-of-band 641b411b363SPhilipp Reisner * only accidentally right because of the "oddly sized" 642b411b363SPhilipp Reisner * adjustment below */ 643b411b363SPhilipp Reisner if (drbd_bm_test_bit(mdev, bit+1) != 1) 644b411b363SPhilipp Reisner break; 645b411b363SPhilipp Reisner bit++; 646b411b363SPhilipp Reisner size += BM_BLOCK_SIZE; 647b411b363SPhilipp Reisner if ((BM_BLOCK_SIZE << align) <= size) 648b411b363SPhilipp Reisner align++; 649b411b363SPhilipp Reisner i++; 650b411b363SPhilipp Reisner } 651b411b363SPhilipp Reisner /* if we merged some, 652b411b363SPhilipp Reisner * reset the offset to start the next drbd_bm_find_next from */ 653b411b363SPhilipp Reisner if (size > BM_BLOCK_SIZE) 654b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 655b411b363SPhilipp Reisner #endif 656b411b363SPhilipp Reisner 657b411b363SPhilipp Reisner /* adjust very last sectors, in case we are oddly sized */ 658b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 659b411b363SPhilipp Reisner size = (capacity-sector)<<9; 660f399002eSLars Ellenberg if (mdev->tconn->agreed_pro_version >= 89 && mdev->tconn->csums_tfm) { 661b411b363SPhilipp Reisner switch (read_for_csum(mdev, sector, size)) { 66280a40e43SLars Ellenberg case -EIO: /* Disk failure */ 663b411b363SPhilipp Reisner put_ldev(mdev); 66499920dc5SAndreas Gruenbacher return -EIO; 66580a40e43SLars Ellenberg case -EAGAIN: /* allocation failed, or ldev busy */ 666b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 667b411b363SPhilipp Reisner mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 668d207450cSPhilipp Reisner i = rollback_i; 669b411b363SPhilipp Reisner goto requeue; 67080a40e43SLars Ellenberg case 0: 67180a40e43SLars Ellenberg /* everything ok */ 67280a40e43SLars Ellenberg break; 67380a40e43SLars Ellenberg default: 67480a40e43SLars Ellenberg BUG(); 675b411b363SPhilipp Reisner } 676b411b363SPhilipp Reisner } else { 67799920dc5SAndreas Gruenbacher int err; 67899920dc5SAndreas Gruenbacher 679b411b363SPhilipp Reisner inc_rs_pending(mdev); 68099920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_RS_DATA_REQUEST, 68199920dc5SAndreas Gruenbacher sector, size, ID_SYNCER); 68299920dc5SAndreas Gruenbacher if (err) { 683b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest() failed, aborting...\n"); 684b411b363SPhilipp Reisner dec_rs_pending(mdev); 685b411b363SPhilipp Reisner put_ldev(mdev); 68699920dc5SAndreas Gruenbacher return err; 687b411b363SPhilipp Reisner } 688b411b363SPhilipp Reisner } 689b411b363SPhilipp Reisner } 690b411b363SPhilipp Reisner 691b411b363SPhilipp Reisner if (mdev->bm_resync_fo >= drbd_bm_bits(mdev)) { 692b411b363SPhilipp Reisner /* last syncer _request_ was sent, 693b411b363SPhilipp Reisner * but the P_RS_DATA_REPLY not yet received. sync will end (and 694b411b363SPhilipp Reisner * next sync group will resume), as soon as we receive the last 695b411b363SPhilipp Reisner * resync data block, and the last bit is cleared. 696b411b363SPhilipp Reisner * until then resync "work" is "inactive" ... 697b411b363SPhilipp Reisner */ 698b411b363SPhilipp Reisner put_ldev(mdev); 69999920dc5SAndreas Gruenbacher return 0; 700b411b363SPhilipp Reisner } 701b411b363SPhilipp Reisner 702b411b363SPhilipp Reisner requeue: 703778f271dSPhilipp Reisner mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 704b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 705b411b363SPhilipp Reisner put_ldev(mdev); 70699920dc5SAndreas Gruenbacher return 0; 707b411b363SPhilipp Reisner } 708b411b363SPhilipp Reisner 70900d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel) 710b411b363SPhilipp Reisner { 71100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 712b411b363SPhilipp Reisner int number, i, size; 713b411b363SPhilipp Reisner sector_t sector; 714b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 715b411b363SPhilipp Reisner 716b411b363SPhilipp Reisner if (unlikely(cancel)) 717b411b363SPhilipp Reisner return 1; 718b411b363SPhilipp Reisner 7192649f080SLars Ellenberg number = drbd_rs_number_requests(mdev); 720b411b363SPhilipp Reisner 721b411b363SPhilipp Reisner sector = mdev->ov_position; 722b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 723b411b363SPhilipp Reisner if (sector >= capacity) { 724b411b363SPhilipp Reisner return 1; 725b411b363SPhilipp Reisner } 726b411b363SPhilipp Reisner 727b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 728b411b363SPhilipp Reisner 729e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 730e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 731b411b363SPhilipp Reisner mdev->ov_position = sector; 732b411b363SPhilipp Reisner goto requeue; 733b411b363SPhilipp Reisner } 734b411b363SPhilipp Reisner 735b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 736b411b363SPhilipp Reisner size = (capacity-sector)<<9; 737b411b363SPhilipp Reisner 738b411b363SPhilipp Reisner inc_rs_pending(mdev); 7395b9f499cSAndreas Gruenbacher if (drbd_send_ov_request(mdev, sector, size)) { 740b411b363SPhilipp Reisner dec_rs_pending(mdev); 741b411b363SPhilipp Reisner return 0; 742b411b363SPhilipp Reisner } 743b411b363SPhilipp Reisner sector += BM_SECT_PER_BIT; 744b411b363SPhilipp Reisner } 745b411b363SPhilipp Reisner mdev->ov_position = sector; 746b411b363SPhilipp Reisner 747b411b363SPhilipp Reisner requeue: 7482649f080SLars Ellenberg mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 749b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 750b411b363SPhilipp Reisner return 1; 751b411b363SPhilipp Reisner } 752b411b363SPhilipp Reisner 75399920dc5SAndreas Gruenbacher int w_ov_finished(struct drbd_work *w, int cancel) 754b411b363SPhilipp Reisner { 75500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 756b411b363SPhilipp Reisner kfree(w); 7578f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 758b411b363SPhilipp Reisner drbd_resync_finished(mdev); 759b411b363SPhilipp Reisner 76099920dc5SAndreas Gruenbacher return 0; 761b411b363SPhilipp Reisner } 762b411b363SPhilipp Reisner 76399920dc5SAndreas Gruenbacher static int w_resync_finished(struct drbd_work *w, int cancel) 764b411b363SPhilipp Reisner { 76500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 766b411b363SPhilipp Reisner kfree(w); 767b411b363SPhilipp Reisner 768b411b363SPhilipp Reisner drbd_resync_finished(mdev); 769b411b363SPhilipp Reisner 77099920dc5SAndreas Gruenbacher return 0; 771b411b363SPhilipp Reisner } 772b411b363SPhilipp Reisner 773af85e8e8SLars Ellenberg static void ping_peer(struct drbd_conf *mdev) 774af85e8e8SLars Ellenberg { 7752a67d8b9SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 7762a67d8b9SPhilipp Reisner 7772a67d8b9SPhilipp Reisner clear_bit(GOT_PING_ACK, &tconn->flags); 7782a67d8b9SPhilipp Reisner request_ping(tconn); 7792a67d8b9SPhilipp Reisner wait_event(tconn->ping_wait, 7802a67d8b9SPhilipp Reisner test_bit(GOT_PING_ACK, &tconn->flags) || mdev->state.conn < C_CONNECTED); 781af85e8e8SLars Ellenberg } 782af85e8e8SLars Ellenberg 783b411b363SPhilipp Reisner int drbd_resync_finished(struct drbd_conf *mdev) 784b411b363SPhilipp Reisner { 785b411b363SPhilipp Reisner unsigned long db, dt, dbdt; 786b411b363SPhilipp Reisner unsigned long n_oos; 787b411b363SPhilipp Reisner union drbd_state os, ns; 788b411b363SPhilipp Reisner struct drbd_work *w; 789b411b363SPhilipp Reisner char *khelper_cmd = NULL; 79026525618SLars Ellenberg int verify_done = 0; 791b411b363SPhilipp Reisner 792b411b363SPhilipp Reisner /* Remove all elements from the resync LRU. Since future actions 793b411b363SPhilipp Reisner * might set bits in the (main) bitmap, then the entries in the 794b411b363SPhilipp Reisner * resync LRU would be wrong. */ 795b411b363SPhilipp Reisner if (drbd_rs_del_all(mdev)) { 796b411b363SPhilipp Reisner /* In case this is not possible now, most probably because 797b411b363SPhilipp Reisner * there are P_RS_DATA_REPLY Packets lingering on the worker's 798b411b363SPhilipp Reisner * queue (or even the read operations for those packets 799b411b363SPhilipp Reisner * is not finished by now). Retry in 100ms. */ 800b411b363SPhilipp Reisner 80120ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 802b411b363SPhilipp Reisner w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC); 803b411b363SPhilipp Reisner if (w) { 804b411b363SPhilipp Reisner w->cb = w_resync_finished; 8059b743da9SPhilipp Reisner w->mdev = mdev; 806e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, w); 807b411b363SPhilipp Reisner return 1; 808b411b363SPhilipp Reisner } 809b411b363SPhilipp Reisner dev_err(DEV, "Warn failed to drbd_rs_del_all() and to kmalloc(w).\n"); 810b411b363SPhilipp Reisner } 811b411b363SPhilipp Reisner 812b411b363SPhilipp Reisner dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ; 813b411b363SPhilipp Reisner if (dt <= 0) 814b411b363SPhilipp Reisner dt = 1; 815b411b363SPhilipp Reisner db = mdev->rs_total; 816b411b363SPhilipp Reisner dbdt = Bit2KB(db/dt); 817b411b363SPhilipp Reisner mdev->rs_paused /= HZ; 818b411b363SPhilipp Reisner 819b411b363SPhilipp Reisner if (!get_ldev(mdev)) 820b411b363SPhilipp Reisner goto out; 821b411b363SPhilipp Reisner 822af85e8e8SLars Ellenberg ping_peer(mdev); 823af85e8e8SLars Ellenberg 82487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 82578bae59bSPhilipp Reisner os = drbd_read_state(mdev); 826b411b363SPhilipp Reisner 82726525618SLars Ellenberg verify_done = (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T); 82826525618SLars Ellenberg 829b411b363SPhilipp Reisner /* This protects us against multiple calls (that can happen in the presence 830b411b363SPhilipp Reisner of application IO), and against connectivity loss just before we arrive here. */ 831b411b363SPhilipp Reisner if (os.conn <= C_CONNECTED) 832b411b363SPhilipp Reisner goto out_unlock; 833b411b363SPhilipp Reisner 834b411b363SPhilipp Reisner ns = os; 835b411b363SPhilipp Reisner ns.conn = C_CONNECTED; 836b411b363SPhilipp Reisner 837b411b363SPhilipp Reisner dev_info(DEV, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n", 83826525618SLars Ellenberg verify_done ? "Online verify " : "Resync", 839b411b363SPhilipp Reisner dt + mdev->rs_paused, mdev->rs_paused, dbdt); 840b411b363SPhilipp Reisner 841b411b363SPhilipp Reisner n_oos = drbd_bm_total_weight(mdev); 842b411b363SPhilipp Reisner 843b411b363SPhilipp Reisner if (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) { 844b411b363SPhilipp Reisner if (n_oos) { 845b411b363SPhilipp Reisner dev_alert(DEV, "Online verify found %lu %dk block out of sync!\n", 846b411b363SPhilipp Reisner n_oos, Bit2KB(1)); 847b411b363SPhilipp Reisner khelper_cmd = "out-of-sync"; 848b411b363SPhilipp Reisner } 849b411b363SPhilipp Reisner } else { 850b411b363SPhilipp Reisner D_ASSERT((n_oos - mdev->rs_failed) == 0); 851b411b363SPhilipp Reisner 852b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) 853b411b363SPhilipp Reisner khelper_cmd = "after-resync-target"; 854b411b363SPhilipp Reisner 855f399002eSLars Ellenberg if (mdev->tconn->csums_tfm && mdev->rs_total) { 856b411b363SPhilipp Reisner const unsigned long s = mdev->rs_same_csum; 857b411b363SPhilipp Reisner const unsigned long t = mdev->rs_total; 858b411b363SPhilipp Reisner const int ratio = 859b411b363SPhilipp Reisner (t == 0) ? 0 : 860b411b363SPhilipp Reisner (t < 100000) ? ((s*100)/t) : (s/(t/100)); 861b411b363SPhilipp Reisner dev_info(DEV, "%u %% had equal checksums, eliminated: %luK; " 862b411b363SPhilipp Reisner "transferred %luK total %luK\n", 863b411b363SPhilipp Reisner ratio, 864b411b363SPhilipp Reisner Bit2KB(mdev->rs_same_csum), 865b411b363SPhilipp Reisner Bit2KB(mdev->rs_total - mdev->rs_same_csum), 866b411b363SPhilipp Reisner Bit2KB(mdev->rs_total)); 867b411b363SPhilipp Reisner } 868b411b363SPhilipp Reisner } 869b411b363SPhilipp Reisner 870b411b363SPhilipp Reisner if (mdev->rs_failed) { 871b411b363SPhilipp Reisner dev_info(DEV, " %lu failed blocks\n", mdev->rs_failed); 872b411b363SPhilipp Reisner 873b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 874b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 875b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 876b411b363SPhilipp Reisner } else { 877b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 878b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 879b411b363SPhilipp Reisner } 880b411b363SPhilipp Reisner } else { 881b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 882b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 883b411b363SPhilipp Reisner 884b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 885b411b363SPhilipp Reisner if (mdev->p_uuid) { 886b411b363SPhilipp Reisner int i; 887b411b363SPhilipp Reisner for (i = UI_BITMAP ; i <= UI_HISTORY_END ; i++) 888b411b363SPhilipp Reisner _drbd_uuid_set(mdev, i, mdev->p_uuid[i]); 889b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_CURRENT]); 890b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, mdev->p_uuid[UI_CURRENT]); 891b411b363SPhilipp Reisner } else { 892b411b363SPhilipp Reisner dev_err(DEV, "mdev->p_uuid is NULL! BUG\n"); 893b411b363SPhilipp Reisner } 894b411b363SPhilipp Reisner } 895b411b363SPhilipp Reisner 89662b0da3aSLars Ellenberg if (!(os.conn == C_VERIFY_S || os.conn == C_VERIFY_T)) { 89762b0da3aSLars Ellenberg /* for verify runs, we don't update uuids here, 89862b0da3aSLars Ellenberg * so there would be nothing to report. */ 899b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 90062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated UUIDs"); 901b411b363SPhilipp Reisner if (mdev->p_uuid) { 902b411b363SPhilipp Reisner /* Now the two UUID sets are equal, update what we 903b411b363SPhilipp Reisner * know of the peer. */ 904b411b363SPhilipp Reisner int i; 905b411b363SPhilipp Reisner for (i = UI_CURRENT ; i <= UI_HISTORY_END ; i++) 906b411b363SPhilipp Reisner mdev->p_uuid[i] = mdev->ldev->md.uuid[i]; 907b411b363SPhilipp Reisner } 908b411b363SPhilipp Reisner } 90962b0da3aSLars Ellenberg } 910b411b363SPhilipp Reisner 911b411b363SPhilipp Reisner _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 912b411b363SPhilipp Reisner out_unlock: 91387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 914b411b363SPhilipp Reisner put_ldev(mdev); 915b411b363SPhilipp Reisner out: 916b411b363SPhilipp Reisner mdev->rs_total = 0; 917b411b363SPhilipp Reisner mdev->rs_failed = 0; 918b411b363SPhilipp Reisner mdev->rs_paused = 0; 91926525618SLars Ellenberg if (verify_done) 920b411b363SPhilipp Reisner mdev->ov_start_sector = 0; 921b411b363SPhilipp Reisner 92213d42685SLars Ellenberg drbd_md_sync(mdev); 92313d42685SLars Ellenberg 924b411b363SPhilipp Reisner if (khelper_cmd) 925b411b363SPhilipp Reisner drbd_khelper(mdev, khelper_cmd); 926b411b363SPhilipp Reisner 927b411b363SPhilipp Reisner return 1; 928b411b363SPhilipp Reisner } 929b411b363SPhilipp Reisner 930b411b363SPhilipp Reisner /* helper */ 931db830c46SAndreas Gruenbacher static void move_to_net_ee_or_free(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 932b411b363SPhilipp Reisner { 933045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) { 934b411b363SPhilipp Reisner /* This might happen if sendpage() has not finished */ 935db830c46SAndreas Gruenbacher int i = (peer_req->i.size + PAGE_SIZE -1) >> PAGE_SHIFT; 936435f0740SLars Ellenberg atomic_add(i, &mdev->pp_in_use_by_net); 937435f0740SLars Ellenberg atomic_sub(i, &mdev->pp_in_use); 93887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 939db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->net_ee); 94087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 941435f0740SLars Ellenberg wake_up(&drbd_pp_wait); 942b411b363SPhilipp Reisner } else 9433967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 944b411b363SPhilipp Reisner } 945b411b363SPhilipp Reisner 946b411b363SPhilipp Reisner /** 947b411b363SPhilipp Reisner * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 948b411b363SPhilipp Reisner * @mdev: DRBD device. 949b411b363SPhilipp Reisner * @w: work object. 950b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 951b411b363SPhilipp Reisner */ 95299920dc5SAndreas Gruenbacher int w_e_end_data_req(struct drbd_work *w, int cancel) 953b411b363SPhilipp Reisner { 954db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 95500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 95699920dc5SAndreas Gruenbacher int err; 957b411b363SPhilipp Reisner 958b411b363SPhilipp Reisner if (unlikely(cancel)) { 9593967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 960b411b363SPhilipp Reisner dec_unacked(mdev); 96199920dc5SAndreas Gruenbacher return 0; 962b411b363SPhilipp Reisner } 963b411b363SPhilipp Reisner 964db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 96599920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_DATA_REPLY, peer_req); 966b411b363SPhilipp Reisner } else { 967b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 968b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. sector=%llus.\n", 969db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 970b411b363SPhilipp Reisner 97199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_DREPLY, peer_req); 972b411b363SPhilipp Reisner } 973b411b363SPhilipp Reisner 974b411b363SPhilipp Reisner dec_unacked(mdev); 975b411b363SPhilipp Reisner 976db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 977b411b363SPhilipp Reisner 97899920dc5SAndreas Gruenbacher if (unlikely(err)) 979b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 98099920dc5SAndreas Gruenbacher return err; 981b411b363SPhilipp Reisner } 982b411b363SPhilipp Reisner 983b411b363SPhilipp Reisner /** 984a209b4aeSAndreas Gruenbacher * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUEST 985b411b363SPhilipp Reisner * @mdev: DRBD device. 986b411b363SPhilipp Reisner * @w: work object. 987b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 988b411b363SPhilipp Reisner */ 98999920dc5SAndreas Gruenbacher int w_e_end_rsdata_req(struct drbd_work *w, int cancel) 990b411b363SPhilipp Reisner { 991db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 99200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 99399920dc5SAndreas Gruenbacher int err; 994b411b363SPhilipp Reisner 995b411b363SPhilipp Reisner if (unlikely(cancel)) { 9963967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 997b411b363SPhilipp Reisner dec_unacked(mdev); 99899920dc5SAndreas Gruenbacher return 0; 999b411b363SPhilipp Reisner } 1000b411b363SPhilipp Reisner 1001b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 1002db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 1003b411b363SPhilipp Reisner put_ldev(mdev); 1004b411b363SPhilipp Reisner } 1005b411b363SPhilipp Reisner 1006d612d309SPhilipp Reisner if (mdev->state.conn == C_AHEAD) { 100799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_CANCEL, peer_req); 1008db830c46SAndreas Gruenbacher } else if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1009b411b363SPhilipp Reisner if (likely(mdev->state.pdsk >= D_INCONSISTENT)) { 1010b411b363SPhilipp Reisner inc_rs_pending(mdev); 101199920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 1012b411b363SPhilipp Reisner } else { 1013b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1014b411b363SPhilipp Reisner dev_err(DEV, "Not sending RSDataReply, " 1015b411b363SPhilipp Reisner "partner DISKLESS!\n"); 101699920dc5SAndreas Gruenbacher err = 0; 1017b411b363SPhilipp Reisner } 1018b411b363SPhilipp Reisner } else { 1019b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1020b411b363SPhilipp Reisner dev_err(DEV, "Sending NegRSDReply. sector %llus.\n", 1021db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 1022b411b363SPhilipp Reisner 102399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 1024b411b363SPhilipp Reisner 1025b411b363SPhilipp Reisner /* update resync data with failure */ 1026db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, peer_req->i.sector, peer_req->i.size); 1027b411b363SPhilipp Reisner } 1028b411b363SPhilipp Reisner 1029b411b363SPhilipp Reisner dec_unacked(mdev); 1030b411b363SPhilipp Reisner 1031db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 1032b411b363SPhilipp Reisner 103399920dc5SAndreas Gruenbacher if (unlikely(err)) 1034b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 103599920dc5SAndreas Gruenbacher return err; 1036b411b363SPhilipp Reisner } 1037b411b363SPhilipp Reisner 103899920dc5SAndreas Gruenbacher int w_e_end_csum_rs_req(struct drbd_work *w, int cancel) 1039b411b363SPhilipp Reisner { 1040db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 104100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1042b411b363SPhilipp Reisner struct digest_info *di; 1043b411b363SPhilipp Reisner int digest_size; 1044b411b363SPhilipp Reisner void *digest = NULL; 104599920dc5SAndreas Gruenbacher int err, eq = 0; 1046b411b363SPhilipp Reisner 1047b411b363SPhilipp Reisner if (unlikely(cancel)) { 10483967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1049b411b363SPhilipp Reisner dec_unacked(mdev); 105099920dc5SAndreas Gruenbacher return 0; 1051b411b363SPhilipp Reisner } 1052b411b363SPhilipp Reisner 10531d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1054db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 10551d53f09eSLars Ellenberg put_ldev(mdev); 10561d53f09eSLars Ellenberg } 1057b411b363SPhilipp Reisner 1058db830c46SAndreas Gruenbacher di = peer_req->digest; 1059b411b363SPhilipp Reisner 1060db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1061b411b363SPhilipp Reisner /* quick hack to try to avoid a race against reconfiguration. 1062b411b363SPhilipp Reisner * a real fix would be much more involved, 1063b411b363SPhilipp Reisner * introducing more locking mechanisms */ 1064f399002eSLars Ellenberg if (mdev->tconn->csums_tfm) { 1065f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 1066b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1067b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1068b411b363SPhilipp Reisner } 1069b411b363SPhilipp Reisner if (digest) { 1070f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 1071b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1072b411b363SPhilipp Reisner kfree(digest); 1073b411b363SPhilipp Reisner } 1074b411b363SPhilipp Reisner 1075b411b363SPhilipp Reisner if (eq) { 1076db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, peer_req->i.sector, peer_req->i.size); 1077676396d5SLars Ellenberg /* rs_same_csums unit is BM_BLOCK_SIZE */ 1078db830c46SAndreas Gruenbacher mdev->rs_same_csum += peer_req->i.size >> BM_BLOCK_SHIFT; 107999920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_IS_IN_SYNC, peer_req); 1080b411b363SPhilipp Reisner } else { 1081b411b363SPhilipp Reisner inc_rs_pending(mdev); 1082db830c46SAndreas Gruenbacher peer_req->block_id = ID_SYNCER; /* By setting block_id, digest pointer becomes invalid! */ 1083db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_HAS_DIGEST; /* This peer request no longer has a digest pointer */ 1084204bba99SPhilipp Reisner kfree(di); 108599920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 1086b411b363SPhilipp Reisner } 1087b411b363SPhilipp Reisner } else { 108899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 1089b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1090b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 1091b411b363SPhilipp Reisner } 1092b411b363SPhilipp Reisner 1093b411b363SPhilipp Reisner dec_unacked(mdev); 1094db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 1095b411b363SPhilipp Reisner 109699920dc5SAndreas Gruenbacher if (unlikely(err)) 1097b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block/ack() failed\n"); 109899920dc5SAndreas Gruenbacher return err; 1099b411b363SPhilipp Reisner } 1100b411b363SPhilipp Reisner 110199920dc5SAndreas Gruenbacher int w_e_end_ov_req(struct drbd_work *w, int cancel) 1102b411b363SPhilipp Reisner { 1103db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 110400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1105db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1106db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 1107b411b363SPhilipp Reisner int digest_size; 1108b411b363SPhilipp Reisner void *digest; 110999920dc5SAndreas Gruenbacher int err = 0; 1110b411b363SPhilipp Reisner 1111b411b363SPhilipp Reisner if (unlikely(cancel)) 1112b411b363SPhilipp Reisner goto out; 1113b411b363SPhilipp Reisner 1114f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1115b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 11168f21420eSPhilipp Reisner if (!digest) { 111799920dc5SAndreas Gruenbacher err = 1; /* terminate the connection in case the allocation failed */ 11188f21420eSPhilipp Reisner goto out; 11198f21420eSPhilipp Reisner } 11208f21420eSPhilipp Reisner 1121db830c46SAndreas Gruenbacher if (likely(!(peer_req->flags & EE_WAS_ERROR))) 1122f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 11238f21420eSPhilipp Reisner else 11248f21420eSPhilipp Reisner memset(digest, 0, digest_size); 11258f21420eSPhilipp Reisner 112653ea4331SLars Ellenberg /* Free e and pages before send. 112753ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 112853ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 112953ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 1130c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 11313967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1132db830c46SAndreas Gruenbacher peer_req = NULL; 1133b411b363SPhilipp Reisner inc_rs_pending(mdev); 113499920dc5SAndreas Gruenbacher err = drbd_send_drequest_csum(mdev, sector, size, digest, digest_size, P_OV_REPLY); 113599920dc5SAndreas Gruenbacher if (err) 1136b411b363SPhilipp Reisner dec_rs_pending(mdev); 1137b411b363SPhilipp Reisner kfree(digest); 1138b411b363SPhilipp Reisner 1139b411b363SPhilipp Reisner out: 1140db830c46SAndreas Gruenbacher if (peer_req) 11413967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1142b411b363SPhilipp Reisner dec_unacked(mdev); 114399920dc5SAndreas Gruenbacher return err; 1144b411b363SPhilipp Reisner } 1145b411b363SPhilipp Reisner 11468f7bed77SAndreas Gruenbacher void drbd_ov_out_of_sync_found(struct drbd_conf *mdev, sector_t sector, int size) 1147b411b363SPhilipp Reisner { 1148b411b363SPhilipp Reisner if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) { 1149b411b363SPhilipp Reisner mdev->ov_last_oos_size += size>>9; 1150b411b363SPhilipp Reisner } else { 1151b411b363SPhilipp Reisner mdev->ov_last_oos_start = sector; 1152b411b363SPhilipp Reisner mdev->ov_last_oos_size = size>>9; 1153b411b363SPhilipp Reisner } 1154b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 1155b411b363SPhilipp Reisner } 1156b411b363SPhilipp Reisner 115799920dc5SAndreas Gruenbacher int w_e_end_ov_reply(struct drbd_work *w, int cancel) 1158b411b363SPhilipp Reisner { 1159db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 116000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1161b411b363SPhilipp Reisner struct digest_info *di; 1162b411b363SPhilipp Reisner void *digest; 1163db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1164db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 116553ea4331SLars Ellenberg int digest_size; 116699920dc5SAndreas Gruenbacher int err, eq = 0; 1167b411b363SPhilipp Reisner 1168b411b363SPhilipp Reisner if (unlikely(cancel)) { 11693967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1170b411b363SPhilipp Reisner dec_unacked(mdev); 117199920dc5SAndreas Gruenbacher return 0; 1172b411b363SPhilipp Reisner } 1173b411b363SPhilipp Reisner 1174b411b363SPhilipp Reisner /* after "cancel", because after drbd_disconnect/drbd_rs_cancel_all 1175b411b363SPhilipp Reisner * the resync lru has been cleaned up already */ 11761d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1177db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 11781d53f09eSLars Ellenberg put_ldev(mdev); 11791d53f09eSLars Ellenberg } 1180b411b363SPhilipp Reisner 1181db830c46SAndreas Gruenbacher di = peer_req->digest; 1182b411b363SPhilipp Reisner 1183db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1184f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1185b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1186b411b363SPhilipp Reisner if (digest) { 1187f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 1188b411b363SPhilipp Reisner 1189b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1190b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1191b411b363SPhilipp Reisner kfree(digest); 1192b411b363SPhilipp Reisner } 1193b411b363SPhilipp Reisner } 1194b411b363SPhilipp Reisner 11959676c760SLars Ellenberg /* Free peer_req and pages before send. 119653ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 119753ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 119853ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 1199c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 12003967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1201b411b363SPhilipp Reisner if (!eq) 12028f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 1203b411b363SPhilipp Reisner else 12048f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1205b411b363SPhilipp Reisner 120699920dc5SAndreas Gruenbacher err = drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, 1207b411b363SPhilipp Reisner eq ? ID_IN_SYNC : ID_OUT_OF_SYNC); 1208b411b363SPhilipp Reisner 120953ea4331SLars Ellenberg dec_unacked(mdev); 1210b411b363SPhilipp Reisner 1211ea5442afSLars Ellenberg --mdev->ov_left; 1212ea5442afSLars Ellenberg 1213ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 1214ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 1215ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 1216ea5442afSLars Ellenberg 1217ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 12188f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1219b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1220b411b363SPhilipp Reisner } 1221b411b363SPhilipp Reisner 122299920dc5SAndreas Gruenbacher return err; 1223b411b363SPhilipp Reisner } 1224b411b363SPhilipp Reisner 122599920dc5SAndreas Gruenbacher int w_prev_work_done(struct drbd_work *w, int cancel) 1226b411b363SPhilipp Reisner { 1227b411b363SPhilipp Reisner struct drbd_wq_barrier *b = container_of(w, struct drbd_wq_barrier, w); 122800d56944SPhilipp Reisner 1229b411b363SPhilipp Reisner complete(&b->done); 123099920dc5SAndreas Gruenbacher return 0; 1231b411b363SPhilipp Reisner } 1232b411b363SPhilipp Reisner 123399920dc5SAndreas Gruenbacher int w_send_barrier(struct drbd_work *w, int cancel) 1234b411b363SPhilipp Reisner { 12359f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 1236b411b363SPhilipp Reisner struct drbd_tl_epoch *b = container_of(w, struct drbd_tl_epoch, w); 123700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 12389f5bdc33SAndreas Gruenbacher struct p_barrier *p; 1239b411b363SPhilipp Reisner 1240b411b363SPhilipp Reisner /* really avoid racing with tl_clear. w.cb may have been referenced 1241b411b363SPhilipp Reisner * just before it was reassigned and re-queued, so double check that. 1242b411b363SPhilipp Reisner * actually, this race was harmless, since we only try to send the 1243b411b363SPhilipp Reisner * barrier packet here, and otherwise do nothing with the object. 1244b411b363SPhilipp Reisner * but compare with the head of w_clear_epoch */ 124587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1246b411b363SPhilipp Reisner if (w->cb != w_send_barrier || mdev->state.conn < C_CONNECTED) 1247b411b363SPhilipp Reisner cancel = 1; 124887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1249b411b363SPhilipp Reisner if (cancel) 1250b411b363SPhilipp Reisner return 0; 125199920dc5SAndreas Gruenbacher 12529f5bdc33SAndreas Gruenbacher sock = &mdev->tconn->data; 12539f5bdc33SAndreas Gruenbacher p = drbd_prepare_command(mdev, sock); 12549f5bdc33SAndreas Gruenbacher if (!p) 12559f5bdc33SAndreas Gruenbacher return -EIO; 1256b411b363SPhilipp Reisner p->barrier = b->br_number; 1257b411b363SPhilipp Reisner /* inc_ap_pending was done where this was queued. 1258b411b363SPhilipp Reisner * dec_ap_pending will be done in got_BarrierAck 1259b411b363SPhilipp Reisner * or (on connection loss) in w_clear_epoch. */ 12609f5bdc33SAndreas Gruenbacher return drbd_send_command(mdev, sock, P_BARRIER, sizeof(*p), NULL, 0); 1261b411b363SPhilipp Reisner } 1262b411b363SPhilipp Reisner 126399920dc5SAndreas Gruenbacher int w_send_write_hint(struct drbd_work *w, int cancel) 1264b411b363SPhilipp Reisner { 126500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 12669f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 12679f5bdc33SAndreas Gruenbacher 1268b411b363SPhilipp Reisner if (cancel) 126999920dc5SAndreas Gruenbacher return 0; 12709f5bdc33SAndreas Gruenbacher sock = &mdev->tconn->data; 12719f5bdc33SAndreas Gruenbacher if (!drbd_prepare_command(mdev, sock)) 12729f5bdc33SAndreas Gruenbacher return -EIO; 1273e658983aSAndreas Gruenbacher return drbd_send_command(mdev, sock, P_UNPLUG_REMOTE, 0, NULL, 0); 1274b411b363SPhilipp Reisner } 1275b411b363SPhilipp Reisner 12768f7bed77SAndreas Gruenbacher int w_send_out_of_sync(struct drbd_work *w, int cancel) 127773a01a18SPhilipp Reisner { 127873a01a18SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 127900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 128099920dc5SAndreas Gruenbacher int err; 128173a01a18SPhilipp Reisner 128273a01a18SPhilipp Reisner if (unlikely(cancel)) { 12838554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 128499920dc5SAndreas Gruenbacher return 0; 128573a01a18SPhilipp Reisner } 128673a01a18SPhilipp Reisner 12878f7bed77SAndreas Gruenbacher err = drbd_send_out_of_sync(mdev, req); 12888554df1cSAndreas Gruenbacher req_mod(req, OOS_HANDED_TO_NETWORK); 128973a01a18SPhilipp Reisner 129099920dc5SAndreas Gruenbacher return err; 129173a01a18SPhilipp Reisner } 129273a01a18SPhilipp Reisner 1293b411b363SPhilipp Reisner /** 1294b411b363SPhilipp Reisner * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1295b411b363SPhilipp Reisner * @mdev: DRBD device. 1296b411b363SPhilipp Reisner * @w: work object. 1297b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1298b411b363SPhilipp Reisner */ 129999920dc5SAndreas Gruenbacher int w_send_dblock(struct drbd_work *w, int cancel) 1300b411b363SPhilipp Reisner { 1301b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 130200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 130399920dc5SAndreas Gruenbacher int err; 1304b411b363SPhilipp Reisner 1305b411b363SPhilipp Reisner if (unlikely(cancel)) { 13068554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 130799920dc5SAndreas Gruenbacher return 0; 1308b411b363SPhilipp Reisner } 1309b411b363SPhilipp Reisner 131099920dc5SAndreas Gruenbacher err = drbd_send_dblock(mdev, req); 131199920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1312b411b363SPhilipp Reisner 131399920dc5SAndreas Gruenbacher return err; 1314b411b363SPhilipp Reisner } 1315b411b363SPhilipp Reisner 1316b411b363SPhilipp Reisner /** 1317b411b363SPhilipp Reisner * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 1318b411b363SPhilipp Reisner * @mdev: DRBD device. 1319b411b363SPhilipp Reisner * @w: work object. 1320b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1321b411b363SPhilipp Reisner */ 132299920dc5SAndreas Gruenbacher int w_send_read_req(struct drbd_work *w, int cancel) 1323b411b363SPhilipp Reisner { 1324b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 132500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 132699920dc5SAndreas Gruenbacher int err; 1327b411b363SPhilipp Reisner 1328b411b363SPhilipp Reisner if (unlikely(cancel)) { 13298554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 133099920dc5SAndreas Gruenbacher return 0; 1331b411b363SPhilipp Reisner } 1332b411b363SPhilipp Reisner 133399920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_DATA_REQUEST, req->i.sector, req->i.size, 1334b411b363SPhilipp Reisner (unsigned long)req); 1335b411b363SPhilipp Reisner 133699920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1337b411b363SPhilipp Reisner 133899920dc5SAndreas Gruenbacher return err; 1339b411b363SPhilipp Reisner } 1340b411b363SPhilipp Reisner 134199920dc5SAndreas Gruenbacher int w_restart_disk_io(struct drbd_work *w, int cancel) 1342265be2d0SPhilipp Reisner { 1343265be2d0SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 134400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1345265be2d0SPhilipp Reisner 13460778286aSPhilipp Reisner if (bio_data_dir(req->master_bio) == WRITE && req->rq_state & RQ_IN_ACT_LOG) 1347181286adSLars Ellenberg drbd_al_begin_io(mdev, &req->i); 1348265be2d0SPhilipp Reisner 1349265be2d0SPhilipp Reisner drbd_req_make_private_bio(req, req->master_bio); 1350265be2d0SPhilipp Reisner req->private_bio->bi_bdev = mdev->ldev->backing_bdev; 1351265be2d0SPhilipp Reisner generic_make_request(req->private_bio); 1352265be2d0SPhilipp Reisner 135399920dc5SAndreas Gruenbacher return 0; 1354265be2d0SPhilipp Reisner } 1355265be2d0SPhilipp Reisner 1356b411b363SPhilipp Reisner static int _drbd_may_sync_now(struct drbd_conf *mdev) 1357b411b363SPhilipp Reisner { 1358b411b363SPhilipp Reisner struct drbd_conf *odev = mdev; 135995f8efd0SAndreas Gruenbacher int resync_after; 1360b411b363SPhilipp Reisner 1361b411b363SPhilipp Reisner while (1) { 1362438c8374SPhilipp Reisner if (!odev->ldev) 1363438c8374SPhilipp Reisner return 1; 1364daeda1ccSPhilipp Reisner rcu_read_lock(); 136595f8efd0SAndreas Gruenbacher resync_after = rcu_dereference(odev->ldev->disk_conf)->resync_after; 1366daeda1ccSPhilipp Reisner rcu_read_unlock(); 136795f8efd0SAndreas Gruenbacher if (resync_after == -1) 1368b411b363SPhilipp Reisner return 1; 136995f8efd0SAndreas Gruenbacher odev = minor_to_mdev(resync_after); 1370841ce241SAndreas Gruenbacher if (!expect(odev)) 1371841ce241SAndreas Gruenbacher return 1; 1372b411b363SPhilipp Reisner if ((odev->state.conn >= C_SYNC_SOURCE && 1373b411b363SPhilipp Reisner odev->state.conn <= C_PAUSED_SYNC_T) || 1374b411b363SPhilipp Reisner odev->state.aftr_isp || odev->state.peer_isp || 1375b411b363SPhilipp Reisner odev->state.user_isp) 1376b411b363SPhilipp Reisner return 0; 1377b411b363SPhilipp Reisner } 1378b411b363SPhilipp Reisner } 1379b411b363SPhilipp Reisner 1380b411b363SPhilipp Reisner /** 1381b411b363SPhilipp Reisner * _drbd_pause_after() - Pause resync on all devices that may not resync now 1382b411b363SPhilipp Reisner * @mdev: DRBD device. 1383b411b363SPhilipp Reisner * 1384b411b363SPhilipp Reisner * Called from process context only (admin command and after_state_ch). 1385b411b363SPhilipp Reisner */ 1386b411b363SPhilipp Reisner static int _drbd_pause_after(struct drbd_conf *mdev) 1387b411b363SPhilipp Reisner { 1388b411b363SPhilipp Reisner struct drbd_conf *odev; 1389b411b363SPhilipp Reisner int i, rv = 0; 1390b411b363SPhilipp Reisner 1391695d08faSPhilipp Reisner rcu_read_lock(); 139281a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1393b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1394b411b363SPhilipp Reisner continue; 1395b411b363SPhilipp Reisner if (!_drbd_may_sync_now(odev)) 1396b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 1), CS_HARD, NULL) 1397b411b363SPhilipp Reisner != SS_NOTHING_TO_DO); 1398b411b363SPhilipp Reisner } 1399695d08faSPhilipp Reisner rcu_read_unlock(); 1400b411b363SPhilipp Reisner 1401b411b363SPhilipp Reisner return rv; 1402b411b363SPhilipp Reisner } 1403b411b363SPhilipp Reisner 1404b411b363SPhilipp Reisner /** 1405b411b363SPhilipp Reisner * _drbd_resume_next() - Resume resync on all devices that may resync now 1406b411b363SPhilipp Reisner * @mdev: DRBD device. 1407b411b363SPhilipp Reisner * 1408b411b363SPhilipp Reisner * Called from process context only (admin command and worker). 1409b411b363SPhilipp Reisner */ 1410b411b363SPhilipp Reisner static int _drbd_resume_next(struct drbd_conf *mdev) 1411b411b363SPhilipp Reisner { 1412b411b363SPhilipp Reisner struct drbd_conf *odev; 1413b411b363SPhilipp Reisner int i, rv = 0; 1414b411b363SPhilipp Reisner 1415695d08faSPhilipp Reisner rcu_read_lock(); 141681a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1417b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1418b411b363SPhilipp Reisner continue; 1419b411b363SPhilipp Reisner if (odev->state.aftr_isp) { 1420b411b363SPhilipp Reisner if (_drbd_may_sync_now(odev)) 1421b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 0), 1422b411b363SPhilipp Reisner CS_HARD, NULL) 1423b411b363SPhilipp Reisner != SS_NOTHING_TO_DO) ; 1424b411b363SPhilipp Reisner } 1425b411b363SPhilipp Reisner } 1426695d08faSPhilipp Reisner rcu_read_unlock(); 1427b411b363SPhilipp Reisner return rv; 1428b411b363SPhilipp Reisner } 1429b411b363SPhilipp Reisner 1430b411b363SPhilipp Reisner void resume_next_sg(struct drbd_conf *mdev) 1431b411b363SPhilipp Reisner { 1432b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1433b411b363SPhilipp Reisner _drbd_resume_next(mdev); 1434b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1435b411b363SPhilipp Reisner } 1436b411b363SPhilipp Reisner 1437b411b363SPhilipp Reisner void suspend_other_sg(struct drbd_conf *mdev) 1438b411b363SPhilipp Reisner { 1439b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1440b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1441b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1442b411b363SPhilipp Reisner } 1443b411b363SPhilipp Reisner 1444dc97b708SPhilipp Reisner /* caller must hold global_state_lock */ 144595f8efd0SAndreas Gruenbacher enum drbd_ret_code drbd_resync_after_valid(struct drbd_conf *mdev, int o_minor) 1446b411b363SPhilipp Reisner { 1447b411b363SPhilipp Reisner struct drbd_conf *odev; 144895f8efd0SAndreas Gruenbacher int resync_after; 1449b411b363SPhilipp Reisner 1450b411b363SPhilipp Reisner if (o_minor == -1) 1451b411b363SPhilipp Reisner return NO_ERROR; 1452b411b363SPhilipp Reisner if (o_minor < -1 || minor_to_mdev(o_minor) == NULL) 145395f8efd0SAndreas Gruenbacher return ERR_RESYNC_AFTER; 1454b411b363SPhilipp Reisner 1455b411b363SPhilipp Reisner /* check for loops */ 1456b411b363SPhilipp Reisner odev = minor_to_mdev(o_minor); 1457b411b363SPhilipp Reisner while (1) { 1458b411b363SPhilipp Reisner if (odev == mdev) 145995f8efd0SAndreas Gruenbacher return ERR_RESYNC_AFTER_CYCLE; 1460b411b363SPhilipp Reisner 1461daeda1ccSPhilipp Reisner rcu_read_lock(); 146295f8efd0SAndreas Gruenbacher resync_after = rcu_dereference(odev->ldev->disk_conf)->resync_after; 1463daeda1ccSPhilipp Reisner rcu_read_unlock(); 1464b411b363SPhilipp Reisner /* dependency chain ends here, no cycles. */ 146595f8efd0SAndreas Gruenbacher if (resync_after == -1) 1466b411b363SPhilipp Reisner return NO_ERROR; 1467b411b363SPhilipp Reisner 1468b411b363SPhilipp Reisner /* follow the dependency chain */ 146995f8efd0SAndreas Gruenbacher odev = minor_to_mdev(resync_after); 1470b411b363SPhilipp Reisner } 1471b411b363SPhilipp Reisner } 1472b411b363SPhilipp Reisner 1473dc97b708SPhilipp Reisner /* caller must hold global_state_lock */ 147495f8efd0SAndreas Gruenbacher void drbd_resync_after_changed(struct drbd_conf *mdev) 1475b411b363SPhilipp Reisner { 1476b411b363SPhilipp Reisner int changes; 1477b411b363SPhilipp Reisner 1478b411b363SPhilipp Reisner do { 1479b411b363SPhilipp Reisner changes = _drbd_pause_after(mdev); 1480b411b363SPhilipp Reisner changes |= _drbd_resume_next(mdev); 1481b411b363SPhilipp Reisner } while (changes); 1482b411b363SPhilipp Reisner } 1483b411b363SPhilipp Reisner 14849bd28d3cSLars Ellenberg void drbd_rs_controller_reset(struct drbd_conf *mdev) 14859bd28d3cSLars Ellenberg { 1486813472ceSPhilipp Reisner struct fifo_buffer *plan; 1487813472ceSPhilipp Reisner 14889bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_in, 0); 14899bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_ev, 0); 14909bd28d3cSLars Ellenberg mdev->rs_in_flight = 0; 1491813472ceSPhilipp Reisner 1492813472ceSPhilipp Reisner /* Updating the RCU protected object in place is necessary since 1493813472ceSPhilipp Reisner this function gets called from atomic context. 1494813472ceSPhilipp Reisner It is valid since all other updates also lead to an completely 1495813472ceSPhilipp Reisner empty fifo */ 1496813472ceSPhilipp Reisner rcu_read_lock(); 1497813472ceSPhilipp Reisner plan = rcu_dereference(mdev->rs_plan_s); 1498813472ceSPhilipp Reisner plan->total = 0; 1499813472ceSPhilipp Reisner fifo_set(plan, 0); 1500813472ceSPhilipp Reisner rcu_read_unlock(); 15019bd28d3cSLars Ellenberg } 15029bd28d3cSLars Ellenberg 15031f04af33SPhilipp Reisner void start_resync_timer_fn(unsigned long data) 15041f04af33SPhilipp Reisner { 15051f04af33SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 15061f04af33SPhilipp Reisner 15071f04af33SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->start_resync_work); 15081f04af33SPhilipp Reisner } 15091f04af33SPhilipp Reisner 151099920dc5SAndreas Gruenbacher int w_start_resync(struct drbd_work *w, int cancel) 15111f04af33SPhilipp Reisner { 151200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 151300d56944SPhilipp Reisner 15141f04af33SPhilipp Reisner if (atomic_read(&mdev->unacked_cnt) || atomic_read(&mdev->rs_pending_cnt)) { 15151f04af33SPhilipp Reisner dev_warn(DEV, "w_start_resync later...\n"); 15161f04af33SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/10; 15171f04af33SPhilipp Reisner add_timer(&mdev->start_resync_timer); 151899920dc5SAndreas Gruenbacher return 0; 15191f04af33SPhilipp Reisner } 15201f04af33SPhilipp Reisner 15211f04af33SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 152236baf611SPhilipp Reisner clear_bit(AHEAD_TO_SYNC_SOURCE, &mdev->flags); 152399920dc5SAndreas Gruenbacher return 0; 15241f04af33SPhilipp Reisner } 15251f04af33SPhilipp Reisner 1526b411b363SPhilipp Reisner /** 1527b411b363SPhilipp Reisner * drbd_start_resync() - Start the resync process 1528b411b363SPhilipp Reisner * @mdev: DRBD device. 1529b411b363SPhilipp Reisner * @side: Either C_SYNC_SOURCE or C_SYNC_TARGET 1530b411b363SPhilipp Reisner * 1531b411b363SPhilipp Reisner * This function might bring you directly into one of the 1532b411b363SPhilipp Reisner * C_PAUSED_SYNC_* states. 1533b411b363SPhilipp Reisner */ 1534b411b363SPhilipp Reisner void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side) 1535b411b363SPhilipp Reisner { 1536b411b363SPhilipp Reisner union drbd_state ns; 1537b411b363SPhilipp Reisner int r; 1538b411b363SPhilipp Reisner 1539c4752ef1SPhilipp Reisner if (mdev->state.conn >= C_SYNC_SOURCE && mdev->state.conn < C_AHEAD) { 1540b411b363SPhilipp Reisner dev_err(DEV, "Resync already running!\n"); 1541b411b363SPhilipp Reisner return; 1542b411b363SPhilipp Reisner } 1543b411b363SPhilipp Reisner 154459817f4fSPhilipp Reisner if (mdev->state.conn < C_AHEAD) { 1545b411b363SPhilipp Reisner /* In case a previous resync run was aborted by an IO error/detach on the peer. */ 1546b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 154759817f4fSPhilipp Reisner /* This should be done when we abort the resync. We definitely do not 154859817f4fSPhilipp Reisner want to have this for connections going back and forth between 154959817f4fSPhilipp Reisner Ahead/Behind and SyncSource/SyncTarget */ 155059817f4fSPhilipp Reisner } 1551b411b363SPhilipp Reisner 1552e64a3294SPhilipp Reisner if (!test_bit(B_RS_H_DONE, &mdev->flags)) { 1553b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1554b411b363SPhilipp Reisner /* Since application IO was locked out during C_WF_BITMAP_T and 1555b411b363SPhilipp Reisner C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET 1556b411b363SPhilipp Reisner we check that we might make the data inconsistent. */ 1557b411b363SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-target"); 1558b411b363SPhilipp Reisner r = (r >> 8) & 0xff; 1559b411b363SPhilipp Reisner if (r > 0) { 1560b411b363SPhilipp Reisner dev_info(DEV, "before-resync-target handler returned %d, " 1561b411b363SPhilipp Reisner "dropping connection.\n", r); 156238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 1563b411b363SPhilipp Reisner return; 1564b411b363SPhilipp Reisner } 156509b9e797SPhilipp Reisner } else /* C_SYNC_SOURCE */ { 156609b9e797SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-source"); 156709b9e797SPhilipp Reisner r = (r >> 8) & 0xff; 156809b9e797SPhilipp Reisner if (r > 0) { 156909b9e797SPhilipp Reisner if (r == 3) { 157009b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 157109b9e797SPhilipp Reisner "ignoring. Old userland tools?", r); 157209b9e797SPhilipp Reisner } else { 157309b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 157409b9e797SPhilipp Reisner "dropping connection.\n", r); 157538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 157609b9e797SPhilipp Reisner return; 157709b9e797SPhilipp Reisner } 157809b9e797SPhilipp Reisner } 1579b411b363SPhilipp Reisner } 1580e64a3294SPhilipp Reisner } 1581b411b363SPhilipp Reisner 1582e64a3294SPhilipp Reisner if (current == mdev->tconn->worker.task) { 1583dad20554SPhilipp Reisner /* The worker should not sleep waiting for state_mutex, 1584e64a3294SPhilipp Reisner that can take long */ 15858410da8fSPhilipp Reisner if (!mutex_trylock(mdev->state_mutex)) { 1586e64a3294SPhilipp Reisner set_bit(B_RS_H_DONE, &mdev->flags); 1587e64a3294SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/5; 1588e64a3294SPhilipp Reisner add_timer(&mdev->start_resync_timer); 1589e64a3294SPhilipp Reisner return; 1590e64a3294SPhilipp Reisner } 1591e64a3294SPhilipp Reisner } else { 15928410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 1593e64a3294SPhilipp Reisner } 1594e64a3294SPhilipp Reisner clear_bit(B_RS_H_DONE, &mdev->flags); 1595b411b363SPhilipp Reisner 15960cfac5ddSPhilipp Reisner write_lock_irq(&global_state_lock); 1597b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_NEGOTIATING)) { 15980cfac5ddSPhilipp Reisner write_unlock_irq(&global_state_lock); 15998410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1600b411b363SPhilipp Reisner return; 1601b411b363SPhilipp Reisner } 1602b411b363SPhilipp Reisner 160378bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 1604b411b363SPhilipp Reisner 1605b411b363SPhilipp Reisner ns.aftr_isp = !_drbd_may_sync_now(mdev); 1606b411b363SPhilipp Reisner 1607b411b363SPhilipp Reisner ns.conn = side; 1608b411b363SPhilipp Reisner 1609b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) 1610b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 1611b411b363SPhilipp Reisner else /* side == C_SYNC_SOURCE */ 1612b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 1613b411b363SPhilipp Reisner 1614b411b363SPhilipp Reisner r = __drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 161578bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 1616b411b363SPhilipp Reisner 1617b411b363SPhilipp Reisner if (ns.conn < C_CONNECTED) 1618b411b363SPhilipp Reisner r = SS_UNKNOWN_ERROR; 1619b411b363SPhilipp Reisner 1620b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 16211d7734a0SLars Ellenberg unsigned long tw = drbd_bm_total_weight(mdev); 16221d7734a0SLars Ellenberg unsigned long now = jiffies; 16231d7734a0SLars Ellenberg int i; 16241d7734a0SLars Ellenberg 1625b411b363SPhilipp Reisner mdev->rs_failed = 0; 1626b411b363SPhilipp Reisner mdev->rs_paused = 0; 1627b411b363SPhilipp Reisner mdev->rs_same_csum = 0; 16280f0601f4SLars Ellenberg mdev->rs_last_events = 0; 16290f0601f4SLars Ellenberg mdev->rs_last_sect_ev = 0; 16301d7734a0SLars Ellenberg mdev->rs_total = tw; 16311d7734a0SLars Ellenberg mdev->rs_start = now; 16321d7734a0SLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 16331d7734a0SLars Ellenberg mdev->rs_mark_left[i] = tw; 16341d7734a0SLars Ellenberg mdev->rs_mark_time[i] = now; 16351d7734a0SLars Ellenberg } 1636b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1637b411b363SPhilipp Reisner } 1638b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 16395a22db89SLars Ellenberg 16406c922ed5SLars Ellenberg if (r == SS_SUCCESS) { 16416c922ed5SLars Ellenberg dev_info(DEV, "Began resync as %s (will sync %lu KB [%lu bits set]).\n", 16426c922ed5SLars Ellenberg drbd_conn_str(ns.conn), 16436c922ed5SLars Ellenberg (unsigned long) mdev->rs_total << (BM_BLOCK_SHIFT-10), 16446c922ed5SLars Ellenberg (unsigned long) mdev->rs_total); 16455a22db89SLars Ellenberg if (side == C_SYNC_TARGET) 16465a22db89SLars Ellenberg mdev->bm_resync_fo = 0; 16475a22db89SLars Ellenberg 16485a22db89SLars Ellenberg /* Since protocol 96, we must serialize drbd_gen_and_send_sync_uuid 16495a22db89SLars Ellenberg * with w_send_oos, or the sync target will get confused as to 16505a22db89SLars Ellenberg * how much bits to resync. We cannot do that always, because for an 16515a22db89SLars Ellenberg * empty resync and protocol < 95, we need to do it here, as we call 16525a22db89SLars Ellenberg * drbd_resync_finished from here in that case. 16535a22db89SLars Ellenberg * We drbd_gen_and_send_sync_uuid here for protocol < 96, 16545a22db89SLars Ellenberg * and from after_state_ch otherwise. */ 165531890f4aSPhilipp Reisner if (side == C_SYNC_SOURCE && mdev->tconn->agreed_pro_version < 96) 16565a22db89SLars Ellenberg drbd_gen_and_send_sync_uuid(mdev); 1657b411b363SPhilipp Reisner 165831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 95 && mdev->rs_total == 0) { 1659af85e8e8SLars Ellenberg /* This still has a race (about when exactly the peers 1660af85e8e8SLars Ellenberg * detect connection loss) that can lead to a full sync 1661af85e8e8SLars Ellenberg * on next handshake. In 8.3.9 we fixed this with explicit 1662af85e8e8SLars Ellenberg * resync-finished notifications, but the fix 1663af85e8e8SLars Ellenberg * introduces a protocol change. Sleeping for some 1664af85e8e8SLars Ellenberg * time longer than the ping interval + timeout on the 1665af85e8e8SLars Ellenberg * SyncSource, to give the SyncTarget the chance to 1666af85e8e8SLars Ellenberg * detect connection loss, then waiting for a ping 1667af85e8e8SLars Ellenberg * response (implicit in drbd_resync_finished) reduces 1668af85e8e8SLars Ellenberg * the race considerably, but does not solve it. */ 166944ed167dSPhilipp Reisner if (side == C_SYNC_SOURCE) { 167044ed167dSPhilipp Reisner struct net_conf *nc; 167144ed167dSPhilipp Reisner int timeo; 167244ed167dSPhilipp Reisner 167344ed167dSPhilipp Reisner rcu_read_lock(); 167444ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 167544ed167dSPhilipp Reisner timeo = nc->ping_int * HZ + nc->ping_timeo * HZ / 9; 167644ed167dSPhilipp Reisner rcu_read_unlock(); 167744ed167dSPhilipp Reisner schedule_timeout_interruptible(timeo); 167844ed167dSPhilipp Reisner } 1679b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1680b411b363SPhilipp Reisner } 1681b411b363SPhilipp Reisner 16829bd28d3cSLars Ellenberg drbd_rs_controller_reset(mdev); 1683b411b363SPhilipp Reisner /* ns.conn may already be != mdev->state.conn, 1684b411b363SPhilipp Reisner * we may have been paused in between, or become paused until 1685b411b363SPhilipp Reisner * the timer triggers. 1686b411b363SPhilipp Reisner * No matter, that is handled in resync_timer_fn() */ 1687b411b363SPhilipp Reisner if (ns.conn == C_SYNC_TARGET) 1688b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies); 1689b411b363SPhilipp Reisner 1690b411b363SPhilipp Reisner drbd_md_sync(mdev); 1691b411b363SPhilipp Reisner } 16925a22db89SLars Ellenberg put_ldev(mdev); 16938410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1694b411b363SPhilipp Reisner } 1695b411b363SPhilipp Reisner 1696b411b363SPhilipp Reisner int drbd_worker(struct drbd_thread *thi) 1697b411b363SPhilipp Reisner { 1698392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 1699b411b363SPhilipp Reisner struct drbd_work *w = NULL; 17000e29d163SPhilipp Reisner struct drbd_conf *mdev; 170144ed167dSPhilipp Reisner struct net_conf *nc; 1702b411b363SPhilipp Reisner LIST_HEAD(work_list); 1703f399002eSLars Ellenberg int vnr, intr = 0; 170444ed167dSPhilipp Reisner int cork; 1705b411b363SPhilipp Reisner 1706e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 170780822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 1708b411b363SPhilipp Reisner 170919393e10SPhilipp Reisner if (down_trylock(&tconn->data.work.s)) { 171019393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 171144ed167dSPhilipp Reisner 171244ed167dSPhilipp Reisner rcu_read_lock(); 171344ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 1714bb77d34eSAndreas Gruenbacher cork = nc ? nc->tcp_cork : 0; 171544ed167dSPhilipp Reisner rcu_read_unlock(); 171644ed167dSPhilipp Reisner 171744ed167dSPhilipp Reisner if (tconn->data.socket && cork) 171819393e10SPhilipp Reisner drbd_tcp_uncork(tconn->data.socket); 171919393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1720b411b363SPhilipp Reisner 172119393e10SPhilipp Reisner intr = down_interruptible(&tconn->data.work.s); 1722b411b363SPhilipp Reisner 172319393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 172444ed167dSPhilipp Reisner if (tconn->data.socket && cork) 172519393e10SPhilipp Reisner drbd_tcp_cork(tconn->data.socket); 172619393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1727b411b363SPhilipp Reisner } 1728b411b363SPhilipp Reisner 1729b411b363SPhilipp Reisner if (intr) { 1730b411b363SPhilipp Reisner flush_signals(current); 173119393e10SPhilipp Reisner if (get_t_state(thi) == RUNNING) { 173219393e10SPhilipp Reisner conn_warn(tconn, "Worker got an unexpected signal\n"); 1733b411b363SPhilipp Reisner continue; 173419393e10SPhilipp Reisner } 1735b411b363SPhilipp Reisner break; 1736b411b363SPhilipp Reisner } 1737b411b363SPhilipp Reisner 1738e77a0a5cSAndreas Gruenbacher if (get_t_state(thi) != RUNNING) 1739b411b363SPhilipp Reisner break; 1740b411b363SPhilipp Reisner /* With this break, we have done a down() but not consumed 1741b411b363SPhilipp Reisner the entry from the list. The cleanup code takes care of 1742b411b363SPhilipp Reisner this... */ 1743b411b363SPhilipp Reisner 1744b411b363SPhilipp Reisner w = NULL; 174519393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 174619393e10SPhilipp Reisner if (list_empty(&tconn->data.work.q)) { 1747b411b363SPhilipp Reisner /* something terribly wrong in our logic. 1748b411b363SPhilipp Reisner * we were able to down() the semaphore, 1749b411b363SPhilipp Reisner * but the list is empty... doh. 1750b411b363SPhilipp Reisner * 1751b411b363SPhilipp Reisner * what is the best thing to do now? 1752b411b363SPhilipp Reisner * try again from scratch, restarting the receiver, 1753b411b363SPhilipp Reisner * asender, whatnot? could break even more ugly, 1754b411b363SPhilipp Reisner * e.g. when we are primary, but no good local data. 1755b411b363SPhilipp Reisner * 1756b411b363SPhilipp Reisner * I'll try to get away just starting over this loop. 1757b411b363SPhilipp Reisner */ 175819393e10SPhilipp Reisner conn_warn(tconn, "Work list unexpectedly empty\n"); 175919393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1760b411b363SPhilipp Reisner continue; 1761b411b363SPhilipp Reisner } 176219393e10SPhilipp Reisner w = list_entry(tconn->data.work.q.next, struct drbd_work, list); 1763b411b363SPhilipp Reisner list_del_init(&w->list); 176419393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1765b411b363SPhilipp Reisner 176699920dc5SAndreas Gruenbacher if (w->cb(w, tconn->cstate < C_WF_REPORT_PARAMS)) { 1767b411b363SPhilipp Reisner /* dev_warn(DEV, "worker: a callback failed! \n"); */ 1768bbeb641cSPhilipp Reisner if (tconn->cstate >= C_WF_REPORT_PARAMS) 1769bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 1770b411b363SPhilipp Reisner } 1771b411b363SPhilipp Reisner } 1772b411b363SPhilipp Reisner 177319393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 177419393e10SPhilipp Reisner while (!list_empty(&tconn->data.work.q)) { 177519393e10SPhilipp Reisner list_splice_init(&tconn->data.work.q, &work_list); 177619393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1777b411b363SPhilipp Reisner 1778b411b363SPhilipp Reisner while (!list_empty(&work_list)) { 1779b411b363SPhilipp Reisner w = list_entry(work_list.next, struct drbd_work, list); 1780b411b363SPhilipp Reisner list_del_init(&w->list); 178100d56944SPhilipp Reisner w->cb(w, 1); 1782b411b363SPhilipp Reisner } 1783b411b363SPhilipp Reisner 178419393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 1785b411b363SPhilipp Reisner } 178619393e10SPhilipp Reisner sema_init(&tconn->data.work.s, 0); 1787b411b363SPhilipp Reisner /* DANGEROUS race: if someone did queue his work within the spinlock, 1788b411b363SPhilipp Reisner * but up() ed outside the spinlock, we could get an up() on the 1789b411b363SPhilipp Reisner * semaphore without corresponding list entry. 1790b411b363SPhilipp Reisner * So don't do that. 1791b411b363SPhilipp Reisner */ 179219393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1793b411b363SPhilipp Reisner 1794c141ebdaSPhilipp Reisner rcu_read_lock(); 1795f399002eSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 17960e29d163SPhilipp Reisner D_ASSERT(mdev->state.disk == D_DISKLESS && mdev->state.conn == C_STANDALONE); 1797c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 1798c141ebdaSPhilipp Reisner rcu_read_unlock(); 17990e29d163SPhilipp Reisner drbd_mdev_cleanup(mdev); 1800c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 1801c141ebdaSPhilipp Reisner rcu_read_lock(); 18020e29d163SPhilipp Reisner } 1803c141ebdaSPhilipp Reisner rcu_read_unlock(); 1804b411b363SPhilipp Reisner 1805b411b363SPhilipp Reisner return 0; 1806b411b363SPhilipp Reisner } 1807