1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_worker.c 3b411b363SPhilipp Reisner 4b411b363SPhilipp Reisner This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5b411b363SPhilipp Reisner 6b411b363SPhilipp Reisner Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7b411b363SPhilipp Reisner Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8b411b363SPhilipp Reisner Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9b411b363SPhilipp Reisner 10b411b363SPhilipp Reisner drbd is free software; you can redistribute it and/or modify 11b411b363SPhilipp Reisner it under the terms of the GNU General Public License as published by 12b411b363SPhilipp Reisner the Free Software Foundation; either version 2, or (at your option) 13b411b363SPhilipp Reisner any later version. 14b411b363SPhilipp Reisner 15b411b363SPhilipp Reisner drbd is distributed in the hope that it will be useful, 16b411b363SPhilipp Reisner but WITHOUT ANY WARRANTY; without even the implied warranty of 17b411b363SPhilipp Reisner MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18b411b363SPhilipp Reisner GNU General Public License for more details. 19b411b363SPhilipp Reisner 20b411b363SPhilipp Reisner You should have received a copy of the GNU General Public License 21b411b363SPhilipp Reisner along with drbd; see the file COPYING. If not, write to 22b411b363SPhilipp Reisner the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23b411b363SPhilipp Reisner 24b411b363SPhilipp Reisner */ 25b411b363SPhilipp Reisner 26b411b363SPhilipp Reisner #include <linux/module.h> 27b411b363SPhilipp Reisner #include <linux/drbd.h> 28b411b363SPhilipp Reisner #include <linux/sched.h> 29b411b363SPhilipp Reisner #include <linux/wait.h> 30b411b363SPhilipp Reisner #include <linux/mm.h> 31b411b363SPhilipp Reisner #include <linux/memcontrol.h> 32b411b363SPhilipp Reisner #include <linux/mm_inline.h> 33b411b363SPhilipp Reisner #include <linux/slab.h> 34b411b363SPhilipp Reisner #include <linux/random.h> 35b411b363SPhilipp Reisner #include <linux/string.h> 36b411b363SPhilipp Reisner #include <linux/scatterlist.h> 37b411b363SPhilipp Reisner 38b411b363SPhilipp Reisner #include "drbd_int.h" 39b411b363SPhilipp Reisner #include "drbd_req.h" 40b411b363SPhilipp Reisner 4100d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel); 42b411b363SPhilipp Reisner 43b411b363SPhilipp Reisner 44c5a91619SAndreas Gruenbacher /* endio handlers: 45c5a91619SAndreas Gruenbacher * drbd_md_io_complete (defined here) 46fcefa62eSAndreas Gruenbacher * drbd_request_endio (defined here) 47fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio (defined here) 48c5a91619SAndreas Gruenbacher * bm_async_io_complete (defined in drbd_bitmap.c) 49c5a91619SAndreas Gruenbacher * 50b411b363SPhilipp Reisner * For all these callbacks, note the following: 51b411b363SPhilipp Reisner * The callbacks will be called in irq context by the IDE drivers, 52b411b363SPhilipp Reisner * and in Softirqs/Tasklets/BH context by the SCSI drivers. 53b411b363SPhilipp Reisner * Try to get the locking right :) 54b411b363SPhilipp Reisner * 55b411b363SPhilipp Reisner */ 56b411b363SPhilipp Reisner 57b411b363SPhilipp Reisner 58b411b363SPhilipp Reisner /* About the global_state_lock 59b411b363SPhilipp Reisner Each state transition on an device holds a read lock. In case we have 60b411b363SPhilipp Reisner to evaluate the sync after dependencies, we grab a write lock, because 61b411b363SPhilipp Reisner we need stable states on all devices for that. */ 62b411b363SPhilipp Reisner rwlock_t global_state_lock; 63b411b363SPhilipp Reisner 64b411b363SPhilipp Reisner /* used for synchronous meta data and bitmap IO 65b411b363SPhilipp Reisner * submitted by drbd_md_sync_page_io() 66b411b363SPhilipp Reisner */ 67b411b363SPhilipp Reisner void drbd_md_io_complete(struct bio *bio, int error) 68b411b363SPhilipp Reisner { 69b411b363SPhilipp Reisner struct drbd_md_io *md_io; 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner md_io = (struct drbd_md_io *)bio->bi_private; 72b411b363SPhilipp Reisner md_io->error = error; 73b411b363SPhilipp Reisner 74b411b363SPhilipp Reisner complete(&md_io->event); 75b411b363SPhilipp Reisner } 76b411b363SPhilipp Reisner 77b411b363SPhilipp Reisner /* reads on behalf of the partner, 78b411b363SPhilipp Reisner * "submitted" by the receiver 79b411b363SPhilipp Reisner */ 80db830c46SAndreas Gruenbacher void drbd_endio_read_sec_final(struct drbd_peer_request *peer_req) __releases(local) 81b411b363SPhilipp Reisner { 82b411b363SPhilipp Reisner unsigned long flags = 0; 83a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 84b411b363SPhilipp Reisner 8587eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 86db830c46SAndreas Gruenbacher mdev->read_cnt += peer_req->i.size >> 9; 87db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 88b411b363SPhilipp Reisner if (list_empty(&mdev->read_ee)) 89b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 90db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 9181e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 9287eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 93b411b363SPhilipp Reisner 94db830c46SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &peer_req->w); 95b411b363SPhilipp Reisner put_ldev(mdev); 96b411b363SPhilipp Reisner } 97b411b363SPhilipp Reisner 98b411b363SPhilipp Reisner /* writes on behalf of the partner, or resync writes, 9945bb912bSLars Ellenberg * "submitted" by the receiver, final stage. */ 100db830c46SAndreas Gruenbacher static void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(local) 101b411b363SPhilipp Reisner { 102b411b363SPhilipp Reisner unsigned long flags = 0; 103a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 104181286adSLars Ellenberg struct drbd_interval i; 105b411b363SPhilipp Reisner int do_wake; 106579b57edSAndreas Gruenbacher u64 block_id; 107b411b363SPhilipp Reisner int do_al_complete_io; 108b411b363SPhilipp Reisner 109db830c46SAndreas Gruenbacher /* after we moved peer_req to done_ee, 110b411b363SPhilipp Reisner * we may no longer access it, 111b411b363SPhilipp Reisner * it may be freed/reused already! 112b411b363SPhilipp Reisner * (as soon as we release the req_lock) */ 113181286adSLars Ellenberg i = peer_req->i; 114db830c46SAndreas Gruenbacher do_al_complete_io = peer_req->flags & EE_CALL_AL_COMPLETE_IO; 115db830c46SAndreas Gruenbacher block_id = peer_req->block_id; 116b411b363SPhilipp Reisner 11787eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 118db830c46SAndreas Gruenbacher mdev->writ_cnt += peer_req->i.size >> 9; 119db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); /* has been on active_ee or sync_ee */ 120db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 121b411b363SPhilipp Reisner 122bb3bfe96SAndreas Gruenbacher /* 1235e472264SAndreas Gruenbacher * Do not remove from the write_requests tree here: we did not send the 124bb3bfe96SAndreas Gruenbacher * Ack yet and did not wake possibly waiting conflicting requests. 125bb3bfe96SAndreas Gruenbacher * Removed from the tree from "drbd_process_done_ee" within the 126bb3bfe96SAndreas Gruenbacher * appropriate w.cb (e_end_block/e_end_resync_block) or from 127bb3bfe96SAndreas Gruenbacher * _drbd_clear_done_ee. 128bb3bfe96SAndreas Gruenbacher */ 129b411b363SPhilipp Reisner 130579b57edSAndreas Gruenbacher do_wake = list_empty(block_id == ID_SYNCER ? &mdev->sync_ee : &mdev->active_ee); 131b411b363SPhilipp Reisner 132db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 13381e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 13487eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 135b411b363SPhilipp Reisner 136579b57edSAndreas Gruenbacher if (block_id == ID_SYNCER) 137181286adSLars Ellenberg drbd_rs_complete_io(mdev, i.sector); 138b411b363SPhilipp Reisner 139b411b363SPhilipp Reisner if (do_wake) 140b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 141b411b363SPhilipp Reisner 142b411b363SPhilipp Reisner if (do_al_complete_io) 143181286adSLars Ellenberg drbd_al_complete_io(mdev, &i); 144b411b363SPhilipp Reisner 1450625ac19SPhilipp Reisner wake_asender(mdev->tconn); 146b411b363SPhilipp Reisner put_ldev(mdev); 14745bb912bSLars Ellenberg } 148b411b363SPhilipp Reisner 14945bb912bSLars Ellenberg /* writes on behalf of the partner, or resync writes, 15045bb912bSLars Ellenberg * "submitted" by the receiver. 15145bb912bSLars Ellenberg */ 152fcefa62eSAndreas Gruenbacher void drbd_peer_request_endio(struct bio *bio, int error) 15345bb912bSLars Ellenberg { 154db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = bio->bi_private; 155a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 15645bb912bSLars Ellenberg int uptodate = bio_flagged(bio, BIO_UPTODATE); 15745bb912bSLars Ellenberg int is_write = bio_data_dir(bio) == WRITE; 15845bb912bSLars Ellenberg 15907194272SLars Ellenberg if (error && __ratelimit(&drbd_ratelimit_state)) 16045bb912bSLars Ellenberg dev_warn(DEV, "%s: error=%d s=%llus\n", 16145bb912bSLars Ellenberg is_write ? "write" : "read", error, 162db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 16345bb912bSLars Ellenberg if (!error && !uptodate) { 16407194272SLars Ellenberg if (__ratelimit(&drbd_ratelimit_state)) 16545bb912bSLars Ellenberg dev_warn(DEV, "%s: setting error to -EIO s=%llus\n", 16645bb912bSLars Ellenberg is_write ? "write" : "read", 167db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 16845bb912bSLars Ellenberg /* strange behavior of some lower level drivers... 16945bb912bSLars Ellenberg * fail the request by clearing the uptodate flag, 17045bb912bSLars Ellenberg * but do not return any error?! */ 17145bb912bSLars Ellenberg error = -EIO; 17245bb912bSLars Ellenberg } 17345bb912bSLars Ellenberg 17445bb912bSLars Ellenberg if (error) 175db830c46SAndreas Gruenbacher set_bit(__EE_WAS_ERROR, &peer_req->flags); 17645bb912bSLars Ellenberg 17745bb912bSLars Ellenberg bio_put(bio); /* no need for the bio anymore */ 178db830c46SAndreas Gruenbacher if (atomic_dec_and_test(&peer_req->pending_bios)) { 17945bb912bSLars Ellenberg if (is_write) 180db830c46SAndreas Gruenbacher drbd_endio_write_sec_final(peer_req); 18145bb912bSLars Ellenberg else 182db830c46SAndreas Gruenbacher drbd_endio_read_sec_final(peer_req); 18345bb912bSLars Ellenberg } 184b411b363SPhilipp Reisner } 185b411b363SPhilipp Reisner 186b411b363SPhilipp Reisner /* read, readA or write requests on R_PRIMARY coming from drbd_make_request 187b411b363SPhilipp Reisner */ 188fcefa62eSAndreas Gruenbacher void drbd_request_endio(struct bio *bio, int error) 189b411b363SPhilipp Reisner { 190a115413dSLars Ellenberg unsigned long flags; 191b411b363SPhilipp Reisner struct drbd_request *req = bio->bi_private; 192a21e9298SPhilipp Reisner struct drbd_conf *mdev = req->w.mdev; 193a115413dSLars Ellenberg struct bio_and_error m; 194b411b363SPhilipp Reisner enum drbd_req_event what; 195b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 196b411b363SPhilipp Reisner 197b411b363SPhilipp Reisner if (!error && !uptodate) { 198b411b363SPhilipp Reisner dev_warn(DEV, "p %s: setting error to -EIO\n", 199b411b363SPhilipp Reisner bio_data_dir(bio) == WRITE ? "write" : "read"); 200b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 201b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 202b411b363SPhilipp Reisner * but do not return any error?! */ 203b411b363SPhilipp Reisner error = -EIO; 204b411b363SPhilipp Reisner } 205b411b363SPhilipp Reisner 206b411b363SPhilipp Reisner /* to avoid recursion in __req_mod */ 207b411b363SPhilipp Reisner if (unlikely(error)) { 208b411b363SPhilipp Reisner what = (bio_data_dir(bio) == WRITE) 2098554df1cSAndreas Gruenbacher ? WRITE_COMPLETED_WITH_ERROR 2105c3c7e64SLars Ellenberg : (bio_rw(bio) == READ) 2118554df1cSAndreas Gruenbacher ? READ_COMPLETED_WITH_ERROR 2128554df1cSAndreas Gruenbacher : READ_AHEAD_COMPLETED_WITH_ERROR; 213b411b363SPhilipp Reisner } else 2148554df1cSAndreas Gruenbacher what = COMPLETED_OK; 215b411b363SPhilipp Reisner 216b411b363SPhilipp Reisner bio_put(req->private_bio); 217b411b363SPhilipp Reisner req->private_bio = ERR_PTR(error); 218b411b363SPhilipp Reisner 219a115413dSLars Ellenberg /* not req_mod(), we need irqsave here! */ 22087eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 221a115413dSLars Ellenberg __req_mod(req, what, &m); 22287eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 223a115413dSLars Ellenberg 224a115413dSLars Ellenberg if (m.bio) 225a115413dSLars Ellenberg complete_master_bio(mdev, &m); 226b411b363SPhilipp Reisner } 227b411b363SPhilipp Reisner 22899920dc5SAndreas Gruenbacher int w_read_retry_remote(struct drbd_work *w, int cancel) 229b411b363SPhilipp Reisner { 230b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 23100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 232b411b363SPhilipp Reisner 233b411b363SPhilipp Reisner /* We should not detach for read io-error, 234b411b363SPhilipp Reisner * but try to WRITE the P_DATA_REPLY to the failed location, 235b411b363SPhilipp Reisner * to give the disk the chance to relocate that block */ 236b411b363SPhilipp Reisner 23787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 238d255e5ffSLars Ellenberg if (cancel || mdev->state.pdsk != D_UP_TO_DATE) { 2398554df1cSAndreas Gruenbacher _req_mod(req, READ_RETRY_REMOTE_CANCELED); 24087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 24199920dc5SAndreas Gruenbacher return 0; 242b411b363SPhilipp Reisner } 24387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 244b411b363SPhilipp Reisner 24500d56944SPhilipp Reisner return w_send_read_req(w, 0); 246b411b363SPhilipp Reisner } 247b411b363SPhilipp Reisner 248f6ffca9fSAndreas Gruenbacher void drbd_csum_ee(struct drbd_conf *mdev, struct crypto_hash *tfm, 249db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, void *digest) 25045bb912bSLars Ellenberg { 25145bb912bSLars Ellenberg struct hash_desc desc; 25245bb912bSLars Ellenberg struct scatterlist sg; 253db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 25445bb912bSLars Ellenberg struct page *tmp; 25545bb912bSLars Ellenberg unsigned len; 25645bb912bSLars Ellenberg 25745bb912bSLars Ellenberg desc.tfm = tfm; 25845bb912bSLars Ellenberg desc.flags = 0; 25945bb912bSLars Ellenberg 26045bb912bSLars Ellenberg sg_init_table(&sg, 1); 26145bb912bSLars Ellenberg crypto_hash_init(&desc); 26245bb912bSLars Ellenberg 26345bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) { 26445bb912bSLars Ellenberg /* all but the last page will be fully used */ 26545bb912bSLars Ellenberg sg_set_page(&sg, page, PAGE_SIZE, 0); 26645bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 26745bb912bSLars Ellenberg page = tmp; 26845bb912bSLars Ellenberg } 26945bb912bSLars Ellenberg /* and now the last, possibly only partially used page */ 270db830c46SAndreas Gruenbacher len = peer_req->i.size & (PAGE_SIZE - 1); 27145bb912bSLars Ellenberg sg_set_page(&sg, page, len ?: PAGE_SIZE, 0); 27245bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 27345bb912bSLars Ellenberg crypto_hash_final(&desc, digest); 27445bb912bSLars Ellenberg } 27545bb912bSLars Ellenberg 27645bb912bSLars Ellenberg void drbd_csum_bio(struct drbd_conf *mdev, struct crypto_hash *tfm, struct bio *bio, void *digest) 277b411b363SPhilipp Reisner { 278b411b363SPhilipp Reisner struct hash_desc desc; 279b411b363SPhilipp Reisner struct scatterlist sg; 280b411b363SPhilipp Reisner struct bio_vec *bvec; 281b411b363SPhilipp Reisner int i; 282b411b363SPhilipp Reisner 283b411b363SPhilipp Reisner desc.tfm = tfm; 284b411b363SPhilipp Reisner desc.flags = 0; 285b411b363SPhilipp Reisner 286b411b363SPhilipp Reisner sg_init_table(&sg, 1); 287b411b363SPhilipp Reisner crypto_hash_init(&desc); 288b411b363SPhilipp Reisner 289b411b363SPhilipp Reisner __bio_for_each_segment(bvec, bio, i, 0) { 290b411b363SPhilipp Reisner sg_set_page(&sg, bvec->bv_page, bvec->bv_len, bvec->bv_offset); 291b411b363SPhilipp Reisner crypto_hash_update(&desc, &sg, sg.length); 292b411b363SPhilipp Reisner } 293b411b363SPhilipp Reisner crypto_hash_final(&desc, digest); 294b411b363SPhilipp Reisner } 295b411b363SPhilipp Reisner 2969676c760SLars Ellenberg /* MAYBE merge common code with w_e_end_ov_req */ 29799920dc5SAndreas Gruenbacher static int w_e_send_csum(struct drbd_work *w, int cancel) 298b411b363SPhilipp Reisner { 29900d56944SPhilipp Reisner struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 30000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 301b411b363SPhilipp Reisner int digest_size; 302b411b363SPhilipp Reisner void *digest; 30399920dc5SAndreas Gruenbacher int err = 0; 304b411b363SPhilipp Reisner 30553ea4331SLars Ellenberg if (unlikely(cancel)) 30653ea4331SLars Ellenberg goto out; 307b411b363SPhilipp Reisner 3089676c760SLars Ellenberg if (unlikely((peer_req->flags & EE_WAS_ERROR) != 0)) 30953ea4331SLars Ellenberg goto out; 31053ea4331SLars Ellenberg 311f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 312b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 313b411b363SPhilipp Reisner if (digest) { 314db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 315db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 316f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 3179676c760SLars Ellenberg /* Free peer_req and pages before send. 31853ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 31953ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 32053ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 321c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 3223967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 323db830c46SAndreas Gruenbacher peer_req = NULL; 324b411b363SPhilipp Reisner inc_rs_pending(mdev); 32599920dc5SAndreas Gruenbacher err = drbd_send_drequest_csum(mdev, sector, size, 32653ea4331SLars Ellenberg digest, digest_size, 327b411b363SPhilipp Reisner P_CSUM_RS_REQUEST); 328b411b363SPhilipp Reisner kfree(digest); 329b411b363SPhilipp Reisner } else { 330b411b363SPhilipp Reisner dev_err(DEV, "kmalloc() of digest failed.\n"); 33199920dc5SAndreas Gruenbacher err = -ENOMEM; 332b411b363SPhilipp Reisner } 333b411b363SPhilipp Reisner 33453ea4331SLars Ellenberg out: 335db830c46SAndreas Gruenbacher if (peer_req) 3363967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 337b411b363SPhilipp Reisner 33899920dc5SAndreas Gruenbacher if (unlikely(err)) 339b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest(..., csum) failed\n"); 34099920dc5SAndreas Gruenbacher return err; 341b411b363SPhilipp Reisner } 342b411b363SPhilipp Reisner 343b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 344b411b363SPhilipp Reisner 345b411b363SPhilipp Reisner static int read_for_csum(struct drbd_conf *mdev, sector_t sector, int size) 346b411b363SPhilipp Reisner { 347db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 348b411b363SPhilipp Reisner 349b411b363SPhilipp Reisner if (!get_ldev(mdev)) 35080a40e43SLars Ellenberg return -EIO; 351b411b363SPhilipp Reisner 352e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector)) 3530f0601f4SLars Ellenberg goto defer; 3540f0601f4SLars Ellenberg 355b411b363SPhilipp Reisner /* GFP_TRY, because if there is no memory available right now, this may 356b411b363SPhilipp Reisner * be rescheduled for later. It is "only" background resync, after all. */ 3570db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, ID_SYNCER /* unused */, sector, 3580db55363SAndreas Gruenbacher size, GFP_TRY); 359db830c46SAndreas Gruenbacher if (!peer_req) 36080a40e43SLars Ellenberg goto defer; 361b411b363SPhilipp Reisner 362db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_send_csum; 36387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 364db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->read_ee); 36587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 366b411b363SPhilipp Reisner 3670f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 368fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, DRBD_FAULT_RS_RD) == 0) 36980a40e43SLars Ellenberg return 0; 37045bb912bSLars Ellenberg 37110f6d992SLars Ellenberg /* If it failed because of ENOMEM, retry should help. If it failed 37210f6d992SLars Ellenberg * because bio_add_page failed (probably broken lower level driver), 37310f6d992SLars Ellenberg * retry may or may not help. 37410f6d992SLars Ellenberg * If it does not, you may need to force disconnect. */ 37587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 376db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 37787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 37822cc37a9SLars Ellenberg 3793967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 38080a40e43SLars Ellenberg defer: 38145bb912bSLars Ellenberg put_ldev(mdev); 38280a40e43SLars Ellenberg return -EAGAIN; 383b411b363SPhilipp Reisner } 384b411b363SPhilipp Reisner 38599920dc5SAndreas Gruenbacher int w_resync_timer(struct drbd_work *w, int cancel) 386794abb75SPhilipp Reisner { 38700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 388794abb75SPhilipp Reisner switch (mdev->state.conn) { 389794abb75SPhilipp Reisner case C_VERIFY_S: 39000d56944SPhilipp Reisner w_make_ov_request(w, cancel); 391794abb75SPhilipp Reisner break; 392794abb75SPhilipp Reisner case C_SYNC_TARGET: 39300d56944SPhilipp Reisner w_make_resync_request(w, cancel); 394794abb75SPhilipp Reisner break; 395794abb75SPhilipp Reisner } 396794abb75SPhilipp Reisner 39799920dc5SAndreas Gruenbacher return 0; 398794abb75SPhilipp Reisner } 399794abb75SPhilipp Reisner 400b411b363SPhilipp Reisner void resync_timer_fn(unsigned long data) 401b411b363SPhilipp Reisner { 402b411b363SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 403b411b363SPhilipp Reisner 404794abb75SPhilipp Reisner if (list_empty(&mdev->resync_work.list)) 405e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->resync_work); 406b411b363SPhilipp Reisner } 407b411b363SPhilipp Reisner 408778f271dSPhilipp Reisner static void fifo_set(struct fifo_buffer *fb, int value) 409778f271dSPhilipp Reisner { 410778f271dSPhilipp Reisner int i; 411778f271dSPhilipp Reisner 412778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 413f10f2623SPhilipp Reisner fb->values[i] = value; 414778f271dSPhilipp Reisner } 415778f271dSPhilipp Reisner 416778f271dSPhilipp Reisner static int fifo_push(struct fifo_buffer *fb, int value) 417778f271dSPhilipp Reisner { 418778f271dSPhilipp Reisner int ov; 419778f271dSPhilipp Reisner 420778f271dSPhilipp Reisner ov = fb->values[fb->head_index]; 421778f271dSPhilipp Reisner fb->values[fb->head_index++] = value; 422778f271dSPhilipp Reisner 423778f271dSPhilipp Reisner if (fb->head_index >= fb->size) 424778f271dSPhilipp Reisner fb->head_index = 0; 425778f271dSPhilipp Reisner 426778f271dSPhilipp Reisner return ov; 427778f271dSPhilipp Reisner } 428778f271dSPhilipp Reisner 429778f271dSPhilipp Reisner static void fifo_add_val(struct fifo_buffer *fb, int value) 430778f271dSPhilipp Reisner { 431778f271dSPhilipp Reisner int i; 432778f271dSPhilipp Reisner 433778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 434778f271dSPhilipp Reisner fb->values[i] += value; 435778f271dSPhilipp Reisner } 436778f271dSPhilipp Reisner 4379d77a5feSPhilipp Reisner static int drbd_rs_controller(struct drbd_conf *mdev) 438778f271dSPhilipp Reisner { 439daeda1ccSPhilipp Reisner struct disk_conf *dc; 440778f271dSPhilipp Reisner unsigned int sect_in; /* Number of sectors that came in since the last turn */ 441778f271dSPhilipp Reisner unsigned int want; /* The number of sectors we want in the proxy */ 442778f271dSPhilipp Reisner int req_sect; /* Number of sectors to request in this turn */ 443778f271dSPhilipp Reisner int correction; /* Number of sectors more we need in the proxy*/ 444778f271dSPhilipp Reisner int cps; /* correction per invocation of drbd_rs_controller() */ 445778f271dSPhilipp Reisner int steps; /* Number of time steps to plan ahead */ 446778f271dSPhilipp Reisner int curr_corr; 447778f271dSPhilipp Reisner int max_sect; 448778f271dSPhilipp Reisner 449778f271dSPhilipp Reisner sect_in = atomic_xchg(&mdev->rs_sect_in, 0); /* Number of sectors that came in */ 450778f271dSPhilipp Reisner mdev->rs_in_flight -= sect_in; 451778f271dSPhilipp Reisner 452778f271dSPhilipp Reisner spin_lock(&mdev->peer_seq_lock); /* get an atomic view on mdev->rs_plan_s */ 453daeda1ccSPhilipp Reisner rcu_read_lock(); 454daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 455778f271dSPhilipp Reisner 456daeda1ccSPhilipp Reisner steps = mdev->rs_plan_s.size; /* (dc->c_plan_ahead * 10 * SLEEP_TIME) / HZ; */ 457778f271dSPhilipp Reisner 458778f271dSPhilipp Reisner if (mdev->rs_in_flight + sect_in == 0) { /* At start of resync */ 459daeda1ccSPhilipp Reisner want = ((dc->resync_rate * 2 * SLEEP_TIME) / HZ) * steps; 460778f271dSPhilipp Reisner } else { /* normal path */ 461daeda1ccSPhilipp Reisner want = dc->c_fill_target ? dc->c_fill_target : 462daeda1ccSPhilipp Reisner sect_in * dc->c_delay_target * HZ / (SLEEP_TIME * 10); 463778f271dSPhilipp Reisner } 464778f271dSPhilipp Reisner 465778f271dSPhilipp Reisner correction = want - mdev->rs_in_flight - mdev->rs_planed; 466778f271dSPhilipp Reisner 467778f271dSPhilipp Reisner /* Plan ahead */ 468778f271dSPhilipp Reisner cps = correction / steps; 469778f271dSPhilipp Reisner fifo_add_val(&mdev->rs_plan_s, cps); 470778f271dSPhilipp Reisner mdev->rs_planed += cps * steps; 471778f271dSPhilipp Reisner 472778f271dSPhilipp Reisner /* What we do in this step */ 473778f271dSPhilipp Reisner curr_corr = fifo_push(&mdev->rs_plan_s, 0); 474778f271dSPhilipp Reisner mdev->rs_planed -= curr_corr; 475778f271dSPhilipp Reisner 476778f271dSPhilipp Reisner req_sect = sect_in + curr_corr; 477778f271dSPhilipp Reisner if (req_sect < 0) 478778f271dSPhilipp Reisner req_sect = 0; 479778f271dSPhilipp Reisner 480daeda1ccSPhilipp Reisner max_sect = (dc->c_max_rate * 2 * SLEEP_TIME) / HZ; 481778f271dSPhilipp Reisner if (req_sect > max_sect) 482778f271dSPhilipp Reisner req_sect = max_sect; 483778f271dSPhilipp Reisner 484778f271dSPhilipp Reisner /* 485778f271dSPhilipp Reisner dev_warn(DEV, "si=%u if=%d wa=%u co=%d st=%d cps=%d pl=%d cc=%d rs=%d\n", 486778f271dSPhilipp Reisner sect_in, mdev->rs_in_flight, want, correction, 487778f271dSPhilipp Reisner steps, cps, mdev->rs_planed, curr_corr, req_sect); 488778f271dSPhilipp Reisner */ 489daeda1ccSPhilipp Reisner rcu_read_unlock(); 490daeda1ccSPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 491778f271dSPhilipp Reisner 492778f271dSPhilipp Reisner return req_sect; 493778f271dSPhilipp Reisner } 494778f271dSPhilipp Reisner 4959d77a5feSPhilipp Reisner static int drbd_rs_number_requests(struct drbd_conf *mdev) 496e65f440dSLars Ellenberg { 497e65f440dSLars Ellenberg int number; 498daeda1ccSPhilipp Reisner if (mdev->rs_plan_s.size) { /* rcu_dereference(mdev->ldev->disk_conf)->c_plan_ahead */ 499e65f440dSLars Ellenberg number = drbd_rs_controller(mdev) >> (BM_BLOCK_SHIFT - 9); 500e65f440dSLars Ellenberg mdev->c_sync_rate = number * HZ * (BM_BLOCK_SIZE / 1024) / SLEEP_TIME; 501e65f440dSLars Ellenberg } else { 502daeda1ccSPhilipp Reisner rcu_read_lock(); 503daeda1ccSPhilipp Reisner mdev->c_sync_rate = rcu_dereference(mdev->ldev->disk_conf)->resync_rate; 504daeda1ccSPhilipp Reisner rcu_read_unlock(); 505e65f440dSLars Ellenberg number = SLEEP_TIME * mdev->c_sync_rate / ((BM_BLOCK_SIZE / 1024) * HZ); 506e65f440dSLars Ellenberg } 507e65f440dSLars Ellenberg 508e65f440dSLars Ellenberg /* ignore the amount of pending requests, the resync controller should 509e65f440dSLars Ellenberg * throttle down to incoming reply rate soon enough anyways. */ 510e65f440dSLars Ellenberg return number; 511e65f440dSLars Ellenberg } 512e65f440dSLars Ellenberg 51399920dc5SAndreas Gruenbacher int w_make_resync_request(struct drbd_work *w, int cancel) 514b411b363SPhilipp Reisner { 51500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 516b411b363SPhilipp Reisner unsigned long bit; 517b411b363SPhilipp Reisner sector_t sector; 518b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 5191816a2b4SLars Ellenberg int max_bio_size; 520e65f440dSLars Ellenberg int number, rollback_i, size; 521b411b363SPhilipp Reisner int align, queued, sndbuf; 5220f0601f4SLars Ellenberg int i = 0; 523b411b363SPhilipp Reisner 524b411b363SPhilipp Reisner if (unlikely(cancel)) 52599920dc5SAndreas Gruenbacher return 0; 526b411b363SPhilipp Reisner 527af85e8e8SLars Ellenberg if (mdev->rs_total == 0) { 528af85e8e8SLars Ellenberg /* empty resync? */ 529af85e8e8SLars Ellenberg drbd_resync_finished(mdev); 53099920dc5SAndreas Gruenbacher return 0; 531af85e8e8SLars Ellenberg } 532af85e8e8SLars Ellenberg 533b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 534b411b363SPhilipp Reisner /* Since we only need to access mdev->rsync a 535b411b363SPhilipp Reisner get_ldev_if_state(mdev,D_FAILED) would be sufficient, but 536b411b363SPhilipp Reisner to continue resync with a broken disk makes no sense at 537b411b363SPhilipp Reisner all */ 538b411b363SPhilipp Reisner dev_err(DEV, "Disk broke down during resync!\n"); 53999920dc5SAndreas Gruenbacher return 0; 540b411b363SPhilipp Reisner } 541b411b363SPhilipp Reisner 5420cfdd247SPhilipp Reisner max_bio_size = queue_max_hw_sectors(mdev->rq_queue) << 9; 543e65f440dSLars Ellenberg number = drbd_rs_number_requests(mdev); 544e65f440dSLars Ellenberg if (number == 0) 5450f0601f4SLars Ellenberg goto requeue; 546b411b363SPhilipp Reisner 547b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 548b411b363SPhilipp Reisner /* Stop generating RS requests, when half of the send buffer is filled */ 549e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 550e42325a5SPhilipp Reisner if (mdev->tconn->data.socket) { 551e42325a5SPhilipp Reisner queued = mdev->tconn->data.socket->sk->sk_wmem_queued; 552e42325a5SPhilipp Reisner sndbuf = mdev->tconn->data.socket->sk->sk_sndbuf; 553b411b363SPhilipp Reisner } else { 554b411b363SPhilipp Reisner queued = 1; 555b411b363SPhilipp Reisner sndbuf = 0; 556b411b363SPhilipp Reisner } 557e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 558b411b363SPhilipp Reisner if (queued > sndbuf / 2) 559b411b363SPhilipp Reisner goto requeue; 560b411b363SPhilipp Reisner 561b411b363SPhilipp Reisner next_sector: 562b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 563b411b363SPhilipp Reisner bit = drbd_bm_find_next(mdev, mdev->bm_resync_fo); 564b411b363SPhilipp Reisner 5654b0715f0SLars Ellenberg if (bit == DRBD_END_OF_BITMAP) { 566b411b363SPhilipp Reisner mdev->bm_resync_fo = drbd_bm_bits(mdev); 567b411b363SPhilipp Reisner put_ldev(mdev); 56899920dc5SAndreas Gruenbacher return 0; 569b411b363SPhilipp Reisner } 570b411b363SPhilipp Reisner 571b411b363SPhilipp Reisner sector = BM_BIT_TO_SECT(bit); 572b411b363SPhilipp Reisner 573e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 574e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 575b411b363SPhilipp Reisner mdev->bm_resync_fo = bit; 576b411b363SPhilipp Reisner goto requeue; 577b411b363SPhilipp Reisner } 578b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 579b411b363SPhilipp Reisner 580b411b363SPhilipp Reisner if (unlikely(drbd_bm_test_bit(mdev, bit) == 0)) { 581b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 582b411b363SPhilipp Reisner goto next_sector; 583b411b363SPhilipp Reisner } 584b411b363SPhilipp Reisner 5851816a2b4SLars Ellenberg #if DRBD_MAX_BIO_SIZE > BM_BLOCK_SIZE 586b411b363SPhilipp Reisner /* try to find some adjacent bits. 587b411b363SPhilipp Reisner * we stop if we have already the maximum req size. 588b411b363SPhilipp Reisner * 589b411b363SPhilipp Reisner * Additionally always align bigger requests, in order to 590b411b363SPhilipp Reisner * be prepared for all stripe sizes of software RAIDs. 591b411b363SPhilipp Reisner */ 592b411b363SPhilipp Reisner align = 1; 593d207450cSPhilipp Reisner rollback_i = i; 594b411b363SPhilipp Reisner for (;;) { 5951816a2b4SLars Ellenberg if (size + BM_BLOCK_SIZE > max_bio_size) 596b411b363SPhilipp Reisner break; 597b411b363SPhilipp Reisner 598b411b363SPhilipp Reisner /* Be always aligned */ 599b411b363SPhilipp Reisner if (sector & ((1<<(align+3))-1)) 600b411b363SPhilipp Reisner break; 601b411b363SPhilipp Reisner 602b411b363SPhilipp Reisner /* do not cross extent boundaries */ 603b411b363SPhilipp Reisner if (((bit+1) & BM_BLOCKS_PER_BM_EXT_MASK) == 0) 604b411b363SPhilipp Reisner break; 605b411b363SPhilipp Reisner /* now, is it actually dirty, after all? 606b411b363SPhilipp Reisner * caution, drbd_bm_test_bit is tri-state for some 607b411b363SPhilipp Reisner * obscure reason; ( b == 0 ) would get the out-of-band 608b411b363SPhilipp Reisner * only accidentally right because of the "oddly sized" 609b411b363SPhilipp Reisner * adjustment below */ 610b411b363SPhilipp Reisner if (drbd_bm_test_bit(mdev, bit+1) != 1) 611b411b363SPhilipp Reisner break; 612b411b363SPhilipp Reisner bit++; 613b411b363SPhilipp Reisner size += BM_BLOCK_SIZE; 614b411b363SPhilipp Reisner if ((BM_BLOCK_SIZE << align) <= size) 615b411b363SPhilipp Reisner align++; 616b411b363SPhilipp Reisner i++; 617b411b363SPhilipp Reisner } 618b411b363SPhilipp Reisner /* if we merged some, 619b411b363SPhilipp Reisner * reset the offset to start the next drbd_bm_find_next from */ 620b411b363SPhilipp Reisner if (size > BM_BLOCK_SIZE) 621b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 622b411b363SPhilipp Reisner #endif 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner /* adjust very last sectors, in case we are oddly sized */ 625b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 626b411b363SPhilipp Reisner size = (capacity-sector)<<9; 627f399002eSLars Ellenberg if (mdev->tconn->agreed_pro_version >= 89 && mdev->tconn->csums_tfm) { 628b411b363SPhilipp Reisner switch (read_for_csum(mdev, sector, size)) { 62980a40e43SLars Ellenberg case -EIO: /* Disk failure */ 630b411b363SPhilipp Reisner put_ldev(mdev); 63199920dc5SAndreas Gruenbacher return -EIO; 63280a40e43SLars Ellenberg case -EAGAIN: /* allocation failed, or ldev busy */ 633b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 634b411b363SPhilipp Reisner mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 635d207450cSPhilipp Reisner i = rollback_i; 636b411b363SPhilipp Reisner goto requeue; 63780a40e43SLars Ellenberg case 0: 63880a40e43SLars Ellenberg /* everything ok */ 63980a40e43SLars Ellenberg break; 64080a40e43SLars Ellenberg default: 64180a40e43SLars Ellenberg BUG(); 642b411b363SPhilipp Reisner } 643b411b363SPhilipp Reisner } else { 64499920dc5SAndreas Gruenbacher int err; 64599920dc5SAndreas Gruenbacher 646b411b363SPhilipp Reisner inc_rs_pending(mdev); 64799920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_RS_DATA_REQUEST, 64899920dc5SAndreas Gruenbacher sector, size, ID_SYNCER); 64999920dc5SAndreas Gruenbacher if (err) { 650b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest() failed, aborting...\n"); 651b411b363SPhilipp Reisner dec_rs_pending(mdev); 652b411b363SPhilipp Reisner put_ldev(mdev); 65399920dc5SAndreas Gruenbacher return err; 654b411b363SPhilipp Reisner } 655b411b363SPhilipp Reisner } 656b411b363SPhilipp Reisner } 657b411b363SPhilipp Reisner 658b411b363SPhilipp Reisner if (mdev->bm_resync_fo >= drbd_bm_bits(mdev)) { 659b411b363SPhilipp Reisner /* last syncer _request_ was sent, 660b411b363SPhilipp Reisner * but the P_RS_DATA_REPLY not yet received. sync will end (and 661b411b363SPhilipp Reisner * next sync group will resume), as soon as we receive the last 662b411b363SPhilipp Reisner * resync data block, and the last bit is cleared. 663b411b363SPhilipp Reisner * until then resync "work" is "inactive" ... 664b411b363SPhilipp Reisner */ 665b411b363SPhilipp Reisner put_ldev(mdev); 66699920dc5SAndreas Gruenbacher return 0; 667b411b363SPhilipp Reisner } 668b411b363SPhilipp Reisner 669b411b363SPhilipp Reisner requeue: 670778f271dSPhilipp Reisner mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 671b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 672b411b363SPhilipp Reisner put_ldev(mdev); 67399920dc5SAndreas Gruenbacher return 0; 674b411b363SPhilipp Reisner } 675b411b363SPhilipp Reisner 67600d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel) 677b411b363SPhilipp Reisner { 67800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 679b411b363SPhilipp Reisner int number, i, size; 680b411b363SPhilipp Reisner sector_t sector; 681b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 682b411b363SPhilipp Reisner 683b411b363SPhilipp Reisner if (unlikely(cancel)) 684b411b363SPhilipp Reisner return 1; 685b411b363SPhilipp Reisner 6862649f080SLars Ellenberg number = drbd_rs_number_requests(mdev); 687b411b363SPhilipp Reisner 688b411b363SPhilipp Reisner sector = mdev->ov_position; 689b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 690b411b363SPhilipp Reisner if (sector >= capacity) { 691b411b363SPhilipp Reisner return 1; 692b411b363SPhilipp Reisner } 693b411b363SPhilipp Reisner 694b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 695b411b363SPhilipp Reisner 696e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 697e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 698b411b363SPhilipp Reisner mdev->ov_position = sector; 699b411b363SPhilipp Reisner goto requeue; 700b411b363SPhilipp Reisner } 701b411b363SPhilipp Reisner 702b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 703b411b363SPhilipp Reisner size = (capacity-sector)<<9; 704b411b363SPhilipp Reisner 705b411b363SPhilipp Reisner inc_rs_pending(mdev); 7065b9f499cSAndreas Gruenbacher if (drbd_send_ov_request(mdev, sector, size)) { 707b411b363SPhilipp Reisner dec_rs_pending(mdev); 708b411b363SPhilipp Reisner return 0; 709b411b363SPhilipp Reisner } 710b411b363SPhilipp Reisner sector += BM_SECT_PER_BIT; 711b411b363SPhilipp Reisner } 712b411b363SPhilipp Reisner mdev->ov_position = sector; 713b411b363SPhilipp Reisner 714b411b363SPhilipp Reisner requeue: 7152649f080SLars Ellenberg mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 716b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 717b411b363SPhilipp Reisner return 1; 718b411b363SPhilipp Reisner } 719b411b363SPhilipp Reisner 72099920dc5SAndreas Gruenbacher int w_ov_finished(struct drbd_work *w, int cancel) 721b411b363SPhilipp Reisner { 72200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 723b411b363SPhilipp Reisner kfree(w); 7248f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 725b411b363SPhilipp Reisner drbd_resync_finished(mdev); 726b411b363SPhilipp Reisner 72799920dc5SAndreas Gruenbacher return 0; 728b411b363SPhilipp Reisner } 729b411b363SPhilipp Reisner 73099920dc5SAndreas Gruenbacher static int w_resync_finished(struct drbd_work *w, int cancel) 731b411b363SPhilipp Reisner { 73200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 733b411b363SPhilipp Reisner kfree(w); 734b411b363SPhilipp Reisner 735b411b363SPhilipp Reisner drbd_resync_finished(mdev); 736b411b363SPhilipp Reisner 73799920dc5SAndreas Gruenbacher return 0; 738b411b363SPhilipp Reisner } 739b411b363SPhilipp Reisner 740af85e8e8SLars Ellenberg static void ping_peer(struct drbd_conf *mdev) 741af85e8e8SLars Ellenberg { 7422a67d8b9SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 7432a67d8b9SPhilipp Reisner 7442a67d8b9SPhilipp Reisner clear_bit(GOT_PING_ACK, &tconn->flags); 7452a67d8b9SPhilipp Reisner request_ping(tconn); 7462a67d8b9SPhilipp Reisner wait_event(tconn->ping_wait, 7472a67d8b9SPhilipp Reisner test_bit(GOT_PING_ACK, &tconn->flags) || mdev->state.conn < C_CONNECTED); 748af85e8e8SLars Ellenberg } 749af85e8e8SLars Ellenberg 750b411b363SPhilipp Reisner int drbd_resync_finished(struct drbd_conf *mdev) 751b411b363SPhilipp Reisner { 752b411b363SPhilipp Reisner unsigned long db, dt, dbdt; 753b411b363SPhilipp Reisner unsigned long n_oos; 754b411b363SPhilipp Reisner union drbd_state os, ns; 755b411b363SPhilipp Reisner struct drbd_work *w; 756b411b363SPhilipp Reisner char *khelper_cmd = NULL; 75726525618SLars Ellenberg int verify_done = 0; 758b411b363SPhilipp Reisner 759b411b363SPhilipp Reisner /* Remove all elements from the resync LRU. Since future actions 760b411b363SPhilipp Reisner * might set bits in the (main) bitmap, then the entries in the 761b411b363SPhilipp Reisner * resync LRU would be wrong. */ 762b411b363SPhilipp Reisner if (drbd_rs_del_all(mdev)) { 763b411b363SPhilipp Reisner /* In case this is not possible now, most probably because 764b411b363SPhilipp Reisner * there are P_RS_DATA_REPLY Packets lingering on the worker's 765b411b363SPhilipp Reisner * queue (or even the read operations for those packets 766b411b363SPhilipp Reisner * is not finished by now). Retry in 100ms. */ 767b411b363SPhilipp Reisner 76820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 769b411b363SPhilipp Reisner w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC); 770b411b363SPhilipp Reisner if (w) { 771b411b363SPhilipp Reisner w->cb = w_resync_finished; 772e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, w); 773b411b363SPhilipp Reisner return 1; 774b411b363SPhilipp Reisner } 775b411b363SPhilipp Reisner dev_err(DEV, "Warn failed to drbd_rs_del_all() and to kmalloc(w).\n"); 776b411b363SPhilipp Reisner } 777b411b363SPhilipp Reisner 778b411b363SPhilipp Reisner dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ; 779b411b363SPhilipp Reisner if (dt <= 0) 780b411b363SPhilipp Reisner dt = 1; 781b411b363SPhilipp Reisner db = mdev->rs_total; 782b411b363SPhilipp Reisner dbdt = Bit2KB(db/dt); 783b411b363SPhilipp Reisner mdev->rs_paused /= HZ; 784b411b363SPhilipp Reisner 785b411b363SPhilipp Reisner if (!get_ldev(mdev)) 786b411b363SPhilipp Reisner goto out; 787b411b363SPhilipp Reisner 788af85e8e8SLars Ellenberg ping_peer(mdev); 789af85e8e8SLars Ellenberg 79087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 79178bae59bSPhilipp Reisner os = drbd_read_state(mdev); 792b411b363SPhilipp Reisner 79326525618SLars Ellenberg verify_done = (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T); 79426525618SLars Ellenberg 795b411b363SPhilipp Reisner /* This protects us against multiple calls (that can happen in the presence 796b411b363SPhilipp Reisner of application IO), and against connectivity loss just before we arrive here. */ 797b411b363SPhilipp Reisner if (os.conn <= C_CONNECTED) 798b411b363SPhilipp Reisner goto out_unlock; 799b411b363SPhilipp Reisner 800b411b363SPhilipp Reisner ns = os; 801b411b363SPhilipp Reisner ns.conn = C_CONNECTED; 802b411b363SPhilipp Reisner 803b411b363SPhilipp Reisner dev_info(DEV, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n", 80426525618SLars Ellenberg verify_done ? "Online verify " : "Resync", 805b411b363SPhilipp Reisner dt + mdev->rs_paused, mdev->rs_paused, dbdt); 806b411b363SPhilipp Reisner 807b411b363SPhilipp Reisner n_oos = drbd_bm_total_weight(mdev); 808b411b363SPhilipp Reisner 809b411b363SPhilipp Reisner if (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) { 810b411b363SPhilipp Reisner if (n_oos) { 811b411b363SPhilipp Reisner dev_alert(DEV, "Online verify found %lu %dk block out of sync!\n", 812b411b363SPhilipp Reisner n_oos, Bit2KB(1)); 813b411b363SPhilipp Reisner khelper_cmd = "out-of-sync"; 814b411b363SPhilipp Reisner } 815b411b363SPhilipp Reisner } else { 816b411b363SPhilipp Reisner D_ASSERT((n_oos - mdev->rs_failed) == 0); 817b411b363SPhilipp Reisner 818b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) 819b411b363SPhilipp Reisner khelper_cmd = "after-resync-target"; 820b411b363SPhilipp Reisner 821f399002eSLars Ellenberg if (mdev->tconn->csums_tfm && mdev->rs_total) { 822b411b363SPhilipp Reisner const unsigned long s = mdev->rs_same_csum; 823b411b363SPhilipp Reisner const unsigned long t = mdev->rs_total; 824b411b363SPhilipp Reisner const int ratio = 825b411b363SPhilipp Reisner (t == 0) ? 0 : 826b411b363SPhilipp Reisner (t < 100000) ? ((s*100)/t) : (s/(t/100)); 827b411b363SPhilipp Reisner dev_info(DEV, "%u %% had equal checksums, eliminated: %luK; " 828b411b363SPhilipp Reisner "transferred %luK total %luK\n", 829b411b363SPhilipp Reisner ratio, 830b411b363SPhilipp Reisner Bit2KB(mdev->rs_same_csum), 831b411b363SPhilipp Reisner Bit2KB(mdev->rs_total - mdev->rs_same_csum), 832b411b363SPhilipp Reisner Bit2KB(mdev->rs_total)); 833b411b363SPhilipp Reisner } 834b411b363SPhilipp Reisner } 835b411b363SPhilipp Reisner 836b411b363SPhilipp Reisner if (mdev->rs_failed) { 837b411b363SPhilipp Reisner dev_info(DEV, " %lu failed blocks\n", mdev->rs_failed); 838b411b363SPhilipp Reisner 839b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 840b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 841b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 842b411b363SPhilipp Reisner } else { 843b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 844b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 845b411b363SPhilipp Reisner } 846b411b363SPhilipp Reisner } else { 847b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 848b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 849b411b363SPhilipp Reisner 850b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 851b411b363SPhilipp Reisner if (mdev->p_uuid) { 852b411b363SPhilipp Reisner int i; 853b411b363SPhilipp Reisner for (i = UI_BITMAP ; i <= UI_HISTORY_END ; i++) 854b411b363SPhilipp Reisner _drbd_uuid_set(mdev, i, mdev->p_uuid[i]); 855b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_CURRENT]); 856b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, mdev->p_uuid[UI_CURRENT]); 857b411b363SPhilipp Reisner } else { 858b411b363SPhilipp Reisner dev_err(DEV, "mdev->p_uuid is NULL! BUG\n"); 859b411b363SPhilipp Reisner } 860b411b363SPhilipp Reisner } 861b411b363SPhilipp Reisner 86262b0da3aSLars Ellenberg if (!(os.conn == C_VERIFY_S || os.conn == C_VERIFY_T)) { 86362b0da3aSLars Ellenberg /* for verify runs, we don't update uuids here, 86462b0da3aSLars Ellenberg * so there would be nothing to report. */ 865b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 86662b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated UUIDs"); 867b411b363SPhilipp Reisner if (mdev->p_uuid) { 868b411b363SPhilipp Reisner /* Now the two UUID sets are equal, update what we 869b411b363SPhilipp Reisner * know of the peer. */ 870b411b363SPhilipp Reisner int i; 871b411b363SPhilipp Reisner for (i = UI_CURRENT ; i <= UI_HISTORY_END ; i++) 872b411b363SPhilipp Reisner mdev->p_uuid[i] = mdev->ldev->md.uuid[i]; 873b411b363SPhilipp Reisner } 874b411b363SPhilipp Reisner } 87562b0da3aSLars Ellenberg } 876b411b363SPhilipp Reisner 877b411b363SPhilipp Reisner _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 878b411b363SPhilipp Reisner out_unlock: 87987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 880b411b363SPhilipp Reisner put_ldev(mdev); 881b411b363SPhilipp Reisner out: 882b411b363SPhilipp Reisner mdev->rs_total = 0; 883b411b363SPhilipp Reisner mdev->rs_failed = 0; 884b411b363SPhilipp Reisner mdev->rs_paused = 0; 88526525618SLars Ellenberg if (verify_done) 886b411b363SPhilipp Reisner mdev->ov_start_sector = 0; 887b411b363SPhilipp Reisner 88813d42685SLars Ellenberg drbd_md_sync(mdev); 88913d42685SLars Ellenberg 890b411b363SPhilipp Reisner if (khelper_cmd) 891b411b363SPhilipp Reisner drbd_khelper(mdev, khelper_cmd); 892b411b363SPhilipp Reisner 893b411b363SPhilipp Reisner return 1; 894b411b363SPhilipp Reisner } 895b411b363SPhilipp Reisner 896b411b363SPhilipp Reisner /* helper */ 897db830c46SAndreas Gruenbacher static void move_to_net_ee_or_free(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 898b411b363SPhilipp Reisner { 899045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) { 900b411b363SPhilipp Reisner /* This might happen if sendpage() has not finished */ 901db830c46SAndreas Gruenbacher int i = (peer_req->i.size + PAGE_SIZE -1) >> PAGE_SHIFT; 902435f0740SLars Ellenberg atomic_add(i, &mdev->pp_in_use_by_net); 903435f0740SLars Ellenberg atomic_sub(i, &mdev->pp_in_use); 90487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 905db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->net_ee); 90687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 907435f0740SLars Ellenberg wake_up(&drbd_pp_wait); 908b411b363SPhilipp Reisner } else 9093967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 910b411b363SPhilipp Reisner } 911b411b363SPhilipp Reisner 912b411b363SPhilipp Reisner /** 913b411b363SPhilipp Reisner * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 914b411b363SPhilipp Reisner * @mdev: DRBD device. 915b411b363SPhilipp Reisner * @w: work object. 916b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 917b411b363SPhilipp Reisner */ 91899920dc5SAndreas Gruenbacher int w_e_end_data_req(struct drbd_work *w, int cancel) 919b411b363SPhilipp Reisner { 920db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 92100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 92299920dc5SAndreas Gruenbacher int err; 923b411b363SPhilipp Reisner 924b411b363SPhilipp Reisner if (unlikely(cancel)) { 9253967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 926b411b363SPhilipp Reisner dec_unacked(mdev); 92799920dc5SAndreas Gruenbacher return 0; 928b411b363SPhilipp Reisner } 929b411b363SPhilipp Reisner 930db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 93199920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_DATA_REPLY, peer_req); 932b411b363SPhilipp Reisner } else { 933b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 934b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. sector=%llus.\n", 935db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 936b411b363SPhilipp Reisner 93799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_DREPLY, peer_req); 938b411b363SPhilipp Reisner } 939b411b363SPhilipp Reisner 940b411b363SPhilipp Reisner dec_unacked(mdev); 941b411b363SPhilipp Reisner 942db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 943b411b363SPhilipp Reisner 94499920dc5SAndreas Gruenbacher if (unlikely(err)) 945b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 94699920dc5SAndreas Gruenbacher return err; 947b411b363SPhilipp Reisner } 948b411b363SPhilipp Reisner 949b411b363SPhilipp Reisner /** 950b411b363SPhilipp Reisner * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUESTRS 951b411b363SPhilipp Reisner * @mdev: DRBD device. 952b411b363SPhilipp Reisner * @w: work object. 953b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 954b411b363SPhilipp Reisner */ 95599920dc5SAndreas Gruenbacher int w_e_end_rsdata_req(struct drbd_work *w, int cancel) 956b411b363SPhilipp Reisner { 957db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 95800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 95999920dc5SAndreas Gruenbacher int err; 960b411b363SPhilipp Reisner 961b411b363SPhilipp Reisner if (unlikely(cancel)) { 9623967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 963b411b363SPhilipp Reisner dec_unacked(mdev); 96499920dc5SAndreas Gruenbacher return 0; 965b411b363SPhilipp Reisner } 966b411b363SPhilipp Reisner 967b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 968db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 969b411b363SPhilipp Reisner put_ldev(mdev); 970b411b363SPhilipp Reisner } 971b411b363SPhilipp Reisner 972d612d309SPhilipp Reisner if (mdev->state.conn == C_AHEAD) { 97399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_CANCEL, peer_req); 974db830c46SAndreas Gruenbacher } else if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 975b411b363SPhilipp Reisner if (likely(mdev->state.pdsk >= D_INCONSISTENT)) { 976b411b363SPhilipp Reisner inc_rs_pending(mdev); 97799920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 978b411b363SPhilipp Reisner } else { 979b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 980b411b363SPhilipp Reisner dev_err(DEV, "Not sending RSDataReply, " 981b411b363SPhilipp Reisner "partner DISKLESS!\n"); 98299920dc5SAndreas Gruenbacher err = 0; 983b411b363SPhilipp Reisner } 984b411b363SPhilipp Reisner } else { 985b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 986b411b363SPhilipp Reisner dev_err(DEV, "Sending NegRSDReply. sector %llus.\n", 987db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 988b411b363SPhilipp Reisner 98999920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 990b411b363SPhilipp Reisner 991b411b363SPhilipp Reisner /* update resync data with failure */ 992db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, peer_req->i.sector, peer_req->i.size); 993b411b363SPhilipp Reisner } 994b411b363SPhilipp Reisner 995b411b363SPhilipp Reisner dec_unacked(mdev); 996b411b363SPhilipp Reisner 997db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 998b411b363SPhilipp Reisner 99999920dc5SAndreas Gruenbacher if (unlikely(err)) 1000b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 100199920dc5SAndreas Gruenbacher return err; 1002b411b363SPhilipp Reisner } 1003b411b363SPhilipp Reisner 100499920dc5SAndreas Gruenbacher int w_e_end_csum_rs_req(struct drbd_work *w, int cancel) 1005b411b363SPhilipp Reisner { 1006db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 100700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1008b411b363SPhilipp Reisner struct digest_info *di; 1009b411b363SPhilipp Reisner int digest_size; 1010b411b363SPhilipp Reisner void *digest = NULL; 101199920dc5SAndreas Gruenbacher int err, eq = 0; 1012b411b363SPhilipp Reisner 1013b411b363SPhilipp Reisner if (unlikely(cancel)) { 10143967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1015b411b363SPhilipp Reisner dec_unacked(mdev); 101699920dc5SAndreas Gruenbacher return 0; 1017b411b363SPhilipp Reisner } 1018b411b363SPhilipp Reisner 10191d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1020db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 10211d53f09eSLars Ellenberg put_ldev(mdev); 10221d53f09eSLars Ellenberg } 1023b411b363SPhilipp Reisner 1024db830c46SAndreas Gruenbacher di = peer_req->digest; 1025b411b363SPhilipp Reisner 1026db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1027b411b363SPhilipp Reisner /* quick hack to try to avoid a race against reconfiguration. 1028b411b363SPhilipp Reisner * a real fix would be much more involved, 1029b411b363SPhilipp Reisner * introducing more locking mechanisms */ 1030f399002eSLars Ellenberg if (mdev->tconn->csums_tfm) { 1031f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 1032b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1033b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1034b411b363SPhilipp Reisner } 1035b411b363SPhilipp Reisner if (digest) { 1036f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 1037b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1038b411b363SPhilipp Reisner kfree(digest); 1039b411b363SPhilipp Reisner } 1040b411b363SPhilipp Reisner 1041b411b363SPhilipp Reisner if (eq) { 1042db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, peer_req->i.sector, peer_req->i.size); 1043676396d5SLars Ellenberg /* rs_same_csums unit is BM_BLOCK_SIZE */ 1044db830c46SAndreas Gruenbacher mdev->rs_same_csum += peer_req->i.size >> BM_BLOCK_SHIFT; 104599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_IS_IN_SYNC, peer_req); 1046b411b363SPhilipp Reisner } else { 1047b411b363SPhilipp Reisner inc_rs_pending(mdev); 1048db830c46SAndreas Gruenbacher peer_req->block_id = ID_SYNCER; /* By setting block_id, digest pointer becomes invalid! */ 1049db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_HAS_DIGEST; /* This peer request no longer has a digest pointer */ 1050204bba99SPhilipp Reisner kfree(di); 105199920dc5SAndreas Gruenbacher err = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 1052b411b363SPhilipp Reisner } 1053b411b363SPhilipp Reisner } else { 105499920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 1055b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1056b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 1057b411b363SPhilipp Reisner } 1058b411b363SPhilipp Reisner 1059b411b363SPhilipp Reisner dec_unacked(mdev); 1060db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 1061b411b363SPhilipp Reisner 106299920dc5SAndreas Gruenbacher if (unlikely(err)) 1063b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block/ack() failed\n"); 106499920dc5SAndreas Gruenbacher return err; 1065b411b363SPhilipp Reisner } 1066b411b363SPhilipp Reisner 106799920dc5SAndreas Gruenbacher int w_e_end_ov_req(struct drbd_work *w, int cancel) 1068b411b363SPhilipp Reisner { 1069db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 107000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1071db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1072db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 1073b411b363SPhilipp Reisner int digest_size; 1074b411b363SPhilipp Reisner void *digest; 107599920dc5SAndreas Gruenbacher int err = 0; 1076b411b363SPhilipp Reisner 1077b411b363SPhilipp Reisner if (unlikely(cancel)) 1078b411b363SPhilipp Reisner goto out; 1079b411b363SPhilipp Reisner 1080f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1081b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 10828f21420eSPhilipp Reisner if (!digest) { 108399920dc5SAndreas Gruenbacher err = 1; /* terminate the connection in case the allocation failed */ 10848f21420eSPhilipp Reisner goto out; 10858f21420eSPhilipp Reisner } 10868f21420eSPhilipp Reisner 1087db830c46SAndreas Gruenbacher if (likely(!(peer_req->flags & EE_WAS_ERROR))) 1088f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 10898f21420eSPhilipp Reisner else 10908f21420eSPhilipp Reisner memset(digest, 0, digest_size); 10918f21420eSPhilipp Reisner 109253ea4331SLars Ellenberg /* Free e and pages before send. 109353ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 109453ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 109553ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 1096c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 10973967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1098db830c46SAndreas Gruenbacher peer_req = NULL; 1099b411b363SPhilipp Reisner inc_rs_pending(mdev); 110099920dc5SAndreas Gruenbacher err = drbd_send_drequest_csum(mdev, sector, size, digest, digest_size, P_OV_REPLY); 110199920dc5SAndreas Gruenbacher if (err) 1102b411b363SPhilipp Reisner dec_rs_pending(mdev); 1103b411b363SPhilipp Reisner kfree(digest); 1104b411b363SPhilipp Reisner 1105b411b363SPhilipp Reisner out: 1106db830c46SAndreas Gruenbacher if (peer_req) 11073967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1108b411b363SPhilipp Reisner dec_unacked(mdev); 110999920dc5SAndreas Gruenbacher return err; 1110b411b363SPhilipp Reisner } 1111b411b363SPhilipp Reisner 11128f7bed77SAndreas Gruenbacher void drbd_ov_out_of_sync_found(struct drbd_conf *mdev, sector_t sector, int size) 1113b411b363SPhilipp Reisner { 1114b411b363SPhilipp Reisner if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) { 1115b411b363SPhilipp Reisner mdev->ov_last_oos_size += size>>9; 1116b411b363SPhilipp Reisner } else { 1117b411b363SPhilipp Reisner mdev->ov_last_oos_start = sector; 1118b411b363SPhilipp Reisner mdev->ov_last_oos_size = size>>9; 1119b411b363SPhilipp Reisner } 1120b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 1121b411b363SPhilipp Reisner } 1122b411b363SPhilipp Reisner 112399920dc5SAndreas Gruenbacher int w_e_end_ov_reply(struct drbd_work *w, int cancel) 1124b411b363SPhilipp Reisner { 1125db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 112600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1127b411b363SPhilipp Reisner struct digest_info *di; 1128b411b363SPhilipp Reisner void *digest; 1129db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1130db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 113153ea4331SLars Ellenberg int digest_size; 113299920dc5SAndreas Gruenbacher int err, eq = 0; 1133b411b363SPhilipp Reisner 1134b411b363SPhilipp Reisner if (unlikely(cancel)) { 11353967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1136b411b363SPhilipp Reisner dec_unacked(mdev); 113799920dc5SAndreas Gruenbacher return 0; 1138b411b363SPhilipp Reisner } 1139b411b363SPhilipp Reisner 1140b411b363SPhilipp Reisner /* after "cancel", because after drbd_disconnect/drbd_rs_cancel_all 1141b411b363SPhilipp Reisner * the resync lru has been cleaned up already */ 11421d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1143db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 11441d53f09eSLars Ellenberg put_ldev(mdev); 11451d53f09eSLars Ellenberg } 1146b411b363SPhilipp Reisner 1147db830c46SAndreas Gruenbacher di = peer_req->digest; 1148b411b363SPhilipp Reisner 1149db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1150f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1151b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1152b411b363SPhilipp Reisner if (digest) { 1153f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 1154b411b363SPhilipp Reisner 1155b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1156b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1157b411b363SPhilipp Reisner kfree(digest); 1158b411b363SPhilipp Reisner } 1159b411b363SPhilipp Reisner } 1160b411b363SPhilipp Reisner 11619676c760SLars Ellenberg /* Free peer_req and pages before send. 116253ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 116353ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 116453ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 1165c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages due to pp_in_use > max_buffers. */ 11663967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1167b411b363SPhilipp Reisner if (!eq) 11688f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 1169b411b363SPhilipp Reisner else 11708f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1171b411b363SPhilipp Reisner 117299920dc5SAndreas Gruenbacher err = drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, 1173b411b363SPhilipp Reisner eq ? ID_IN_SYNC : ID_OUT_OF_SYNC); 1174b411b363SPhilipp Reisner 117553ea4331SLars Ellenberg dec_unacked(mdev); 1176b411b363SPhilipp Reisner 1177ea5442afSLars Ellenberg --mdev->ov_left; 1178ea5442afSLars Ellenberg 1179ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 1180ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 1181ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 1182ea5442afSLars Ellenberg 1183ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 11848f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 1185b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1186b411b363SPhilipp Reisner } 1187b411b363SPhilipp Reisner 118899920dc5SAndreas Gruenbacher return err; 1189b411b363SPhilipp Reisner } 1190b411b363SPhilipp Reisner 119199920dc5SAndreas Gruenbacher int w_prev_work_done(struct drbd_work *w, int cancel) 1192b411b363SPhilipp Reisner { 1193b411b363SPhilipp Reisner struct drbd_wq_barrier *b = container_of(w, struct drbd_wq_barrier, w); 119400d56944SPhilipp Reisner 1195b411b363SPhilipp Reisner complete(&b->done); 119699920dc5SAndreas Gruenbacher return 0; 1197b411b363SPhilipp Reisner } 1198b411b363SPhilipp Reisner 119999920dc5SAndreas Gruenbacher int w_send_barrier(struct drbd_work *w, int cancel) 1200b411b363SPhilipp Reisner { 12019f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 1202b411b363SPhilipp Reisner struct drbd_tl_epoch *b = container_of(w, struct drbd_tl_epoch, w); 120300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 12049f5bdc33SAndreas Gruenbacher struct p_barrier *p; 1205b411b363SPhilipp Reisner 1206b411b363SPhilipp Reisner /* really avoid racing with tl_clear. w.cb may have been referenced 1207b411b363SPhilipp Reisner * just before it was reassigned and re-queued, so double check that. 1208b411b363SPhilipp Reisner * actually, this race was harmless, since we only try to send the 1209b411b363SPhilipp Reisner * barrier packet here, and otherwise do nothing with the object. 1210b411b363SPhilipp Reisner * but compare with the head of w_clear_epoch */ 121187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1212b411b363SPhilipp Reisner if (w->cb != w_send_barrier || mdev->state.conn < C_CONNECTED) 1213b411b363SPhilipp Reisner cancel = 1; 121487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1215b411b363SPhilipp Reisner if (cancel) 1216b411b363SPhilipp Reisner return 0; 121799920dc5SAndreas Gruenbacher 12189f5bdc33SAndreas Gruenbacher sock = &mdev->tconn->data; 12199f5bdc33SAndreas Gruenbacher p = drbd_prepare_command(mdev, sock); 12209f5bdc33SAndreas Gruenbacher if (!p) 12219f5bdc33SAndreas Gruenbacher return -EIO; 1222b411b363SPhilipp Reisner p->barrier = b->br_number; 1223b411b363SPhilipp Reisner /* inc_ap_pending was done where this was queued. 1224b411b363SPhilipp Reisner * dec_ap_pending will be done in got_BarrierAck 1225b411b363SPhilipp Reisner * or (on connection loss) in w_clear_epoch. */ 12269f5bdc33SAndreas Gruenbacher return drbd_send_command(mdev, sock, P_BARRIER, sizeof(*p), NULL, 0); 1227b411b363SPhilipp Reisner } 1228b411b363SPhilipp Reisner 122999920dc5SAndreas Gruenbacher int w_send_write_hint(struct drbd_work *w, int cancel) 1230b411b363SPhilipp Reisner { 123100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 12329f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 12339f5bdc33SAndreas Gruenbacher 1234b411b363SPhilipp Reisner if (cancel) 123599920dc5SAndreas Gruenbacher return 0; 12369f5bdc33SAndreas Gruenbacher sock = &mdev->tconn->data; 12379f5bdc33SAndreas Gruenbacher if (!drbd_prepare_command(mdev, sock)) 12389f5bdc33SAndreas Gruenbacher return -EIO; 1239e658983aSAndreas Gruenbacher return drbd_send_command(mdev, sock, P_UNPLUG_REMOTE, 0, NULL, 0); 1240b411b363SPhilipp Reisner } 1241b411b363SPhilipp Reisner 12428f7bed77SAndreas Gruenbacher int w_send_out_of_sync(struct drbd_work *w, int cancel) 124373a01a18SPhilipp Reisner { 124473a01a18SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 124500d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 124699920dc5SAndreas Gruenbacher int err; 124773a01a18SPhilipp Reisner 124873a01a18SPhilipp Reisner if (unlikely(cancel)) { 12498554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 125099920dc5SAndreas Gruenbacher return 0; 125173a01a18SPhilipp Reisner } 125273a01a18SPhilipp Reisner 12538f7bed77SAndreas Gruenbacher err = drbd_send_out_of_sync(mdev, req); 12548554df1cSAndreas Gruenbacher req_mod(req, OOS_HANDED_TO_NETWORK); 125573a01a18SPhilipp Reisner 125699920dc5SAndreas Gruenbacher return err; 125773a01a18SPhilipp Reisner } 125873a01a18SPhilipp Reisner 1259b411b363SPhilipp Reisner /** 1260b411b363SPhilipp Reisner * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1261b411b363SPhilipp Reisner * @mdev: DRBD device. 1262b411b363SPhilipp Reisner * @w: work object. 1263b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1264b411b363SPhilipp Reisner */ 126599920dc5SAndreas Gruenbacher int w_send_dblock(struct drbd_work *w, int cancel) 1266b411b363SPhilipp Reisner { 1267b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 126800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 126999920dc5SAndreas Gruenbacher int err; 1270b411b363SPhilipp Reisner 1271b411b363SPhilipp Reisner if (unlikely(cancel)) { 12728554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 127399920dc5SAndreas Gruenbacher return 0; 1274b411b363SPhilipp Reisner } 1275b411b363SPhilipp Reisner 127699920dc5SAndreas Gruenbacher err = drbd_send_dblock(mdev, req); 127799920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1278b411b363SPhilipp Reisner 127999920dc5SAndreas Gruenbacher return err; 1280b411b363SPhilipp Reisner } 1281b411b363SPhilipp Reisner 1282b411b363SPhilipp Reisner /** 1283b411b363SPhilipp Reisner * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 1284b411b363SPhilipp Reisner * @mdev: DRBD device. 1285b411b363SPhilipp Reisner * @w: work object. 1286b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1287b411b363SPhilipp Reisner */ 128899920dc5SAndreas Gruenbacher int w_send_read_req(struct drbd_work *w, int cancel) 1289b411b363SPhilipp Reisner { 1290b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 129100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 129299920dc5SAndreas Gruenbacher int err; 1293b411b363SPhilipp Reisner 1294b411b363SPhilipp Reisner if (unlikely(cancel)) { 12958554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 129699920dc5SAndreas Gruenbacher return 0; 1297b411b363SPhilipp Reisner } 1298b411b363SPhilipp Reisner 129999920dc5SAndreas Gruenbacher err = drbd_send_drequest(mdev, P_DATA_REQUEST, req->i.sector, req->i.size, 1300b411b363SPhilipp Reisner (unsigned long)req); 1301b411b363SPhilipp Reisner 130299920dc5SAndreas Gruenbacher req_mod(req, err ? SEND_FAILED : HANDED_OVER_TO_NETWORK); 1303b411b363SPhilipp Reisner 130499920dc5SAndreas Gruenbacher return err; 1305b411b363SPhilipp Reisner } 1306b411b363SPhilipp Reisner 130799920dc5SAndreas Gruenbacher int w_restart_disk_io(struct drbd_work *w, int cancel) 1308265be2d0SPhilipp Reisner { 1309265be2d0SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 131000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1311265be2d0SPhilipp Reisner 13120778286aSPhilipp Reisner if (bio_data_dir(req->master_bio) == WRITE && req->rq_state & RQ_IN_ACT_LOG) 1313181286adSLars Ellenberg drbd_al_begin_io(mdev, &req->i); 1314265be2d0SPhilipp Reisner /* Calling drbd_al_begin_io() out of the worker might deadlocks 1315265be2d0SPhilipp Reisner theoretically. Practically it can not deadlock, since this is 1316265be2d0SPhilipp Reisner only used when unfreezing IOs. All the extents of the requests 1317265be2d0SPhilipp Reisner that made it into the TL are already active */ 1318265be2d0SPhilipp Reisner 1319265be2d0SPhilipp Reisner drbd_req_make_private_bio(req, req->master_bio); 1320265be2d0SPhilipp Reisner req->private_bio->bi_bdev = mdev->ldev->backing_bdev; 1321265be2d0SPhilipp Reisner generic_make_request(req->private_bio); 1322265be2d0SPhilipp Reisner 132399920dc5SAndreas Gruenbacher return 0; 1324265be2d0SPhilipp Reisner } 1325265be2d0SPhilipp Reisner 1326b411b363SPhilipp Reisner static int _drbd_may_sync_now(struct drbd_conf *mdev) 1327b411b363SPhilipp Reisner { 1328b411b363SPhilipp Reisner struct drbd_conf *odev = mdev; 1329daeda1ccSPhilipp Reisner int ra; 1330b411b363SPhilipp Reisner 1331b411b363SPhilipp Reisner while (1) { 1332438c8374SPhilipp Reisner if (!odev->ldev) 1333438c8374SPhilipp Reisner return 1; 1334daeda1ccSPhilipp Reisner rcu_read_lock(); 1335daeda1ccSPhilipp Reisner ra = rcu_dereference(odev->ldev->disk_conf)->resync_after; 1336daeda1ccSPhilipp Reisner rcu_read_unlock(); 1337daeda1ccSPhilipp Reisner if (ra == -1) 1338b411b363SPhilipp Reisner return 1; 1339daeda1ccSPhilipp Reisner odev = minor_to_mdev(ra); 1340841ce241SAndreas Gruenbacher if (!expect(odev)) 1341841ce241SAndreas Gruenbacher return 1; 1342b411b363SPhilipp Reisner if ((odev->state.conn >= C_SYNC_SOURCE && 1343b411b363SPhilipp Reisner odev->state.conn <= C_PAUSED_SYNC_T) || 1344b411b363SPhilipp Reisner odev->state.aftr_isp || odev->state.peer_isp || 1345b411b363SPhilipp Reisner odev->state.user_isp) 1346b411b363SPhilipp Reisner return 0; 1347b411b363SPhilipp Reisner } 1348b411b363SPhilipp Reisner } 1349b411b363SPhilipp Reisner 1350b411b363SPhilipp Reisner /** 1351b411b363SPhilipp Reisner * _drbd_pause_after() - Pause resync on all devices that may not resync now 1352b411b363SPhilipp Reisner * @mdev: DRBD device. 1353b411b363SPhilipp Reisner * 1354b411b363SPhilipp Reisner * Called from process context only (admin command and after_state_ch). 1355b411b363SPhilipp Reisner */ 1356b411b363SPhilipp Reisner static int _drbd_pause_after(struct drbd_conf *mdev) 1357b411b363SPhilipp Reisner { 1358b411b363SPhilipp Reisner struct drbd_conf *odev; 1359b411b363SPhilipp Reisner int i, rv = 0; 1360b411b363SPhilipp Reisner 1361695d08faSPhilipp Reisner rcu_read_lock(); 136281a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1363b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1364b411b363SPhilipp Reisner continue; 1365b411b363SPhilipp Reisner if (!_drbd_may_sync_now(odev)) 1366b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 1), CS_HARD, NULL) 1367b411b363SPhilipp Reisner != SS_NOTHING_TO_DO); 1368b411b363SPhilipp Reisner } 1369695d08faSPhilipp Reisner rcu_read_unlock(); 1370b411b363SPhilipp Reisner 1371b411b363SPhilipp Reisner return rv; 1372b411b363SPhilipp Reisner } 1373b411b363SPhilipp Reisner 1374b411b363SPhilipp Reisner /** 1375b411b363SPhilipp Reisner * _drbd_resume_next() - Resume resync on all devices that may resync now 1376b411b363SPhilipp Reisner * @mdev: DRBD device. 1377b411b363SPhilipp Reisner * 1378b411b363SPhilipp Reisner * Called from process context only (admin command and worker). 1379b411b363SPhilipp Reisner */ 1380b411b363SPhilipp Reisner static int _drbd_resume_next(struct drbd_conf *mdev) 1381b411b363SPhilipp Reisner { 1382b411b363SPhilipp Reisner struct drbd_conf *odev; 1383b411b363SPhilipp Reisner int i, rv = 0; 1384b411b363SPhilipp Reisner 1385695d08faSPhilipp Reisner rcu_read_lock(); 138681a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1387b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1388b411b363SPhilipp Reisner continue; 1389b411b363SPhilipp Reisner if (odev->state.aftr_isp) { 1390b411b363SPhilipp Reisner if (_drbd_may_sync_now(odev)) 1391b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 0), 1392b411b363SPhilipp Reisner CS_HARD, NULL) 1393b411b363SPhilipp Reisner != SS_NOTHING_TO_DO) ; 1394b411b363SPhilipp Reisner } 1395b411b363SPhilipp Reisner } 1396695d08faSPhilipp Reisner rcu_read_unlock(); 1397b411b363SPhilipp Reisner return rv; 1398b411b363SPhilipp Reisner } 1399b411b363SPhilipp Reisner 1400b411b363SPhilipp Reisner void resume_next_sg(struct drbd_conf *mdev) 1401b411b363SPhilipp Reisner { 1402b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1403b411b363SPhilipp Reisner _drbd_resume_next(mdev); 1404b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1405b411b363SPhilipp Reisner } 1406b411b363SPhilipp Reisner 1407b411b363SPhilipp Reisner void suspend_other_sg(struct drbd_conf *mdev) 1408b411b363SPhilipp Reisner { 1409b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1410b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1411b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1412b411b363SPhilipp Reisner } 1413b411b363SPhilipp Reisner 1414dc97b708SPhilipp Reisner /* caller must hold global_state_lock */ 1415dc97b708SPhilipp Reisner enum drbd_ret_code drbd_sync_after_valid(struct drbd_conf *mdev, int o_minor) 1416b411b363SPhilipp Reisner { 1417b411b363SPhilipp Reisner struct drbd_conf *odev; 1418daeda1ccSPhilipp Reisner int ra; 1419b411b363SPhilipp Reisner 1420b411b363SPhilipp Reisner if (o_minor == -1) 1421b411b363SPhilipp Reisner return NO_ERROR; 1422b411b363SPhilipp Reisner if (o_minor < -1 || minor_to_mdev(o_minor) == NULL) 1423b411b363SPhilipp Reisner return ERR_SYNC_AFTER; 1424b411b363SPhilipp Reisner 1425b411b363SPhilipp Reisner /* check for loops */ 1426b411b363SPhilipp Reisner odev = minor_to_mdev(o_minor); 1427b411b363SPhilipp Reisner while (1) { 1428b411b363SPhilipp Reisner if (odev == mdev) 1429b411b363SPhilipp Reisner return ERR_SYNC_AFTER_CYCLE; 1430b411b363SPhilipp Reisner 1431daeda1ccSPhilipp Reisner rcu_read_lock(); 1432daeda1ccSPhilipp Reisner ra = rcu_dereference(odev->ldev->disk_conf)->resync_after; 1433daeda1ccSPhilipp Reisner rcu_read_unlock(); 1434b411b363SPhilipp Reisner /* dependency chain ends here, no cycles. */ 1435daeda1ccSPhilipp Reisner if (ra == -1) 1436b411b363SPhilipp Reisner return NO_ERROR; 1437b411b363SPhilipp Reisner 1438b411b363SPhilipp Reisner /* follow the dependency chain */ 1439daeda1ccSPhilipp Reisner odev = minor_to_mdev(ra); 1440b411b363SPhilipp Reisner } 1441b411b363SPhilipp Reisner } 1442b411b363SPhilipp Reisner 1443dc97b708SPhilipp Reisner /* caller must hold global_state_lock */ 1444dc97b708SPhilipp Reisner void drbd_sync_after_changed(struct drbd_conf *mdev) 1445b411b363SPhilipp Reisner { 1446b411b363SPhilipp Reisner int changes; 1447b411b363SPhilipp Reisner 1448b411b363SPhilipp Reisner do { 1449b411b363SPhilipp Reisner changes = _drbd_pause_after(mdev); 1450b411b363SPhilipp Reisner changes |= _drbd_resume_next(mdev); 1451b411b363SPhilipp Reisner } while (changes); 1452b411b363SPhilipp Reisner } 1453b411b363SPhilipp Reisner 14549bd28d3cSLars Ellenberg void drbd_rs_controller_reset(struct drbd_conf *mdev) 14559bd28d3cSLars Ellenberg { 14569bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_in, 0); 14579bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_ev, 0); 14589bd28d3cSLars Ellenberg mdev->rs_in_flight = 0; 14599bd28d3cSLars Ellenberg mdev->rs_planed = 0; 14609bd28d3cSLars Ellenberg spin_lock(&mdev->peer_seq_lock); 14619bd28d3cSLars Ellenberg fifo_set(&mdev->rs_plan_s, 0); 14629bd28d3cSLars Ellenberg spin_unlock(&mdev->peer_seq_lock); 14639bd28d3cSLars Ellenberg } 14649bd28d3cSLars Ellenberg 14651f04af33SPhilipp Reisner void start_resync_timer_fn(unsigned long data) 14661f04af33SPhilipp Reisner { 14671f04af33SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 14681f04af33SPhilipp Reisner 14691f04af33SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->start_resync_work); 14701f04af33SPhilipp Reisner } 14711f04af33SPhilipp Reisner 147299920dc5SAndreas Gruenbacher int w_start_resync(struct drbd_work *w, int cancel) 14731f04af33SPhilipp Reisner { 147400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 147500d56944SPhilipp Reisner 14761f04af33SPhilipp Reisner if (atomic_read(&mdev->unacked_cnt) || atomic_read(&mdev->rs_pending_cnt)) { 14771f04af33SPhilipp Reisner dev_warn(DEV, "w_start_resync later...\n"); 14781f04af33SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/10; 14791f04af33SPhilipp Reisner add_timer(&mdev->start_resync_timer); 148099920dc5SAndreas Gruenbacher return 0; 14811f04af33SPhilipp Reisner } 14821f04af33SPhilipp Reisner 14831f04af33SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 14841f04af33SPhilipp Reisner clear_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags); 148599920dc5SAndreas Gruenbacher return 0; 14861f04af33SPhilipp Reisner } 14871f04af33SPhilipp Reisner 1488b411b363SPhilipp Reisner /** 1489b411b363SPhilipp Reisner * drbd_start_resync() - Start the resync process 1490b411b363SPhilipp Reisner * @mdev: DRBD device. 1491b411b363SPhilipp Reisner * @side: Either C_SYNC_SOURCE or C_SYNC_TARGET 1492b411b363SPhilipp Reisner * 1493b411b363SPhilipp Reisner * This function might bring you directly into one of the 1494b411b363SPhilipp Reisner * C_PAUSED_SYNC_* states. 1495b411b363SPhilipp Reisner */ 1496b411b363SPhilipp Reisner void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side) 1497b411b363SPhilipp Reisner { 1498b411b363SPhilipp Reisner union drbd_state ns; 1499b411b363SPhilipp Reisner int r; 1500b411b363SPhilipp Reisner 1501c4752ef1SPhilipp Reisner if (mdev->state.conn >= C_SYNC_SOURCE && mdev->state.conn < C_AHEAD) { 1502b411b363SPhilipp Reisner dev_err(DEV, "Resync already running!\n"); 1503b411b363SPhilipp Reisner return; 1504b411b363SPhilipp Reisner } 1505b411b363SPhilipp Reisner 150659817f4fSPhilipp Reisner if (mdev->state.conn < C_AHEAD) { 1507b411b363SPhilipp Reisner /* In case a previous resync run was aborted by an IO error/detach on the peer. */ 1508b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 150959817f4fSPhilipp Reisner /* This should be done when we abort the resync. We definitely do not 151059817f4fSPhilipp Reisner want to have this for connections going back and forth between 151159817f4fSPhilipp Reisner Ahead/Behind and SyncSource/SyncTarget */ 151259817f4fSPhilipp Reisner } 1513b411b363SPhilipp Reisner 1514e64a3294SPhilipp Reisner if (!test_bit(B_RS_H_DONE, &mdev->flags)) { 1515b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1516b411b363SPhilipp Reisner /* Since application IO was locked out during C_WF_BITMAP_T and 1517b411b363SPhilipp Reisner C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET 1518b411b363SPhilipp Reisner we check that we might make the data inconsistent. */ 1519b411b363SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-target"); 1520b411b363SPhilipp Reisner r = (r >> 8) & 0xff; 1521b411b363SPhilipp Reisner if (r > 0) { 1522b411b363SPhilipp Reisner dev_info(DEV, "before-resync-target handler returned %d, " 1523b411b363SPhilipp Reisner "dropping connection.\n", r); 152438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 1525b411b363SPhilipp Reisner return; 1526b411b363SPhilipp Reisner } 152709b9e797SPhilipp Reisner } else /* C_SYNC_SOURCE */ { 152809b9e797SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-source"); 152909b9e797SPhilipp Reisner r = (r >> 8) & 0xff; 153009b9e797SPhilipp Reisner if (r > 0) { 153109b9e797SPhilipp Reisner if (r == 3) { 153209b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 153309b9e797SPhilipp Reisner "ignoring. Old userland tools?", r); 153409b9e797SPhilipp Reisner } else { 153509b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 153609b9e797SPhilipp Reisner "dropping connection.\n", r); 153738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 153809b9e797SPhilipp Reisner return; 153909b9e797SPhilipp Reisner } 154009b9e797SPhilipp Reisner } 1541b411b363SPhilipp Reisner } 1542e64a3294SPhilipp Reisner } 1543b411b363SPhilipp Reisner 1544e64a3294SPhilipp Reisner if (current == mdev->tconn->worker.task) { 1545dad20554SPhilipp Reisner /* The worker should not sleep waiting for state_mutex, 1546e64a3294SPhilipp Reisner that can take long */ 15478410da8fSPhilipp Reisner if (!mutex_trylock(mdev->state_mutex)) { 1548e64a3294SPhilipp Reisner set_bit(B_RS_H_DONE, &mdev->flags); 1549e64a3294SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/5; 1550e64a3294SPhilipp Reisner add_timer(&mdev->start_resync_timer); 1551e64a3294SPhilipp Reisner return; 1552e64a3294SPhilipp Reisner } 1553e64a3294SPhilipp Reisner } else { 15548410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 1555e64a3294SPhilipp Reisner } 1556e64a3294SPhilipp Reisner clear_bit(B_RS_H_DONE, &mdev->flags); 1557b411b363SPhilipp Reisner 1558b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_NEGOTIATING)) { 15598410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1560b411b363SPhilipp Reisner return; 1561b411b363SPhilipp Reisner } 1562b411b363SPhilipp Reisner 1563b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 156478bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 1565b411b363SPhilipp Reisner 1566b411b363SPhilipp Reisner ns.aftr_isp = !_drbd_may_sync_now(mdev); 1567b411b363SPhilipp Reisner 1568b411b363SPhilipp Reisner ns.conn = side; 1569b411b363SPhilipp Reisner 1570b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) 1571b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 1572b411b363SPhilipp Reisner else /* side == C_SYNC_SOURCE */ 1573b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 1574b411b363SPhilipp Reisner 1575b411b363SPhilipp Reisner r = __drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 157678bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 1577b411b363SPhilipp Reisner 1578b411b363SPhilipp Reisner if (ns.conn < C_CONNECTED) 1579b411b363SPhilipp Reisner r = SS_UNKNOWN_ERROR; 1580b411b363SPhilipp Reisner 1581b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 15821d7734a0SLars Ellenberg unsigned long tw = drbd_bm_total_weight(mdev); 15831d7734a0SLars Ellenberg unsigned long now = jiffies; 15841d7734a0SLars Ellenberg int i; 15851d7734a0SLars Ellenberg 1586b411b363SPhilipp Reisner mdev->rs_failed = 0; 1587b411b363SPhilipp Reisner mdev->rs_paused = 0; 1588b411b363SPhilipp Reisner mdev->rs_same_csum = 0; 15890f0601f4SLars Ellenberg mdev->rs_last_events = 0; 15900f0601f4SLars Ellenberg mdev->rs_last_sect_ev = 0; 15911d7734a0SLars Ellenberg mdev->rs_total = tw; 15921d7734a0SLars Ellenberg mdev->rs_start = now; 15931d7734a0SLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 15941d7734a0SLars Ellenberg mdev->rs_mark_left[i] = tw; 15951d7734a0SLars Ellenberg mdev->rs_mark_time[i] = now; 15961d7734a0SLars Ellenberg } 1597b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1598b411b363SPhilipp Reisner } 1599b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 16005a22db89SLars Ellenberg 16016c922ed5SLars Ellenberg if (r == SS_SUCCESS) { 16026c922ed5SLars Ellenberg dev_info(DEV, "Began resync as %s (will sync %lu KB [%lu bits set]).\n", 16036c922ed5SLars Ellenberg drbd_conn_str(ns.conn), 16046c922ed5SLars Ellenberg (unsigned long) mdev->rs_total << (BM_BLOCK_SHIFT-10), 16056c922ed5SLars Ellenberg (unsigned long) mdev->rs_total); 16065a22db89SLars Ellenberg if (side == C_SYNC_TARGET) 16075a22db89SLars Ellenberg mdev->bm_resync_fo = 0; 16085a22db89SLars Ellenberg 16095a22db89SLars Ellenberg /* Since protocol 96, we must serialize drbd_gen_and_send_sync_uuid 16105a22db89SLars Ellenberg * with w_send_oos, or the sync target will get confused as to 16115a22db89SLars Ellenberg * how much bits to resync. We cannot do that always, because for an 16125a22db89SLars Ellenberg * empty resync and protocol < 95, we need to do it here, as we call 16135a22db89SLars Ellenberg * drbd_resync_finished from here in that case. 16145a22db89SLars Ellenberg * We drbd_gen_and_send_sync_uuid here for protocol < 96, 16155a22db89SLars Ellenberg * and from after_state_ch otherwise. */ 161631890f4aSPhilipp Reisner if (side == C_SYNC_SOURCE && mdev->tconn->agreed_pro_version < 96) 16175a22db89SLars Ellenberg drbd_gen_and_send_sync_uuid(mdev); 1618b411b363SPhilipp Reisner 161931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 95 && mdev->rs_total == 0) { 1620af85e8e8SLars Ellenberg /* This still has a race (about when exactly the peers 1621af85e8e8SLars Ellenberg * detect connection loss) that can lead to a full sync 1622af85e8e8SLars Ellenberg * on next handshake. In 8.3.9 we fixed this with explicit 1623af85e8e8SLars Ellenberg * resync-finished notifications, but the fix 1624af85e8e8SLars Ellenberg * introduces a protocol change. Sleeping for some 1625af85e8e8SLars Ellenberg * time longer than the ping interval + timeout on the 1626af85e8e8SLars Ellenberg * SyncSource, to give the SyncTarget the chance to 1627af85e8e8SLars Ellenberg * detect connection loss, then waiting for a ping 1628af85e8e8SLars Ellenberg * response (implicit in drbd_resync_finished) reduces 1629af85e8e8SLars Ellenberg * the race considerably, but does not solve it. */ 163044ed167dSPhilipp Reisner if (side == C_SYNC_SOURCE) { 163144ed167dSPhilipp Reisner struct net_conf *nc; 163244ed167dSPhilipp Reisner int timeo; 163344ed167dSPhilipp Reisner 163444ed167dSPhilipp Reisner rcu_read_lock(); 163544ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 163644ed167dSPhilipp Reisner timeo = nc->ping_int * HZ + nc->ping_timeo * HZ / 9; 163744ed167dSPhilipp Reisner rcu_read_unlock(); 163844ed167dSPhilipp Reisner schedule_timeout_interruptible(timeo); 163944ed167dSPhilipp Reisner } 1640b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1641b411b363SPhilipp Reisner } 1642b411b363SPhilipp Reisner 16439bd28d3cSLars Ellenberg drbd_rs_controller_reset(mdev); 1644b411b363SPhilipp Reisner /* ns.conn may already be != mdev->state.conn, 1645b411b363SPhilipp Reisner * we may have been paused in between, or become paused until 1646b411b363SPhilipp Reisner * the timer triggers. 1647b411b363SPhilipp Reisner * No matter, that is handled in resync_timer_fn() */ 1648b411b363SPhilipp Reisner if (ns.conn == C_SYNC_TARGET) 1649b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies); 1650b411b363SPhilipp Reisner 1651b411b363SPhilipp Reisner drbd_md_sync(mdev); 1652b411b363SPhilipp Reisner } 16535a22db89SLars Ellenberg put_ldev(mdev); 16548410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1655b411b363SPhilipp Reisner } 1656b411b363SPhilipp Reisner 1657b411b363SPhilipp Reisner int drbd_worker(struct drbd_thread *thi) 1658b411b363SPhilipp Reisner { 1659392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 1660b411b363SPhilipp Reisner struct drbd_work *w = NULL; 16610e29d163SPhilipp Reisner struct drbd_conf *mdev; 166244ed167dSPhilipp Reisner struct net_conf *nc; 1663b411b363SPhilipp Reisner LIST_HEAD(work_list); 1664f399002eSLars Ellenberg int vnr, intr = 0; 166544ed167dSPhilipp Reisner int cork; 1666b411b363SPhilipp Reisner 1667e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 166880822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 1669b411b363SPhilipp Reisner 167019393e10SPhilipp Reisner if (down_trylock(&tconn->data.work.s)) { 167119393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 167244ed167dSPhilipp Reisner 167344ed167dSPhilipp Reisner rcu_read_lock(); 167444ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 167544ed167dSPhilipp Reisner cork = nc ? !nc->no_cork : 0; 167644ed167dSPhilipp Reisner rcu_read_unlock(); 167744ed167dSPhilipp Reisner 167844ed167dSPhilipp Reisner if (tconn->data.socket && cork) 167919393e10SPhilipp Reisner drbd_tcp_uncork(tconn->data.socket); 168019393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1681b411b363SPhilipp Reisner 168219393e10SPhilipp Reisner intr = down_interruptible(&tconn->data.work.s); 1683b411b363SPhilipp Reisner 168419393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 168544ed167dSPhilipp Reisner if (tconn->data.socket && cork) 168619393e10SPhilipp Reisner drbd_tcp_cork(tconn->data.socket); 168719393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1688b411b363SPhilipp Reisner } 1689b411b363SPhilipp Reisner 1690b411b363SPhilipp Reisner if (intr) { 1691b411b363SPhilipp Reisner flush_signals(current); 169219393e10SPhilipp Reisner if (get_t_state(thi) == RUNNING) { 169319393e10SPhilipp Reisner conn_warn(tconn, "Worker got an unexpected signal\n"); 1694b411b363SPhilipp Reisner continue; 169519393e10SPhilipp Reisner } 1696b411b363SPhilipp Reisner break; 1697b411b363SPhilipp Reisner } 1698b411b363SPhilipp Reisner 1699e77a0a5cSAndreas Gruenbacher if (get_t_state(thi) != RUNNING) 1700b411b363SPhilipp Reisner break; 1701b411b363SPhilipp Reisner /* With this break, we have done a down() but not consumed 1702b411b363SPhilipp Reisner the entry from the list. The cleanup code takes care of 1703b411b363SPhilipp Reisner this... */ 1704b411b363SPhilipp Reisner 1705b411b363SPhilipp Reisner w = NULL; 170619393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 170719393e10SPhilipp Reisner if (list_empty(&tconn->data.work.q)) { 1708b411b363SPhilipp Reisner /* something terribly wrong in our logic. 1709b411b363SPhilipp Reisner * we were able to down() the semaphore, 1710b411b363SPhilipp Reisner * but the list is empty... doh. 1711b411b363SPhilipp Reisner * 1712b411b363SPhilipp Reisner * what is the best thing to do now? 1713b411b363SPhilipp Reisner * try again from scratch, restarting the receiver, 1714b411b363SPhilipp Reisner * asender, whatnot? could break even more ugly, 1715b411b363SPhilipp Reisner * e.g. when we are primary, but no good local data. 1716b411b363SPhilipp Reisner * 1717b411b363SPhilipp Reisner * I'll try to get away just starting over this loop. 1718b411b363SPhilipp Reisner */ 171919393e10SPhilipp Reisner conn_warn(tconn, "Work list unexpectedly empty\n"); 172019393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1721b411b363SPhilipp Reisner continue; 1722b411b363SPhilipp Reisner } 172319393e10SPhilipp Reisner w = list_entry(tconn->data.work.q.next, struct drbd_work, list); 1724b411b363SPhilipp Reisner list_del_init(&w->list); 172519393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1726b411b363SPhilipp Reisner 172799920dc5SAndreas Gruenbacher if (w->cb(w, tconn->cstate < C_WF_REPORT_PARAMS)) { 1728b411b363SPhilipp Reisner /* dev_warn(DEV, "worker: a callback failed! \n"); */ 1729bbeb641cSPhilipp Reisner if (tconn->cstate >= C_WF_REPORT_PARAMS) 1730bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 1731b411b363SPhilipp Reisner } 1732b411b363SPhilipp Reisner } 1733b411b363SPhilipp Reisner 173419393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 173519393e10SPhilipp Reisner while (!list_empty(&tconn->data.work.q)) { 173619393e10SPhilipp Reisner list_splice_init(&tconn->data.work.q, &work_list); 173719393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1738b411b363SPhilipp Reisner 1739b411b363SPhilipp Reisner while (!list_empty(&work_list)) { 1740b411b363SPhilipp Reisner w = list_entry(work_list.next, struct drbd_work, list); 1741b411b363SPhilipp Reisner list_del_init(&w->list); 174200d56944SPhilipp Reisner w->cb(w, 1); 1743b411b363SPhilipp Reisner } 1744b411b363SPhilipp Reisner 174519393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 1746b411b363SPhilipp Reisner } 174719393e10SPhilipp Reisner sema_init(&tconn->data.work.s, 0); 1748b411b363SPhilipp Reisner /* DANGEROUS race: if someone did queue his work within the spinlock, 1749b411b363SPhilipp Reisner * but up() ed outside the spinlock, we could get an up() on the 1750b411b363SPhilipp Reisner * semaphore without corresponding list entry. 1751b411b363SPhilipp Reisner * So don't do that. 1752b411b363SPhilipp Reisner */ 175319393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1754b411b363SPhilipp Reisner 1755d3fcb490SPhilipp Reisner down_read(&drbd_cfg_rwsem); 1756f399002eSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 17570e29d163SPhilipp Reisner D_ASSERT(mdev->state.disk == D_DISKLESS && mdev->state.conn == C_STANDALONE); 17580e29d163SPhilipp Reisner drbd_mdev_cleanup(mdev); 17590e29d163SPhilipp Reisner } 1760d3fcb490SPhilipp Reisner up_read(&drbd_cfg_rwsem); 1761b411b363SPhilipp Reisner 1762b411b363SPhilipp Reisner return 0; 1763b411b363SPhilipp Reisner } 1764