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 60b411b363SPhilipp Reisner to evaluate the sync 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; 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner md_io = (struct drbd_md_io *)bio->bi_private; 72b411b363SPhilipp Reisner md_io->error = error; 73b411b363SPhilipp Reisner 74b411b363SPhilipp Reisner complete(&md_io->event); 75b411b363SPhilipp Reisner } 76b411b363SPhilipp Reisner 77b411b363SPhilipp Reisner /* reads on behalf of the partner, 78b411b363SPhilipp Reisner * "submitted" by the receiver 79b411b363SPhilipp Reisner */ 80db830c46SAndreas Gruenbacher void drbd_endio_read_sec_final(struct drbd_peer_request *peer_req) __releases(local) 81b411b363SPhilipp Reisner { 82b411b363SPhilipp Reisner unsigned long flags = 0; 83a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 84b411b363SPhilipp Reisner 8587eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 86db830c46SAndreas Gruenbacher mdev->read_cnt += peer_req->i.size >> 9; 87db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 88b411b363SPhilipp Reisner if (list_empty(&mdev->read_ee)) 89b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 90db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 9181e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 9287eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 93b411b363SPhilipp Reisner 94db830c46SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &peer_req->w); 95b411b363SPhilipp Reisner put_ldev(mdev); 96b411b363SPhilipp Reisner } 97b411b363SPhilipp Reisner 98b411b363SPhilipp Reisner /* writes on behalf of the partner, or resync writes, 9945bb912bSLars Ellenberg * "submitted" by the receiver, final stage. */ 100db830c46SAndreas Gruenbacher static void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(local) 101b411b363SPhilipp Reisner { 102b411b363SPhilipp Reisner unsigned long flags = 0; 103a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 104181286adSLars Ellenberg struct drbd_interval i; 105b411b363SPhilipp Reisner int do_wake; 106579b57edSAndreas Gruenbacher u64 block_id; 107b411b363SPhilipp Reisner int do_al_complete_io; 108b411b363SPhilipp Reisner 109db830c46SAndreas Gruenbacher /* after we moved peer_req to done_ee, 110b411b363SPhilipp Reisner * we may no longer access it, 111b411b363SPhilipp Reisner * it may be freed/reused already! 112b411b363SPhilipp Reisner * (as soon as we release the req_lock) */ 113181286adSLars Ellenberg i = peer_req->i; 114db830c46SAndreas Gruenbacher do_al_complete_io = peer_req->flags & EE_CALL_AL_COMPLETE_IO; 115db830c46SAndreas Gruenbacher block_id = peer_req->block_id; 116b411b363SPhilipp Reisner 11787eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 118db830c46SAndreas Gruenbacher mdev->writ_cnt += peer_req->i.size >> 9; 119db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); /* has been on active_ee or sync_ee */ 120db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 121b411b363SPhilipp Reisner 122bb3bfe96SAndreas Gruenbacher /* 1235e472264SAndreas Gruenbacher * Do not remove from the write_requests tree here: we did not send the 124bb3bfe96SAndreas Gruenbacher * Ack yet and did not wake possibly waiting conflicting requests. 125bb3bfe96SAndreas Gruenbacher * Removed from the tree from "drbd_process_done_ee" within the 126bb3bfe96SAndreas Gruenbacher * appropriate w.cb (e_end_block/e_end_resync_block) or from 127bb3bfe96SAndreas Gruenbacher * _drbd_clear_done_ee. 128bb3bfe96SAndreas Gruenbacher */ 129b411b363SPhilipp Reisner 130579b57edSAndreas Gruenbacher do_wake = list_empty(block_id == ID_SYNCER ? &mdev->sync_ee : &mdev->active_ee); 131b411b363SPhilipp Reisner 132db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 13381e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 13487eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 135b411b363SPhilipp Reisner 136579b57edSAndreas Gruenbacher if (block_id == ID_SYNCER) 137181286adSLars Ellenberg drbd_rs_complete_io(mdev, i.sector); 138b411b363SPhilipp Reisner 139b411b363SPhilipp Reisner if (do_wake) 140b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 141b411b363SPhilipp Reisner 142b411b363SPhilipp Reisner if (do_al_complete_io) 143181286adSLars Ellenberg drbd_al_complete_io(mdev, &i); 144b411b363SPhilipp Reisner 1450625ac19SPhilipp Reisner wake_asender(mdev->tconn); 146b411b363SPhilipp Reisner put_ldev(mdev); 14745bb912bSLars Ellenberg } 148b411b363SPhilipp Reisner 14945bb912bSLars Ellenberg /* writes on behalf of the partner, or resync writes, 15045bb912bSLars Ellenberg * "submitted" by the receiver. 15145bb912bSLars Ellenberg */ 152fcefa62eSAndreas Gruenbacher void drbd_peer_request_endio(struct bio *bio, int error) 15345bb912bSLars Ellenberg { 154db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = bio->bi_private; 155a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 15645bb912bSLars Ellenberg int uptodate = bio_flagged(bio, BIO_UPTODATE); 15745bb912bSLars Ellenberg int is_write = bio_data_dir(bio) == WRITE; 15845bb912bSLars Ellenberg 15907194272SLars Ellenberg if (error && __ratelimit(&drbd_ratelimit_state)) 16045bb912bSLars Ellenberg dev_warn(DEV, "%s: error=%d s=%llus\n", 16145bb912bSLars Ellenberg is_write ? "write" : "read", error, 162db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 16345bb912bSLars Ellenberg if (!error && !uptodate) { 16407194272SLars Ellenberg if (__ratelimit(&drbd_ratelimit_state)) 16545bb912bSLars Ellenberg dev_warn(DEV, "%s: setting error to -EIO s=%llus\n", 16645bb912bSLars Ellenberg is_write ? "write" : "read", 167db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 16845bb912bSLars Ellenberg /* strange behavior of some lower level drivers... 16945bb912bSLars Ellenberg * fail the request by clearing the uptodate flag, 17045bb912bSLars Ellenberg * but do not return any error?! */ 17145bb912bSLars Ellenberg error = -EIO; 17245bb912bSLars Ellenberg } 17345bb912bSLars Ellenberg 17445bb912bSLars Ellenberg if (error) 175db830c46SAndreas Gruenbacher set_bit(__EE_WAS_ERROR, &peer_req->flags); 17645bb912bSLars Ellenberg 17745bb912bSLars Ellenberg bio_put(bio); /* no need for the bio anymore */ 178db830c46SAndreas Gruenbacher if (atomic_dec_and_test(&peer_req->pending_bios)) { 17945bb912bSLars Ellenberg if (is_write) 180db830c46SAndreas Gruenbacher drbd_endio_write_sec_final(peer_req); 18145bb912bSLars Ellenberg else 182db830c46SAndreas Gruenbacher drbd_endio_read_sec_final(peer_req); 18345bb912bSLars Ellenberg } 184b411b363SPhilipp Reisner } 185b411b363SPhilipp Reisner 186b411b363SPhilipp Reisner /* read, readA or write requests on R_PRIMARY coming from drbd_make_request 187b411b363SPhilipp Reisner */ 188fcefa62eSAndreas Gruenbacher void drbd_request_endio(struct bio *bio, int error) 189b411b363SPhilipp Reisner { 190a115413dSLars Ellenberg unsigned long flags; 191b411b363SPhilipp Reisner struct drbd_request *req = bio->bi_private; 192a21e9298SPhilipp Reisner struct drbd_conf *mdev = req->w.mdev; 193a115413dSLars Ellenberg struct bio_and_error m; 194b411b363SPhilipp Reisner enum drbd_req_event what; 195b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 196b411b363SPhilipp Reisner 197b411b363SPhilipp Reisner if (!error && !uptodate) { 198b411b363SPhilipp Reisner dev_warn(DEV, "p %s: setting error to -EIO\n", 199b411b363SPhilipp Reisner bio_data_dir(bio) == WRITE ? "write" : "read"); 200b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 201b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 202b411b363SPhilipp Reisner * but do not return any error?! */ 203b411b363SPhilipp Reisner error = -EIO; 204b411b363SPhilipp Reisner } 205b411b363SPhilipp Reisner 206b411b363SPhilipp Reisner /* to avoid recursion in __req_mod */ 207b411b363SPhilipp Reisner if (unlikely(error)) { 208b411b363SPhilipp Reisner what = (bio_data_dir(bio) == WRITE) 2098554df1cSAndreas Gruenbacher ? WRITE_COMPLETED_WITH_ERROR 2105c3c7e64SLars Ellenberg : (bio_rw(bio) == READ) 2118554df1cSAndreas Gruenbacher ? READ_COMPLETED_WITH_ERROR 2128554df1cSAndreas Gruenbacher : READ_AHEAD_COMPLETED_WITH_ERROR; 213b411b363SPhilipp Reisner } else 2148554df1cSAndreas Gruenbacher what = COMPLETED_OK; 215b411b363SPhilipp Reisner 216b411b363SPhilipp Reisner bio_put(req->private_bio); 217b411b363SPhilipp Reisner req->private_bio = ERR_PTR(error); 218b411b363SPhilipp Reisner 219a115413dSLars Ellenberg /* not req_mod(), we need irqsave here! */ 22087eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 221a115413dSLars Ellenberg __req_mod(req, what, &m); 22287eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 223a115413dSLars Ellenberg 224a115413dSLars Ellenberg if (m.bio) 225a115413dSLars Ellenberg complete_master_bio(mdev, &m); 226b411b363SPhilipp Reisner } 227b411b363SPhilipp Reisner 22899920dc5SAndreas Gruenbacher int w_read_retry_remote(struct drbd_work *w, int cancel) 229b411b363SPhilipp Reisner { 230b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 23100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 232b411b363SPhilipp Reisner 233b411b363SPhilipp Reisner /* We should not detach for read io-error, 234b411b363SPhilipp Reisner * but try to WRITE the P_DATA_REPLY to the failed location, 235b411b363SPhilipp Reisner * to give the disk the chance to relocate that block */ 236b411b363SPhilipp Reisner 23787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 238d255e5ffSLars Ellenberg if (cancel || mdev->state.pdsk != D_UP_TO_DATE) { 2398554df1cSAndreas Gruenbacher _req_mod(req, READ_RETRY_REMOTE_CANCELED); 24087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 24199920dc5SAndreas Gruenbacher return 0; 242b411b363SPhilipp Reisner } 24387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 244b411b363SPhilipp Reisner 24500d56944SPhilipp Reisner return w_send_read_req(w, 0); 246b411b363SPhilipp Reisner } 247b411b363SPhilipp Reisner 248f6ffca9fSAndreas Gruenbacher void drbd_csum_ee(struct drbd_conf *mdev, struct crypto_hash *tfm, 249db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, void *digest) 25045bb912bSLars Ellenberg { 25145bb912bSLars Ellenberg struct hash_desc desc; 25245bb912bSLars Ellenberg struct scatterlist sg; 253db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 25445bb912bSLars Ellenberg struct page *tmp; 25545bb912bSLars Ellenberg unsigned len; 25645bb912bSLars Ellenberg 25745bb912bSLars Ellenberg desc.tfm = tfm; 25845bb912bSLars Ellenberg desc.flags = 0; 25945bb912bSLars Ellenberg 26045bb912bSLars Ellenberg sg_init_table(&sg, 1); 26145bb912bSLars Ellenberg crypto_hash_init(&desc); 26245bb912bSLars Ellenberg 26345bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) { 26445bb912bSLars Ellenberg /* all but the last page will be fully used */ 26545bb912bSLars Ellenberg sg_set_page(&sg, page, PAGE_SIZE, 0); 26645bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 26745bb912bSLars Ellenberg page = tmp; 26845bb912bSLars Ellenberg } 26945bb912bSLars Ellenberg /* and now the last, possibly only partially used page */ 270db830c46SAndreas Gruenbacher len = peer_req->i.size & (PAGE_SIZE - 1); 27145bb912bSLars Ellenberg sg_set_page(&sg, page, len ?: PAGE_SIZE, 0); 27245bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 27345bb912bSLars Ellenberg crypto_hash_final(&desc, digest); 27445bb912bSLars Ellenberg } 27545bb912bSLars Ellenberg 27645bb912bSLars Ellenberg void drbd_csum_bio(struct drbd_conf *mdev, struct crypto_hash *tfm, struct bio *bio, void *digest) 277b411b363SPhilipp Reisner { 278b411b363SPhilipp Reisner struct hash_desc desc; 279b411b363SPhilipp Reisner struct scatterlist sg; 280b411b363SPhilipp Reisner struct bio_vec *bvec; 281b411b363SPhilipp Reisner int i; 282b411b363SPhilipp Reisner 283b411b363SPhilipp Reisner desc.tfm = tfm; 284b411b363SPhilipp Reisner desc.flags = 0; 285b411b363SPhilipp Reisner 286b411b363SPhilipp Reisner sg_init_table(&sg, 1); 287b411b363SPhilipp Reisner crypto_hash_init(&desc); 288b411b363SPhilipp Reisner 289b411b363SPhilipp Reisner __bio_for_each_segment(bvec, bio, i, 0) { 290b411b363SPhilipp Reisner sg_set_page(&sg, bvec->bv_page, bvec->bv_len, bvec->bv_offset); 291b411b363SPhilipp Reisner crypto_hash_update(&desc, &sg, sg.length); 292b411b363SPhilipp Reisner } 293b411b363SPhilipp Reisner crypto_hash_final(&desc, digest); 294b411b363SPhilipp Reisner } 295b411b363SPhilipp Reisner 2969676c760SLars Ellenberg /* MAYBE merge common code with w_e_end_ov_req */ 29799920dc5SAndreas Gruenbacher static int w_e_send_csum(struct drbd_work *w, int cancel) 298b411b363SPhilipp Reisner { 29900d56944SPhilipp Reisner struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 30000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 301b411b363SPhilipp Reisner int digest_size; 302b411b363SPhilipp Reisner void *digest; 30399920dc5SAndreas Gruenbacher int err = 0; 304b411b363SPhilipp Reisner 30553ea4331SLars Ellenberg if (unlikely(cancel)) 30653ea4331SLars Ellenberg goto out; 307b411b363SPhilipp Reisner 3089676c760SLars Ellenberg if (unlikely((peer_req->flags & EE_WAS_ERROR) != 0)) 30953ea4331SLars Ellenberg goto out; 31053ea4331SLars Ellenberg 311f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 312b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 313b411b363SPhilipp Reisner if (digest) { 314db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 315db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 316f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 3179676c760SLars Ellenberg /* Free peer_req and pages before send. 31853ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 31953ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 32053ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 321c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 3223967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 323db830c46SAndreas Gruenbacher peer_req = NULL; 324b411b363SPhilipp Reisner inc_rs_pending(mdev); 32599920dc5SAndreas Gruenbacher err = drbd_send_drequest_csum(mdev, sector, size, 32653ea4331SLars Ellenberg digest, digest_size, 327b411b363SPhilipp Reisner P_CSUM_RS_REQUEST); 328b411b363SPhilipp Reisner kfree(digest); 329b411b363SPhilipp Reisner } else { 330b411b363SPhilipp Reisner dev_err(DEV, "kmalloc() of digest failed.\n"); 33199920dc5SAndreas Gruenbacher err = -ENOMEM; 332b411b363SPhilipp Reisner } 333b411b363SPhilipp Reisner 33453ea4331SLars Ellenberg out: 335db830c46SAndreas Gruenbacher if (peer_req) 3363967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 337b411b363SPhilipp Reisner 33899920dc5SAndreas Gruenbacher if (unlikely(err)) 339b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest(..., csum) failed\n"); 34099920dc5SAndreas Gruenbacher return err; 341b411b363SPhilipp Reisner } 342b411b363SPhilipp Reisner 343b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 344b411b363SPhilipp Reisner 345b411b363SPhilipp Reisner static int read_for_csum(struct drbd_conf *mdev, sector_t sector, int size) 346b411b363SPhilipp Reisner { 347db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 348b411b363SPhilipp Reisner 349b411b363SPhilipp Reisner if (!get_ldev(mdev)) 35080a40e43SLars Ellenberg return -EIO; 351b411b363SPhilipp Reisner 352e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector)) 3530f0601f4SLars Ellenberg goto defer; 3540f0601f4SLars Ellenberg 355b411b363SPhilipp Reisner /* GFP_TRY, because if there is no memory available right now, this may 356b411b363SPhilipp Reisner * be rescheduled for later. It is "only" background resync, after all. */ 3570db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, ID_SYNCER /* unused */, sector, 3580db55363SAndreas Gruenbacher size, GFP_TRY); 359db830c46SAndreas Gruenbacher if (!peer_req) 36080a40e43SLars Ellenberg goto defer; 361b411b363SPhilipp Reisner 362db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_send_csum; 36387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 364db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->read_ee); 36587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 366b411b363SPhilipp Reisner 3670f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 368fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, DRBD_FAULT_RS_RD) == 0) 36980a40e43SLars Ellenberg return 0; 37045bb912bSLars Ellenberg 37110f6d992SLars Ellenberg /* If it failed because of ENOMEM, retry should help. If it failed 37210f6d992SLars Ellenberg * because bio_add_page failed (probably broken lower level driver), 37310f6d992SLars Ellenberg * retry may or may not help. 37410f6d992SLars Ellenberg * If it does not, you may need to force disconnect. */ 37587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 376db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 37787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 37822cc37a9SLars Ellenberg 3793967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 38080a40e43SLars Ellenberg defer: 38145bb912bSLars Ellenberg put_ldev(mdev); 38280a40e43SLars Ellenberg return -EAGAIN; 383b411b363SPhilipp Reisner } 384b411b363SPhilipp Reisner 38599920dc5SAndreas Gruenbacher int w_resync_timer(struct drbd_work *w, int cancel) 386794abb75SPhilipp Reisner { 38700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 388794abb75SPhilipp Reisner switch (mdev->state.conn) { 389794abb75SPhilipp Reisner case C_VERIFY_S: 39000d56944SPhilipp Reisner w_make_ov_request(w, cancel); 391794abb75SPhilipp Reisner break; 392794abb75SPhilipp Reisner case C_SYNC_TARGET: 39300d56944SPhilipp Reisner w_make_resync_request(w, cancel); 394794abb75SPhilipp Reisner break; 395794abb75SPhilipp Reisner } 396794abb75SPhilipp Reisner 39799920dc5SAndreas Gruenbacher return 0; 398794abb75SPhilipp Reisner } 399794abb75SPhilipp Reisner 400b411b363SPhilipp Reisner void resync_timer_fn(unsigned long data) 401b411b363SPhilipp Reisner { 402b411b363SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 403b411b363SPhilipp Reisner 404794abb75SPhilipp Reisner if (list_empty(&mdev->resync_work.list)) 405e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->resync_work); 406b411b363SPhilipp Reisner } 407b411b363SPhilipp Reisner 408778f271dSPhilipp Reisner static void fifo_set(struct fifo_buffer *fb, int value) 409778f271dSPhilipp Reisner { 410778f271dSPhilipp Reisner int i; 411778f271dSPhilipp Reisner 412778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 413f10f2623SPhilipp Reisner fb->values[i] = value; 414778f271dSPhilipp Reisner } 415778f271dSPhilipp Reisner 416778f271dSPhilipp Reisner static int fifo_push(struct fifo_buffer *fb, int value) 417778f271dSPhilipp Reisner { 418778f271dSPhilipp Reisner int ov; 419778f271dSPhilipp Reisner 420778f271dSPhilipp Reisner ov = fb->values[fb->head_index]; 421778f271dSPhilipp Reisner fb->values[fb->head_index++] = value; 422778f271dSPhilipp Reisner 423778f271dSPhilipp Reisner if (fb->head_index >= fb->size) 424778f271dSPhilipp Reisner fb->head_index = 0; 425778f271dSPhilipp Reisner 426778f271dSPhilipp Reisner return ov; 427778f271dSPhilipp Reisner } 428778f271dSPhilipp Reisner 429778f271dSPhilipp Reisner static void fifo_add_val(struct fifo_buffer *fb, int value) 430778f271dSPhilipp Reisner { 431778f271dSPhilipp Reisner int i; 432778f271dSPhilipp Reisner 433778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 434778f271dSPhilipp Reisner fb->values[i] += value; 435778f271dSPhilipp Reisner } 436778f271dSPhilipp Reisner 4379d77a5feSPhilipp Reisner static int drbd_rs_controller(struct drbd_conf *mdev) 438778f271dSPhilipp Reisner { 439778f271dSPhilipp Reisner unsigned int sect_in; /* Number of sectors that came in since the last turn */ 440778f271dSPhilipp Reisner unsigned int want; /* The number of sectors we want in the proxy */ 441778f271dSPhilipp Reisner int req_sect; /* Number of sectors to request in this turn */ 442778f271dSPhilipp Reisner int correction; /* Number of sectors more we need in the proxy*/ 443778f271dSPhilipp Reisner int cps; /* correction per invocation of drbd_rs_controller() */ 444778f271dSPhilipp Reisner int steps; /* Number of time steps to plan ahead */ 445778f271dSPhilipp Reisner int curr_corr; 446778f271dSPhilipp Reisner int max_sect; 447778f271dSPhilipp Reisner 448778f271dSPhilipp Reisner sect_in = atomic_xchg(&mdev->rs_sect_in, 0); /* Number of sectors that came in */ 449778f271dSPhilipp Reisner mdev->rs_in_flight -= sect_in; 450778f271dSPhilipp Reisner 451778f271dSPhilipp Reisner spin_lock(&mdev->peer_seq_lock); /* get an atomic view on mdev->rs_plan_s */ 452778f271dSPhilipp Reisner 453f399002eSLars Ellenberg steps = mdev->rs_plan_s.size; /* (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; */ 454778f271dSPhilipp Reisner 455778f271dSPhilipp Reisner if (mdev->rs_in_flight + sect_in == 0) { /* At start of resync */ 456f399002eSLars Ellenberg want = ((mdev->ldev->dc.resync_rate * 2 * SLEEP_TIME) / HZ) * steps; 457778f271dSPhilipp Reisner } else { /* normal path */ 458f399002eSLars Ellenberg want = mdev->ldev->dc.c_fill_target ? mdev->ldev->dc.c_fill_target : 459f399002eSLars Ellenberg sect_in * mdev->ldev->dc.c_delay_target * HZ / (SLEEP_TIME * 10); 460778f271dSPhilipp Reisner } 461778f271dSPhilipp Reisner 462778f271dSPhilipp Reisner correction = want - mdev->rs_in_flight - mdev->rs_planed; 463778f271dSPhilipp Reisner 464778f271dSPhilipp Reisner /* Plan ahead */ 465778f271dSPhilipp Reisner cps = correction / steps; 466778f271dSPhilipp Reisner fifo_add_val(&mdev->rs_plan_s, cps); 467778f271dSPhilipp Reisner mdev->rs_planed += cps * steps; 468778f271dSPhilipp Reisner 469778f271dSPhilipp Reisner /* What we do in this step */ 470778f271dSPhilipp Reisner curr_corr = fifo_push(&mdev->rs_plan_s, 0); 471778f271dSPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 472778f271dSPhilipp Reisner mdev->rs_planed -= curr_corr; 473778f271dSPhilipp Reisner 474778f271dSPhilipp Reisner req_sect = sect_in + curr_corr; 475778f271dSPhilipp Reisner if (req_sect < 0) 476778f271dSPhilipp Reisner req_sect = 0; 477778f271dSPhilipp Reisner 478f399002eSLars Ellenberg max_sect = (mdev->ldev->dc.c_max_rate * 2 * SLEEP_TIME) / HZ; 479778f271dSPhilipp Reisner if (req_sect > max_sect) 480778f271dSPhilipp Reisner req_sect = max_sect; 481778f271dSPhilipp Reisner 482778f271dSPhilipp Reisner /* 483778f271dSPhilipp Reisner dev_warn(DEV, "si=%u if=%d wa=%u co=%d st=%d cps=%d pl=%d cc=%d rs=%d\n", 484778f271dSPhilipp Reisner sect_in, mdev->rs_in_flight, want, correction, 485778f271dSPhilipp Reisner steps, cps, mdev->rs_planed, curr_corr, req_sect); 486778f271dSPhilipp Reisner */ 487778f271dSPhilipp Reisner 488778f271dSPhilipp Reisner return req_sect; 489778f271dSPhilipp Reisner } 490778f271dSPhilipp Reisner 4919d77a5feSPhilipp Reisner static int drbd_rs_number_requests(struct drbd_conf *mdev) 492e65f440dSLars Ellenberg { 493e65f440dSLars Ellenberg int number; 494f399002eSLars Ellenberg if (mdev->rs_plan_s.size) { /* mdev->ldev->dc.c_plan_ahead */ 495e65f440dSLars Ellenberg number = drbd_rs_controller(mdev) >> (BM_BLOCK_SHIFT - 9); 496e65f440dSLars Ellenberg mdev->c_sync_rate = number * HZ * (BM_BLOCK_SIZE / 1024) / SLEEP_TIME; 497e65f440dSLars Ellenberg } else { 498f399002eSLars Ellenberg mdev->c_sync_rate = mdev->ldev->dc.resync_rate; 499e65f440dSLars Ellenberg number = SLEEP_TIME * mdev->c_sync_rate / ((BM_BLOCK_SIZE / 1024) * HZ); 500e65f440dSLars Ellenberg } 501e65f440dSLars Ellenberg 502e65f440dSLars Ellenberg /* ignore the amount of pending requests, the resync controller should 503e65f440dSLars Ellenberg * throttle down to incoming reply rate soon enough anyways. */ 504e65f440dSLars Ellenberg return number; 505e65f440dSLars Ellenberg } 506e65f440dSLars Ellenberg 50799920dc5SAndreas Gruenbacher int w_make_resync_request(struct drbd_work *w, int cancel) 508b411b363SPhilipp Reisner { 50900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 510b411b363SPhilipp Reisner unsigned long bit; 511b411b363SPhilipp Reisner sector_t sector; 512b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 5131816a2b4SLars Ellenberg int max_bio_size; 514e65f440dSLars Ellenberg int number, rollback_i, size; 515b411b363SPhilipp Reisner int align, queued, sndbuf; 5160f0601f4SLars Ellenberg int i = 0; 517b411b363SPhilipp Reisner 518b411b363SPhilipp Reisner if (unlikely(cancel)) 51999920dc5SAndreas Gruenbacher return 0; 520b411b363SPhilipp Reisner 521af85e8e8SLars Ellenberg if (mdev->rs_total == 0) { 522af85e8e8SLars Ellenberg /* empty resync? */ 523af85e8e8SLars Ellenberg drbd_resync_finished(mdev); 52499920dc5SAndreas Gruenbacher return 0; 525af85e8e8SLars Ellenberg } 526af85e8e8SLars Ellenberg 527b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 528b411b363SPhilipp Reisner /* Since we only need to access mdev->rsync a 529b411b363SPhilipp Reisner get_ldev_if_state(mdev,D_FAILED) would be sufficient, but 530b411b363SPhilipp Reisner to continue resync with a broken disk makes no sense at 531b411b363SPhilipp Reisner all */ 532b411b363SPhilipp Reisner dev_err(DEV, "Disk broke down during resync!\n"); 53399920dc5SAndreas Gruenbacher return 0; 534b411b363SPhilipp Reisner } 535b411b363SPhilipp Reisner 5360cfdd247SPhilipp Reisner max_bio_size = queue_max_hw_sectors(mdev->rq_queue) << 9; 537e65f440dSLars Ellenberg number = drbd_rs_number_requests(mdev); 538e65f440dSLars Ellenberg if (number == 0) 5390f0601f4SLars Ellenberg goto requeue; 540b411b363SPhilipp Reisner 541b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 542b411b363SPhilipp Reisner /* Stop generating RS requests, when half of the send buffer is filled */ 543e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 544e42325a5SPhilipp Reisner if (mdev->tconn->data.socket) { 545e42325a5SPhilipp Reisner queued = mdev->tconn->data.socket->sk->sk_wmem_queued; 546e42325a5SPhilipp Reisner sndbuf = mdev->tconn->data.socket->sk->sk_sndbuf; 547b411b363SPhilipp Reisner } else { 548b411b363SPhilipp Reisner queued = 1; 549b411b363SPhilipp Reisner sndbuf = 0; 550b411b363SPhilipp Reisner } 551e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 552b411b363SPhilipp Reisner if (queued > sndbuf / 2) 553b411b363SPhilipp Reisner goto requeue; 554b411b363SPhilipp Reisner 555b411b363SPhilipp Reisner next_sector: 556b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 557b411b363SPhilipp Reisner bit = drbd_bm_find_next(mdev, mdev->bm_resync_fo); 558b411b363SPhilipp Reisner 5594b0715f0SLars Ellenberg if (bit == DRBD_END_OF_BITMAP) { 560b411b363SPhilipp Reisner mdev->bm_resync_fo = drbd_bm_bits(mdev); 561b411b363SPhilipp Reisner put_ldev(mdev); 56299920dc5SAndreas Gruenbacher return 0; 563b411b363SPhilipp Reisner } 564b411b363SPhilipp Reisner 565b411b363SPhilipp Reisner sector = BM_BIT_TO_SECT(bit); 566b411b363SPhilipp Reisner 567e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 568e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 569b411b363SPhilipp Reisner mdev->bm_resync_fo = bit; 570b411b363SPhilipp Reisner goto requeue; 571b411b363SPhilipp Reisner } 572b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 573b411b363SPhilipp Reisner 574b411b363SPhilipp Reisner if (unlikely(drbd_bm_test_bit(mdev, bit) == 0)) { 575b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 576b411b363SPhilipp Reisner goto next_sector; 577b411b363SPhilipp Reisner } 578b411b363SPhilipp Reisner 5791816a2b4SLars Ellenberg #if DRBD_MAX_BIO_SIZE > BM_BLOCK_SIZE 580b411b363SPhilipp Reisner /* try to find some adjacent bits. 581b411b363SPhilipp Reisner * we stop if we have already the maximum req size. 582b411b363SPhilipp Reisner * 583b411b363SPhilipp Reisner * Additionally always align bigger requests, in order to 584b411b363SPhilipp Reisner * be prepared for all stripe sizes of software RAIDs. 585b411b363SPhilipp Reisner */ 586b411b363SPhilipp Reisner align = 1; 587d207450cSPhilipp Reisner rollback_i = i; 588b411b363SPhilipp Reisner for (;;) { 5891816a2b4SLars Ellenberg if (size + BM_BLOCK_SIZE > max_bio_size) 590b411b363SPhilipp Reisner break; 591b411b363SPhilipp Reisner 592b411b363SPhilipp Reisner /* Be always aligned */ 593b411b363SPhilipp Reisner if (sector & ((1<<(align+3))-1)) 594b411b363SPhilipp Reisner break; 595b411b363SPhilipp Reisner 596b411b363SPhilipp Reisner /* do not cross extent boundaries */ 597b411b363SPhilipp Reisner if (((bit+1) & BM_BLOCKS_PER_BM_EXT_MASK) == 0) 598b411b363SPhilipp Reisner break; 599b411b363SPhilipp Reisner /* now, is it actually dirty, after all? 600b411b363SPhilipp Reisner * caution, drbd_bm_test_bit is tri-state for some 601b411b363SPhilipp Reisner * obscure reason; ( b == 0 ) would get the out-of-band 602b411b363SPhilipp Reisner * only accidentally right because of the "oddly sized" 603b411b363SPhilipp Reisner * adjustment below */ 604b411b363SPhilipp Reisner if (drbd_bm_test_bit(mdev, bit+1) != 1) 605b411b363SPhilipp Reisner break; 606b411b363SPhilipp Reisner bit++; 607b411b363SPhilipp Reisner size += BM_BLOCK_SIZE; 608b411b363SPhilipp Reisner if ((BM_BLOCK_SIZE << align) <= size) 609b411b363SPhilipp Reisner align++; 610b411b363SPhilipp Reisner i++; 611b411b363SPhilipp Reisner } 612b411b363SPhilipp Reisner /* if we merged some, 613b411b363SPhilipp Reisner * reset the offset to start the next drbd_bm_find_next from */ 614b411b363SPhilipp Reisner if (size > BM_BLOCK_SIZE) 615b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 616b411b363SPhilipp Reisner #endif 617b411b363SPhilipp Reisner 618b411b363SPhilipp Reisner /* adjust very last sectors, in case we are oddly sized */ 619b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 620b411b363SPhilipp Reisner size = (capacity-sector)<<9; 621f399002eSLars Ellenberg if (mdev->tconn->agreed_pro_version >= 89 && mdev->tconn->csums_tfm) { 622b411b363SPhilipp Reisner switch (read_for_csum(mdev, sector, size)) { 62380a40e43SLars Ellenberg case -EIO: /* Disk failure */ 624b411b363SPhilipp Reisner put_ldev(mdev); 62599920dc5SAndreas Gruenbacher return -EIO; 62680a40e43SLars Ellenberg case -EAGAIN: /* allocation failed, or ldev busy */ 627b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 628b411b363SPhilipp Reisner mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 629d207450cSPhilipp Reisner i = rollback_i; 630b411b363SPhilipp Reisner goto requeue; 63180a40e43SLars Ellenberg case 0: 63280a40e43SLars Ellenberg /* everything ok */ 63380a40e43SLars Ellenberg break; 63480a40e43SLars Ellenberg default: 63580a40e43SLars Ellenberg BUG(); 636b411b363SPhilipp Reisner } 637b411b363SPhilipp Reisner } else { 63899920dc5SAndreas Gruenbacher int err; 63999920dc5SAndreas Gruenbacher 640b411b363SPhilipp Reisner inc_rs_pending(mdev); 64199920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_RS_DATA_REQUEST, 64299920dc5SAndreas Gruenbacher sector, size, ID_SYNCER); 64399920dc5SAndreas Gruenbacher if (err) { 644b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest() failed, aborting...\n"); 645b411b363SPhilipp Reisner dec_rs_pending(mdev); 646b411b363SPhilipp Reisner put_ldev(mdev); 64799920dc5SAndreas Gruenbacher return err; 648b411b363SPhilipp Reisner } 649b411b363SPhilipp Reisner } 650b411b363SPhilipp Reisner } 651b411b363SPhilipp Reisner 652b411b363SPhilipp Reisner if (mdev->bm_resync_fo >= drbd_bm_bits(mdev)) { 653b411b363SPhilipp Reisner /* last syncer _request_ was sent, 654b411b363SPhilipp Reisner * but the P_RS_DATA_REPLY not yet received. sync will end (and 655b411b363SPhilipp Reisner * next sync group will resume), as soon as we receive the last 656b411b363SPhilipp Reisner * resync data block, and the last bit is cleared. 657b411b363SPhilipp Reisner * until then resync "work" is "inactive" ... 658b411b363SPhilipp Reisner */ 659b411b363SPhilipp Reisner put_ldev(mdev); 66099920dc5SAndreas Gruenbacher return 0; 661b411b363SPhilipp Reisner } 662b411b363SPhilipp Reisner 663b411b363SPhilipp Reisner requeue: 664778f271dSPhilipp Reisner mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 665b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 666b411b363SPhilipp Reisner put_ldev(mdev); 66799920dc5SAndreas Gruenbacher return 0; 668b411b363SPhilipp Reisner } 669b411b363SPhilipp Reisner 67000d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel) 671b411b363SPhilipp Reisner { 67200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 673b411b363SPhilipp Reisner int number, i, size; 674b411b363SPhilipp Reisner sector_t sector; 675b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 676b411b363SPhilipp Reisner 677b411b363SPhilipp Reisner if (unlikely(cancel)) 678b411b363SPhilipp Reisner return 1; 679b411b363SPhilipp Reisner 6802649f080SLars Ellenberg number = drbd_rs_number_requests(mdev); 681b411b363SPhilipp Reisner 682b411b363SPhilipp Reisner sector = mdev->ov_position; 683b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 684b411b363SPhilipp Reisner if (sector >= capacity) { 685b411b363SPhilipp Reisner return 1; 686b411b363SPhilipp Reisner } 687b411b363SPhilipp Reisner 688b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 689b411b363SPhilipp Reisner 690e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 691e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 692b411b363SPhilipp Reisner mdev->ov_position = sector; 693b411b363SPhilipp Reisner goto requeue; 694b411b363SPhilipp Reisner } 695b411b363SPhilipp Reisner 696b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 697b411b363SPhilipp Reisner size = (capacity-sector)<<9; 698b411b363SPhilipp Reisner 699b411b363SPhilipp Reisner inc_rs_pending(mdev); 7005b9f499cSAndreas Gruenbacher if (drbd_send_ov_request(mdev, sector, size)) { 701b411b363SPhilipp Reisner dec_rs_pending(mdev); 702b411b363SPhilipp Reisner return 0; 703b411b363SPhilipp Reisner } 704b411b363SPhilipp Reisner sector += BM_SECT_PER_BIT; 705b411b363SPhilipp Reisner } 706b411b363SPhilipp Reisner mdev->ov_position = sector; 707b411b363SPhilipp Reisner 708b411b363SPhilipp Reisner requeue: 7092649f080SLars Ellenberg mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 710b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 711b411b363SPhilipp Reisner return 1; 712b411b363SPhilipp Reisner } 713b411b363SPhilipp Reisner 71499920dc5SAndreas Gruenbacher int w_ov_finished(struct drbd_work *w, int cancel) 715b411b363SPhilipp Reisner { 71600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 717b411b363SPhilipp Reisner kfree(w); 7188f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 719b411b363SPhilipp Reisner drbd_resync_finished(mdev); 720b411b363SPhilipp Reisner 72199920dc5SAndreas Gruenbacher return 0; 722b411b363SPhilipp Reisner } 723b411b363SPhilipp Reisner 72499920dc5SAndreas Gruenbacher static int w_resync_finished(struct drbd_work *w, int cancel) 725b411b363SPhilipp Reisner { 72600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 727b411b363SPhilipp Reisner kfree(w); 728b411b363SPhilipp Reisner 729b411b363SPhilipp Reisner drbd_resync_finished(mdev); 730b411b363SPhilipp Reisner 73199920dc5SAndreas Gruenbacher return 0; 732b411b363SPhilipp Reisner } 733b411b363SPhilipp Reisner 734af85e8e8SLars Ellenberg static void ping_peer(struct drbd_conf *mdev) 735af85e8e8SLars Ellenberg { 7362a67d8b9SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 7372a67d8b9SPhilipp Reisner 7382a67d8b9SPhilipp Reisner clear_bit(GOT_PING_ACK, &tconn->flags); 7392a67d8b9SPhilipp Reisner request_ping(tconn); 7402a67d8b9SPhilipp Reisner wait_event(tconn->ping_wait, 7412a67d8b9SPhilipp Reisner test_bit(GOT_PING_ACK, &tconn->flags) || mdev->state.conn < C_CONNECTED); 742af85e8e8SLars Ellenberg } 743af85e8e8SLars Ellenberg 744b411b363SPhilipp Reisner int drbd_resync_finished(struct drbd_conf *mdev) 745b411b363SPhilipp Reisner { 746b411b363SPhilipp Reisner unsigned long db, dt, dbdt; 747b411b363SPhilipp Reisner unsigned long n_oos; 748b411b363SPhilipp Reisner union drbd_state os, ns; 749b411b363SPhilipp Reisner struct drbd_work *w; 750b411b363SPhilipp Reisner char *khelper_cmd = NULL; 75126525618SLars Ellenberg int verify_done = 0; 752b411b363SPhilipp Reisner 753b411b363SPhilipp Reisner /* Remove all elements from the resync LRU. Since future actions 754b411b363SPhilipp Reisner * might set bits in the (main) bitmap, then the entries in the 755b411b363SPhilipp Reisner * resync LRU would be wrong. */ 756b411b363SPhilipp Reisner if (drbd_rs_del_all(mdev)) { 757b411b363SPhilipp Reisner /* In case this is not possible now, most probably because 758b411b363SPhilipp Reisner * there are P_RS_DATA_REPLY Packets lingering on the worker's 759b411b363SPhilipp Reisner * queue (or even the read operations for those packets 760b411b363SPhilipp Reisner * is not finished by now). Retry in 100ms. */ 761b411b363SPhilipp Reisner 76220ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 763b411b363SPhilipp Reisner w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC); 764b411b363SPhilipp Reisner if (w) { 765b411b363SPhilipp Reisner w->cb = w_resync_finished; 766e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, w); 767b411b363SPhilipp Reisner return 1; 768b411b363SPhilipp Reisner } 769b411b363SPhilipp Reisner dev_err(DEV, "Warn failed to drbd_rs_del_all() and to kmalloc(w).\n"); 770b411b363SPhilipp Reisner } 771b411b363SPhilipp Reisner 772b411b363SPhilipp Reisner dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ; 773b411b363SPhilipp Reisner if (dt <= 0) 774b411b363SPhilipp Reisner dt = 1; 775b411b363SPhilipp Reisner db = mdev->rs_total; 776b411b363SPhilipp Reisner dbdt = Bit2KB(db/dt); 777b411b363SPhilipp Reisner mdev->rs_paused /= HZ; 778b411b363SPhilipp Reisner 779b411b363SPhilipp Reisner if (!get_ldev(mdev)) 780b411b363SPhilipp Reisner goto out; 781b411b363SPhilipp Reisner 782af85e8e8SLars Ellenberg ping_peer(mdev); 783af85e8e8SLars Ellenberg 78487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 78578bae59bSPhilipp Reisner os = drbd_read_state(mdev); 786b411b363SPhilipp Reisner 78726525618SLars Ellenberg verify_done = (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T); 78826525618SLars Ellenberg 789b411b363SPhilipp Reisner /* This protects us against multiple calls (that can happen in the presence 790b411b363SPhilipp Reisner of application IO), and against connectivity loss just before we arrive here. */ 791b411b363SPhilipp Reisner if (os.conn <= C_CONNECTED) 792b411b363SPhilipp Reisner goto out_unlock; 793b411b363SPhilipp Reisner 794b411b363SPhilipp Reisner ns = os; 795b411b363SPhilipp Reisner ns.conn = C_CONNECTED; 796b411b363SPhilipp Reisner 797b411b363SPhilipp Reisner dev_info(DEV, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n", 79826525618SLars Ellenberg verify_done ? "Online verify " : "Resync", 799b411b363SPhilipp Reisner dt + mdev->rs_paused, mdev->rs_paused, dbdt); 800b411b363SPhilipp Reisner 801b411b363SPhilipp Reisner n_oos = drbd_bm_total_weight(mdev); 802b411b363SPhilipp Reisner 803b411b363SPhilipp Reisner if (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) { 804b411b363SPhilipp Reisner if (n_oos) { 805b411b363SPhilipp Reisner dev_alert(DEV, "Online verify found %lu %dk block out of sync!\n", 806b411b363SPhilipp Reisner n_oos, Bit2KB(1)); 807b411b363SPhilipp Reisner khelper_cmd = "out-of-sync"; 808b411b363SPhilipp Reisner } 809b411b363SPhilipp Reisner } else { 810b411b363SPhilipp Reisner D_ASSERT((n_oos - mdev->rs_failed) == 0); 811b411b363SPhilipp Reisner 812b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) 813b411b363SPhilipp Reisner khelper_cmd = "after-resync-target"; 814b411b363SPhilipp Reisner 815f399002eSLars Ellenberg if (mdev->tconn->csums_tfm && mdev->rs_total) { 816b411b363SPhilipp Reisner const unsigned long s = mdev->rs_same_csum; 817b411b363SPhilipp Reisner const unsigned long t = mdev->rs_total; 818b411b363SPhilipp Reisner const int ratio = 819b411b363SPhilipp Reisner (t == 0) ? 0 : 820b411b363SPhilipp Reisner (t < 100000) ? ((s*100)/t) : (s/(t/100)); 821b411b363SPhilipp Reisner dev_info(DEV, "%u %% had equal checksums, eliminated: %luK; " 822b411b363SPhilipp Reisner "transferred %luK total %luK\n", 823b411b363SPhilipp Reisner ratio, 824b411b363SPhilipp Reisner Bit2KB(mdev->rs_same_csum), 825b411b363SPhilipp Reisner Bit2KB(mdev->rs_total - mdev->rs_same_csum), 826b411b363SPhilipp Reisner Bit2KB(mdev->rs_total)); 827b411b363SPhilipp Reisner } 828b411b363SPhilipp Reisner } 829b411b363SPhilipp Reisner 830b411b363SPhilipp Reisner if (mdev->rs_failed) { 831b411b363SPhilipp Reisner dev_info(DEV, " %lu failed blocks\n", mdev->rs_failed); 832b411b363SPhilipp Reisner 833b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 834b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 835b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 836b411b363SPhilipp Reisner } else { 837b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 838b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 839b411b363SPhilipp Reisner } 840b411b363SPhilipp Reisner } else { 841b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 842b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 843b411b363SPhilipp Reisner 844b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 845b411b363SPhilipp Reisner if (mdev->p_uuid) { 846b411b363SPhilipp Reisner int i; 847b411b363SPhilipp Reisner for (i = UI_BITMAP ; i <= UI_HISTORY_END ; i++) 848b411b363SPhilipp Reisner _drbd_uuid_set(mdev, i, mdev->p_uuid[i]); 849b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_CURRENT]); 850b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, mdev->p_uuid[UI_CURRENT]); 851b411b363SPhilipp Reisner } else { 852b411b363SPhilipp Reisner dev_err(DEV, "mdev->p_uuid is NULL! BUG\n"); 853b411b363SPhilipp Reisner } 854b411b363SPhilipp Reisner } 855b411b363SPhilipp Reisner 85662b0da3aSLars Ellenberg if (!(os.conn == C_VERIFY_S || os.conn == C_VERIFY_T)) { 85762b0da3aSLars Ellenberg /* for verify runs, we don't update uuids here, 85862b0da3aSLars Ellenberg * so there would be nothing to report. */ 859b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 86062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated UUIDs"); 861b411b363SPhilipp Reisner if (mdev->p_uuid) { 862b411b363SPhilipp Reisner /* Now the two UUID sets are equal, update what we 863b411b363SPhilipp Reisner * know of the peer. */ 864b411b363SPhilipp Reisner int i; 865b411b363SPhilipp Reisner for (i = UI_CURRENT ; i <= UI_HISTORY_END ; i++) 866b411b363SPhilipp Reisner mdev->p_uuid[i] = mdev->ldev->md.uuid[i]; 867b411b363SPhilipp Reisner } 868b411b363SPhilipp Reisner } 86962b0da3aSLars Ellenberg } 870b411b363SPhilipp Reisner 871b411b363SPhilipp Reisner _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 872b411b363SPhilipp Reisner out_unlock: 87387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 874b411b363SPhilipp Reisner put_ldev(mdev); 875b411b363SPhilipp Reisner out: 876b411b363SPhilipp Reisner mdev->rs_total = 0; 877b411b363SPhilipp Reisner mdev->rs_failed = 0; 878b411b363SPhilipp Reisner mdev->rs_paused = 0; 87926525618SLars Ellenberg if (verify_done) 880b411b363SPhilipp Reisner mdev->ov_start_sector = 0; 881b411b363SPhilipp Reisner 88213d42685SLars Ellenberg drbd_md_sync(mdev); 88313d42685SLars Ellenberg 884b411b363SPhilipp Reisner if (khelper_cmd) 885b411b363SPhilipp Reisner drbd_khelper(mdev, khelper_cmd); 886b411b363SPhilipp Reisner 887b411b363SPhilipp Reisner return 1; 888b411b363SPhilipp Reisner } 889b411b363SPhilipp Reisner 890b411b363SPhilipp Reisner /* helper */ 891db830c46SAndreas Gruenbacher static void move_to_net_ee_or_free(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 892b411b363SPhilipp Reisner { 893045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) { 894b411b363SPhilipp Reisner /* This might happen if sendpage() has not finished */ 895db830c46SAndreas Gruenbacher int i = (peer_req->i.size + PAGE_SIZE -1) >> PAGE_SHIFT; 896435f0740SLars Ellenberg atomic_add(i, &mdev->pp_in_use_by_net); 897435f0740SLars Ellenberg atomic_sub(i, &mdev->pp_in_use); 89887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 899db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->net_ee); 90087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 901435f0740SLars Ellenberg wake_up(&drbd_pp_wait); 902b411b363SPhilipp Reisner } else 9033967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 904b411b363SPhilipp Reisner } 905b411b363SPhilipp Reisner 906b411b363SPhilipp Reisner /** 907b411b363SPhilipp Reisner * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 908b411b363SPhilipp Reisner * @mdev: DRBD device. 909b411b363SPhilipp Reisner * @w: work object. 910b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 911b411b363SPhilipp Reisner */ 91299920dc5SAndreas Gruenbacher int w_e_end_data_req(struct drbd_work *w, int cancel) 913b411b363SPhilipp Reisner { 914db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 91500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 91699920dc5SAndreas Gruenbacher int err; 917b411b363SPhilipp Reisner 918b411b363SPhilipp Reisner if (unlikely(cancel)) { 9193967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 920b411b363SPhilipp Reisner dec_unacked(mdev); 92199920dc5SAndreas Gruenbacher return 0; 922b411b363SPhilipp Reisner } 923b411b363SPhilipp Reisner 924db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 92599920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_DATA_REPLY, peer_req); 926b411b363SPhilipp Reisner } else { 927b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 928b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. sector=%llus.\n", 929db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 930b411b363SPhilipp Reisner 93199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_DREPLY, peer_req); 932b411b363SPhilipp Reisner } 933b411b363SPhilipp Reisner 934b411b363SPhilipp Reisner dec_unacked(mdev); 935b411b363SPhilipp Reisner 936db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 937b411b363SPhilipp Reisner 93899920dc5SAndreas Gruenbacher if (unlikely(err)) 939b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 94099920dc5SAndreas Gruenbacher return err; 941b411b363SPhilipp Reisner } 942b411b363SPhilipp Reisner 943b411b363SPhilipp Reisner /** 944b411b363SPhilipp Reisner * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUESTRS 945b411b363SPhilipp Reisner * @mdev: DRBD device. 946b411b363SPhilipp Reisner * @w: work object. 947b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 948b411b363SPhilipp Reisner */ 94999920dc5SAndreas Gruenbacher int w_e_end_rsdata_req(struct drbd_work *w, int cancel) 950b411b363SPhilipp Reisner { 951db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 95200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 95399920dc5SAndreas Gruenbacher int err; 954b411b363SPhilipp Reisner 955b411b363SPhilipp Reisner if (unlikely(cancel)) { 9563967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 957b411b363SPhilipp Reisner dec_unacked(mdev); 95899920dc5SAndreas Gruenbacher return 0; 959b411b363SPhilipp Reisner } 960b411b363SPhilipp Reisner 961b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 962db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 963b411b363SPhilipp Reisner put_ldev(mdev); 964b411b363SPhilipp Reisner } 965b411b363SPhilipp Reisner 966d612d309SPhilipp Reisner if (mdev->state.conn == C_AHEAD) { 96799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_CANCEL, peer_req); 968db830c46SAndreas Gruenbacher } else if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 969b411b363SPhilipp Reisner if (likely(mdev->state.pdsk >= D_INCONSISTENT)) { 970b411b363SPhilipp Reisner inc_rs_pending(mdev); 97199920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 972b411b363SPhilipp Reisner } else { 973b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 974b411b363SPhilipp Reisner dev_err(DEV, "Not sending RSDataReply, " 975b411b363SPhilipp Reisner "partner DISKLESS!\n"); 97699920dc5SAndreas Gruenbacher err = 0; 977b411b363SPhilipp Reisner } 978b411b363SPhilipp Reisner } else { 979b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 980b411b363SPhilipp Reisner dev_err(DEV, "Sending NegRSDReply. sector %llus.\n", 981db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 982b411b363SPhilipp Reisner 98399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 984b411b363SPhilipp Reisner 985b411b363SPhilipp Reisner /* update resync data with failure */ 986db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, peer_req->i.sector, peer_req->i.size); 987b411b363SPhilipp Reisner } 988b411b363SPhilipp Reisner 989b411b363SPhilipp Reisner dec_unacked(mdev); 990b411b363SPhilipp Reisner 991db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 992b411b363SPhilipp Reisner 99399920dc5SAndreas Gruenbacher if (unlikely(err)) 994b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 99599920dc5SAndreas Gruenbacher return err; 996b411b363SPhilipp Reisner } 997b411b363SPhilipp Reisner 99899920dc5SAndreas Gruenbacher int w_e_end_csum_rs_req(struct drbd_work *w, int cancel) 999b411b363SPhilipp Reisner { 1000db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 100100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1002b411b363SPhilipp Reisner struct digest_info *di; 1003b411b363SPhilipp Reisner int digest_size; 1004b411b363SPhilipp Reisner void *digest = NULL; 100599920dc5SAndreas Gruenbacher int err, eq = 0; 1006b411b363SPhilipp Reisner 1007b411b363SPhilipp Reisner if (unlikely(cancel)) { 10083967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1009b411b363SPhilipp Reisner dec_unacked(mdev); 101099920dc5SAndreas Gruenbacher return 0; 1011b411b363SPhilipp Reisner } 1012b411b363SPhilipp Reisner 10131d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1014db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 10151d53f09eSLars Ellenberg put_ldev(mdev); 10161d53f09eSLars Ellenberg } 1017b411b363SPhilipp Reisner 1018db830c46SAndreas Gruenbacher di = peer_req->digest; 1019b411b363SPhilipp Reisner 1020db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1021b411b363SPhilipp Reisner /* quick hack to try to avoid a race against reconfiguration. 1022b411b363SPhilipp Reisner * a real fix would be much more involved, 1023b411b363SPhilipp Reisner * introducing more locking mechanisms */ 1024f399002eSLars Ellenberg if (mdev->tconn->csums_tfm) { 1025f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 1026b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1027b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1028b411b363SPhilipp Reisner } 1029b411b363SPhilipp Reisner if (digest) { 1030f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 1031b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1032b411b363SPhilipp Reisner kfree(digest); 1033b411b363SPhilipp Reisner } 1034b411b363SPhilipp Reisner 1035b411b363SPhilipp Reisner if (eq) { 1036db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, peer_req->i.sector, peer_req->i.size); 1037676396d5SLars Ellenberg /* rs_same_csums unit is BM_BLOCK_SIZE */ 1038db830c46SAndreas Gruenbacher mdev->rs_same_csum += peer_req->i.size >> BM_BLOCK_SHIFT; 103999920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_IS_IN_SYNC, peer_req); 1040b411b363SPhilipp Reisner } else { 1041b411b363SPhilipp Reisner inc_rs_pending(mdev); 1042db830c46SAndreas Gruenbacher peer_req->block_id = ID_SYNCER; /* By setting block_id, digest pointer becomes invalid! */ 1043db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_HAS_DIGEST; /* This peer request no longer has a digest pointer */ 1044204bba99SPhilipp Reisner kfree(di); 104599920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 1046b411b363SPhilipp Reisner } 1047b411b363SPhilipp Reisner } else { 104899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 1049b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1050b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 1051b411b363SPhilipp Reisner } 1052b411b363SPhilipp Reisner 1053b411b363SPhilipp Reisner dec_unacked(mdev); 1054db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 1055b411b363SPhilipp Reisner 105699920dc5SAndreas Gruenbacher if (unlikely(err)) 1057b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block/ack() failed\n"); 105899920dc5SAndreas Gruenbacher return err; 1059b411b363SPhilipp Reisner } 1060b411b363SPhilipp Reisner 106199920dc5SAndreas Gruenbacher int w_e_end_ov_req(struct drbd_work *w, int cancel) 1062b411b363SPhilipp Reisner { 1063db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 106400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1065db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1066db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 1067b411b363SPhilipp Reisner int digest_size; 1068b411b363SPhilipp Reisner void *digest; 106999920dc5SAndreas Gruenbacher int err = 0; 1070b411b363SPhilipp Reisner 1071b411b363SPhilipp Reisner if (unlikely(cancel)) 1072b411b363SPhilipp Reisner goto out; 1073b411b363SPhilipp Reisner 1074f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1075b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 10768f21420eSPhilipp Reisner if (!digest) { 107799920dc5SAndreas Gruenbacher err = 1; /* terminate the connection in case the allocation failed */ 10788f21420eSPhilipp Reisner goto out; 10798f21420eSPhilipp Reisner } 10808f21420eSPhilipp Reisner 1081db830c46SAndreas Gruenbacher if (likely(!(peer_req->flags & EE_WAS_ERROR))) 1082f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 10838f21420eSPhilipp Reisner else 10848f21420eSPhilipp Reisner memset(digest, 0, digest_size); 10858f21420eSPhilipp Reisner 108653ea4331SLars Ellenberg /* Free e and pages before send. 108753ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 108853ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 108953ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 1090c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 10913967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1092db830c46SAndreas Gruenbacher peer_req = NULL; 1093b411b363SPhilipp Reisner inc_rs_pending(mdev); 109499920dc5SAndreas Gruenbacher err = drbd_send_drequest_csum(mdev, sector, size, digest, digest_size, P_OV_REPLY); 109599920dc5SAndreas Gruenbacher if (err) 1096b411b363SPhilipp Reisner dec_rs_pending(mdev); 1097b411b363SPhilipp Reisner kfree(digest); 1098b411b363SPhilipp Reisner 1099b411b363SPhilipp Reisner out: 1100db830c46SAndreas Gruenbacher if (peer_req) 11013967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1102b411b363SPhilipp Reisner dec_unacked(mdev); 110399920dc5SAndreas Gruenbacher return err; 1104b411b363SPhilipp Reisner } 1105b411b363SPhilipp Reisner 11068f7bed77SAndreas Gruenbacher void drbd_ov_out_of_sync_found(struct drbd_conf *mdev, sector_t sector, int size) 1107b411b363SPhilipp Reisner { 1108b411b363SPhilipp Reisner if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) { 1109b411b363SPhilipp Reisner mdev->ov_last_oos_size += size>>9; 1110b411b363SPhilipp Reisner } else { 1111b411b363SPhilipp Reisner mdev->ov_last_oos_start = sector; 1112b411b363SPhilipp Reisner mdev->ov_last_oos_size = size>>9; 1113b411b363SPhilipp Reisner } 1114b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 1115b411b363SPhilipp Reisner } 1116b411b363SPhilipp Reisner 111799920dc5SAndreas Gruenbacher int w_e_end_ov_reply(struct drbd_work *w, int cancel) 1118b411b363SPhilipp Reisner { 1119db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 112000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1121b411b363SPhilipp Reisner struct digest_info *di; 1122b411b363SPhilipp Reisner void *digest; 1123db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1124db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 112553ea4331SLars Ellenberg int digest_size; 112699920dc5SAndreas Gruenbacher int err, eq = 0; 1127b411b363SPhilipp Reisner 1128b411b363SPhilipp Reisner if (unlikely(cancel)) { 11293967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1130b411b363SPhilipp Reisner dec_unacked(mdev); 113199920dc5SAndreas Gruenbacher return 0; 1132b411b363SPhilipp Reisner } 1133b411b363SPhilipp Reisner 1134b411b363SPhilipp Reisner /* after "cancel", because after drbd_disconnect/drbd_rs_cancel_all 1135b411b363SPhilipp Reisner * the resync lru has been cleaned up already */ 11361d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1137db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 11381d53f09eSLars Ellenberg put_ldev(mdev); 11391d53f09eSLars Ellenberg } 1140b411b363SPhilipp Reisner 1141db830c46SAndreas Gruenbacher di = peer_req->digest; 1142b411b363SPhilipp Reisner 1143db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1144f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1145b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1146b411b363SPhilipp Reisner if (digest) { 1147f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 1148b411b363SPhilipp Reisner 1149b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1150b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1151b411b363SPhilipp Reisner kfree(digest); 1152b411b363SPhilipp Reisner } 1153b411b363SPhilipp Reisner } 1154b411b363SPhilipp Reisner 11559676c760SLars Ellenberg /* Free peer_req and pages before send. 115653ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 115753ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 115853ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 1159c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 11603967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1161b411b363SPhilipp Reisner if (!eq) 11628f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 1163b411b363SPhilipp Reisner else 11648f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1165b411b363SPhilipp Reisner 116699920dc5SAndreas Gruenbacher err = drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, 1167b411b363SPhilipp Reisner eq ? ID_IN_SYNC : ID_OUT_OF_SYNC); 1168b411b363SPhilipp Reisner 116953ea4331SLars Ellenberg dec_unacked(mdev); 1170b411b363SPhilipp Reisner 1171ea5442afSLars Ellenberg --mdev->ov_left; 1172ea5442afSLars Ellenberg 1173ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 1174ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 1175ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 1176ea5442afSLars Ellenberg 1177ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 11788f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1179b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1180b411b363SPhilipp Reisner } 1181b411b363SPhilipp Reisner 118299920dc5SAndreas Gruenbacher return err; 1183b411b363SPhilipp Reisner } 1184b411b363SPhilipp Reisner 118599920dc5SAndreas Gruenbacher int w_prev_work_done(struct drbd_work *w, int cancel) 1186b411b363SPhilipp Reisner { 1187b411b363SPhilipp Reisner struct drbd_wq_barrier *b = container_of(w, struct drbd_wq_barrier, w); 118800d56944SPhilipp Reisner 1189b411b363SPhilipp Reisner complete(&b->done); 119099920dc5SAndreas Gruenbacher return 0; 1191b411b363SPhilipp Reisner } 1192b411b363SPhilipp Reisner 119399920dc5SAndreas Gruenbacher int w_send_barrier(struct drbd_work *w, int cancel) 1194b411b363SPhilipp Reisner { 11959f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 1196b411b363SPhilipp Reisner struct drbd_tl_epoch *b = container_of(w, struct drbd_tl_epoch, w); 119700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 11989f5bdc33SAndreas Gruenbacher struct p_barrier *p; 1199b411b363SPhilipp Reisner 1200b411b363SPhilipp Reisner /* really avoid racing with tl_clear. w.cb may have been referenced 1201b411b363SPhilipp Reisner * just before it was reassigned and re-queued, so double check that. 1202b411b363SPhilipp Reisner * actually, this race was harmless, since we only try to send the 1203b411b363SPhilipp Reisner * barrier packet here, and otherwise do nothing with the object. 1204b411b363SPhilipp Reisner * but compare with the head of w_clear_epoch */ 120587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1206b411b363SPhilipp Reisner if (w->cb != w_send_barrier || mdev->state.conn < C_CONNECTED) 1207b411b363SPhilipp Reisner cancel = 1; 120887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1209b411b363SPhilipp Reisner if (cancel) 1210b411b363SPhilipp Reisner return 0; 121199920dc5SAndreas Gruenbacher 12129f5bdc33SAndreas Gruenbacher sock = &mdev->tconn->data; 12139f5bdc33SAndreas Gruenbacher p = drbd_prepare_command(mdev, sock); 12149f5bdc33SAndreas Gruenbacher if (!p) 12159f5bdc33SAndreas Gruenbacher return -EIO; 1216b411b363SPhilipp Reisner p->barrier = b->br_number; 1217b411b363SPhilipp Reisner /* inc_ap_pending was done where this was queued. 1218b411b363SPhilipp Reisner * dec_ap_pending will be done in got_BarrierAck 1219b411b363SPhilipp Reisner * or (on connection loss) in w_clear_epoch. */ 12209f5bdc33SAndreas Gruenbacher return drbd_send_command(mdev, sock, P_BARRIER, sizeof(*p), NULL, 0); 1221b411b363SPhilipp Reisner } 1222b411b363SPhilipp Reisner 122399920dc5SAndreas Gruenbacher int w_send_write_hint(struct drbd_work *w, int cancel) 1224b411b363SPhilipp Reisner { 122500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 12269f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 12279f5bdc33SAndreas Gruenbacher 1228b411b363SPhilipp Reisner if (cancel) 122999920dc5SAndreas Gruenbacher return 0; 12309f5bdc33SAndreas Gruenbacher sock = &mdev->tconn->data; 12319f5bdc33SAndreas Gruenbacher if (!drbd_prepare_command(mdev, sock)) 12329f5bdc33SAndreas Gruenbacher return -EIO; 1233e658983aSAndreas Gruenbacher return drbd_send_command(mdev, sock, P_UNPLUG_REMOTE, 0, NULL, 0); 1234b411b363SPhilipp Reisner } 1235b411b363SPhilipp Reisner 12368f7bed77SAndreas Gruenbacher int w_send_out_of_sync(struct drbd_work *w, int cancel) 123773a01a18SPhilipp Reisner { 123873a01a18SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 123900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 124099920dc5SAndreas Gruenbacher int err; 124173a01a18SPhilipp Reisner 124273a01a18SPhilipp Reisner if (unlikely(cancel)) { 12438554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 124499920dc5SAndreas Gruenbacher return 0; 124573a01a18SPhilipp Reisner } 124673a01a18SPhilipp Reisner 12478f7bed77SAndreas Gruenbacher err = drbd_send_out_of_sync(mdev, req); 12488554df1cSAndreas Gruenbacher req_mod(req, OOS_HANDED_TO_NETWORK); 124973a01a18SPhilipp Reisner 125099920dc5SAndreas Gruenbacher return err; 125173a01a18SPhilipp Reisner } 125273a01a18SPhilipp Reisner 1253b411b363SPhilipp Reisner /** 1254b411b363SPhilipp Reisner * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1255b411b363SPhilipp Reisner * @mdev: DRBD device. 1256b411b363SPhilipp Reisner * @w: work object. 1257b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1258b411b363SPhilipp Reisner */ 125999920dc5SAndreas Gruenbacher int w_send_dblock(struct drbd_work *w, int cancel) 1260b411b363SPhilipp Reisner { 1261b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 126200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 126399920dc5SAndreas Gruenbacher int err; 1264b411b363SPhilipp Reisner 1265b411b363SPhilipp Reisner if (unlikely(cancel)) { 12668554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 126799920dc5SAndreas Gruenbacher return 0; 1268b411b363SPhilipp Reisner } 1269b411b363SPhilipp Reisner 127099920dc5SAndreas Gruenbacher err = drbd_send_dblock(mdev, req); 127199920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1272b411b363SPhilipp Reisner 127399920dc5SAndreas Gruenbacher return err; 1274b411b363SPhilipp Reisner } 1275b411b363SPhilipp Reisner 1276b411b363SPhilipp Reisner /** 1277b411b363SPhilipp Reisner * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 1278b411b363SPhilipp Reisner * @mdev: DRBD device. 1279b411b363SPhilipp Reisner * @w: work object. 1280b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1281b411b363SPhilipp Reisner */ 128299920dc5SAndreas Gruenbacher int w_send_read_req(struct drbd_work *w, int cancel) 1283b411b363SPhilipp Reisner { 1284b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 128500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 128699920dc5SAndreas Gruenbacher int err; 1287b411b363SPhilipp Reisner 1288b411b363SPhilipp Reisner if (unlikely(cancel)) { 12898554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 129099920dc5SAndreas Gruenbacher return 0; 1291b411b363SPhilipp Reisner } 1292b411b363SPhilipp Reisner 129399920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_DATA_REQUEST, req->i.sector, req->i.size, 1294b411b363SPhilipp Reisner (unsigned long)req); 1295b411b363SPhilipp Reisner 129699920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1297b411b363SPhilipp Reisner 129899920dc5SAndreas Gruenbacher return err; 1299b411b363SPhilipp Reisner } 1300b411b363SPhilipp Reisner 130199920dc5SAndreas Gruenbacher int w_restart_disk_io(struct drbd_work *w, int cancel) 1302265be2d0SPhilipp Reisner { 1303265be2d0SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 130400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1305265be2d0SPhilipp Reisner 13060778286aSPhilipp Reisner if (bio_data_dir(req->master_bio) == WRITE && req->rq_state & RQ_IN_ACT_LOG) 1307181286adSLars Ellenberg drbd_al_begin_io(mdev, &req->i); 1308265be2d0SPhilipp Reisner /* Calling drbd_al_begin_io() out of the worker might deadlocks 1309265be2d0SPhilipp Reisner theoretically. Practically it can not deadlock, since this is 1310265be2d0SPhilipp Reisner only used when unfreezing IOs. All the extents of the requests 1311265be2d0SPhilipp Reisner that made it into the TL are already active */ 1312265be2d0SPhilipp Reisner 1313265be2d0SPhilipp Reisner drbd_req_make_private_bio(req, req->master_bio); 1314265be2d0SPhilipp Reisner req->private_bio->bi_bdev = mdev->ldev->backing_bdev; 1315265be2d0SPhilipp Reisner generic_make_request(req->private_bio); 1316265be2d0SPhilipp Reisner 131799920dc5SAndreas Gruenbacher return 0; 1318265be2d0SPhilipp Reisner } 1319265be2d0SPhilipp Reisner 1320b411b363SPhilipp Reisner static int _drbd_may_sync_now(struct drbd_conf *mdev) 1321b411b363SPhilipp Reisner { 1322b411b363SPhilipp Reisner struct drbd_conf *odev = mdev; 1323b411b363SPhilipp Reisner 1324b411b363SPhilipp Reisner while (1) { 1325438c8374SPhilipp Reisner if (!odev->ldev) 1326438c8374SPhilipp Reisner return 1; 1327f399002eSLars Ellenberg if (odev->ldev->dc.resync_after == -1) 1328b411b363SPhilipp Reisner return 1; 1329f399002eSLars Ellenberg odev = minor_to_mdev(odev->ldev->dc.resync_after); 1330841ce241SAndreas Gruenbacher if (!expect(odev)) 1331841ce241SAndreas Gruenbacher return 1; 1332b411b363SPhilipp Reisner if ((odev->state.conn >= C_SYNC_SOURCE && 1333b411b363SPhilipp Reisner odev->state.conn <= C_PAUSED_SYNC_T) || 1334b411b363SPhilipp Reisner odev->state.aftr_isp || odev->state.peer_isp || 1335b411b363SPhilipp Reisner odev->state.user_isp) 1336b411b363SPhilipp Reisner return 0; 1337b411b363SPhilipp Reisner } 1338b411b363SPhilipp Reisner } 1339b411b363SPhilipp Reisner 1340b411b363SPhilipp Reisner /** 1341b411b363SPhilipp Reisner * _drbd_pause_after() - Pause resync on all devices that may not resync now 1342b411b363SPhilipp Reisner * @mdev: DRBD device. 1343b411b363SPhilipp Reisner * 1344b411b363SPhilipp Reisner * Called from process context only (admin command and after_state_ch). 1345b411b363SPhilipp Reisner */ 1346b411b363SPhilipp Reisner static int _drbd_pause_after(struct drbd_conf *mdev) 1347b411b363SPhilipp Reisner { 1348b411b363SPhilipp Reisner struct drbd_conf *odev; 1349b411b363SPhilipp Reisner int i, rv = 0; 1350b411b363SPhilipp Reisner 1351695d08faSPhilipp Reisner rcu_read_lock(); 135281a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1353b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1354b411b363SPhilipp Reisner continue; 1355b411b363SPhilipp Reisner if (!_drbd_may_sync_now(odev)) 1356b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 1), CS_HARD, NULL) 1357b411b363SPhilipp Reisner != SS_NOTHING_TO_DO); 1358b411b363SPhilipp Reisner } 1359695d08faSPhilipp Reisner rcu_read_unlock(); 1360b411b363SPhilipp Reisner 1361b411b363SPhilipp Reisner return rv; 1362b411b363SPhilipp Reisner } 1363b411b363SPhilipp Reisner 1364b411b363SPhilipp Reisner /** 1365b411b363SPhilipp Reisner * _drbd_resume_next() - Resume resync on all devices that may resync now 1366b411b363SPhilipp Reisner * @mdev: DRBD device. 1367b411b363SPhilipp Reisner * 1368b411b363SPhilipp Reisner * Called from process context only (admin command and worker). 1369b411b363SPhilipp Reisner */ 1370b411b363SPhilipp Reisner static int _drbd_resume_next(struct drbd_conf *mdev) 1371b411b363SPhilipp Reisner { 1372b411b363SPhilipp Reisner struct drbd_conf *odev; 1373b411b363SPhilipp Reisner int i, rv = 0; 1374b411b363SPhilipp Reisner 1375695d08faSPhilipp Reisner rcu_read_lock(); 137681a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1377b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1378b411b363SPhilipp Reisner continue; 1379b411b363SPhilipp Reisner if (odev->state.aftr_isp) { 1380b411b363SPhilipp Reisner if (_drbd_may_sync_now(odev)) 1381b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 0), 1382b411b363SPhilipp Reisner CS_HARD, NULL) 1383b411b363SPhilipp Reisner != SS_NOTHING_TO_DO) ; 1384b411b363SPhilipp Reisner } 1385b411b363SPhilipp Reisner } 1386695d08faSPhilipp Reisner rcu_read_unlock(); 1387b411b363SPhilipp Reisner return rv; 1388b411b363SPhilipp Reisner } 1389b411b363SPhilipp Reisner 1390b411b363SPhilipp Reisner void resume_next_sg(struct drbd_conf *mdev) 1391b411b363SPhilipp Reisner { 1392b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1393b411b363SPhilipp Reisner _drbd_resume_next(mdev); 1394b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1395b411b363SPhilipp Reisner } 1396b411b363SPhilipp Reisner 1397b411b363SPhilipp Reisner void suspend_other_sg(struct drbd_conf *mdev) 1398b411b363SPhilipp Reisner { 1399b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1400b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1401b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1402b411b363SPhilipp Reisner } 1403b411b363SPhilipp Reisner 1404dc97b708SPhilipp Reisner /* caller must hold global_state_lock */ 1405dc97b708SPhilipp Reisner enum drbd_ret_code drbd_sync_after_valid(struct drbd_conf *mdev, int o_minor) 1406b411b363SPhilipp Reisner { 1407b411b363SPhilipp Reisner struct drbd_conf *odev; 1408b411b363SPhilipp Reisner 1409b411b363SPhilipp Reisner if (o_minor == -1) 1410b411b363SPhilipp Reisner return NO_ERROR; 1411b411b363SPhilipp Reisner if (o_minor < -1 || minor_to_mdev(o_minor) == NULL) 1412b411b363SPhilipp Reisner return ERR_SYNC_AFTER; 1413b411b363SPhilipp Reisner 1414b411b363SPhilipp Reisner /* check for loops */ 1415b411b363SPhilipp Reisner odev = minor_to_mdev(o_minor); 1416b411b363SPhilipp Reisner while (1) { 1417b411b363SPhilipp Reisner if (odev == mdev) 1418b411b363SPhilipp Reisner return ERR_SYNC_AFTER_CYCLE; 1419b411b363SPhilipp Reisner 1420b411b363SPhilipp Reisner /* dependency chain ends here, no cycles. */ 1421f399002eSLars Ellenberg if (odev->ldev->dc.resync_after == -1) 1422b411b363SPhilipp Reisner return NO_ERROR; 1423b411b363SPhilipp Reisner 1424b411b363SPhilipp Reisner /* follow the dependency chain */ 1425f399002eSLars Ellenberg odev = minor_to_mdev(odev->ldev->dc.resync_after); 1426b411b363SPhilipp Reisner } 1427b411b363SPhilipp Reisner } 1428b411b363SPhilipp Reisner 1429dc97b708SPhilipp Reisner /* caller must hold global_state_lock */ 1430dc97b708SPhilipp Reisner void drbd_sync_after_changed(struct drbd_conf *mdev) 1431b411b363SPhilipp Reisner { 1432b411b363SPhilipp Reisner int changes; 1433b411b363SPhilipp Reisner 1434b411b363SPhilipp Reisner do { 1435b411b363SPhilipp Reisner changes = _drbd_pause_after(mdev); 1436b411b363SPhilipp Reisner changes |= _drbd_resume_next(mdev); 1437b411b363SPhilipp Reisner } while (changes); 1438b411b363SPhilipp Reisner } 1439b411b363SPhilipp Reisner 14409bd28d3cSLars Ellenberg void drbd_rs_controller_reset(struct drbd_conf *mdev) 14419bd28d3cSLars Ellenberg { 14429bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_in, 0); 14439bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_ev, 0); 14449bd28d3cSLars Ellenberg mdev->rs_in_flight = 0; 14459bd28d3cSLars Ellenberg mdev->rs_planed = 0; 14469bd28d3cSLars Ellenberg spin_lock(&mdev->peer_seq_lock); 14479bd28d3cSLars Ellenberg fifo_set(&mdev->rs_plan_s, 0); 14489bd28d3cSLars Ellenberg spin_unlock(&mdev->peer_seq_lock); 14499bd28d3cSLars Ellenberg } 14509bd28d3cSLars Ellenberg 14511f04af33SPhilipp Reisner void start_resync_timer_fn(unsigned long data) 14521f04af33SPhilipp Reisner { 14531f04af33SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 14541f04af33SPhilipp Reisner 14551f04af33SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->start_resync_work); 14561f04af33SPhilipp Reisner } 14571f04af33SPhilipp Reisner 145899920dc5SAndreas Gruenbacher int w_start_resync(struct drbd_work *w, int cancel) 14591f04af33SPhilipp Reisner { 146000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 146100d56944SPhilipp Reisner 14621f04af33SPhilipp Reisner if (atomic_read(&mdev->unacked_cnt) || atomic_read(&mdev->rs_pending_cnt)) { 14631f04af33SPhilipp Reisner dev_warn(DEV, "w_start_resync later...\n"); 14641f04af33SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/10; 14651f04af33SPhilipp Reisner add_timer(&mdev->start_resync_timer); 146699920dc5SAndreas Gruenbacher return 0; 14671f04af33SPhilipp Reisner } 14681f04af33SPhilipp Reisner 14691f04af33SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 14701f04af33SPhilipp Reisner clear_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags); 147199920dc5SAndreas Gruenbacher return 0; 14721f04af33SPhilipp Reisner } 14731f04af33SPhilipp Reisner 1474b411b363SPhilipp Reisner /** 1475b411b363SPhilipp Reisner * drbd_start_resync() - Start the resync process 1476b411b363SPhilipp Reisner * @mdev: DRBD device. 1477b411b363SPhilipp Reisner * @side: Either C_SYNC_SOURCE or C_SYNC_TARGET 1478b411b363SPhilipp Reisner * 1479b411b363SPhilipp Reisner * This function might bring you directly into one of the 1480b411b363SPhilipp Reisner * C_PAUSED_SYNC_* states. 1481b411b363SPhilipp Reisner */ 1482b411b363SPhilipp Reisner void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side) 1483b411b363SPhilipp Reisner { 1484b411b363SPhilipp Reisner union drbd_state ns; 1485b411b363SPhilipp Reisner int r; 1486b411b363SPhilipp Reisner 1487c4752ef1SPhilipp Reisner if (mdev->state.conn >= C_SYNC_SOURCE && mdev->state.conn < C_AHEAD) { 1488b411b363SPhilipp Reisner dev_err(DEV, "Resync already running!\n"); 1489b411b363SPhilipp Reisner return; 1490b411b363SPhilipp Reisner } 1491b411b363SPhilipp Reisner 149259817f4fSPhilipp Reisner if (mdev->state.conn < C_AHEAD) { 1493b411b363SPhilipp Reisner /* In case a previous resync run was aborted by an IO error/detach on the peer. */ 1494b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 149559817f4fSPhilipp Reisner /* This should be done when we abort the resync. We definitely do not 149659817f4fSPhilipp Reisner want to have this for connections going back and forth between 149759817f4fSPhilipp Reisner Ahead/Behind and SyncSource/SyncTarget */ 149859817f4fSPhilipp Reisner } 1499b411b363SPhilipp Reisner 1500e64a3294SPhilipp Reisner if (!test_bit(B_RS_H_DONE, &mdev->flags)) { 1501b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1502b411b363SPhilipp Reisner /* Since application IO was locked out during C_WF_BITMAP_T and 1503b411b363SPhilipp Reisner C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET 1504b411b363SPhilipp Reisner we check that we might make the data inconsistent. */ 1505b411b363SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-target"); 1506b411b363SPhilipp Reisner r = (r >> 8) & 0xff; 1507b411b363SPhilipp Reisner if (r > 0) { 1508b411b363SPhilipp Reisner dev_info(DEV, "before-resync-target handler returned %d, " 1509b411b363SPhilipp Reisner "dropping connection.\n", r); 151038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 1511b411b363SPhilipp Reisner return; 1512b411b363SPhilipp Reisner } 151309b9e797SPhilipp Reisner } else /* C_SYNC_SOURCE */ { 151409b9e797SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-source"); 151509b9e797SPhilipp Reisner r = (r >> 8) & 0xff; 151609b9e797SPhilipp Reisner if (r > 0) { 151709b9e797SPhilipp Reisner if (r == 3) { 151809b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 151909b9e797SPhilipp Reisner "ignoring. Old userland tools?", r); 152009b9e797SPhilipp Reisner } else { 152109b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 152209b9e797SPhilipp Reisner "dropping connection.\n", r); 152338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 152409b9e797SPhilipp Reisner return; 152509b9e797SPhilipp Reisner } 152609b9e797SPhilipp Reisner } 1527b411b363SPhilipp Reisner } 1528e64a3294SPhilipp Reisner } 1529b411b363SPhilipp Reisner 1530e64a3294SPhilipp Reisner if (current == mdev->tconn->worker.task) { 1531dad20554SPhilipp Reisner /* The worker should not sleep waiting for state_mutex, 1532e64a3294SPhilipp Reisner that can take long */ 15338410da8fSPhilipp Reisner if (!mutex_trylock(mdev->state_mutex)) { 1534e64a3294SPhilipp Reisner set_bit(B_RS_H_DONE, &mdev->flags); 1535e64a3294SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/5; 1536e64a3294SPhilipp Reisner add_timer(&mdev->start_resync_timer); 1537e64a3294SPhilipp Reisner return; 1538e64a3294SPhilipp Reisner } 1539e64a3294SPhilipp Reisner } else { 15408410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 1541e64a3294SPhilipp Reisner } 1542e64a3294SPhilipp Reisner clear_bit(B_RS_H_DONE, &mdev->flags); 1543b411b363SPhilipp Reisner 1544b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_NEGOTIATING)) { 15458410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1546b411b363SPhilipp Reisner return; 1547b411b363SPhilipp Reisner } 1548b411b363SPhilipp Reisner 1549b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 155078bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 1551b411b363SPhilipp Reisner 1552b411b363SPhilipp Reisner ns.aftr_isp = !_drbd_may_sync_now(mdev); 1553b411b363SPhilipp Reisner 1554b411b363SPhilipp Reisner ns.conn = side; 1555b411b363SPhilipp Reisner 1556b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) 1557b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 1558b411b363SPhilipp Reisner else /* side == C_SYNC_SOURCE */ 1559b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 1560b411b363SPhilipp Reisner 1561b411b363SPhilipp Reisner r = __drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 156278bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 1563b411b363SPhilipp Reisner 1564b411b363SPhilipp Reisner if (ns.conn < C_CONNECTED) 1565b411b363SPhilipp Reisner r = SS_UNKNOWN_ERROR; 1566b411b363SPhilipp Reisner 1567b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 15681d7734a0SLars Ellenberg unsigned long tw = drbd_bm_total_weight(mdev); 15691d7734a0SLars Ellenberg unsigned long now = jiffies; 15701d7734a0SLars Ellenberg int i; 15711d7734a0SLars Ellenberg 1572b411b363SPhilipp Reisner mdev->rs_failed = 0; 1573b411b363SPhilipp Reisner mdev->rs_paused = 0; 1574b411b363SPhilipp Reisner mdev->rs_same_csum = 0; 15750f0601f4SLars Ellenberg mdev->rs_last_events = 0; 15760f0601f4SLars Ellenberg mdev->rs_last_sect_ev = 0; 15771d7734a0SLars Ellenberg mdev->rs_total = tw; 15781d7734a0SLars Ellenberg mdev->rs_start = now; 15791d7734a0SLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 15801d7734a0SLars Ellenberg mdev->rs_mark_left[i] = tw; 15811d7734a0SLars Ellenberg mdev->rs_mark_time[i] = now; 15821d7734a0SLars Ellenberg } 1583b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1584b411b363SPhilipp Reisner } 1585b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 15865a22db89SLars Ellenberg 15876c922ed5SLars Ellenberg if (r == SS_SUCCESS) { 15886c922ed5SLars Ellenberg dev_info(DEV, "Began resync as %s (will sync %lu KB [%lu bits set]).\n", 15896c922ed5SLars Ellenberg drbd_conn_str(ns.conn), 15906c922ed5SLars Ellenberg (unsigned long) mdev->rs_total << (BM_BLOCK_SHIFT-10), 15916c922ed5SLars Ellenberg (unsigned long) mdev->rs_total); 15925a22db89SLars Ellenberg if (side == C_SYNC_TARGET) 15935a22db89SLars Ellenberg mdev->bm_resync_fo = 0; 15945a22db89SLars Ellenberg 15955a22db89SLars Ellenberg /* Since protocol 96, we must serialize drbd_gen_and_send_sync_uuid 15965a22db89SLars Ellenberg * with w_send_oos, or the sync target will get confused as to 15975a22db89SLars Ellenberg * how much bits to resync. We cannot do that always, because for an 15985a22db89SLars Ellenberg * empty resync and protocol < 95, we need to do it here, as we call 15995a22db89SLars Ellenberg * drbd_resync_finished from here in that case. 16005a22db89SLars Ellenberg * We drbd_gen_and_send_sync_uuid here for protocol < 96, 16015a22db89SLars Ellenberg * and from after_state_ch otherwise. */ 160231890f4aSPhilipp Reisner if (side == C_SYNC_SOURCE && mdev->tconn->agreed_pro_version < 96) 16035a22db89SLars Ellenberg drbd_gen_and_send_sync_uuid(mdev); 1604b411b363SPhilipp Reisner 160531890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 95 && mdev->rs_total == 0) { 1606af85e8e8SLars Ellenberg /* This still has a race (about when exactly the peers 1607af85e8e8SLars Ellenberg * detect connection loss) that can lead to a full sync 1608af85e8e8SLars Ellenberg * on next handshake. In 8.3.9 we fixed this with explicit 1609af85e8e8SLars Ellenberg * resync-finished notifications, but the fix 1610af85e8e8SLars Ellenberg * introduces a protocol change. Sleeping for some 1611af85e8e8SLars Ellenberg * time longer than the ping interval + timeout on the 1612af85e8e8SLars Ellenberg * SyncSource, to give the SyncTarget the chance to 1613af85e8e8SLars Ellenberg * detect connection loss, then waiting for a ping 1614af85e8e8SLars Ellenberg * response (implicit in drbd_resync_finished) reduces 1615af85e8e8SLars Ellenberg * the race considerably, but does not solve it. */ 161644ed167dSPhilipp Reisner if (side == C_SYNC_SOURCE) { 161744ed167dSPhilipp Reisner struct net_conf *nc; 161844ed167dSPhilipp Reisner int timeo; 161944ed167dSPhilipp Reisner 162044ed167dSPhilipp Reisner rcu_read_lock(); 162144ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 162244ed167dSPhilipp Reisner timeo = nc->ping_int * HZ + nc->ping_timeo * HZ / 9; 162344ed167dSPhilipp Reisner rcu_read_unlock(); 162444ed167dSPhilipp Reisner schedule_timeout_interruptible(timeo); 162544ed167dSPhilipp Reisner } 1626b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1627b411b363SPhilipp Reisner } 1628b411b363SPhilipp Reisner 16299bd28d3cSLars Ellenberg drbd_rs_controller_reset(mdev); 1630b411b363SPhilipp Reisner /* ns.conn may already be != mdev->state.conn, 1631b411b363SPhilipp Reisner * we may have been paused in between, or become paused until 1632b411b363SPhilipp Reisner * the timer triggers. 1633b411b363SPhilipp Reisner * No matter, that is handled in resync_timer_fn() */ 1634b411b363SPhilipp Reisner if (ns.conn == C_SYNC_TARGET) 1635b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies); 1636b411b363SPhilipp Reisner 1637b411b363SPhilipp Reisner drbd_md_sync(mdev); 1638b411b363SPhilipp Reisner } 16395a22db89SLars Ellenberg put_ldev(mdev); 16408410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1641b411b363SPhilipp Reisner } 1642b411b363SPhilipp Reisner 1643b411b363SPhilipp Reisner int drbd_worker(struct drbd_thread *thi) 1644b411b363SPhilipp Reisner { 1645392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 1646b411b363SPhilipp Reisner struct drbd_work *w = NULL; 16470e29d163SPhilipp Reisner struct drbd_conf *mdev; 164844ed167dSPhilipp Reisner struct net_conf *nc; 1649b411b363SPhilipp Reisner LIST_HEAD(work_list); 1650f399002eSLars Ellenberg int vnr, intr = 0; 165144ed167dSPhilipp Reisner int cork; 1652b411b363SPhilipp Reisner 1653e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 165480822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 1655b411b363SPhilipp Reisner 165619393e10SPhilipp Reisner if (down_trylock(&tconn->data.work.s)) { 165719393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 165844ed167dSPhilipp Reisner 165944ed167dSPhilipp Reisner rcu_read_lock(); 166044ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 166144ed167dSPhilipp Reisner cork = nc ? !nc->no_cork : 0; 166244ed167dSPhilipp Reisner rcu_read_unlock(); 166344ed167dSPhilipp Reisner 166444ed167dSPhilipp Reisner if (tconn->data.socket && cork) 166519393e10SPhilipp Reisner drbd_tcp_uncork(tconn->data.socket); 166619393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1667b411b363SPhilipp Reisner 166819393e10SPhilipp Reisner intr = down_interruptible(&tconn->data.work.s); 1669b411b363SPhilipp Reisner 167019393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 167144ed167dSPhilipp Reisner if (tconn->data.socket && cork) 167219393e10SPhilipp Reisner drbd_tcp_cork(tconn->data.socket); 167319393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1674b411b363SPhilipp Reisner } 1675b411b363SPhilipp Reisner 1676b411b363SPhilipp Reisner if (intr) { 1677b411b363SPhilipp Reisner flush_signals(current); 167819393e10SPhilipp Reisner if (get_t_state(thi) == RUNNING) { 167919393e10SPhilipp Reisner conn_warn(tconn, "Worker got an unexpected signal\n"); 1680b411b363SPhilipp Reisner continue; 168119393e10SPhilipp Reisner } 1682b411b363SPhilipp Reisner break; 1683b411b363SPhilipp Reisner } 1684b411b363SPhilipp Reisner 1685e77a0a5cSAndreas Gruenbacher if (get_t_state(thi) != RUNNING) 1686b411b363SPhilipp Reisner break; 1687b411b363SPhilipp Reisner /* With this break, we have done a down() but not consumed 1688b411b363SPhilipp Reisner the entry from the list. The cleanup code takes care of 1689b411b363SPhilipp Reisner this... */ 1690b411b363SPhilipp Reisner 1691b411b363SPhilipp Reisner w = NULL; 169219393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 169319393e10SPhilipp Reisner if (list_empty(&tconn->data.work.q)) { 1694b411b363SPhilipp Reisner /* something terribly wrong in our logic. 1695b411b363SPhilipp Reisner * we were able to down() the semaphore, 1696b411b363SPhilipp Reisner * but the list is empty... doh. 1697b411b363SPhilipp Reisner * 1698b411b363SPhilipp Reisner * what is the best thing to do now? 1699b411b363SPhilipp Reisner * try again from scratch, restarting the receiver, 1700b411b363SPhilipp Reisner * asender, whatnot? could break even more ugly, 1701b411b363SPhilipp Reisner * e.g. when we are primary, but no good local data. 1702b411b363SPhilipp Reisner * 1703b411b363SPhilipp Reisner * I'll try to get away just starting over this loop. 1704b411b363SPhilipp Reisner */ 170519393e10SPhilipp Reisner conn_warn(tconn, "Work list unexpectedly empty\n"); 170619393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1707b411b363SPhilipp Reisner continue; 1708b411b363SPhilipp Reisner } 170919393e10SPhilipp Reisner w = list_entry(tconn->data.work.q.next, struct drbd_work, list); 1710b411b363SPhilipp Reisner list_del_init(&w->list); 171119393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1712b411b363SPhilipp Reisner 171399920dc5SAndreas Gruenbacher if (w->cb(w, tconn->cstate < C_WF_REPORT_PARAMS)) { 1714b411b363SPhilipp Reisner /* dev_warn(DEV, "worker: a callback failed! \n"); */ 1715bbeb641cSPhilipp Reisner if (tconn->cstate >= C_WF_REPORT_PARAMS) 1716bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 1717b411b363SPhilipp Reisner } 1718b411b363SPhilipp Reisner } 1719b411b363SPhilipp Reisner 172019393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 172119393e10SPhilipp Reisner while (!list_empty(&tconn->data.work.q)) { 172219393e10SPhilipp Reisner list_splice_init(&tconn->data.work.q, &work_list); 172319393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1724b411b363SPhilipp Reisner 1725b411b363SPhilipp Reisner while (!list_empty(&work_list)) { 1726b411b363SPhilipp Reisner w = list_entry(work_list.next, struct drbd_work, list); 1727b411b363SPhilipp Reisner list_del_init(&w->list); 172800d56944SPhilipp Reisner w->cb(w, 1); 1729b411b363SPhilipp Reisner } 1730b411b363SPhilipp Reisner 173119393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 1732b411b363SPhilipp Reisner } 173319393e10SPhilipp Reisner sema_init(&tconn->data.work.s, 0); 1734b411b363SPhilipp Reisner /* DANGEROUS race: if someone did queue his work within the spinlock, 1735b411b363SPhilipp Reisner * but up() ed outside the spinlock, we could get an up() on the 1736b411b363SPhilipp Reisner * semaphore without corresponding list entry. 1737b411b363SPhilipp Reisner * So don't do that. 1738b411b363SPhilipp Reisner */ 173919393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1740b411b363SPhilipp Reisner 1741d3fcb490SPhilipp Reisner down_read(&drbd_cfg_rwsem); 1742f399002eSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 17430e29d163SPhilipp Reisner D_ASSERT(mdev->state.disk == D_DISKLESS && mdev->state.conn == C_STANDALONE); 17440e29d163SPhilipp Reisner drbd_mdev_cleanup(mdev); 17450e29d163SPhilipp Reisner } 1746d3fcb490SPhilipp Reisner up_read(&drbd_cfg_rwsem); 1747b411b363SPhilipp Reisner 1748b411b363SPhilipp Reisner return 0; 1749b411b363SPhilipp Reisner } 1750