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; 104b411b363SPhilipp Reisner sector_t e_sector; 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) */ 113db830c46SAndreas Gruenbacher e_sector = peer_req->i.sector; 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) 137b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, e_sector); 138b411b363SPhilipp Reisner 139b411b363SPhilipp Reisner if (do_wake) 140b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 141b411b363SPhilipp Reisner 142b411b363SPhilipp Reisner if (do_al_complete_io) 143b411b363SPhilipp Reisner drbd_al_complete_io(mdev, e_sector); 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 32153ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 322db830c46SAndreas Gruenbacher drbd_free_ee(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) 336db830c46SAndreas Gruenbacher drbd_free_ee(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. */ 357db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, ID_SYNCER /* unused */, sector, size, GFP_TRY); 358db830c46SAndreas Gruenbacher if (!peer_req) 35980a40e43SLars Ellenberg goto defer; 360b411b363SPhilipp Reisner 361db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_send_csum; 36287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 363db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->read_ee); 36487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 365b411b363SPhilipp Reisner 3660f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 367fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, DRBD_FAULT_RS_RD) == 0) 36880a40e43SLars Ellenberg return 0; 36945bb912bSLars Ellenberg 37010f6d992SLars Ellenberg /* If it failed because of ENOMEM, retry should help. If it failed 37110f6d992SLars Ellenberg * because bio_add_page failed (probably broken lower level driver), 37210f6d992SLars Ellenberg * retry may or may not help. 37310f6d992SLars Ellenberg * If it does not, you may need to force disconnect. */ 37487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 375db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 37687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 37722cc37a9SLars Ellenberg 378db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 37980a40e43SLars Ellenberg defer: 38045bb912bSLars Ellenberg put_ldev(mdev); 38180a40e43SLars Ellenberg return -EAGAIN; 382b411b363SPhilipp Reisner } 383b411b363SPhilipp Reisner 38499920dc5SAndreas Gruenbacher int w_resync_timer(struct drbd_work *w, int cancel) 385794abb75SPhilipp Reisner { 38600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 387794abb75SPhilipp Reisner switch (mdev->state.conn) { 388794abb75SPhilipp Reisner case C_VERIFY_S: 38900d56944SPhilipp Reisner w_make_ov_request(w, cancel); 390794abb75SPhilipp Reisner break; 391794abb75SPhilipp Reisner case C_SYNC_TARGET: 39200d56944SPhilipp Reisner w_make_resync_request(w, cancel); 393794abb75SPhilipp Reisner break; 394794abb75SPhilipp Reisner } 395794abb75SPhilipp Reisner 39699920dc5SAndreas Gruenbacher return 0; 397794abb75SPhilipp Reisner } 398794abb75SPhilipp Reisner 399b411b363SPhilipp Reisner void resync_timer_fn(unsigned long data) 400b411b363SPhilipp Reisner { 401b411b363SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 402b411b363SPhilipp Reisner 403794abb75SPhilipp Reisner if (list_empty(&mdev->resync_work.list)) 404e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->resync_work); 405b411b363SPhilipp Reisner } 406b411b363SPhilipp Reisner 407778f271dSPhilipp Reisner static void fifo_set(struct fifo_buffer *fb, int value) 408778f271dSPhilipp Reisner { 409778f271dSPhilipp Reisner int i; 410778f271dSPhilipp Reisner 411778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 412f10f2623SPhilipp Reisner fb->values[i] = value; 413778f271dSPhilipp Reisner } 414778f271dSPhilipp Reisner 415778f271dSPhilipp Reisner static int fifo_push(struct fifo_buffer *fb, int value) 416778f271dSPhilipp Reisner { 417778f271dSPhilipp Reisner int ov; 418778f271dSPhilipp Reisner 419778f271dSPhilipp Reisner ov = fb->values[fb->head_index]; 420778f271dSPhilipp Reisner fb->values[fb->head_index++] = value; 421778f271dSPhilipp Reisner 422778f271dSPhilipp Reisner if (fb->head_index >= fb->size) 423778f271dSPhilipp Reisner fb->head_index = 0; 424778f271dSPhilipp Reisner 425778f271dSPhilipp Reisner return ov; 426778f271dSPhilipp Reisner } 427778f271dSPhilipp Reisner 428778f271dSPhilipp Reisner static void fifo_add_val(struct fifo_buffer *fb, int value) 429778f271dSPhilipp Reisner { 430778f271dSPhilipp Reisner int i; 431778f271dSPhilipp Reisner 432778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 433778f271dSPhilipp Reisner fb->values[i] += value; 434778f271dSPhilipp Reisner } 435778f271dSPhilipp Reisner 4369d77a5feSPhilipp Reisner static int drbd_rs_controller(struct drbd_conf *mdev) 437778f271dSPhilipp Reisner { 438778f271dSPhilipp Reisner unsigned int sect_in; /* Number of sectors that came in since the last turn */ 439778f271dSPhilipp Reisner unsigned int want; /* The number of sectors we want in the proxy */ 440778f271dSPhilipp Reisner int req_sect; /* Number of sectors to request in this turn */ 441778f271dSPhilipp Reisner int correction; /* Number of sectors more we need in the proxy*/ 442778f271dSPhilipp Reisner int cps; /* correction per invocation of drbd_rs_controller() */ 443778f271dSPhilipp Reisner int steps; /* Number of time steps to plan ahead */ 444778f271dSPhilipp Reisner int curr_corr; 445778f271dSPhilipp Reisner int max_sect; 446778f271dSPhilipp Reisner 447778f271dSPhilipp Reisner sect_in = atomic_xchg(&mdev->rs_sect_in, 0); /* Number of sectors that came in */ 448778f271dSPhilipp Reisner mdev->rs_in_flight -= sect_in; 449778f271dSPhilipp Reisner 450778f271dSPhilipp Reisner spin_lock(&mdev->peer_seq_lock); /* get an atomic view on mdev->rs_plan_s */ 451778f271dSPhilipp Reisner 452f399002eSLars Ellenberg steps = mdev->rs_plan_s.size; /* (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; */ 453778f271dSPhilipp Reisner 454778f271dSPhilipp Reisner if (mdev->rs_in_flight + sect_in == 0) { /* At start of resync */ 455f399002eSLars Ellenberg want = ((mdev->ldev->dc.resync_rate * 2 * SLEEP_TIME) / HZ) * steps; 456778f271dSPhilipp Reisner } else { /* normal path */ 457f399002eSLars Ellenberg want = mdev->ldev->dc.c_fill_target ? mdev->ldev->dc.c_fill_target : 458f399002eSLars Ellenberg sect_in * mdev->ldev->dc.c_delay_target * HZ / (SLEEP_TIME * 10); 459778f271dSPhilipp Reisner } 460778f271dSPhilipp Reisner 461778f271dSPhilipp Reisner correction = want - mdev->rs_in_flight - mdev->rs_planed; 462778f271dSPhilipp Reisner 463778f271dSPhilipp Reisner /* Plan ahead */ 464778f271dSPhilipp Reisner cps = correction / steps; 465778f271dSPhilipp Reisner fifo_add_val(&mdev->rs_plan_s, cps); 466778f271dSPhilipp Reisner mdev->rs_planed += cps * steps; 467778f271dSPhilipp Reisner 468778f271dSPhilipp Reisner /* What we do in this step */ 469778f271dSPhilipp Reisner curr_corr = fifo_push(&mdev->rs_plan_s, 0); 470778f271dSPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 471778f271dSPhilipp Reisner mdev->rs_planed -= curr_corr; 472778f271dSPhilipp Reisner 473778f271dSPhilipp Reisner req_sect = sect_in + curr_corr; 474778f271dSPhilipp Reisner if (req_sect < 0) 475778f271dSPhilipp Reisner req_sect = 0; 476778f271dSPhilipp Reisner 477f399002eSLars Ellenberg max_sect = (mdev->ldev->dc.c_max_rate * 2 * SLEEP_TIME) / HZ; 478778f271dSPhilipp Reisner if (req_sect > max_sect) 479778f271dSPhilipp Reisner req_sect = max_sect; 480778f271dSPhilipp Reisner 481778f271dSPhilipp Reisner /* 482778f271dSPhilipp Reisner dev_warn(DEV, "si=%u if=%d wa=%u co=%d st=%d cps=%d pl=%d cc=%d rs=%d\n", 483778f271dSPhilipp Reisner sect_in, mdev->rs_in_flight, want, correction, 484778f271dSPhilipp Reisner steps, cps, mdev->rs_planed, curr_corr, req_sect); 485778f271dSPhilipp Reisner */ 486778f271dSPhilipp Reisner 487778f271dSPhilipp Reisner return req_sect; 488778f271dSPhilipp Reisner } 489778f271dSPhilipp Reisner 4909d77a5feSPhilipp Reisner static int drbd_rs_number_requests(struct drbd_conf *mdev) 491e65f440dSLars Ellenberg { 492e65f440dSLars Ellenberg int number; 493f399002eSLars Ellenberg if (mdev->rs_plan_s.size) { /* mdev->ldev->dc.c_plan_ahead */ 494e65f440dSLars Ellenberg number = drbd_rs_controller(mdev) >> (BM_BLOCK_SHIFT - 9); 495e65f440dSLars Ellenberg mdev->c_sync_rate = number * HZ * (BM_BLOCK_SIZE / 1024) / SLEEP_TIME; 496e65f440dSLars Ellenberg } else { 497f399002eSLars Ellenberg mdev->c_sync_rate = mdev->ldev->dc.resync_rate; 498e65f440dSLars Ellenberg number = SLEEP_TIME * mdev->c_sync_rate / ((BM_BLOCK_SIZE / 1024) * HZ); 499e65f440dSLars Ellenberg } 500e65f440dSLars Ellenberg 501e65f440dSLars Ellenberg /* ignore the amount of pending requests, the resync controller should 502e65f440dSLars Ellenberg * throttle down to incoming reply rate soon enough anyways. */ 503e65f440dSLars Ellenberg return number; 504e65f440dSLars Ellenberg } 505e65f440dSLars Ellenberg 50699920dc5SAndreas Gruenbacher int w_make_resync_request(struct drbd_work *w, int cancel) 507b411b363SPhilipp Reisner { 50800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 509b411b363SPhilipp Reisner unsigned long bit; 510b411b363SPhilipp Reisner sector_t sector; 511b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 5121816a2b4SLars Ellenberg int max_bio_size; 513e65f440dSLars Ellenberg int number, rollback_i, size; 514b411b363SPhilipp Reisner int align, queued, sndbuf; 5150f0601f4SLars Ellenberg int i = 0; 516b411b363SPhilipp Reisner 517b411b363SPhilipp Reisner if (unlikely(cancel)) 51899920dc5SAndreas Gruenbacher return 0; 519b411b363SPhilipp Reisner 520af85e8e8SLars Ellenberg if (mdev->rs_total == 0) { 521af85e8e8SLars Ellenberg /* empty resync? */ 522af85e8e8SLars Ellenberg drbd_resync_finished(mdev); 52399920dc5SAndreas Gruenbacher return 0; 524af85e8e8SLars Ellenberg } 525af85e8e8SLars Ellenberg 526b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 527b411b363SPhilipp Reisner /* Since we only need to access mdev->rsync a 528b411b363SPhilipp Reisner get_ldev_if_state(mdev,D_FAILED) would be sufficient, but 529b411b363SPhilipp Reisner to continue resync with a broken disk makes no sense at 530b411b363SPhilipp Reisner all */ 531b411b363SPhilipp Reisner dev_err(DEV, "Disk broke down during resync!\n"); 53299920dc5SAndreas Gruenbacher return 0; 533b411b363SPhilipp Reisner } 534b411b363SPhilipp Reisner 5350cfdd247SPhilipp Reisner max_bio_size = queue_max_hw_sectors(mdev->rq_queue) << 9; 536e65f440dSLars Ellenberg number = drbd_rs_number_requests(mdev); 537e65f440dSLars Ellenberg if (number == 0) 5380f0601f4SLars Ellenberg goto requeue; 539b411b363SPhilipp Reisner 540b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 541b411b363SPhilipp Reisner /* Stop generating RS requests, when half of the send buffer is filled */ 542e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 543e42325a5SPhilipp Reisner if (mdev->tconn->data.socket) { 544e42325a5SPhilipp Reisner queued = mdev->tconn->data.socket->sk->sk_wmem_queued; 545e42325a5SPhilipp Reisner sndbuf = mdev->tconn->data.socket->sk->sk_sndbuf; 546b411b363SPhilipp Reisner } else { 547b411b363SPhilipp Reisner queued = 1; 548b411b363SPhilipp Reisner sndbuf = 0; 549b411b363SPhilipp Reisner } 550e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 551b411b363SPhilipp Reisner if (queued > sndbuf / 2) 552b411b363SPhilipp Reisner goto requeue; 553b411b363SPhilipp Reisner 554b411b363SPhilipp Reisner next_sector: 555b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 556b411b363SPhilipp Reisner bit = drbd_bm_find_next(mdev, mdev->bm_resync_fo); 557b411b363SPhilipp Reisner 5584b0715f0SLars Ellenberg if (bit == DRBD_END_OF_BITMAP) { 559b411b363SPhilipp Reisner mdev->bm_resync_fo = drbd_bm_bits(mdev); 560b411b363SPhilipp Reisner put_ldev(mdev); 56199920dc5SAndreas Gruenbacher return 0; 562b411b363SPhilipp Reisner } 563b411b363SPhilipp Reisner 564b411b363SPhilipp Reisner sector = BM_BIT_TO_SECT(bit); 565b411b363SPhilipp Reisner 566e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 567e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 568b411b363SPhilipp Reisner mdev->bm_resync_fo = bit; 569b411b363SPhilipp Reisner goto requeue; 570b411b363SPhilipp Reisner } 571b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 572b411b363SPhilipp Reisner 573b411b363SPhilipp Reisner if (unlikely(drbd_bm_test_bit(mdev, bit) == 0)) { 574b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 575b411b363SPhilipp Reisner goto next_sector; 576b411b363SPhilipp Reisner } 577b411b363SPhilipp Reisner 5781816a2b4SLars Ellenberg #if DRBD_MAX_BIO_SIZE > BM_BLOCK_SIZE 579b411b363SPhilipp Reisner /* try to find some adjacent bits. 580b411b363SPhilipp Reisner * we stop if we have already the maximum req size. 581b411b363SPhilipp Reisner * 582b411b363SPhilipp Reisner * Additionally always align bigger requests, in order to 583b411b363SPhilipp Reisner * be prepared for all stripe sizes of software RAIDs. 584b411b363SPhilipp Reisner */ 585b411b363SPhilipp Reisner align = 1; 586d207450cSPhilipp Reisner rollback_i = i; 587b411b363SPhilipp Reisner for (;;) { 5881816a2b4SLars Ellenberg if (size + BM_BLOCK_SIZE > max_bio_size) 589b411b363SPhilipp Reisner break; 590b411b363SPhilipp Reisner 591b411b363SPhilipp Reisner /* Be always aligned */ 592b411b363SPhilipp Reisner if (sector & ((1<<(align+3))-1)) 593b411b363SPhilipp Reisner break; 594b411b363SPhilipp Reisner 595b411b363SPhilipp Reisner /* do not cross extent boundaries */ 596b411b363SPhilipp Reisner if (((bit+1) & BM_BLOCKS_PER_BM_EXT_MASK) == 0) 597b411b363SPhilipp Reisner break; 598b411b363SPhilipp Reisner /* now, is it actually dirty, after all? 599b411b363SPhilipp Reisner * caution, drbd_bm_test_bit is tri-state for some 600b411b363SPhilipp Reisner * obscure reason; ( b == 0 ) would get the out-of-band 601b411b363SPhilipp Reisner * only accidentally right because of the "oddly sized" 602b411b363SPhilipp Reisner * adjustment below */ 603b411b363SPhilipp Reisner if (drbd_bm_test_bit(mdev, bit+1) != 1) 604b411b363SPhilipp Reisner break; 605b411b363SPhilipp Reisner bit++; 606b411b363SPhilipp Reisner size += BM_BLOCK_SIZE; 607b411b363SPhilipp Reisner if ((BM_BLOCK_SIZE << align) <= size) 608b411b363SPhilipp Reisner align++; 609b411b363SPhilipp Reisner i++; 610b411b363SPhilipp Reisner } 611b411b363SPhilipp Reisner /* if we merged some, 612b411b363SPhilipp Reisner * reset the offset to start the next drbd_bm_find_next from */ 613b411b363SPhilipp Reisner if (size > BM_BLOCK_SIZE) 614b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 615b411b363SPhilipp Reisner #endif 616b411b363SPhilipp Reisner 617b411b363SPhilipp Reisner /* adjust very last sectors, in case we are oddly sized */ 618b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 619b411b363SPhilipp Reisner size = (capacity-sector)<<9; 620f399002eSLars Ellenberg if (mdev->tconn->agreed_pro_version >= 89 && mdev->tconn->csums_tfm) { 621b411b363SPhilipp Reisner switch (read_for_csum(mdev, sector, size)) { 62280a40e43SLars Ellenberg case -EIO: /* Disk failure */ 623b411b363SPhilipp Reisner put_ldev(mdev); 62499920dc5SAndreas Gruenbacher return -EIO; 62580a40e43SLars Ellenberg case -EAGAIN: /* allocation failed, or ldev busy */ 626b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 627b411b363SPhilipp Reisner mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 628d207450cSPhilipp Reisner i = rollback_i; 629b411b363SPhilipp Reisner goto requeue; 63080a40e43SLars Ellenberg case 0: 63180a40e43SLars Ellenberg /* everything ok */ 63280a40e43SLars Ellenberg break; 63380a40e43SLars Ellenberg default: 63480a40e43SLars Ellenberg BUG(); 635b411b363SPhilipp Reisner } 636b411b363SPhilipp Reisner } else { 63799920dc5SAndreas Gruenbacher int err; 63899920dc5SAndreas Gruenbacher 639b411b363SPhilipp Reisner inc_rs_pending(mdev); 64099920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_RS_DATA_REQUEST, 64199920dc5SAndreas Gruenbacher sector, size, ID_SYNCER); 64299920dc5SAndreas Gruenbacher if (err) { 643b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest() failed, aborting...\n"); 644b411b363SPhilipp Reisner dec_rs_pending(mdev); 645b411b363SPhilipp Reisner put_ldev(mdev); 64699920dc5SAndreas Gruenbacher return err; 647b411b363SPhilipp Reisner } 648b411b363SPhilipp Reisner } 649b411b363SPhilipp Reisner } 650b411b363SPhilipp Reisner 651b411b363SPhilipp Reisner if (mdev->bm_resync_fo >= drbd_bm_bits(mdev)) { 652b411b363SPhilipp Reisner /* last syncer _request_ was sent, 653b411b363SPhilipp Reisner * but the P_RS_DATA_REPLY not yet received. sync will end (and 654b411b363SPhilipp Reisner * next sync group will resume), as soon as we receive the last 655b411b363SPhilipp Reisner * resync data block, and the last bit is cleared. 656b411b363SPhilipp Reisner * until then resync "work" is "inactive" ... 657b411b363SPhilipp Reisner */ 658b411b363SPhilipp Reisner put_ldev(mdev); 65999920dc5SAndreas Gruenbacher return 0; 660b411b363SPhilipp Reisner } 661b411b363SPhilipp Reisner 662b411b363SPhilipp Reisner requeue: 663778f271dSPhilipp Reisner mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 664b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 665b411b363SPhilipp Reisner put_ldev(mdev); 66699920dc5SAndreas Gruenbacher return 0; 667b411b363SPhilipp Reisner } 668b411b363SPhilipp Reisner 66900d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel) 670b411b363SPhilipp Reisner { 67100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 672b411b363SPhilipp Reisner int number, i, size; 673b411b363SPhilipp Reisner sector_t sector; 674b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 675b411b363SPhilipp Reisner 676b411b363SPhilipp Reisner if (unlikely(cancel)) 677b411b363SPhilipp Reisner return 1; 678b411b363SPhilipp Reisner 6792649f080SLars Ellenberg number = drbd_rs_number_requests(mdev); 680b411b363SPhilipp Reisner 681b411b363SPhilipp Reisner sector = mdev->ov_position; 682b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 683b411b363SPhilipp Reisner if (sector >= capacity) { 684b411b363SPhilipp Reisner return 1; 685b411b363SPhilipp Reisner } 686b411b363SPhilipp Reisner 687b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 688b411b363SPhilipp Reisner 689e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 690e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 691b411b363SPhilipp Reisner mdev->ov_position = sector; 692b411b363SPhilipp Reisner goto requeue; 693b411b363SPhilipp Reisner } 694b411b363SPhilipp Reisner 695b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 696b411b363SPhilipp Reisner size = (capacity-sector)<<9; 697b411b363SPhilipp Reisner 698b411b363SPhilipp Reisner inc_rs_pending(mdev); 6995b9f499cSAndreas Gruenbacher if (drbd_send_ov_request(mdev, sector, size)) { 700b411b363SPhilipp Reisner dec_rs_pending(mdev); 701b411b363SPhilipp Reisner return 0; 702b411b363SPhilipp Reisner } 703b411b363SPhilipp Reisner sector += BM_SECT_PER_BIT; 704b411b363SPhilipp Reisner } 705b411b363SPhilipp Reisner mdev->ov_position = sector; 706b411b363SPhilipp Reisner 707b411b363SPhilipp Reisner requeue: 7082649f080SLars Ellenberg mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 709b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 710b411b363SPhilipp Reisner return 1; 711b411b363SPhilipp Reisner } 712b411b363SPhilipp Reisner 71399920dc5SAndreas Gruenbacher int w_ov_finished(struct drbd_work *w, int cancel) 714b411b363SPhilipp Reisner { 71500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 716b411b363SPhilipp Reisner kfree(w); 7178f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 718b411b363SPhilipp Reisner drbd_resync_finished(mdev); 719b411b363SPhilipp Reisner 72099920dc5SAndreas Gruenbacher return 0; 721b411b363SPhilipp Reisner } 722b411b363SPhilipp Reisner 72399920dc5SAndreas Gruenbacher static int w_resync_finished(struct drbd_work *w, int cancel) 724b411b363SPhilipp Reisner { 72500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 726b411b363SPhilipp Reisner kfree(w); 727b411b363SPhilipp Reisner 728b411b363SPhilipp Reisner drbd_resync_finished(mdev); 729b411b363SPhilipp Reisner 73099920dc5SAndreas Gruenbacher return 0; 731b411b363SPhilipp Reisner } 732b411b363SPhilipp Reisner 733af85e8e8SLars Ellenberg static void ping_peer(struct drbd_conf *mdev) 734af85e8e8SLars Ellenberg { 7352a67d8b9SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 7362a67d8b9SPhilipp Reisner 7372a67d8b9SPhilipp Reisner clear_bit(GOT_PING_ACK, &tconn->flags); 7382a67d8b9SPhilipp Reisner request_ping(tconn); 7392a67d8b9SPhilipp Reisner wait_event(tconn->ping_wait, 7402a67d8b9SPhilipp Reisner test_bit(GOT_PING_ACK, &tconn->flags) || mdev->state.conn < C_CONNECTED); 741af85e8e8SLars Ellenberg } 742af85e8e8SLars Ellenberg 743b411b363SPhilipp Reisner int drbd_resync_finished(struct drbd_conf *mdev) 744b411b363SPhilipp Reisner { 745b411b363SPhilipp Reisner unsigned long db, dt, dbdt; 746b411b363SPhilipp Reisner unsigned long n_oos; 747b411b363SPhilipp Reisner union drbd_state os, ns; 748b411b363SPhilipp Reisner struct drbd_work *w; 749b411b363SPhilipp Reisner char *khelper_cmd = NULL; 75026525618SLars Ellenberg int verify_done = 0; 751b411b363SPhilipp Reisner 752b411b363SPhilipp Reisner /* Remove all elements from the resync LRU. Since future actions 753b411b363SPhilipp Reisner * might set bits in the (main) bitmap, then the entries in the 754b411b363SPhilipp Reisner * resync LRU would be wrong. */ 755b411b363SPhilipp Reisner if (drbd_rs_del_all(mdev)) { 756b411b363SPhilipp Reisner /* In case this is not possible now, most probably because 757b411b363SPhilipp Reisner * there are P_RS_DATA_REPLY Packets lingering on the worker's 758b411b363SPhilipp Reisner * queue (or even the read operations for those packets 759b411b363SPhilipp Reisner * is not finished by now). Retry in 100ms. */ 760b411b363SPhilipp Reisner 76120ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 762b411b363SPhilipp Reisner w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC); 763b411b363SPhilipp Reisner if (w) { 764b411b363SPhilipp Reisner w->cb = w_resync_finished; 765e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, w); 766b411b363SPhilipp Reisner return 1; 767b411b363SPhilipp Reisner } 768b411b363SPhilipp Reisner dev_err(DEV, "Warn failed to drbd_rs_del_all() and to kmalloc(w).\n"); 769b411b363SPhilipp Reisner } 770b411b363SPhilipp Reisner 771b411b363SPhilipp Reisner dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ; 772b411b363SPhilipp Reisner if (dt <= 0) 773b411b363SPhilipp Reisner dt = 1; 774b411b363SPhilipp Reisner db = mdev->rs_total; 775b411b363SPhilipp Reisner dbdt = Bit2KB(db/dt); 776b411b363SPhilipp Reisner mdev->rs_paused /= HZ; 777b411b363SPhilipp Reisner 778b411b363SPhilipp Reisner if (!get_ldev(mdev)) 779b411b363SPhilipp Reisner goto out; 780b411b363SPhilipp Reisner 781af85e8e8SLars Ellenberg ping_peer(mdev); 782af85e8e8SLars Ellenberg 78387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 784b411b363SPhilipp Reisner os = mdev->state; 785b411b363SPhilipp Reisner 78626525618SLars Ellenberg verify_done = (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T); 78726525618SLars Ellenberg 788b411b363SPhilipp Reisner /* This protects us against multiple calls (that can happen in the presence 789b411b363SPhilipp Reisner of application IO), and against connectivity loss just before we arrive here. */ 790b411b363SPhilipp Reisner if (os.conn <= C_CONNECTED) 791b411b363SPhilipp Reisner goto out_unlock; 792b411b363SPhilipp Reisner 793b411b363SPhilipp Reisner ns = os; 794b411b363SPhilipp Reisner ns.conn = C_CONNECTED; 795b411b363SPhilipp Reisner 796b411b363SPhilipp Reisner dev_info(DEV, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n", 79726525618SLars Ellenberg verify_done ? "Online verify " : "Resync", 798b411b363SPhilipp Reisner dt + mdev->rs_paused, mdev->rs_paused, dbdt); 799b411b363SPhilipp Reisner 800b411b363SPhilipp Reisner n_oos = drbd_bm_total_weight(mdev); 801b411b363SPhilipp Reisner 802b411b363SPhilipp Reisner if (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) { 803b411b363SPhilipp Reisner if (n_oos) { 804b411b363SPhilipp Reisner dev_alert(DEV, "Online verify found %lu %dk block out of sync!\n", 805b411b363SPhilipp Reisner n_oos, Bit2KB(1)); 806b411b363SPhilipp Reisner khelper_cmd = "out-of-sync"; 807b411b363SPhilipp Reisner } 808b411b363SPhilipp Reisner } else { 809b411b363SPhilipp Reisner D_ASSERT((n_oos - mdev->rs_failed) == 0); 810b411b363SPhilipp Reisner 811b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) 812b411b363SPhilipp Reisner khelper_cmd = "after-resync-target"; 813b411b363SPhilipp Reisner 814f399002eSLars Ellenberg if (mdev->tconn->csums_tfm && mdev->rs_total) { 815b411b363SPhilipp Reisner const unsigned long s = mdev->rs_same_csum; 816b411b363SPhilipp Reisner const unsigned long t = mdev->rs_total; 817b411b363SPhilipp Reisner const int ratio = 818b411b363SPhilipp Reisner (t == 0) ? 0 : 819b411b363SPhilipp Reisner (t < 100000) ? ((s*100)/t) : (s/(t/100)); 820b411b363SPhilipp Reisner dev_info(DEV, "%u %% had equal checksums, eliminated: %luK; " 821b411b363SPhilipp Reisner "transferred %luK total %luK\n", 822b411b363SPhilipp Reisner ratio, 823b411b363SPhilipp Reisner Bit2KB(mdev->rs_same_csum), 824b411b363SPhilipp Reisner Bit2KB(mdev->rs_total - mdev->rs_same_csum), 825b411b363SPhilipp Reisner Bit2KB(mdev->rs_total)); 826b411b363SPhilipp Reisner } 827b411b363SPhilipp Reisner } 828b411b363SPhilipp Reisner 829b411b363SPhilipp Reisner if (mdev->rs_failed) { 830b411b363SPhilipp Reisner dev_info(DEV, " %lu failed blocks\n", mdev->rs_failed); 831b411b363SPhilipp Reisner 832b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 833b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 834b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 835b411b363SPhilipp Reisner } else { 836b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 837b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 838b411b363SPhilipp Reisner } 839b411b363SPhilipp Reisner } else { 840b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 841b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 842b411b363SPhilipp Reisner 843b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 844b411b363SPhilipp Reisner if (mdev->p_uuid) { 845b411b363SPhilipp Reisner int i; 846b411b363SPhilipp Reisner for (i = UI_BITMAP ; i <= UI_HISTORY_END ; i++) 847b411b363SPhilipp Reisner _drbd_uuid_set(mdev, i, mdev->p_uuid[i]); 848b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_CURRENT]); 849b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, mdev->p_uuid[UI_CURRENT]); 850b411b363SPhilipp Reisner } else { 851b411b363SPhilipp Reisner dev_err(DEV, "mdev->p_uuid is NULL! BUG\n"); 852b411b363SPhilipp Reisner } 853b411b363SPhilipp Reisner } 854b411b363SPhilipp Reisner 85562b0da3aSLars Ellenberg if (!(os.conn == C_VERIFY_S || os.conn == C_VERIFY_T)) { 85662b0da3aSLars Ellenberg /* for verify runs, we don't update uuids here, 85762b0da3aSLars Ellenberg * so there would be nothing to report. */ 858b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 85962b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated UUIDs"); 860b411b363SPhilipp Reisner if (mdev->p_uuid) { 861b411b363SPhilipp Reisner /* Now the two UUID sets are equal, update what we 862b411b363SPhilipp Reisner * know of the peer. */ 863b411b363SPhilipp Reisner int i; 864b411b363SPhilipp Reisner for (i = UI_CURRENT ; i <= UI_HISTORY_END ; i++) 865b411b363SPhilipp Reisner mdev->p_uuid[i] = mdev->ldev->md.uuid[i]; 866b411b363SPhilipp Reisner } 867b411b363SPhilipp Reisner } 86862b0da3aSLars Ellenberg } 869b411b363SPhilipp Reisner 870b411b363SPhilipp Reisner _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 871b411b363SPhilipp Reisner out_unlock: 87287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 873b411b363SPhilipp Reisner put_ldev(mdev); 874b411b363SPhilipp Reisner out: 875b411b363SPhilipp Reisner mdev->rs_total = 0; 876b411b363SPhilipp Reisner mdev->rs_failed = 0; 877b411b363SPhilipp Reisner mdev->rs_paused = 0; 87826525618SLars Ellenberg if (verify_done) 879b411b363SPhilipp Reisner mdev->ov_start_sector = 0; 880b411b363SPhilipp Reisner 88113d42685SLars Ellenberg drbd_md_sync(mdev); 88213d42685SLars Ellenberg 883b411b363SPhilipp Reisner if (khelper_cmd) 884b411b363SPhilipp Reisner drbd_khelper(mdev, khelper_cmd); 885b411b363SPhilipp Reisner 886b411b363SPhilipp Reisner return 1; 887b411b363SPhilipp Reisner } 888b411b363SPhilipp Reisner 889b411b363SPhilipp Reisner /* helper */ 890db830c46SAndreas Gruenbacher static void move_to_net_ee_or_free(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 891b411b363SPhilipp Reisner { 892db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) { 893b411b363SPhilipp Reisner /* This might happen if sendpage() has not finished */ 894db830c46SAndreas Gruenbacher int i = (peer_req->i.size + PAGE_SIZE -1) >> PAGE_SHIFT; 895435f0740SLars Ellenberg atomic_add(i, &mdev->pp_in_use_by_net); 896435f0740SLars Ellenberg atomic_sub(i, &mdev->pp_in_use); 89787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 898db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->net_ee); 89987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 900435f0740SLars Ellenberg wake_up(&drbd_pp_wait); 901b411b363SPhilipp Reisner } else 902db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 903b411b363SPhilipp Reisner } 904b411b363SPhilipp Reisner 905b411b363SPhilipp Reisner /** 906b411b363SPhilipp Reisner * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 907b411b363SPhilipp Reisner * @mdev: DRBD device. 908b411b363SPhilipp Reisner * @w: work object. 909b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 910b411b363SPhilipp Reisner */ 91199920dc5SAndreas Gruenbacher int w_e_end_data_req(struct drbd_work *w, int cancel) 912b411b363SPhilipp Reisner { 913db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 91400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 91599920dc5SAndreas Gruenbacher int err; 916b411b363SPhilipp Reisner 917b411b363SPhilipp Reisner if (unlikely(cancel)) { 918db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 919b411b363SPhilipp Reisner dec_unacked(mdev); 92099920dc5SAndreas Gruenbacher return 0; 921b411b363SPhilipp Reisner } 922b411b363SPhilipp Reisner 923db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 92499920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_DATA_REPLY, peer_req); 925b411b363SPhilipp Reisner } else { 926b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 927b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. sector=%llus.\n", 928db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 929b411b363SPhilipp Reisner 93099920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_DREPLY, peer_req); 931b411b363SPhilipp Reisner } 932b411b363SPhilipp Reisner 933b411b363SPhilipp Reisner dec_unacked(mdev); 934b411b363SPhilipp Reisner 935db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 936b411b363SPhilipp Reisner 93799920dc5SAndreas Gruenbacher if (unlikely(err)) 938b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 93999920dc5SAndreas Gruenbacher return err; 940b411b363SPhilipp Reisner } 941b411b363SPhilipp Reisner 942b411b363SPhilipp Reisner /** 943b411b363SPhilipp Reisner * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUESTRS 944b411b363SPhilipp Reisner * @mdev: DRBD device. 945b411b363SPhilipp Reisner * @w: work object. 946b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 947b411b363SPhilipp Reisner */ 94899920dc5SAndreas Gruenbacher int w_e_end_rsdata_req(struct drbd_work *w, int cancel) 949b411b363SPhilipp Reisner { 950db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 95100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 95299920dc5SAndreas Gruenbacher int err; 953b411b363SPhilipp Reisner 954b411b363SPhilipp Reisner if (unlikely(cancel)) { 955db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 956b411b363SPhilipp Reisner dec_unacked(mdev); 95799920dc5SAndreas Gruenbacher return 0; 958b411b363SPhilipp Reisner } 959b411b363SPhilipp Reisner 960b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 961db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 962b411b363SPhilipp Reisner put_ldev(mdev); 963b411b363SPhilipp Reisner } 964b411b363SPhilipp Reisner 965d612d309SPhilipp Reisner if (mdev->state.conn == C_AHEAD) { 96699920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_CANCEL, peer_req); 967db830c46SAndreas Gruenbacher } else if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 968b411b363SPhilipp Reisner if (likely(mdev->state.pdsk >= D_INCONSISTENT)) { 969b411b363SPhilipp Reisner inc_rs_pending(mdev); 97099920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 971b411b363SPhilipp Reisner } else { 972b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 973b411b363SPhilipp Reisner dev_err(DEV, "Not sending RSDataReply, " 974b411b363SPhilipp Reisner "partner DISKLESS!\n"); 97599920dc5SAndreas Gruenbacher err = 0; 976b411b363SPhilipp Reisner } 977b411b363SPhilipp Reisner } else { 978b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 979b411b363SPhilipp Reisner dev_err(DEV, "Sending NegRSDReply. sector %llus.\n", 980db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 981b411b363SPhilipp Reisner 98299920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 983b411b363SPhilipp Reisner 984b411b363SPhilipp Reisner /* update resync data with failure */ 985db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, peer_req->i.sector, peer_req->i.size); 986b411b363SPhilipp Reisner } 987b411b363SPhilipp Reisner 988b411b363SPhilipp Reisner dec_unacked(mdev); 989b411b363SPhilipp Reisner 990db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 991b411b363SPhilipp Reisner 99299920dc5SAndreas Gruenbacher if (unlikely(err)) 993b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 99499920dc5SAndreas Gruenbacher return err; 995b411b363SPhilipp Reisner } 996b411b363SPhilipp Reisner 99799920dc5SAndreas Gruenbacher int w_e_end_csum_rs_req(struct drbd_work *w, int cancel) 998b411b363SPhilipp Reisner { 999db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 100000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1001b411b363SPhilipp Reisner struct digest_info *di; 1002b411b363SPhilipp Reisner int digest_size; 1003b411b363SPhilipp Reisner void *digest = NULL; 100499920dc5SAndreas Gruenbacher int err, eq = 0; 1005b411b363SPhilipp Reisner 1006b411b363SPhilipp Reisner if (unlikely(cancel)) { 1007db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1008b411b363SPhilipp Reisner dec_unacked(mdev); 100999920dc5SAndreas Gruenbacher return 0; 1010b411b363SPhilipp Reisner } 1011b411b363SPhilipp Reisner 10121d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1013db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 10141d53f09eSLars Ellenberg put_ldev(mdev); 10151d53f09eSLars Ellenberg } 1016b411b363SPhilipp Reisner 1017db830c46SAndreas Gruenbacher di = peer_req->digest; 1018b411b363SPhilipp Reisner 1019db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1020b411b363SPhilipp Reisner /* quick hack to try to avoid a race against reconfiguration. 1021b411b363SPhilipp Reisner * a real fix would be much more involved, 1022b411b363SPhilipp Reisner * introducing more locking mechanisms */ 1023f399002eSLars Ellenberg if (mdev->tconn->csums_tfm) { 1024f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 1025b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1026b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1027b411b363SPhilipp Reisner } 1028b411b363SPhilipp Reisner if (digest) { 1029f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 1030b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1031b411b363SPhilipp Reisner kfree(digest); 1032b411b363SPhilipp Reisner } 1033b411b363SPhilipp Reisner 1034b411b363SPhilipp Reisner if (eq) { 1035db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, peer_req->i.sector, peer_req->i.size); 1036676396d5SLars Ellenberg /* rs_same_csums unit is BM_BLOCK_SIZE */ 1037db830c46SAndreas Gruenbacher mdev->rs_same_csum += peer_req->i.size >> BM_BLOCK_SHIFT; 103899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_IS_IN_SYNC, peer_req); 1039b411b363SPhilipp Reisner } else { 1040b411b363SPhilipp Reisner inc_rs_pending(mdev); 1041db830c46SAndreas Gruenbacher peer_req->block_id = ID_SYNCER; /* By setting block_id, digest pointer becomes invalid! */ 1042db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_HAS_DIGEST; /* This peer request no longer has a digest pointer */ 1043204bba99SPhilipp Reisner kfree(di); 104499920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 1045b411b363SPhilipp Reisner } 1046b411b363SPhilipp Reisner } else { 104799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 1048b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1049b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 1050b411b363SPhilipp Reisner } 1051b411b363SPhilipp Reisner 1052b411b363SPhilipp Reisner dec_unacked(mdev); 1053db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 1054b411b363SPhilipp Reisner 105599920dc5SAndreas Gruenbacher if (unlikely(err)) 1056b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block/ack() failed\n"); 105799920dc5SAndreas Gruenbacher return err; 1058b411b363SPhilipp Reisner } 1059b411b363SPhilipp Reisner 106099920dc5SAndreas Gruenbacher int w_e_end_ov_req(struct drbd_work *w, int cancel) 1061b411b363SPhilipp Reisner { 1062db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 106300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1064db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1065db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 1066b411b363SPhilipp Reisner int digest_size; 1067b411b363SPhilipp Reisner void *digest; 106899920dc5SAndreas Gruenbacher int err = 0; 1069b411b363SPhilipp Reisner 1070b411b363SPhilipp Reisner if (unlikely(cancel)) 1071b411b363SPhilipp Reisner goto out; 1072b411b363SPhilipp Reisner 1073f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1074b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 10758f21420eSPhilipp Reisner if (!digest) { 107699920dc5SAndreas Gruenbacher err = 1; /* terminate the connection in case the allocation failed */ 10778f21420eSPhilipp Reisner goto out; 10788f21420eSPhilipp Reisner } 10798f21420eSPhilipp Reisner 1080db830c46SAndreas Gruenbacher if (likely(!(peer_req->flags & EE_WAS_ERROR))) 1081f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 10828f21420eSPhilipp Reisner else 10838f21420eSPhilipp Reisner memset(digest, 0, digest_size); 10848f21420eSPhilipp Reisner 108553ea4331SLars Ellenberg /* Free e and pages before send. 108653ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 108753ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 108853ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 108953ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 1090db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1091db830c46SAndreas Gruenbacher peer_req = NULL; 1092b411b363SPhilipp Reisner inc_rs_pending(mdev); 109399920dc5SAndreas Gruenbacher err = drbd_send_drequest_csum(mdev, sector, size, digest, digest_size, P_OV_REPLY); 109499920dc5SAndreas Gruenbacher if (err) 1095b411b363SPhilipp Reisner dec_rs_pending(mdev); 1096b411b363SPhilipp Reisner kfree(digest); 1097b411b363SPhilipp Reisner 1098b411b363SPhilipp Reisner out: 1099db830c46SAndreas Gruenbacher if (peer_req) 1100db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1101b411b363SPhilipp Reisner dec_unacked(mdev); 110299920dc5SAndreas Gruenbacher return err; 1103b411b363SPhilipp Reisner } 1104b411b363SPhilipp Reisner 11058f7bed77SAndreas Gruenbacher void drbd_ov_out_of_sync_found(struct drbd_conf *mdev, sector_t sector, int size) 1106b411b363SPhilipp Reisner { 1107b411b363SPhilipp Reisner if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) { 1108b411b363SPhilipp Reisner mdev->ov_last_oos_size += size>>9; 1109b411b363SPhilipp Reisner } else { 1110b411b363SPhilipp Reisner mdev->ov_last_oos_start = sector; 1111b411b363SPhilipp Reisner mdev->ov_last_oos_size = size>>9; 1112b411b363SPhilipp Reisner } 1113b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 1114b411b363SPhilipp Reisner } 1115b411b363SPhilipp Reisner 111699920dc5SAndreas Gruenbacher int w_e_end_ov_reply(struct drbd_work *w, int cancel) 1117b411b363SPhilipp Reisner { 1118db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 111900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1120b411b363SPhilipp Reisner struct digest_info *di; 1121b411b363SPhilipp Reisner void *digest; 1122db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1123db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 112453ea4331SLars Ellenberg int digest_size; 112599920dc5SAndreas Gruenbacher int err, eq = 0; 1126b411b363SPhilipp Reisner 1127b411b363SPhilipp Reisner if (unlikely(cancel)) { 1128db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1129b411b363SPhilipp Reisner dec_unacked(mdev); 113099920dc5SAndreas Gruenbacher return 0; 1131b411b363SPhilipp Reisner } 1132b411b363SPhilipp Reisner 1133b411b363SPhilipp Reisner /* after "cancel", because after drbd_disconnect/drbd_rs_cancel_all 1134b411b363SPhilipp Reisner * the resync lru has been cleaned up already */ 11351d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1136db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 11371d53f09eSLars Ellenberg put_ldev(mdev); 11381d53f09eSLars Ellenberg } 1139b411b363SPhilipp Reisner 1140db830c46SAndreas Gruenbacher di = peer_req->digest; 1141b411b363SPhilipp Reisner 1142db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1143f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1144b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1145b411b363SPhilipp Reisner if (digest) { 1146f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 1147b411b363SPhilipp Reisner 1148b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1149b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1150b411b363SPhilipp Reisner kfree(digest); 1151b411b363SPhilipp Reisner } 1152b411b363SPhilipp Reisner } 1153b411b363SPhilipp Reisner 11549676c760SLars Ellenberg /* Free peer_req and pages before send. 115553ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 115653ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 115753ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 115853ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 1159db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1160b411b363SPhilipp Reisner if (!eq) 11618f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 1162b411b363SPhilipp Reisner else 11638f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1164b411b363SPhilipp Reisner 116599920dc5SAndreas Gruenbacher err = drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, 1166b411b363SPhilipp Reisner eq ? ID_IN_SYNC : ID_OUT_OF_SYNC); 1167b411b363SPhilipp Reisner 116853ea4331SLars Ellenberg dec_unacked(mdev); 1169b411b363SPhilipp Reisner 1170ea5442afSLars Ellenberg --mdev->ov_left; 1171ea5442afSLars Ellenberg 1172ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 1173ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 1174ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 1175ea5442afSLars Ellenberg 1176ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 11778f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1178b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1179b411b363SPhilipp Reisner } 1180b411b363SPhilipp Reisner 118199920dc5SAndreas Gruenbacher return err; 1182b411b363SPhilipp Reisner } 1183b411b363SPhilipp Reisner 118499920dc5SAndreas Gruenbacher int w_prev_work_done(struct drbd_work *w, int cancel) 1185b411b363SPhilipp Reisner { 1186b411b363SPhilipp Reisner struct drbd_wq_barrier *b = container_of(w, struct drbd_wq_barrier, w); 118700d56944SPhilipp Reisner 1188b411b363SPhilipp Reisner complete(&b->done); 118999920dc5SAndreas Gruenbacher return 0; 1190b411b363SPhilipp Reisner } 1191b411b363SPhilipp Reisner 119299920dc5SAndreas Gruenbacher int w_send_barrier(struct drbd_work *w, int cancel) 1193b411b363SPhilipp Reisner { 1194b411b363SPhilipp Reisner struct drbd_tl_epoch *b = container_of(w, struct drbd_tl_epoch, w); 119500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1196e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.sbuf.barrier; 119799920dc5SAndreas Gruenbacher int err = 0; 1198b411b363SPhilipp Reisner 1199b411b363SPhilipp Reisner /* really avoid racing with tl_clear. w.cb may have been referenced 1200b411b363SPhilipp Reisner * just before it was reassigned and re-queued, so double check that. 1201b411b363SPhilipp Reisner * actually, this race was harmless, since we only try to send the 1202b411b363SPhilipp Reisner * barrier packet here, and otherwise do nothing with the object. 1203b411b363SPhilipp Reisner * but compare with the head of w_clear_epoch */ 120487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1205b411b363SPhilipp Reisner if (w->cb != w_send_barrier || mdev->state.conn < C_CONNECTED) 1206b411b363SPhilipp Reisner cancel = 1; 120787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1208b411b363SPhilipp Reisner if (cancel) 1209b411b363SPhilipp Reisner return 0; 121099920dc5SAndreas Gruenbacher 121199920dc5SAndreas Gruenbacher err = drbd_get_data_sock(mdev->tconn); 121299920dc5SAndreas Gruenbacher if (err) 121399920dc5SAndreas Gruenbacher return err; 1214b411b363SPhilipp Reisner p->barrier = b->br_number; 1215b411b363SPhilipp Reisner /* inc_ap_pending was done where this was queued. 1216b411b363SPhilipp Reisner * dec_ap_pending will be done in got_BarrierAck 1217b411b363SPhilipp Reisner * or (on connection loss) in w_clear_epoch. */ 121899920dc5SAndreas Gruenbacher err = _drbd_send_cmd(mdev, mdev->tconn->data.socket, P_BARRIER, 1219c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 122061120870SPhilipp Reisner drbd_put_data_sock(mdev->tconn); 1221b411b363SPhilipp Reisner 122299920dc5SAndreas Gruenbacher return err; 1223b411b363SPhilipp Reisner } 1224b411b363SPhilipp Reisner 122599920dc5SAndreas Gruenbacher int w_send_write_hint(struct drbd_work *w, int cancel) 1226b411b363SPhilipp Reisner { 122700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1228b411b363SPhilipp Reisner if (cancel) 122999920dc5SAndreas Gruenbacher return 0; 123099920dc5SAndreas Gruenbacher return drbd_send_short_cmd(mdev, P_UNPLUG_REMOTE); 1231b411b363SPhilipp Reisner } 1232b411b363SPhilipp Reisner 12338f7bed77SAndreas Gruenbacher int w_send_out_of_sync(struct drbd_work *w, int cancel) 123473a01a18SPhilipp Reisner { 123573a01a18SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 123600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 123799920dc5SAndreas Gruenbacher int err; 123873a01a18SPhilipp Reisner 123973a01a18SPhilipp Reisner if (unlikely(cancel)) { 12408554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 124199920dc5SAndreas Gruenbacher return 0; 124273a01a18SPhilipp Reisner } 124373a01a18SPhilipp Reisner 12448f7bed77SAndreas Gruenbacher err = drbd_send_out_of_sync(mdev, req); 12458554df1cSAndreas Gruenbacher req_mod(req, OOS_HANDED_TO_NETWORK); 124673a01a18SPhilipp Reisner 124799920dc5SAndreas Gruenbacher return err; 124873a01a18SPhilipp Reisner } 124973a01a18SPhilipp Reisner 1250b411b363SPhilipp Reisner /** 1251b411b363SPhilipp Reisner * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1252b411b363SPhilipp Reisner * @mdev: DRBD device. 1253b411b363SPhilipp Reisner * @w: work object. 1254b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1255b411b363SPhilipp Reisner */ 125699920dc5SAndreas Gruenbacher int w_send_dblock(struct drbd_work *w, int cancel) 1257b411b363SPhilipp Reisner { 1258b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 125900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 126099920dc5SAndreas Gruenbacher int err; 1261b411b363SPhilipp Reisner 1262b411b363SPhilipp Reisner if (unlikely(cancel)) { 12638554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 126499920dc5SAndreas Gruenbacher return 0; 1265b411b363SPhilipp Reisner } 1266b411b363SPhilipp Reisner 126799920dc5SAndreas Gruenbacher err = drbd_send_dblock(mdev, req); 126899920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1269b411b363SPhilipp Reisner 127099920dc5SAndreas Gruenbacher return err; 1271b411b363SPhilipp Reisner } 1272b411b363SPhilipp Reisner 1273b411b363SPhilipp Reisner /** 1274b411b363SPhilipp Reisner * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 1275b411b363SPhilipp Reisner * @mdev: DRBD device. 1276b411b363SPhilipp Reisner * @w: work object. 1277b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1278b411b363SPhilipp Reisner */ 127999920dc5SAndreas Gruenbacher int w_send_read_req(struct drbd_work *w, int cancel) 1280b411b363SPhilipp Reisner { 1281b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 128200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 128399920dc5SAndreas Gruenbacher int err; 1284b411b363SPhilipp Reisner 1285b411b363SPhilipp Reisner if (unlikely(cancel)) { 12868554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 128799920dc5SAndreas Gruenbacher return 0; 1288b411b363SPhilipp Reisner } 1289b411b363SPhilipp Reisner 129099920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_DATA_REQUEST, req->i.sector, req->i.size, 1291b411b363SPhilipp Reisner (unsigned long)req); 1292b411b363SPhilipp Reisner 129399920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1294b411b363SPhilipp Reisner 129599920dc5SAndreas Gruenbacher return err; 1296b411b363SPhilipp Reisner } 1297b411b363SPhilipp Reisner 129899920dc5SAndreas Gruenbacher int w_restart_disk_io(struct drbd_work *w, int cancel) 1299265be2d0SPhilipp Reisner { 1300265be2d0SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 130100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1302265be2d0SPhilipp Reisner 13030778286aSPhilipp Reisner if (bio_data_dir(req->master_bio) == WRITE && req->rq_state & RQ_IN_ACT_LOG) 1304ace652acSAndreas Gruenbacher drbd_al_begin_io(mdev, req->i.sector); 1305265be2d0SPhilipp Reisner /* Calling drbd_al_begin_io() out of the worker might deadlocks 1306265be2d0SPhilipp Reisner theoretically. Practically it can not deadlock, since this is 1307265be2d0SPhilipp Reisner only used when unfreezing IOs. All the extents of the requests 1308265be2d0SPhilipp Reisner that made it into the TL are already active */ 1309265be2d0SPhilipp Reisner 1310265be2d0SPhilipp Reisner drbd_req_make_private_bio(req, req->master_bio); 1311265be2d0SPhilipp Reisner req->private_bio->bi_bdev = mdev->ldev->backing_bdev; 1312265be2d0SPhilipp Reisner generic_make_request(req->private_bio); 1313265be2d0SPhilipp Reisner 131499920dc5SAndreas Gruenbacher return 0; 1315265be2d0SPhilipp Reisner } 1316265be2d0SPhilipp Reisner 1317b411b363SPhilipp Reisner static int _drbd_may_sync_now(struct drbd_conf *mdev) 1318b411b363SPhilipp Reisner { 1319b411b363SPhilipp Reisner struct drbd_conf *odev = mdev; 1320b411b363SPhilipp Reisner 1321b411b363SPhilipp Reisner while (1) { 1322f399002eSLars Ellenberg if (odev->ldev->dc.resync_after == -1) 1323b411b363SPhilipp Reisner return 1; 1324f399002eSLars Ellenberg odev = minor_to_mdev(odev->ldev->dc.resync_after); 1325841ce241SAndreas Gruenbacher if (!expect(odev)) 1326841ce241SAndreas Gruenbacher return 1; 1327b411b363SPhilipp Reisner if ((odev->state.conn >= C_SYNC_SOURCE && 1328b411b363SPhilipp Reisner odev->state.conn <= C_PAUSED_SYNC_T) || 1329b411b363SPhilipp Reisner odev->state.aftr_isp || odev->state.peer_isp || 1330b411b363SPhilipp Reisner odev->state.user_isp) 1331b411b363SPhilipp Reisner return 0; 1332b411b363SPhilipp Reisner } 1333b411b363SPhilipp Reisner } 1334b411b363SPhilipp Reisner 1335b411b363SPhilipp Reisner /** 1336b411b363SPhilipp Reisner * _drbd_pause_after() - Pause resync on all devices that may not resync now 1337b411b363SPhilipp Reisner * @mdev: DRBD device. 1338b411b363SPhilipp Reisner * 1339b411b363SPhilipp Reisner * Called from process context only (admin command and after_state_ch). 1340b411b363SPhilipp Reisner */ 1341b411b363SPhilipp Reisner static int _drbd_pause_after(struct drbd_conf *mdev) 1342b411b363SPhilipp Reisner { 1343b411b363SPhilipp Reisner struct drbd_conf *odev; 1344b411b363SPhilipp Reisner int i, rv = 0; 1345b411b363SPhilipp Reisner 134681a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1347b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1348b411b363SPhilipp Reisner continue; 1349b411b363SPhilipp Reisner if (!_drbd_may_sync_now(odev)) 1350b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 1), CS_HARD, NULL) 1351b411b363SPhilipp Reisner != SS_NOTHING_TO_DO); 1352b411b363SPhilipp Reisner } 1353b411b363SPhilipp Reisner 1354b411b363SPhilipp Reisner return rv; 1355b411b363SPhilipp Reisner } 1356b411b363SPhilipp Reisner 1357b411b363SPhilipp Reisner /** 1358b411b363SPhilipp Reisner * _drbd_resume_next() - Resume resync on all devices that may resync now 1359b411b363SPhilipp Reisner * @mdev: DRBD device. 1360b411b363SPhilipp Reisner * 1361b411b363SPhilipp Reisner * Called from process context only (admin command and worker). 1362b411b363SPhilipp Reisner */ 1363b411b363SPhilipp Reisner static int _drbd_resume_next(struct drbd_conf *mdev) 1364b411b363SPhilipp Reisner { 1365b411b363SPhilipp Reisner struct drbd_conf *odev; 1366b411b363SPhilipp Reisner int i, rv = 0; 1367b411b363SPhilipp Reisner 136881a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1369b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1370b411b363SPhilipp Reisner continue; 1371b411b363SPhilipp Reisner if (odev->state.aftr_isp) { 1372b411b363SPhilipp Reisner if (_drbd_may_sync_now(odev)) 1373b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 0), 1374b411b363SPhilipp Reisner CS_HARD, NULL) 1375b411b363SPhilipp Reisner != SS_NOTHING_TO_DO) ; 1376b411b363SPhilipp Reisner } 1377b411b363SPhilipp Reisner } 1378b411b363SPhilipp Reisner return rv; 1379b411b363SPhilipp Reisner } 1380b411b363SPhilipp Reisner 1381b411b363SPhilipp Reisner void resume_next_sg(struct drbd_conf *mdev) 1382b411b363SPhilipp Reisner { 1383b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1384b411b363SPhilipp Reisner _drbd_resume_next(mdev); 1385b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1386b411b363SPhilipp Reisner } 1387b411b363SPhilipp Reisner 1388b411b363SPhilipp Reisner void suspend_other_sg(struct drbd_conf *mdev) 1389b411b363SPhilipp Reisner { 1390b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1391b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1392b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1393b411b363SPhilipp Reisner } 1394b411b363SPhilipp Reisner 1395b411b363SPhilipp Reisner static int sync_after_error(struct drbd_conf *mdev, int o_minor) 1396b411b363SPhilipp Reisner { 1397b411b363SPhilipp Reisner struct drbd_conf *odev; 1398b411b363SPhilipp Reisner 1399b411b363SPhilipp Reisner if (o_minor == -1) 1400b411b363SPhilipp Reisner return NO_ERROR; 1401b411b363SPhilipp Reisner if (o_minor < -1 || minor_to_mdev(o_minor) == NULL) 1402b411b363SPhilipp Reisner return ERR_SYNC_AFTER; 1403b411b363SPhilipp Reisner 1404b411b363SPhilipp Reisner /* check for loops */ 1405b411b363SPhilipp Reisner odev = minor_to_mdev(o_minor); 1406b411b363SPhilipp Reisner while (1) { 1407b411b363SPhilipp Reisner if (odev == mdev) 1408b411b363SPhilipp Reisner return ERR_SYNC_AFTER_CYCLE; 1409b411b363SPhilipp Reisner 1410b411b363SPhilipp Reisner /* dependency chain ends here, no cycles. */ 1411f399002eSLars Ellenberg if (odev->ldev->dc.resync_after == -1) 1412b411b363SPhilipp Reisner return NO_ERROR; 1413b411b363SPhilipp Reisner 1414b411b363SPhilipp Reisner /* follow the dependency chain */ 1415f399002eSLars Ellenberg odev = minor_to_mdev(odev->ldev->dc.resync_after); 1416b411b363SPhilipp Reisner } 1417b411b363SPhilipp Reisner } 1418b411b363SPhilipp Reisner 1419b411b363SPhilipp Reisner int drbd_alter_sa(struct drbd_conf *mdev, int na) 1420b411b363SPhilipp Reisner { 1421b411b363SPhilipp Reisner int changes; 1422b411b363SPhilipp Reisner int retcode; 1423b411b363SPhilipp Reisner 1424b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1425b411b363SPhilipp Reisner retcode = sync_after_error(mdev, na); 1426b411b363SPhilipp Reisner if (retcode == NO_ERROR) { 1427f399002eSLars Ellenberg mdev->ldev->dc.resync_after = na; 1428b411b363SPhilipp Reisner do { 1429b411b363SPhilipp Reisner changes = _drbd_pause_after(mdev); 1430b411b363SPhilipp Reisner changes |= _drbd_resume_next(mdev); 1431b411b363SPhilipp Reisner } while (changes); 1432b411b363SPhilipp Reisner } 1433b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1434b411b363SPhilipp Reisner return retcode; 1435b411b363SPhilipp Reisner } 1436b411b363SPhilipp Reisner 14379bd28d3cSLars Ellenberg void drbd_rs_controller_reset(struct drbd_conf *mdev) 14389bd28d3cSLars Ellenberg { 14399bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_in, 0); 14409bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_ev, 0); 14419bd28d3cSLars Ellenberg mdev->rs_in_flight = 0; 14429bd28d3cSLars Ellenberg mdev->rs_planed = 0; 14439bd28d3cSLars Ellenberg spin_lock(&mdev->peer_seq_lock); 14449bd28d3cSLars Ellenberg fifo_set(&mdev->rs_plan_s, 0); 14459bd28d3cSLars Ellenberg spin_unlock(&mdev->peer_seq_lock); 14469bd28d3cSLars Ellenberg } 14479bd28d3cSLars Ellenberg 14481f04af33SPhilipp Reisner void start_resync_timer_fn(unsigned long data) 14491f04af33SPhilipp Reisner { 14501f04af33SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 14511f04af33SPhilipp Reisner 14521f04af33SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->start_resync_work); 14531f04af33SPhilipp Reisner } 14541f04af33SPhilipp Reisner 145599920dc5SAndreas Gruenbacher int w_start_resync(struct drbd_work *w, int cancel) 14561f04af33SPhilipp Reisner { 145700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 145800d56944SPhilipp Reisner 14591f04af33SPhilipp Reisner if (atomic_read(&mdev->unacked_cnt) || atomic_read(&mdev->rs_pending_cnt)) { 14601f04af33SPhilipp Reisner dev_warn(DEV, "w_start_resync later...\n"); 14611f04af33SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/10; 14621f04af33SPhilipp Reisner add_timer(&mdev->start_resync_timer); 146399920dc5SAndreas Gruenbacher return 0; 14641f04af33SPhilipp Reisner } 14651f04af33SPhilipp Reisner 14661f04af33SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 14671f04af33SPhilipp Reisner clear_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags); 146899920dc5SAndreas Gruenbacher return 0; 14691f04af33SPhilipp Reisner } 14701f04af33SPhilipp Reisner 1471b411b363SPhilipp Reisner /** 1472b411b363SPhilipp Reisner * drbd_start_resync() - Start the resync process 1473b411b363SPhilipp Reisner * @mdev: DRBD device. 1474b411b363SPhilipp Reisner * @side: Either C_SYNC_SOURCE or C_SYNC_TARGET 1475b411b363SPhilipp Reisner * 1476b411b363SPhilipp Reisner * This function might bring you directly into one of the 1477b411b363SPhilipp Reisner * C_PAUSED_SYNC_* states. 1478b411b363SPhilipp Reisner */ 1479b411b363SPhilipp Reisner void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side) 1480b411b363SPhilipp Reisner { 1481b411b363SPhilipp Reisner union drbd_state ns; 1482b411b363SPhilipp Reisner int r; 1483b411b363SPhilipp Reisner 1484c4752ef1SPhilipp Reisner if (mdev->state.conn >= C_SYNC_SOURCE && mdev->state.conn < C_AHEAD) { 1485b411b363SPhilipp Reisner dev_err(DEV, "Resync already running!\n"); 1486b411b363SPhilipp Reisner return; 1487b411b363SPhilipp Reisner } 1488b411b363SPhilipp Reisner 148959817f4fSPhilipp Reisner if (mdev->state.conn < C_AHEAD) { 1490b411b363SPhilipp Reisner /* In case a previous resync run was aborted by an IO error/detach on the peer. */ 1491b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 149259817f4fSPhilipp Reisner /* This should be done when we abort the resync. We definitely do not 149359817f4fSPhilipp Reisner want to have this for connections going back and forth between 149459817f4fSPhilipp Reisner Ahead/Behind and SyncSource/SyncTarget */ 149559817f4fSPhilipp Reisner } 1496b411b363SPhilipp Reisner 1497e64a3294SPhilipp Reisner if (!test_bit(B_RS_H_DONE, &mdev->flags)) { 1498b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1499b411b363SPhilipp Reisner /* Since application IO was locked out during C_WF_BITMAP_T and 1500b411b363SPhilipp Reisner C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET 1501b411b363SPhilipp Reisner we check that we might make the data inconsistent. */ 1502b411b363SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-target"); 1503b411b363SPhilipp Reisner r = (r >> 8) & 0xff; 1504b411b363SPhilipp Reisner if (r > 0) { 1505b411b363SPhilipp Reisner dev_info(DEV, "before-resync-target handler returned %d, " 1506b411b363SPhilipp Reisner "dropping connection.\n", r); 150738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 1508b411b363SPhilipp Reisner return; 1509b411b363SPhilipp Reisner } 151009b9e797SPhilipp Reisner } else /* C_SYNC_SOURCE */ { 151109b9e797SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-source"); 151209b9e797SPhilipp Reisner r = (r >> 8) & 0xff; 151309b9e797SPhilipp Reisner if (r > 0) { 151409b9e797SPhilipp Reisner if (r == 3) { 151509b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 151609b9e797SPhilipp Reisner "ignoring. Old userland tools?", r); 151709b9e797SPhilipp Reisner } else { 151809b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 151909b9e797SPhilipp Reisner "dropping connection.\n", r); 152038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 152109b9e797SPhilipp Reisner return; 152209b9e797SPhilipp Reisner } 152309b9e797SPhilipp Reisner } 1524b411b363SPhilipp Reisner } 1525e64a3294SPhilipp Reisner } 1526b411b363SPhilipp Reisner 1527e64a3294SPhilipp Reisner if (current == mdev->tconn->worker.task) { 1528dad20554SPhilipp Reisner /* The worker should not sleep waiting for state_mutex, 1529e64a3294SPhilipp Reisner that can take long */ 15308410da8fSPhilipp Reisner if (!mutex_trylock(mdev->state_mutex)) { 1531e64a3294SPhilipp Reisner set_bit(B_RS_H_DONE, &mdev->flags); 1532e64a3294SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/5; 1533e64a3294SPhilipp Reisner add_timer(&mdev->start_resync_timer); 1534e64a3294SPhilipp Reisner return; 1535e64a3294SPhilipp Reisner } 1536e64a3294SPhilipp Reisner } else { 15378410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 1538e64a3294SPhilipp Reisner } 1539e64a3294SPhilipp Reisner clear_bit(B_RS_H_DONE, &mdev->flags); 1540b411b363SPhilipp Reisner 1541b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_NEGOTIATING)) { 15428410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1543b411b363SPhilipp Reisner return; 1544b411b363SPhilipp Reisner } 1545b411b363SPhilipp Reisner 1546b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1547b411b363SPhilipp Reisner ns = mdev->state; 1548b411b363SPhilipp Reisner 1549b411b363SPhilipp Reisner ns.aftr_isp = !_drbd_may_sync_now(mdev); 1550b411b363SPhilipp Reisner 1551b411b363SPhilipp Reisner ns.conn = side; 1552b411b363SPhilipp Reisner 1553b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) 1554b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 1555b411b363SPhilipp Reisner else /* side == C_SYNC_SOURCE */ 1556b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 1557b411b363SPhilipp Reisner 1558b411b363SPhilipp Reisner r = __drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 1559b411b363SPhilipp Reisner ns = mdev->state; 1560b411b363SPhilipp Reisner 1561b411b363SPhilipp Reisner if (ns.conn < C_CONNECTED) 1562b411b363SPhilipp Reisner r = SS_UNKNOWN_ERROR; 1563b411b363SPhilipp Reisner 1564b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 15651d7734a0SLars Ellenberg unsigned long tw = drbd_bm_total_weight(mdev); 15661d7734a0SLars Ellenberg unsigned long now = jiffies; 15671d7734a0SLars Ellenberg int i; 15681d7734a0SLars Ellenberg 1569b411b363SPhilipp Reisner mdev->rs_failed = 0; 1570b411b363SPhilipp Reisner mdev->rs_paused = 0; 1571b411b363SPhilipp Reisner mdev->rs_same_csum = 0; 15720f0601f4SLars Ellenberg mdev->rs_last_events = 0; 15730f0601f4SLars Ellenberg mdev->rs_last_sect_ev = 0; 15741d7734a0SLars Ellenberg mdev->rs_total = tw; 15751d7734a0SLars Ellenberg mdev->rs_start = now; 15761d7734a0SLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 15771d7734a0SLars Ellenberg mdev->rs_mark_left[i] = tw; 15781d7734a0SLars Ellenberg mdev->rs_mark_time[i] = now; 15791d7734a0SLars Ellenberg } 1580b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1581b411b363SPhilipp Reisner } 1582b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 15835a22db89SLars Ellenberg 15846c922ed5SLars Ellenberg if (r == SS_SUCCESS) { 15856c922ed5SLars Ellenberg dev_info(DEV, "Began resync as %s (will sync %lu KB [%lu bits set]).\n", 15866c922ed5SLars Ellenberg drbd_conn_str(ns.conn), 15876c922ed5SLars Ellenberg (unsigned long) mdev->rs_total << (BM_BLOCK_SHIFT-10), 15886c922ed5SLars Ellenberg (unsigned long) mdev->rs_total); 15895a22db89SLars Ellenberg if (side == C_SYNC_TARGET) 15905a22db89SLars Ellenberg mdev->bm_resync_fo = 0; 15915a22db89SLars Ellenberg 15925a22db89SLars Ellenberg /* Since protocol 96, we must serialize drbd_gen_and_send_sync_uuid 15935a22db89SLars Ellenberg * with w_send_oos, or the sync target will get confused as to 15945a22db89SLars Ellenberg * how much bits to resync. We cannot do that always, because for an 15955a22db89SLars Ellenberg * empty resync and protocol < 95, we need to do it here, as we call 15965a22db89SLars Ellenberg * drbd_resync_finished from here in that case. 15975a22db89SLars Ellenberg * We drbd_gen_and_send_sync_uuid here for protocol < 96, 15985a22db89SLars Ellenberg * and from after_state_ch otherwise. */ 159931890f4aSPhilipp Reisner if (side == C_SYNC_SOURCE && mdev->tconn->agreed_pro_version < 96) 16005a22db89SLars Ellenberg drbd_gen_and_send_sync_uuid(mdev); 1601b411b363SPhilipp Reisner 160231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 95 && mdev->rs_total == 0) { 1603af85e8e8SLars Ellenberg /* This still has a race (about when exactly the peers 1604af85e8e8SLars Ellenberg * detect connection loss) that can lead to a full sync 1605af85e8e8SLars Ellenberg * on next handshake. In 8.3.9 we fixed this with explicit 1606af85e8e8SLars Ellenberg * resync-finished notifications, but the fix 1607af85e8e8SLars Ellenberg * introduces a protocol change. Sleeping for some 1608af85e8e8SLars Ellenberg * time longer than the ping interval + timeout on the 1609af85e8e8SLars Ellenberg * SyncSource, to give the SyncTarget the chance to 1610af85e8e8SLars Ellenberg * detect connection loss, then waiting for a ping 1611af85e8e8SLars Ellenberg * response (implicit in drbd_resync_finished) reduces 1612af85e8e8SLars Ellenberg * the race considerably, but does not solve it. */ 1613af85e8e8SLars Ellenberg if (side == C_SYNC_SOURCE) 1614af85e8e8SLars Ellenberg schedule_timeout_interruptible( 161589e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_int * HZ + 161689e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_timeo*HZ/9); 1617b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1618b411b363SPhilipp Reisner } 1619b411b363SPhilipp Reisner 16209bd28d3cSLars Ellenberg drbd_rs_controller_reset(mdev); 1621b411b363SPhilipp Reisner /* ns.conn may already be != mdev->state.conn, 1622b411b363SPhilipp Reisner * we may have been paused in between, or become paused until 1623b411b363SPhilipp Reisner * the timer triggers. 1624b411b363SPhilipp Reisner * No matter, that is handled in resync_timer_fn() */ 1625b411b363SPhilipp Reisner if (ns.conn == C_SYNC_TARGET) 1626b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies); 1627b411b363SPhilipp Reisner 1628b411b363SPhilipp Reisner drbd_md_sync(mdev); 1629b411b363SPhilipp Reisner } 16305a22db89SLars Ellenberg put_ldev(mdev); 16318410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1632b411b363SPhilipp Reisner } 1633b411b363SPhilipp Reisner 1634b411b363SPhilipp Reisner int drbd_worker(struct drbd_thread *thi) 1635b411b363SPhilipp Reisner { 1636392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 1637b411b363SPhilipp Reisner struct drbd_work *w = NULL; 16380e29d163SPhilipp Reisner struct drbd_conf *mdev; 1639b411b363SPhilipp Reisner LIST_HEAD(work_list); 1640f399002eSLars Ellenberg int vnr, intr = 0; 1641b411b363SPhilipp Reisner 1642e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 164380822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 1644b411b363SPhilipp Reisner 164519393e10SPhilipp Reisner if (down_trylock(&tconn->data.work.s)) { 164619393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 164719393e10SPhilipp Reisner if (tconn->data.socket && !tconn->net_conf->no_cork) 164819393e10SPhilipp Reisner drbd_tcp_uncork(tconn->data.socket); 164919393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1650b411b363SPhilipp Reisner 165119393e10SPhilipp Reisner intr = down_interruptible(&tconn->data.work.s); 1652b411b363SPhilipp Reisner 165319393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 165419393e10SPhilipp Reisner if (tconn->data.socket && !tconn->net_conf->no_cork) 165519393e10SPhilipp Reisner drbd_tcp_cork(tconn->data.socket); 165619393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1657b411b363SPhilipp Reisner } 1658b411b363SPhilipp Reisner 1659b411b363SPhilipp Reisner if (intr) { 1660b411b363SPhilipp Reisner flush_signals(current); 166119393e10SPhilipp Reisner if (get_t_state(thi) == RUNNING) { 166219393e10SPhilipp Reisner conn_warn(tconn, "Worker got an unexpected signal\n"); 1663b411b363SPhilipp Reisner continue; 166419393e10SPhilipp Reisner } 1665b411b363SPhilipp Reisner break; 1666b411b363SPhilipp Reisner } 1667b411b363SPhilipp Reisner 1668e77a0a5cSAndreas Gruenbacher if (get_t_state(thi) != RUNNING) 1669b411b363SPhilipp Reisner break; 1670b411b363SPhilipp Reisner /* With this break, we have done a down() but not consumed 1671b411b363SPhilipp Reisner the entry from the list. The cleanup code takes care of 1672b411b363SPhilipp Reisner this... */ 1673b411b363SPhilipp Reisner 1674b411b363SPhilipp Reisner w = NULL; 167519393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 167619393e10SPhilipp Reisner if (list_empty(&tconn->data.work.q)) { 1677b411b363SPhilipp Reisner /* something terribly wrong in our logic. 1678b411b363SPhilipp Reisner * we were able to down() the semaphore, 1679b411b363SPhilipp Reisner * but the list is empty... doh. 1680b411b363SPhilipp Reisner * 1681b411b363SPhilipp Reisner * what is the best thing to do now? 1682b411b363SPhilipp Reisner * try again from scratch, restarting the receiver, 1683b411b363SPhilipp Reisner * asender, whatnot? could break even more ugly, 1684b411b363SPhilipp Reisner * e.g. when we are primary, but no good local data. 1685b411b363SPhilipp Reisner * 1686b411b363SPhilipp Reisner * I'll try to get away just starting over this loop. 1687b411b363SPhilipp Reisner */ 168819393e10SPhilipp Reisner conn_warn(tconn, "Work list unexpectedly empty\n"); 168919393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1690b411b363SPhilipp Reisner continue; 1691b411b363SPhilipp Reisner } 169219393e10SPhilipp Reisner w = list_entry(tconn->data.work.q.next, struct drbd_work, list); 1693b411b363SPhilipp Reisner list_del_init(&w->list); 169419393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1695b411b363SPhilipp Reisner 169699920dc5SAndreas Gruenbacher if (w->cb(w, tconn->cstate < C_WF_REPORT_PARAMS)) { 1697b411b363SPhilipp Reisner /* dev_warn(DEV, "worker: a callback failed! \n"); */ 1698bbeb641cSPhilipp Reisner if (tconn->cstate >= C_WF_REPORT_PARAMS) 1699bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 1700b411b363SPhilipp Reisner } 1701b411b363SPhilipp Reisner } 1702b411b363SPhilipp Reisner 170319393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 170419393e10SPhilipp Reisner while (!list_empty(&tconn->data.work.q)) { 170519393e10SPhilipp Reisner list_splice_init(&tconn->data.work.q, &work_list); 170619393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1707b411b363SPhilipp Reisner 1708b411b363SPhilipp Reisner while (!list_empty(&work_list)) { 1709b411b363SPhilipp Reisner w = list_entry(work_list.next, struct drbd_work, list); 1710b411b363SPhilipp Reisner list_del_init(&w->list); 171100d56944SPhilipp Reisner w->cb(w, 1); 1712b411b363SPhilipp Reisner } 1713b411b363SPhilipp Reisner 171419393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 1715b411b363SPhilipp Reisner } 171619393e10SPhilipp Reisner sema_init(&tconn->data.work.s, 0); 1717b411b363SPhilipp Reisner /* DANGEROUS race: if someone did queue his work within the spinlock, 1718b411b363SPhilipp Reisner * but up() ed outside the spinlock, we could get an up() on the 1719b411b363SPhilipp Reisner * semaphore without corresponding list entry. 1720b411b363SPhilipp Reisner * So don't do that. 1721b411b363SPhilipp Reisner */ 172219393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1723b411b363SPhilipp Reisner 17240e29d163SPhilipp Reisner drbd_thread_stop(&tconn->receiver); 1725f399002eSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 17260e29d163SPhilipp Reisner D_ASSERT(mdev->state.disk == D_DISKLESS && mdev->state.conn == C_STANDALONE); 17270e29d163SPhilipp Reisner /* _drbd_set_state only uses stop_nowait. 17280e29d163SPhilipp Reisner * wait here for the exiting receiver. */ 17290e29d163SPhilipp Reisner drbd_mdev_cleanup(mdev); 17300e29d163SPhilipp Reisner } 17310e29d163SPhilipp Reisner clear_bit(OBJECT_DYING, &tconn->flags); 17320e29d163SPhilipp Reisner clear_bit(CONFIG_PENDING, &tconn->flags); 17330e29d163SPhilipp Reisner wake_up(&tconn->ping_wait); 1734b411b363SPhilipp Reisner 1735b411b363SPhilipp Reisner return 0; 1736b411b363SPhilipp Reisner } 1737