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 41b411b363SPhilipp Reisner static int w_make_ov_request(struct drbd_conf *mdev, struct drbd_work *w, int cancel); 429d77a5feSPhilipp Reisner static int w_make_resync_request(struct drbd_conf *mdev, 439d77a5feSPhilipp Reisner struct drbd_work *w, int cancel); 44b411b363SPhilipp Reisner 45b411b363SPhilipp Reisner 46b411b363SPhilipp Reisner 47c5a91619SAndreas Gruenbacher /* endio handlers: 48c5a91619SAndreas Gruenbacher * drbd_md_io_complete (defined here) 49c5a91619SAndreas Gruenbacher * drbd_endio_pri (defined here) 50c5a91619SAndreas Gruenbacher * drbd_endio_sec (defined here) 51c5a91619SAndreas Gruenbacher * bm_async_io_complete (defined in drbd_bitmap.c) 52c5a91619SAndreas Gruenbacher * 53b411b363SPhilipp Reisner * For all these callbacks, note the following: 54b411b363SPhilipp Reisner * The callbacks will be called in irq context by the IDE drivers, 55b411b363SPhilipp Reisner * and in Softirqs/Tasklets/BH context by the SCSI drivers. 56b411b363SPhilipp Reisner * Try to get the locking right :) 57b411b363SPhilipp Reisner * 58b411b363SPhilipp Reisner */ 59b411b363SPhilipp Reisner 60b411b363SPhilipp Reisner 61b411b363SPhilipp Reisner /* About the global_state_lock 62b411b363SPhilipp Reisner Each state transition on an device holds a read lock. In case we have 63b411b363SPhilipp Reisner to evaluate the sync after dependencies, we grab a write lock, because 64b411b363SPhilipp Reisner we need stable states on all devices for that. */ 65b411b363SPhilipp Reisner rwlock_t global_state_lock; 66b411b363SPhilipp Reisner 67b411b363SPhilipp Reisner /* used for synchronous meta data and bitmap IO 68b411b363SPhilipp Reisner * submitted by drbd_md_sync_page_io() 69b411b363SPhilipp Reisner */ 70b411b363SPhilipp Reisner void drbd_md_io_complete(struct bio *bio, int error) 71b411b363SPhilipp Reisner { 72b411b363SPhilipp Reisner struct drbd_md_io *md_io; 73b411b363SPhilipp Reisner 74b411b363SPhilipp Reisner md_io = (struct drbd_md_io *)bio->bi_private; 75b411b363SPhilipp Reisner md_io->error = error; 76b411b363SPhilipp Reisner 77b411b363SPhilipp Reisner complete(&md_io->event); 78b411b363SPhilipp Reisner } 79b411b363SPhilipp Reisner 80b411b363SPhilipp Reisner /* reads on behalf of the partner, 81b411b363SPhilipp Reisner * "submitted" by the receiver 82b411b363SPhilipp Reisner */ 83db830c46SAndreas Gruenbacher void drbd_endio_read_sec_final(struct drbd_peer_request *peer_req) __releases(local) 84b411b363SPhilipp Reisner { 85b411b363SPhilipp Reisner unsigned long flags = 0; 86a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 87b411b363SPhilipp Reisner 8887eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 89db830c46SAndreas Gruenbacher mdev->read_cnt += peer_req->i.size >> 9; 90db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 91b411b363SPhilipp Reisner if (list_empty(&mdev->read_ee)) 92b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 93db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 9481e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 9587eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 96b411b363SPhilipp Reisner 97db830c46SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &peer_req->w); 98b411b363SPhilipp Reisner put_ldev(mdev); 99b411b363SPhilipp Reisner } 100b411b363SPhilipp Reisner 101b411b363SPhilipp Reisner /* writes on behalf of the partner, or resync writes, 10245bb912bSLars Ellenberg * "submitted" by the receiver, final stage. */ 103db830c46SAndreas Gruenbacher static void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(local) 104b411b363SPhilipp Reisner { 105b411b363SPhilipp Reisner unsigned long flags = 0; 106a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 107b411b363SPhilipp Reisner sector_t e_sector; 108b411b363SPhilipp Reisner int do_wake; 109579b57edSAndreas Gruenbacher u64 block_id; 110b411b363SPhilipp Reisner int do_al_complete_io; 111b411b363SPhilipp Reisner 112db830c46SAndreas Gruenbacher /* after we moved peer_req to done_ee, 113b411b363SPhilipp Reisner * we may no longer access it, 114b411b363SPhilipp Reisner * it may be freed/reused already! 115b411b363SPhilipp Reisner * (as soon as we release the req_lock) */ 116db830c46SAndreas Gruenbacher e_sector = peer_req->i.sector; 117db830c46SAndreas Gruenbacher do_al_complete_io = peer_req->flags & EE_CALL_AL_COMPLETE_IO; 118db830c46SAndreas Gruenbacher block_id = peer_req->block_id; 119b411b363SPhilipp Reisner 12087eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 121db830c46SAndreas Gruenbacher mdev->writ_cnt += peer_req->i.size >> 9; 122db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); /* has been on active_ee or sync_ee */ 123db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 124b411b363SPhilipp Reisner 125bb3bfe96SAndreas Gruenbacher /* 1265e472264SAndreas Gruenbacher * Do not remove from the write_requests tree here: we did not send the 127bb3bfe96SAndreas Gruenbacher * Ack yet and did not wake possibly waiting conflicting requests. 128bb3bfe96SAndreas Gruenbacher * Removed from the tree from "drbd_process_done_ee" within the 129bb3bfe96SAndreas Gruenbacher * appropriate w.cb (e_end_block/e_end_resync_block) or from 130bb3bfe96SAndreas Gruenbacher * _drbd_clear_done_ee. 131bb3bfe96SAndreas Gruenbacher */ 132b411b363SPhilipp Reisner 133579b57edSAndreas Gruenbacher do_wake = list_empty(block_id == ID_SYNCER ? &mdev->sync_ee : &mdev->active_ee); 134b411b363SPhilipp Reisner 135db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 13681e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 13787eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 138b411b363SPhilipp Reisner 139579b57edSAndreas Gruenbacher if (block_id == ID_SYNCER) 140b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, e_sector); 141b411b363SPhilipp Reisner 142b411b363SPhilipp Reisner if (do_wake) 143b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 144b411b363SPhilipp Reisner 145b411b363SPhilipp Reisner if (do_al_complete_io) 146b411b363SPhilipp Reisner drbd_al_complete_io(mdev, e_sector); 147b411b363SPhilipp Reisner 1480625ac19SPhilipp Reisner wake_asender(mdev->tconn); 149b411b363SPhilipp Reisner put_ldev(mdev); 15045bb912bSLars Ellenberg } 151b411b363SPhilipp Reisner 15245bb912bSLars Ellenberg /* writes on behalf of the partner, or resync writes, 15345bb912bSLars Ellenberg * "submitted" by the receiver. 15445bb912bSLars Ellenberg */ 15545bb912bSLars Ellenberg void drbd_endio_sec(struct bio *bio, int error) 15645bb912bSLars Ellenberg { 157db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = bio->bi_private; 158a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 15945bb912bSLars Ellenberg int uptodate = bio_flagged(bio, BIO_UPTODATE); 16045bb912bSLars Ellenberg int is_write = bio_data_dir(bio) == WRITE; 16145bb912bSLars Ellenberg 16207194272SLars Ellenberg if (error && __ratelimit(&drbd_ratelimit_state)) 16345bb912bSLars Ellenberg dev_warn(DEV, "%s: error=%d s=%llus\n", 16445bb912bSLars Ellenberg is_write ? "write" : "read", error, 165db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 16645bb912bSLars Ellenberg if (!error && !uptodate) { 16707194272SLars Ellenberg if (__ratelimit(&drbd_ratelimit_state)) 16845bb912bSLars Ellenberg dev_warn(DEV, "%s: setting error to -EIO s=%llus\n", 16945bb912bSLars Ellenberg is_write ? "write" : "read", 170db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 17145bb912bSLars Ellenberg /* strange behavior of some lower level drivers... 17245bb912bSLars Ellenberg * fail the request by clearing the uptodate flag, 17345bb912bSLars Ellenberg * but do not return any error?! */ 17445bb912bSLars Ellenberg error = -EIO; 17545bb912bSLars Ellenberg } 17645bb912bSLars Ellenberg 17745bb912bSLars Ellenberg if (error) 178db830c46SAndreas Gruenbacher set_bit(__EE_WAS_ERROR, &peer_req->flags); 17945bb912bSLars Ellenberg 18045bb912bSLars Ellenberg bio_put(bio); /* no need for the bio anymore */ 181db830c46SAndreas Gruenbacher if (atomic_dec_and_test(&peer_req->pending_bios)) { 18245bb912bSLars Ellenberg if (is_write) 183db830c46SAndreas Gruenbacher drbd_endio_write_sec_final(peer_req); 18445bb912bSLars Ellenberg else 185db830c46SAndreas Gruenbacher drbd_endio_read_sec_final(peer_req); 18645bb912bSLars Ellenberg } 187b411b363SPhilipp Reisner } 188b411b363SPhilipp Reisner 189b411b363SPhilipp Reisner /* read, readA or write requests on R_PRIMARY coming from drbd_make_request 190b411b363SPhilipp Reisner */ 191b411b363SPhilipp Reisner void drbd_endio_pri(struct bio *bio, int error) 192b411b363SPhilipp Reisner { 193a115413dSLars Ellenberg unsigned long flags; 194b411b363SPhilipp Reisner struct drbd_request *req = bio->bi_private; 195a21e9298SPhilipp Reisner struct drbd_conf *mdev = req->w.mdev; 196a115413dSLars Ellenberg struct bio_and_error m; 197b411b363SPhilipp Reisner enum drbd_req_event what; 198b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 199b411b363SPhilipp Reisner 200b411b363SPhilipp Reisner if (!error && !uptodate) { 201b411b363SPhilipp Reisner dev_warn(DEV, "p %s: setting error to -EIO\n", 202b411b363SPhilipp Reisner bio_data_dir(bio) == WRITE ? "write" : "read"); 203b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 204b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 205b411b363SPhilipp Reisner * but do not return any error?! */ 206b411b363SPhilipp Reisner error = -EIO; 207b411b363SPhilipp Reisner } 208b411b363SPhilipp Reisner 209b411b363SPhilipp Reisner /* to avoid recursion in __req_mod */ 210b411b363SPhilipp Reisner if (unlikely(error)) { 211b411b363SPhilipp Reisner what = (bio_data_dir(bio) == WRITE) 2128554df1cSAndreas Gruenbacher ? WRITE_COMPLETED_WITH_ERROR 2135c3c7e64SLars Ellenberg : (bio_rw(bio) == READ) 2148554df1cSAndreas Gruenbacher ? READ_COMPLETED_WITH_ERROR 2158554df1cSAndreas Gruenbacher : READ_AHEAD_COMPLETED_WITH_ERROR; 216b411b363SPhilipp Reisner } else 2178554df1cSAndreas Gruenbacher what = COMPLETED_OK; 218b411b363SPhilipp Reisner 219b411b363SPhilipp Reisner bio_put(req->private_bio); 220b411b363SPhilipp Reisner req->private_bio = ERR_PTR(error); 221b411b363SPhilipp Reisner 222a115413dSLars Ellenberg /* not req_mod(), we need irqsave here! */ 22387eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 224a115413dSLars Ellenberg __req_mod(req, what, &m); 22587eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 226a115413dSLars Ellenberg 227a115413dSLars Ellenberg if (m.bio) 228a115413dSLars Ellenberg complete_master_bio(mdev, &m); 229b411b363SPhilipp Reisner } 230b411b363SPhilipp Reisner 231b411b363SPhilipp Reisner int w_read_retry_remote(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 232b411b363SPhilipp Reisner { 233b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 234b411b363SPhilipp Reisner 235b411b363SPhilipp Reisner /* We should not detach for read io-error, 236b411b363SPhilipp Reisner * but try to WRITE the P_DATA_REPLY to the failed location, 237b411b363SPhilipp Reisner * to give the disk the chance to relocate that block */ 238b411b363SPhilipp Reisner 23987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 240d255e5ffSLars Ellenberg if (cancel || mdev->state.pdsk != D_UP_TO_DATE) { 2418554df1cSAndreas Gruenbacher _req_mod(req, READ_RETRY_REMOTE_CANCELED); 24287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 243b411b363SPhilipp Reisner return 1; 244b411b363SPhilipp Reisner } 24587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 246b411b363SPhilipp Reisner 247b411b363SPhilipp Reisner return w_send_read_req(mdev, w, 0); 248b411b363SPhilipp Reisner } 249b411b363SPhilipp Reisner 250f6ffca9fSAndreas Gruenbacher void drbd_csum_ee(struct drbd_conf *mdev, struct crypto_hash *tfm, 251db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, void *digest) 25245bb912bSLars Ellenberg { 25345bb912bSLars Ellenberg struct hash_desc desc; 25445bb912bSLars Ellenberg struct scatterlist sg; 255db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 25645bb912bSLars Ellenberg struct page *tmp; 25745bb912bSLars Ellenberg unsigned len; 25845bb912bSLars Ellenberg 25945bb912bSLars Ellenberg desc.tfm = tfm; 26045bb912bSLars Ellenberg desc.flags = 0; 26145bb912bSLars Ellenberg 26245bb912bSLars Ellenberg sg_init_table(&sg, 1); 26345bb912bSLars Ellenberg crypto_hash_init(&desc); 26445bb912bSLars Ellenberg 26545bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) { 26645bb912bSLars Ellenberg /* all but the last page will be fully used */ 26745bb912bSLars Ellenberg sg_set_page(&sg, page, PAGE_SIZE, 0); 26845bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 26945bb912bSLars Ellenberg page = tmp; 27045bb912bSLars Ellenberg } 27145bb912bSLars Ellenberg /* and now the last, possibly only partially used page */ 272db830c46SAndreas Gruenbacher len = peer_req->i.size & (PAGE_SIZE - 1); 27345bb912bSLars Ellenberg sg_set_page(&sg, page, len ?: PAGE_SIZE, 0); 27445bb912bSLars Ellenberg crypto_hash_update(&desc, &sg, sg.length); 27545bb912bSLars Ellenberg crypto_hash_final(&desc, digest); 27645bb912bSLars Ellenberg } 27745bb912bSLars Ellenberg 27845bb912bSLars Ellenberg void drbd_csum_bio(struct drbd_conf *mdev, struct crypto_hash *tfm, struct bio *bio, void *digest) 279b411b363SPhilipp Reisner { 280b411b363SPhilipp Reisner struct hash_desc desc; 281b411b363SPhilipp Reisner struct scatterlist sg; 282b411b363SPhilipp Reisner struct bio_vec *bvec; 283b411b363SPhilipp Reisner int i; 284b411b363SPhilipp Reisner 285b411b363SPhilipp Reisner desc.tfm = tfm; 286b411b363SPhilipp Reisner desc.flags = 0; 287b411b363SPhilipp Reisner 288b411b363SPhilipp Reisner sg_init_table(&sg, 1); 289b411b363SPhilipp Reisner crypto_hash_init(&desc); 290b411b363SPhilipp Reisner 291b411b363SPhilipp Reisner __bio_for_each_segment(bvec, bio, i, 0) { 292b411b363SPhilipp Reisner sg_set_page(&sg, bvec->bv_page, bvec->bv_len, bvec->bv_offset); 293b411b363SPhilipp Reisner crypto_hash_update(&desc, &sg, sg.length); 294b411b363SPhilipp Reisner } 295b411b363SPhilipp Reisner crypto_hash_final(&desc, digest); 296b411b363SPhilipp Reisner } 297b411b363SPhilipp Reisner 29853ea4331SLars Ellenberg /* TODO merge common code with w_e_end_ov_req */ 29953ea4331SLars Ellenberg int w_e_send_csum(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 300b411b363SPhilipp Reisner { 301db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = 302db830c46SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 303b411b363SPhilipp Reisner int digest_size; 304b411b363SPhilipp Reisner void *digest; 30553ea4331SLars Ellenberg int ok = 1; 306b411b363SPhilipp Reisner 30753ea4331SLars Ellenberg if (unlikely(cancel)) 30853ea4331SLars Ellenberg goto out; 309b411b363SPhilipp Reisner 310db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) != 0)) 31153ea4331SLars Ellenberg goto out; 31253ea4331SLars Ellenberg 313b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->csums_tfm); 314b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 315b411b363SPhilipp Reisner if (digest) { 316db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 317db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 318db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->csums_tfm, peer_req, digest); 31953ea4331SLars Ellenberg /* Free e and pages before send. 32053ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 32153ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 32253ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 32353ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 324db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 325db830c46SAndreas Gruenbacher peer_req = NULL; 326b411b363SPhilipp Reisner inc_rs_pending(mdev); 32753ea4331SLars Ellenberg ok = drbd_send_drequest_csum(mdev, sector, size, 32853ea4331SLars Ellenberg digest, digest_size, 329b411b363SPhilipp Reisner P_CSUM_RS_REQUEST); 330b411b363SPhilipp Reisner kfree(digest); 331b411b363SPhilipp Reisner } else { 332b411b363SPhilipp Reisner dev_err(DEV, "kmalloc() of digest failed.\n"); 333b411b363SPhilipp Reisner ok = 0; 334b411b363SPhilipp Reisner } 335b411b363SPhilipp Reisner 33653ea4331SLars Ellenberg out: 337db830c46SAndreas Gruenbacher if (peer_req) 338db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 339b411b363SPhilipp Reisner 340b411b363SPhilipp Reisner if (unlikely(!ok)) 341b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest(..., csum) failed\n"); 342b411b363SPhilipp Reisner return ok; 343b411b363SPhilipp Reisner } 344b411b363SPhilipp Reisner 345b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 346b411b363SPhilipp Reisner 347b411b363SPhilipp Reisner static int read_for_csum(struct drbd_conf *mdev, sector_t sector, int size) 348b411b363SPhilipp Reisner { 349db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 350b411b363SPhilipp Reisner 351b411b363SPhilipp Reisner if (!get_ldev(mdev)) 35280a40e43SLars Ellenberg return -EIO; 353b411b363SPhilipp Reisner 354e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector)) 3550f0601f4SLars Ellenberg goto defer; 3560f0601f4SLars Ellenberg 357b411b363SPhilipp Reisner /* GFP_TRY, because if there is no memory available right now, this may 358b411b363SPhilipp Reisner * be rescheduled for later. It is "only" background resync, after all. */ 359db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, ID_SYNCER /* unused */, sector, size, GFP_TRY); 360db830c46SAndreas Gruenbacher if (!peer_req) 36180a40e43SLars Ellenberg goto defer; 362b411b363SPhilipp Reisner 363db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_send_csum; 36487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 365db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->read_ee); 36687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 367b411b363SPhilipp Reisner 3680f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 369db830c46SAndreas Gruenbacher if (drbd_submit_ee(mdev, peer_req, READ, DRBD_FAULT_RS_RD) == 0) 37080a40e43SLars Ellenberg return 0; 37145bb912bSLars Ellenberg 37210f6d992SLars Ellenberg /* If it failed because of ENOMEM, retry should help. If it failed 37310f6d992SLars Ellenberg * because bio_add_page failed (probably broken lower level driver), 37410f6d992SLars Ellenberg * retry may or may not help. 37510f6d992SLars Ellenberg * If it does not, you may need to force disconnect. */ 37687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 377db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 37887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 37922cc37a9SLars Ellenberg 380db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 38180a40e43SLars Ellenberg defer: 38245bb912bSLars Ellenberg put_ldev(mdev); 38380a40e43SLars Ellenberg return -EAGAIN; 384b411b363SPhilipp Reisner } 385b411b363SPhilipp Reisner 386794abb75SPhilipp Reisner int w_resync_timer(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 387794abb75SPhilipp Reisner { 388794abb75SPhilipp Reisner switch (mdev->state.conn) { 389794abb75SPhilipp Reisner case C_VERIFY_S: 390794abb75SPhilipp Reisner w_make_ov_request(mdev, w, cancel); 391794abb75SPhilipp Reisner break; 392794abb75SPhilipp Reisner case C_SYNC_TARGET: 393794abb75SPhilipp Reisner w_make_resync_request(mdev, w, cancel); 394794abb75SPhilipp Reisner break; 395794abb75SPhilipp Reisner } 396794abb75SPhilipp Reisner 397794abb75SPhilipp Reisner return 1; 398794abb75SPhilipp Reisner } 399794abb75SPhilipp Reisner 400b411b363SPhilipp Reisner void resync_timer_fn(unsigned long data) 401b411b363SPhilipp Reisner { 402b411b363SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 403b411b363SPhilipp Reisner 404794abb75SPhilipp Reisner if (list_empty(&mdev->resync_work.list)) 405e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->resync_work); 406b411b363SPhilipp Reisner } 407b411b363SPhilipp Reisner 408778f271dSPhilipp Reisner static void fifo_set(struct fifo_buffer *fb, int value) 409778f271dSPhilipp Reisner { 410778f271dSPhilipp Reisner int i; 411778f271dSPhilipp Reisner 412778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 413f10f2623SPhilipp Reisner fb->values[i] = value; 414778f271dSPhilipp Reisner } 415778f271dSPhilipp Reisner 416778f271dSPhilipp Reisner static int fifo_push(struct fifo_buffer *fb, int value) 417778f271dSPhilipp Reisner { 418778f271dSPhilipp Reisner int ov; 419778f271dSPhilipp Reisner 420778f271dSPhilipp Reisner ov = fb->values[fb->head_index]; 421778f271dSPhilipp Reisner fb->values[fb->head_index++] = value; 422778f271dSPhilipp Reisner 423778f271dSPhilipp Reisner if (fb->head_index >= fb->size) 424778f271dSPhilipp Reisner fb->head_index = 0; 425778f271dSPhilipp Reisner 426778f271dSPhilipp Reisner return ov; 427778f271dSPhilipp Reisner } 428778f271dSPhilipp Reisner 429778f271dSPhilipp Reisner static void fifo_add_val(struct fifo_buffer *fb, int value) 430778f271dSPhilipp Reisner { 431778f271dSPhilipp Reisner int i; 432778f271dSPhilipp Reisner 433778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 434778f271dSPhilipp Reisner fb->values[i] += value; 435778f271dSPhilipp Reisner } 436778f271dSPhilipp Reisner 4379d77a5feSPhilipp Reisner static int drbd_rs_controller(struct drbd_conf *mdev) 438778f271dSPhilipp Reisner { 439778f271dSPhilipp Reisner unsigned int sect_in; /* Number of sectors that came in since the last turn */ 440778f271dSPhilipp Reisner unsigned int want; /* The number of sectors we want in the proxy */ 441778f271dSPhilipp Reisner int req_sect; /* Number of sectors to request in this turn */ 442778f271dSPhilipp Reisner int correction; /* Number of sectors more we need in the proxy*/ 443778f271dSPhilipp Reisner int cps; /* correction per invocation of drbd_rs_controller() */ 444778f271dSPhilipp Reisner int steps; /* Number of time steps to plan ahead */ 445778f271dSPhilipp Reisner int curr_corr; 446778f271dSPhilipp Reisner int max_sect; 447778f271dSPhilipp Reisner 448778f271dSPhilipp Reisner sect_in = atomic_xchg(&mdev->rs_sect_in, 0); /* Number of sectors that came in */ 449778f271dSPhilipp Reisner mdev->rs_in_flight -= sect_in; 450778f271dSPhilipp Reisner 451778f271dSPhilipp Reisner spin_lock(&mdev->peer_seq_lock); /* get an atomic view on mdev->rs_plan_s */ 452778f271dSPhilipp Reisner 453778f271dSPhilipp Reisner steps = mdev->rs_plan_s.size; /* (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; */ 454778f271dSPhilipp Reisner 455778f271dSPhilipp Reisner if (mdev->rs_in_flight + sect_in == 0) { /* At start of resync */ 456778f271dSPhilipp Reisner want = ((mdev->sync_conf.rate * 2 * SLEEP_TIME) / HZ) * steps; 457778f271dSPhilipp Reisner } else { /* normal path */ 458778f271dSPhilipp Reisner want = mdev->sync_conf.c_fill_target ? mdev->sync_conf.c_fill_target : 459778f271dSPhilipp Reisner sect_in * mdev->sync_conf.c_delay_target * HZ / (SLEEP_TIME * 10); 460778f271dSPhilipp Reisner } 461778f271dSPhilipp Reisner 462778f271dSPhilipp Reisner correction = want - mdev->rs_in_flight - mdev->rs_planed; 463778f271dSPhilipp Reisner 464778f271dSPhilipp Reisner /* Plan ahead */ 465778f271dSPhilipp Reisner cps = correction / steps; 466778f271dSPhilipp Reisner fifo_add_val(&mdev->rs_plan_s, cps); 467778f271dSPhilipp Reisner mdev->rs_planed += cps * steps; 468778f271dSPhilipp Reisner 469778f271dSPhilipp Reisner /* What we do in this step */ 470778f271dSPhilipp Reisner curr_corr = fifo_push(&mdev->rs_plan_s, 0); 471778f271dSPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 472778f271dSPhilipp Reisner mdev->rs_planed -= curr_corr; 473778f271dSPhilipp Reisner 474778f271dSPhilipp Reisner req_sect = sect_in + curr_corr; 475778f271dSPhilipp Reisner if (req_sect < 0) 476778f271dSPhilipp Reisner req_sect = 0; 477778f271dSPhilipp Reisner 478778f271dSPhilipp Reisner max_sect = (mdev->sync_conf.c_max_rate * 2 * SLEEP_TIME) / HZ; 479778f271dSPhilipp Reisner if (req_sect > max_sect) 480778f271dSPhilipp Reisner req_sect = max_sect; 481778f271dSPhilipp Reisner 482778f271dSPhilipp Reisner /* 483778f271dSPhilipp Reisner dev_warn(DEV, "si=%u if=%d wa=%u co=%d st=%d cps=%d pl=%d cc=%d rs=%d\n", 484778f271dSPhilipp Reisner sect_in, mdev->rs_in_flight, want, correction, 485778f271dSPhilipp Reisner steps, cps, mdev->rs_planed, curr_corr, req_sect); 486778f271dSPhilipp Reisner */ 487778f271dSPhilipp Reisner 488778f271dSPhilipp Reisner return req_sect; 489778f271dSPhilipp Reisner } 490778f271dSPhilipp Reisner 4919d77a5feSPhilipp Reisner static int drbd_rs_number_requests(struct drbd_conf *mdev) 492e65f440dSLars Ellenberg { 493e65f440dSLars Ellenberg int number; 494e65f440dSLars Ellenberg if (mdev->rs_plan_s.size) { /* mdev->sync_conf.c_plan_ahead */ 495e65f440dSLars Ellenberg number = drbd_rs_controller(mdev) >> (BM_BLOCK_SHIFT - 9); 496e65f440dSLars Ellenberg mdev->c_sync_rate = number * HZ * (BM_BLOCK_SIZE / 1024) / SLEEP_TIME; 497e65f440dSLars Ellenberg } else { 498e65f440dSLars Ellenberg mdev->c_sync_rate = mdev->sync_conf.rate; 499e65f440dSLars Ellenberg number = SLEEP_TIME * mdev->c_sync_rate / ((BM_BLOCK_SIZE / 1024) * HZ); 500e65f440dSLars Ellenberg } 501e65f440dSLars Ellenberg 502e65f440dSLars Ellenberg /* ignore the amount of pending requests, the resync controller should 503e65f440dSLars Ellenberg * throttle down to incoming reply rate soon enough anyways. */ 504e65f440dSLars Ellenberg return number; 505e65f440dSLars Ellenberg } 506e65f440dSLars Ellenberg 5079d77a5feSPhilipp Reisner static int w_make_resync_request(struct drbd_conf *mdev, 508b411b363SPhilipp Reisner struct drbd_work *w, int cancel) 509b411b363SPhilipp Reisner { 510b411b363SPhilipp Reisner unsigned long bit; 511b411b363SPhilipp Reisner sector_t sector; 512b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 5131816a2b4SLars Ellenberg int max_bio_size; 514e65f440dSLars Ellenberg int number, rollback_i, size; 515b411b363SPhilipp Reisner int align, queued, sndbuf; 5160f0601f4SLars Ellenberg int i = 0; 517b411b363SPhilipp Reisner 518b411b363SPhilipp Reisner if (unlikely(cancel)) 519b411b363SPhilipp Reisner return 1; 520b411b363SPhilipp Reisner 521af85e8e8SLars Ellenberg if (mdev->rs_total == 0) { 522af85e8e8SLars Ellenberg /* empty resync? */ 523af85e8e8SLars Ellenberg drbd_resync_finished(mdev); 524af85e8e8SLars Ellenberg return 1; 525af85e8e8SLars Ellenberg } 526af85e8e8SLars Ellenberg 527b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 528b411b363SPhilipp Reisner /* Since we only need to access mdev->rsync a 529b411b363SPhilipp Reisner get_ldev_if_state(mdev,D_FAILED) would be sufficient, but 530b411b363SPhilipp Reisner to continue resync with a broken disk makes no sense at 531b411b363SPhilipp Reisner all */ 532b411b363SPhilipp Reisner dev_err(DEV, "Disk broke down during resync!\n"); 533b411b363SPhilipp Reisner return 1; 534b411b363SPhilipp Reisner } 535b411b363SPhilipp Reisner 5360cfdd247SPhilipp Reisner max_bio_size = queue_max_hw_sectors(mdev->rq_queue) << 9; 537e65f440dSLars Ellenberg number = drbd_rs_number_requests(mdev); 538e65f440dSLars Ellenberg if (number == 0) 5390f0601f4SLars Ellenberg goto requeue; 540b411b363SPhilipp Reisner 541b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 542b411b363SPhilipp Reisner /* Stop generating RS requests, when half of the send buffer is filled */ 543e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 544e42325a5SPhilipp Reisner if (mdev->tconn->data.socket) { 545e42325a5SPhilipp Reisner queued = mdev->tconn->data.socket->sk->sk_wmem_queued; 546e42325a5SPhilipp Reisner sndbuf = mdev->tconn->data.socket->sk->sk_sndbuf; 547b411b363SPhilipp Reisner } else { 548b411b363SPhilipp Reisner queued = 1; 549b411b363SPhilipp Reisner sndbuf = 0; 550b411b363SPhilipp Reisner } 551e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 552b411b363SPhilipp Reisner if (queued > sndbuf / 2) 553b411b363SPhilipp Reisner goto requeue; 554b411b363SPhilipp Reisner 555b411b363SPhilipp Reisner next_sector: 556b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 557b411b363SPhilipp Reisner bit = drbd_bm_find_next(mdev, mdev->bm_resync_fo); 558b411b363SPhilipp Reisner 5594b0715f0SLars Ellenberg if (bit == DRBD_END_OF_BITMAP) { 560b411b363SPhilipp Reisner mdev->bm_resync_fo = drbd_bm_bits(mdev); 561b411b363SPhilipp Reisner put_ldev(mdev); 562b411b363SPhilipp Reisner return 1; 563b411b363SPhilipp Reisner } 564b411b363SPhilipp Reisner 565b411b363SPhilipp Reisner sector = BM_BIT_TO_SECT(bit); 566b411b363SPhilipp Reisner 567e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 568e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 569b411b363SPhilipp Reisner mdev->bm_resync_fo = bit; 570b411b363SPhilipp Reisner goto requeue; 571b411b363SPhilipp Reisner } 572b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 573b411b363SPhilipp Reisner 574b411b363SPhilipp Reisner if (unlikely(drbd_bm_test_bit(mdev, bit) == 0)) { 575b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 576b411b363SPhilipp Reisner goto next_sector; 577b411b363SPhilipp Reisner } 578b411b363SPhilipp Reisner 5791816a2b4SLars Ellenberg #if DRBD_MAX_BIO_SIZE > BM_BLOCK_SIZE 580b411b363SPhilipp Reisner /* try to find some adjacent bits. 581b411b363SPhilipp Reisner * we stop if we have already the maximum req size. 582b411b363SPhilipp Reisner * 583b411b363SPhilipp Reisner * Additionally always align bigger requests, in order to 584b411b363SPhilipp Reisner * be prepared for all stripe sizes of software RAIDs. 585b411b363SPhilipp Reisner */ 586b411b363SPhilipp Reisner align = 1; 587d207450cSPhilipp Reisner rollback_i = i; 588b411b363SPhilipp Reisner for (;;) { 5891816a2b4SLars Ellenberg if (size + BM_BLOCK_SIZE > max_bio_size) 590b411b363SPhilipp Reisner break; 591b411b363SPhilipp Reisner 592b411b363SPhilipp Reisner /* Be always aligned */ 593b411b363SPhilipp Reisner if (sector & ((1<<(align+3))-1)) 594b411b363SPhilipp Reisner break; 595b411b363SPhilipp Reisner 596b411b363SPhilipp Reisner /* do not cross extent boundaries */ 597b411b363SPhilipp Reisner if (((bit+1) & BM_BLOCKS_PER_BM_EXT_MASK) == 0) 598b411b363SPhilipp Reisner break; 599b411b363SPhilipp Reisner /* now, is it actually dirty, after all? 600b411b363SPhilipp Reisner * caution, drbd_bm_test_bit is tri-state for some 601b411b363SPhilipp Reisner * obscure reason; ( b == 0 ) would get the out-of-band 602b411b363SPhilipp Reisner * only accidentally right because of the "oddly sized" 603b411b363SPhilipp Reisner * adjustment below */ 604b411b363SPhilipp Reisner if (drbd_bm_test_bit(mdev, bit+1) != 1) 605b411b363SPhilipp Reisner break; 606b411b363SPhilipp Reisner bit++; 607b411b363SPhilipp Reisner size += BM_BLOCK_SIZE; 608b411b363SPhilipp Reisner if ((BM_BLOCK_SIZE << align) <= size) 609b411b363SPhilipp Reisner align++; 610b411b363SPhilipp Reisner i++; 611b411b363SPhilipp Reisner } 612b411b363SPhilipp Reisner /* if we merged some, 613b411b363SPhilipp Reisner * reset the offset to start the next drbd_bm_find_next from */ 614b411b363SPhilipp Reisner if (size > BM_BLOCK_SIZE) 615b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 616b411b363SPhilipp Reisner #endif 617b411b363SPhilipp Reisner 618b411b363SPhilipp Reisner /* adjust very last sectors, in case we are oddly sized */ 619b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 620b411b363SPhilipp Reisner size = (capacity-sector)<<9; 62131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version >= 89 && mdev->csums_tfm) { 622b411b363SPhilipp Reisner switch (read_for_csum(mdev, sector, size)) { 62380a40e43SLars Ellenberg case -EIO: /* Disk failure */ 624b411b363SPhilipp Reisner put_ldev(mdev); 625b411b363SPhilipp Reisner return 0; 62680a40e43SLars Ellenberg case -EAGAIN: /* allocation failed, or ldev busy */ 627b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 628b411b363SPhilipp Reisner mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 629d207450cSPhilipp Reisner i = rollback_i; 630b411b363SPhilipp Reisner goto requeue; 63180a40e43SLars Ellenberg case 0: 63280a40e43SLars Ellenberg /* everything ok */ 63380a40e43SLars Ellenberg break; 63480a40e43SLars Ellenberg default: 63580a40e43SLars Ellenberg BUG(); 636b411b363SPhilipp Reisner } 637b411b363SPhilipp Reisner } else { 638b411b363SPhilipp Reisner inc_rs_pending(mdev); 639b411b363SPhilipp Reisner if (!drbd_send_drequest(mdev, P_RS_DATA_REQUEST, 640b411b363SPhilipp Reisner sector, size, ID_SYNCER)) { 641b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest() failed, aborting...\n"); 642b411b363SPhilipp Reisner dec_rs_pending(mdev); 643b411b363SPhilipp Reisner put_ldev(mdev); 644b411b363SPhilipp Reisner return 0; 645b411b363SPhilipp Reisner } 646b411b363SPhilipp Reisner } 647b411b363SPhilipp Reisner } 648b411b363SPhilipp Reisner 649b411b363SPhilipp Reisner if (mdev->bm_resync_fo >= drbd_bm_bits(mdev)) { 650b411b363SPhilipp Reisner /* last syncer _request_ was sent, 651b411b363SPhilipp Reisner * but the P_RS_DATA_REPLY not yet received. sync will end (and 652b411b363SPhilipp Reisner * next sync group will resume), as soon as we receive the last 653b411b363SPhilipp Reisner * resync data block, and the last bit is cleared. 654b411b363SPhilipp Reisner * until then resync "work" is "inactive" ... 655b411b363SPhilipp Reisner */ 656b411b363SPhilipp Reisner put_ldev(mdev); 657b411b363SPhilipp Reisner return 1; 658b411b363SPhilipp Reisner } 659b411b363SPhilipp Reisner 660b411b363SPhilipp Reisner requeue: 661778f271dSPhilipp Reisner mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 662b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 663b411b363SPhilipp Reisner put_ldev(mdev); 664b411b363SPhilipp Reisner return 1; 665b411b363SPhilipp Reisner } 666b411b363SPhilipp Reisner 667b411b363SPhilipp Reisner static int w_make_ov_request(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 668b411b363SPhilipp Reisner { 669b411b363SPhilipp Reisner int number, i, size; 670b411b363SPhilipp Reisner sector_t sector; 671b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 672b411b363SPhilipp Reisner 673b411b363SPhilipp Reisner if (unlikely(cancel)) 674b411b363SPhilipp Reisner return 1; 675b411b363SPhilipp Reisner 6762649f080SLars Ellenberg number = drbd_rs_number_requests(mdev); 677b411b363SPhilipp Reisner 678b411b363SPhilipp Reisner sector = mdev->ov_position; 679b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 680b411b363SPhilipp Reisner if (sector >= capacity) { 681b411b363SPhilipp Reisner return 1; 682b411b363SPhilipp Reisner } 683b411b363SPhilipp Reisner 684b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 685b411b363SPhilipp Reisner 686e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 687e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 688b411b363SPhilipp Reisner mdev->ov_position = sector; 689b411b363SPhilipp Reisner goto requeue; 690b411b363SPhilipp Reisner } 691b411b363SPhilipp Reisner 692b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 693b411b363SPhilipp Reisner size = (capacity-sector)<<9; 694b411b363SPhilipp Reisner 695b411b363SPhilipp Reisner inc_rs_pending(mdev); 696b411b363SPhilipp Reisner if (!drbd_send_ov_request(mdev, sector, size)) { 697b411b363SPhilipp Reisner dec_rs_pending(mdev); 698b411b363SPhilipp Reisner return 0; 699b411b363SPhilipp Reisner } 700b411b363SPhilipp Reisner sector += BM_SECT_PER_BIT; 701b411b363SPhilipp Reisner } 702b411b363SPhilipp Reisner mdev->ov_position = sector; 703b411b363SPhilipp Reisner 704b411b363SPhilipp Reisner requeue: 7052649f080SLars Ellenberg mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 706b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 707b411b363SPhilipp Reisner return 1; 708b411b363SPhilipp Reisner } 709b411b363SPhilipp Reisner 710b411b363SPhilipp Reisner int w_ov_finished(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 711b411b363SPhilipp Reisner { 712b411b363SPhilipp Reisner kfree(w); 713b411b363SPhilipp Reisner ov_oos_print(mdev); 714b411b363SPhilipp Reisner drbd_resync_finished(mdev); 715b411b363SPhilipp Reisner 716b411b363SPhilipp Reisner return 1; 717b411b363SPhilipp Reisner } 718b411b363SPhilipp Reisner 719b411b363SPhilipp Reisner static int w_resync_finished(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 720b411b363SPhilipp Reisner { 721b411b363SPhilipp Reisner kfree(w); 722b411b363SPhilipp Reisner 723b411b363SPhilipp Reisner drbd_resync_finished(mdev); 724b411b363SPhilipp Reisner 725b411b363SPhilipp Reisner return 1; 726b411b363SPhilipp Reisner } 727b411b363SPhilipp Reisner 728af85e8e8SLars Ellenberg static void ping_peer(struct drbd_conf *mdev) 729af85e8e8SLars Ellenberg { 730af85e8e8SLars Ellenberg clear_bit(GOT_PING_ACK, &mdev->flags); 7310625ac19SPhilipp Reisner request_ping(mdev->tconn); 732af85e8e8SLars Ellenberg wait_event(mdev->misc_wait, 733af85e8e8SLars Ellenberg test_bit(GOT_PING_ACK, &mdev->flags) || mdev->state.conn < C_CONNECTED); 734af85e8e8SLars Ellenberg } 735af85e8e8SLars Ellenberg 736b411b363SPhilipp Reisner int drbd_resync_finished(struct drbd_conf *mdev) 737b411b363SPhilipp Reisner { 738b411b363SPhilipp Reisner unsigned long db, dt, dbdt; 739b411b363SPhilipp Reisner unsigned long n_oos; 740b411b363SPhilipp Reisner union drbd_state os, ns; 741b411b363SPhilipp Reisner struct drbd_work *w; 742b411b363SPhilipp Reisner char *khelper_cmd = NULL; 74326525618SLars Ellenberg int verify_done = 0; 744b411b363SPhilipp Reisner 745b411b363SPhilipp Reisner /* Remove all elements from the resync LRU. Since future actions 746b411b363SPhilipp Reisner * might set bits in the (main) bitmap, then the entries in the 747b411b363SPhilipp Reisner * resync LRU would be wrong. */ 748b411b363SPhilipp Reisner if (drbd_rs_del_all(mdev)) { 749b411b363SPhilipp Reisner /* In case this is not possible now, most probably because 750b411b363SPhilipp Reisner * there are P_RS_DATA_REPLY Packets lingering on the worker's 751b411b363SPhilipp Reisner * queue (or even the read operations for those packets 752b411b363SPhilipp Reisner * is not finished by now). Retry in 100ms. */ 753b411b363SPhilipp Reisner 75420ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 755b411b363SPhilipp Reisner w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC); 756b411b363SPhilipp Reisner if (w) { 757b411b363SPhilipp Reisner w->cb = w_resync_finished; 758e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, w); 759b411b363SPhilipp Reisner return 1; 760b411b363SPhilipp Reisner } 761b411b363SPhilipp Reisner dev_err(DEV, "Warn failed to drbd_rs_del_all() and to kmalloc(w).\n"); 762b411b363SPhilipp Reisner } 763b411b363SPhilipp Reisner 764b411b363SPhilipp Reisner dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ; 765b411b363SPhilipp Reisner if (dt <= 0) 766b411b363SPhilipp Reisner dt = 1; 767b411b363SPhilipp Reisner db = mdev->rs_total; 768b411b363SPhilipp Reisner dbdt = Bit2KB(db/dt); 769b411b363SPhilipp Reisner mdev->rs_paused /= HZ; 770b411b363SPhilipp Reisner 771b411b363SPhilipp Reisner if (!get_ldev(mdev)) 772b411b363SPhilipp Reisner goto out; 773b411b363SPhilipp Reisner 774af85e8e8SLars Ellenberg ping_peer(mdev); 775af85e8e8SLars Ellenberg 77687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 777b411b363SPhilipp Reisner os = mdev->state; 778b411b363SPhilipp Reisner 77926525618SLars Ellenberg verify_done = (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T); 78026525618SLars Ellenberg 781b411b363SPhilipp Reisner /* This protects us against multiple calls (that can happen in the presence 782b411b363SPhilipp Reisner of application IO), and against connectivity loss just before we arrive here. */ 783b411b363SPhilipp Reisner if (os.conn <= C_CONNECTED) 784b411b363SPhilipp Reisner goto out_unlock; 785b411b363SPhilipp Reisner 786b411b363SPhilipp Reisner ns = os; 787b411b363SPhilipp Reisner ns.conn = C_CONNECTED; 788b411b363SPhilipp Reisner 789b411b363SPhilipp Reisner dev_info(DEV, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n", 79026525618SLars Ellenberg verify_done ? "Online verify " : "Resync", 791b411b363SPhilipp Reisner dt + mdev->rs_paused, mdev->rs_paused, dbdt); 792b411b363SPhilipp Reisner 793b411b363SPhilipp Reisner n_oos = drbd_bm_total_weight(mdev); 794b411b363SPhilipp Reisner 795b411b363SPhilipp Reisner if (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) { 796b411b363SPhilipp Reisner if (n_oos) { 797b411b363SPhilipp Reisner dev_alert(DEV, "Online verify found %lu %dk block out of sync!\n", 798b411b363SPhilipp Reisner n_oos, Bit2KB(1)); 799b411b363SPhilipp Reisner khelper_cmd = "out-of-sync"; 800b411b363SPhilipp Reisner } 801b411b363SPhilipp Reisner } else { 802b411b363SPhilipp Reisner D_ASSERT((n_oos - mdev->rs_failed) == 0); 803b411b363SPhilipp Reisner 804b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) 805b411b363SPhilipp Reisner khelper_cmd = "after-resync-target"; 806b411b363SPhilipp Reisner 807b411b363SPhilipp Reisner if (mdev->csums_tfm && mdev->rs_total) { 808b411b363SPhilipp Reisner const unsigned long s = mdev->rs_same_csum; 809b411b363SPhilipp Reisner const unsigned long t = mdev->rs_total; 810b411b363SPhilipp Reisner const int ratio = 811b411b363SPhilipp Reisner (t == 0) ? 0 : 812b411b363SPhilipp Reisner (t < 100000) ? ((s*100)/t) : (s/(t/100)); 813b411b363SPhilipp Reisner dev_info(DEV, "%u %% had equal checksums, eliminated: %luK; " 814b411b363SPhilipp Reisner "transferred %luK total %luK\n", 815b411b363SPhilipp Reisner ratio, 816b411b363SPhilipp Reisner Bit2KB(mdev->rs_same_csum), 817b411b363SPhilipp Reisner Bit2KB(mdev->rs_total - mdev->rs_same_csum), 818b411b363SPhilipp Reisner Bit2KB(mdev->rs_total)); 819b411b363SPhilipp Reisner } 820b411b363SPhilipp Reisner } 821b411b363SPhilipp Reisner 822b411b363SPhilipp Reisner if (mdev->rs_failed) { 823b411b363SPhilipp Reisner dev_info(DEV, " %lu failed blocks\n", mdev->rs_failed); 824b411b363SPhilipp Reisner 825b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 826b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 827b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 828b411b363SPhilipp Reisner } else { 829b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 830b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 831b411b363SPhilipp Reisner } 832b411b363SPhilipp Reisner } else { 833b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 834b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 835b411b363SPhilipp Reisner 836b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 837b411b363SPhilipp Reisner if (mdev->p_uuid) { 838b411b363SPhilipp Reisner int i; 839b411b363SPhilipp Reisner for (i = UI_BITMAP ; i <= UI_HISTORY_END ; i++) 840b411b363SPhilipp Reisner _drbd_uuid_set(mdev, i, mdev->p_uuid[i]); 841b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_CURRENT]); 842b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, mdev->p_uuid[UI_CURRENT]); 843b411b363SPhilipp Reisner } else { 844b411b363SPhilipp Reisner dev_err(DEV, "mdev->p_uuid is NULL! BUG\n"); 845b411b363SPhilipp Reisner } 846b411b363SPhilipp Reisner } 847b411b363SPhilipp Reisner 84862b0da3aSLars Ellenberg if (!(os.conn == C_VERIFY_S || os.conn == C_VERIFY_T)) { 84962b0da3aSLars Ellenberg /* for verify runs, we don't update uuids here, 85062b0da3aSLars Ellenberg * so there would be nothing to report. */ 851b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 85262b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated UUIDs"); 853b411b363SPhilipp Reisner if (mdev->p_uuid) { 854b411b363SPhilipp Reisner /* Now the two UUID sets are equal, update what we 855b411b363SPhilipp Reisner * know of the peer. */ 856b411b363SPhilipp Reisner int i; 857b411b363SPhilipp Reisner for (i = UI_CURRENT ; i <= UI_HISTORY_END ; i++) 858b411b363SPhilipp Reisner mdev->p_uuid[i] = mdev->ldev->md.uuid[i]; 859b411b363SPhilipp Reisner } 860b411b363SPhilipp Reisner } 86162b0da3aSLars Ellenberg } 862b411b363SPhilipp Reisner 863b411b363SPhilipp Reisner _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 864b411b363SPhilipp Reisner out_unlock: 86587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 866b411b363SPhilipp Reisner put_ldev(mdev); 867b411b363SPhilipp Reisner out: 868b411b363SPhilipp Reisner mdev->rs_total = 0; 869b411b363SPhilipp Reisner mdev->rs_failed = 0; 870b411b363SPhilipp Reisner mdev->rs_paused = 0; 87126525618SLars Ellenberg if (verify_done) 872b411b363SPhilipp Reisner mdev->ov_start_sector = 0; 873b411b363SPhilipp Reisner 87413d42685SLars Ellenberg drbd_md_sync(mdev); 87513d42685SLars Ellenberg 876b411b363SPhilipp Reisner if (khelper_cmd) 877b411b363SPhilipp Reisner drbd_khelper(mdev, khelper_cmd); 878b411b363SPhilipp Reisner 879b411b363SPhilipp Reisner return 1; 880b411b363SPhilipp Reisner } 881b411b363SPhilipp Reisner 882b411b363SPhilipp Reisner /* helper */ 883db830c46SAndreas Gruenbacher static void move_to_net_ee_or_free(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 884b411b363SPhilipp Reisner { 885db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) { 886b411b363SPhilipp Reisner /* This might happen if sendpage() has not finished */ 887db830c46SAndreas Gruenbacher int i = (peer_req->i.size + PAGE_SIZE -1) >> PAGE_SHIFT; 888435f0740SLars Ellenberg atomic_add(i, &mdev->pp_in_use_by_net); 889435f0740SLars Ellenberg atomic_sub(i, &mdev->pp_in_use); 89087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 891db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->net_ee); 89287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 893435f0740SLars Ellenberg wake_up(&drbd_pp_wait); 894b411b363SPhilipp Reisner } else 895db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 896b411b363SPhilipp Reisner } 897b411b363SPhilipp Reisner 898b411b363SPhilipp Reisner /** 899b411b363SPhilipp Reisner * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 900b411b363SPhilipp Reisner * @mdev: DRBD device. 901b411b363SPhilipp Reisner * @w: work object. 902b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 903b411b363SPhilipp Reisner */ 904b411b363SPhilipp Reisner int w_e_end_data_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 905b411b363SPhilipp Reisner { 906db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 907b411b363SPhilipp Reisner int ok; 908b411b363SPhilipp Reisner 909b411b363SPhilipp Reisner if (unlikely(cancel)) { 910db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 911b411b363SPhilipp Reisner dec_unacked(mdev); 912b411b363SPhilipp Reisner return 1; 913b411b363SPhilipp Reisner } 914b411b363SPhilipp Reisner 915db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 916db830c46SAndreas Gruenbacher ok = drbd_send_block(mdev, P_DATA_REPLY, peer_req); 917b411b363SPhilipp Reisner } else { 918b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 919b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. sector=%llus.\n", 920db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 921b411b363SPhilipp Reisner 922db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_DREPLY, peer_req); 923b411b363SPhilipp Reisner } 924b411b363SPhilipp Reisner 925b411b363SPhilipp Reisner dec_unacked(mdev); 926b411b363SPhilipp Reisner 927db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 928b411b363SPhilipp Reisner 929b411b363SPhilipp Reisner if (unlikely(!ok)) 930b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 931b411b363SPhilipp Reisner return ok; 932b411b363SPhilipp Reisner } 933b411b363SPhilipp Reisner 934b411b363SPhilipp Reisner /** 935b411b363SPhilipp Reisner * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUESTRS 936b411b363SPhilipp Reisner * @mdev: DRBD device. 937b411b363SPhilipp Reisner * @w: work object. 938b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 939b411b363SPhilipp Reisner */ 940b411b363SPhilipp Reisner int w_e_end_rsdata_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 941b411b363SPhilipp Reisner { 942db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 943b411b363SPhilipp Reisner int ok; 944b411b363SPhilipp Reisner 945b411b363SPhilipp Reisner if (unlikely(cancel)) { 946db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 947b411b363SPhilipp Reisner dec_unacked(mdev); 948b411b363SPhilipp Reisner return 1; 949b411b363SPhilipp Reisner } 950b411b363SPhilipp Reisner 951b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 952db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 953b411b363SPhilipp Reisner put_ldev(mdev); 954b411b363SPhilipp Reisner } 955b411b363SPhilipp Reisner 956d612d309SPhilipp Reisner if (mdev->state.conn == C_AHEAD) { 957db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_RS_CANCEL, peer_req); 958db830c46SAndreas Gruenbacher } else if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 959b411b363SPhilipp Reisner if (likely(mdev->state.pdsk >= D_INCONSISTENT)) { 960b411b363SPhilipp Reisner inc_rs_pending(mdev); 961db830c46SAndreas Gruenbacher ok = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 962b411b363SPhilipp Reisner } else { 963b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 964b411b363SPhilipp Reisner dev_err(DEV, "Not sending RSDataReply, " 965b411b363SPhilipp Reisner "partner DISKLESS!\n"); 966b411b363SPhilipp Reisner ok = 1; 967b411b363SPhilipp Reisner } 968b411b363SPhilipp Reisner } else { 969b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 970b411b363SPhilipp Reisner dev_err(DEV, "Sending NegRSDReply. sector %llus.\n", 971db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 972b411b363SPhilipp Reisner 973db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 974b411b363SPhilipp Reisner 975b411b363SPhilipp Reisner /* update resync data with failure */ 976db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, peer_req->i.sector, peer_req->i.size); 977b411b363SPhilipp Reisner } 978b411b363SPhilipp Reisner 979b411b363SPhilipp Reisner dec_unacked(mdev); 980b411b363SPhilipp Reisner 981db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 982b411b363SPhilipp Reisner 983b411b363SPhilipp Reisner if (unlikely(!ok)) 984b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 985b411b363SPhilipp Reisner return ok; 986b411b363SPhilipp Reisner } 987b411b363SPhilipp Reisner 988b411b363SPhilipp Reisner int w_e_end_csum_rs_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 989b411b363SPhilipp Reisner { 990db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 991b411b363SPhilipp Reisner struct digest_info *di; 992b411b363SPhilipp Reisner int digest_size; 993b411b363SPhilipp Reisner void *digest = NULL; 994b411b363SPhilipp Reisner int ok, eq = 0; 995b411b363SPhilipp Reisner 996b411b363SPhilipp Reisner if (unlikely(cancel)) { 997db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 998b411b363SPhilipp Reisner dec_unacked(mdev); 999b411b363SPhilipp Reisner return 1; 1000b411b363SPhilipp Reisner } 1001b411b363SPhilipp Reisner 10021d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1003db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 10041d53f09eSLars Ellenberg put_ldev(mdev); 10051d53f09eSLars Ellenberg } 1006b411b363SPhilipp Reisner 1007db830c46SAndreas Gruenbacher di = peer_req->digest; 1008b411b363SPhilipp Reisner 1009db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1010b411b363SPhilipp Reisner /* quick hack to try to avoid a race against reconfiguration. 1011b411b363SPhilipp Reisner * a real fix would be much more involved, 1012b411b363SPhilipp Reisner * introducing more locking mechanisms */ 1013b411b363SPhilipp Reisner if (mdev->csums_tfm) { 1014b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->csums_tfm); 1015b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1016b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1017b411b363SPhilipp Reisner } 1018b411b363SPhilipp Reisner if (digest) { 1019db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->csums_tfm, peer_req, digest); 1020b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1021b411b363SPhilipp Reisner kfree(digest); 1022b411b363SPhilipp Reisner } 1023b411b363SPhilipp Reisner 1024b411b363SPhilipp Reisner if (eq) { 1025db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, peer_req->i.sector, peer_req->i.size); 1026676396d5SLars Ellenberg /* rs_same_csums unit is BM_BLOCK_SIZE */ 1027db830c46SAndreas Gruenbacher mdev->rs_same_csum += peer_req->i.size >> BM_BLOCK_SHIFT; 1028db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_RS_IS_IN_SYNC, peer_req); 1029b411b363SPhilipp Reisner } else { 1030b411b363SPhilipp Reisner inc_rs_pending(mdev); 1031db830c46SAndreas Gruenbacher peer_req->block_id = ID_SYNCER; /* By setting block_id, digest pointer becomes invalid! */ 1032db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_HAS_DIGEST; /* This peer request no longer has a digest pointer */ 1033204bba99SPhilipp Reisner kfree(di); 1034db830c46SAndreas Gruenbacher ok = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 1035b411b363SPhilipp Reisner } 1036b411b363SPhilipp Reisner } else { 1037db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 1038b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1039b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 1040b411b363SPhilipp Reisner } 1041b411b363SPhilipp Reisner 1042b411b363SPhilipp Reisner dec_unacked(mdev); 1043db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 1044b411b363SPhilipp Reisner 1045b411b363SPhilipp Reisner if (unlikely(!ok)) 1046b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block/ack() failed\n"); 1047b411b363SPhilipp Reisner return ok; 1048b411b363SPhilipp Reisner } 1049b411b363SPhilipp Reisner 105053ea4331SLars Ellenberg /* TODO merge common code with w_e_send_csum */ 1051b411b363SPhilipp Reisner int w_e_end_ov_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1052b411b363SPhilipp Reisner { 1053db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 1054db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1055db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 1056b411b363SPhilipp Reisner int digest_size; 1057b411b363SPhilipp Reisner void *digest; 1058b411b363SPhilipp Reisner int ok = 1; 1059b411b363SPhilipp Reisner 1060b411b363SPhilipp Reisner if (unlikely(cancel)) 1061b411b363SPhilipp Reisner goto out; 1062b411b363SPhilipp Reisner 1063b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->verify_tfm); 1064b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 10658f21420eSPhilipp Reisner if (!digest) { 10668f21420eSPhilipp Reisner ok = 0; /* terminate the connection in case the allocation failed */ 10678f21420eSPhilipp Reisner goto out; 10688f21420eSPhilipp Reisner } 10698f21420eSPhilipp Reisner 1070db830c46SAndreas Gruenbacher if (likely(!(peer_req->flags & EE_WAS_ERROR))) 1071db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->verify_tfm, peer_req, digest); 10728f21420eSPhilipp Reisner else 10738f21420eSPhilipp Reisner memset(digest, 0, digest_size); 10748f21420eSPhilipp Reisner 107553ea4331SLars Ellenberg /* Free e and pages before send. 107653ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 107753ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 107853ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 107953ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 1080db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1081db830c46SAndreas Gruenbacher peer_req = NULL; 1082b411b363SPhilipp Reisner inc_rs_pending(mdev); 108353ea4331SLars Ellenberg ok = drbd_send_drequest_csum(mdev, sector, size, 108453ea4331SLars Ellenberg digest, digest_size, 108553ea4331SLars Ellenberg P_OV_REPLY); 1086b411b363SPhilipp Reisner if (!ok) 1087b411b363SPhilipp Reisner dec_rs_pending(mdev); 1088b411b363SPhilipp Reisner kfree(digest); 1089b411b363SPhilipp Reisner 1090b411b363SPhilipp Reisner out: 1091db830c46SAndreas Gruenbacher if (peer_req) 1092db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1093b411b363SPhilipp Reisner dec_unacked(mdev); 1094b411b363SPhilipp Reisner return ok; 1095b411b363SPhilipp Reisner } 1096b411b363SPhilipp Reisner 1097b411b363SPhilipp Reisner void drbd_ov_oos_found(struct drbd_conf *mdev, sector_t sector, int size) 1098b411b363SPhilipp Reisner { 1099b411b363SPhilipp Reisner if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) { 1100b411b363SPhilipp Reisner mdev->ov_last_oos_size += size>>9; 1101b411b363SPhilipp Reisner } else { 1102b411b363SPhilipp Reisner mdev->ov_last_oos_start = sector; 1103b411b363SPhilipp Reisner mdev->ov_last_oos_size = size>>9; 1104b411b363SPhilipp Reisner } 1105b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 1106b411b363SPhilipp Reisner } 1107b411b363SPhilipp Reisner 1108b411b363SPhilipp Reisner int w_e_end_ov_reply(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1109b411b363SPhilipp Reisner { 1110db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 1111b411b363SPhilipp Reisner struct digest_info *di; 1112b411b363SPhilipp Reisner void *digest; 1113db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1114db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 111553ea4331SLars Ellenberg int digest_size; 1116b411b363SPhilipp Reisner int ok, eq = 0; 1117b411b363SPhilipp Reisner 1118b411b363SPhilipp Reisner if (unlikely(cancel)) { 1119db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1120b411b363SPhilipp Reisner dec_unacked(mdev); 1121b411b363SPhilipp Reisner return 1; 1122b411b363SPhilipp Reisner } 1123b411b363SPhilipp Reisner 1124b411b363SPhilipp Reisner /* after "cancel", because after drbd_disconnect/drbd_rs_cancel_all 1125b411b363SPhilipp Reisner * the resync lru has been cleaned up already */ 11261d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1127db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 11281d53f09eSLars Ellenberg put_ldev(mdev); 11291d53f09eSLars Ellenberg } 1130b411b363SPhilipp Reisner 1131db830c46SAndreas Gruenbacher di = peer_req->digest; 1132b411b363SPhilipp Reisner 1133db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1134b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->verify_tfm); 1135b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1136b411b363SPhilipp Reisner if (digest) { 1137db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->verify_tfm, peer_req, digest); 1138b411b363SPhilipp Reisner 1139b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1140b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1141b411b363SPhilipp Reisner kfree(digest); 1142b411b363SPhilipp Reisner } 1143b411b363SPhilipp Reisner } 1144b411b363SPhilipp Reisner 114553ea4331SLars Ellenberg /* Free e and pages before send. 114653ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 114753ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 114853ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 114953ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 1150db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1151b411b363SPhilipp Reisner if (!eq) 115253ea4331SLars Ellenberg drbd_ov_oos_found(mdev, sector, size); 1153b411b363SPhilipp Reisner else 1154b411b363SPhilipp Reisner ov_oos_print(mdev); 1155b411b363SPhilipp Reisner 115653ea4331SLars Ellenberg ok = drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, 1157b411b363SPhilipp Reisner eq ? ID_IN_SYNC : ID_OUT_OF_SYNC); 1158b411b363SPhilipp Reisner 115953ea4331SLars Ellenberg dec_unacked(mdev); 1160b411b363SPhilipp Reisner 1161ea5442afSLars Ellenberg --mdev->ov_left; 1162ea5442afSLars Ellenberg 1163ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 1164ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 1165ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 1166ea5442afSLars Ellenberg 1167ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 1168b411b363SPhilipp Reisner ov_oos_print(mdev); 1169b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1170b411b363SPhilipp Reisner } 1171b411b363SPhilipp Reisner 1172b411b363SPhilipp Reisner return ok; 1173b411b363SPhilipp Reisner } 1174b411b363SPhilipp Reisner 1175b411b363SPhilipp Reisner int w_prev_work_done(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1176b411b363SPhilipp Reisner { 1177b411b363SPhilipp Reisner struct drbd_wq_barrier *b = container_of(w, struct drbd_wq_barrier, w); 1178b411b363SPhilipp Reisner complete(&b->done); 1179b411b363SPhilipp Reisner return 1; 1180b411b363SPhilipp Reisner } 1181b411b363SPhilipp Reisner 1182b411b363SPhilipp Reisner int w_send_barrier(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1183b411b363SPhilipp Reisner { 1184b411b363SPhilipp Reisner struct drbd_tl_epoch *b = container_of(w, struct drbd_tl_epoch, w); 1185e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.sbuf.barrier; 1186b411b363SPhilipp Reisner int ok = 1; 1187b411b363SPhilipp Reisner 1188b411b363SPhilipp Reisner /* really avoid racing with tl_clear. w.cb may have been referenced 1189b411b363SPhilipp Reisner * just before it was reassigned and re-queued, so double check that. 1190b411b363SPhilipp Reisner * actually, this race was harmless, since we only try to send the 1191b411b363SPhilipp Reisner * barrier packet here, and otherwise do nothing with the object. 1192b411b363SPhilipp Reisner * but compare with the head of w_clear_epoch */ 119387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1194b411b363SPhilipp Reisner if (w->cb != w_send_barrier || mdev->state.conn < C_CONNECTED) 1195b411b363SPhilipp Reisner cancel = 1; 119687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1197b411b363SPhilipp Reisner if (cancel) 1198b411b363SPhilipp Reisner return 1; 1199b411b363SPhilipp Reisner 120061120870SPhilipp Reisner if (!drbd_get_data_sock(mdev->tconn)) 1201b411b363SPhilipp Reisner return 0; 1202b411b363SPhilipp Reisner p->barrier = b->br_number; 1203b411b363SPhilipp Reisner /* inc_ap_pending was done where this was queued. 1204b411b363SPhilipp Reisner * dec_ap_pending will be done in got_BarrierAck 1205b411b363SPhilipp Reisner * or (on connection loss) in w_clear_epoch. */ 1206e42325a5SPhilipp Reisner ok = _drbd_send_cmd(mdev, mdev->tconn->data.socket, P_BARRIER, 1207c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 120861120870SPhilipp Reisner drbd_put_data_sock(mdev->tconn); 1209b411b363SPhilipp Reisner 1210b411b363SPhilipp Reisner return ok; 1211b411b363SPhilipp Reisner } 1212b411b363SPhilipp Reisner 1213b411b363SPhilipp Reisner int w_send_write_hint(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1214b411b363SPhilipp Reisner { 1215b411b363SPhilipp Reisner if (cancel) 1216b411b363SPhilipp Reisner return 1; 1217b411b363SPhilipp Reisner return drbd_send_short_cmd(mdev, P_UNPLUG_REMOTE); 1218b411b363SPhilipp Reisner } 1219b411b363SPhilipp Reisner 122073a01a18SPhilipp Reisner int w_send_oos(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 122173a01a18SPhilipp Reisner { 122273a01a18SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 122373a01a18SPhilipp Reisner int ok; 122473a01a18SPhilipp Reisner 122573a01a18SPhilipp Reisner if (unlikely(cancel)) { 12268554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 122773a01a18SPhilipp Reisner return 1; 122873a01a18SPhilipp Reisner } 122973a01a18SPhilipp Reisner 123073a01a18SPhilipp Reisner ok = drbd_send_oos(mdev, req); 12318554df1cSAndreas Gruenbacher req_mod(req, OOS_HANDED_TO_NETWORK); 123273a01a18SPhilipp Reisner 123373a01a18SPhilipp Reisner return ok; 123473a01a18SPhilipp Reisner } 123573a01a18SPhilipp Reisner 1236b411b363SPhilipp Reisner /** 1237b411b363SPhilipp Reisner * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1238b411b363SPhilipp Reisner * @mdev: DRBD device. 1239b411b363SPhilipp Reisner * @w: work object. 1240b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1241b411b363SPhilipp Reisner */ 1242b411b363SPhilipp Reisner int w_send_dblock(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1243b411b363SPhilipp Reisner { 1244b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 1245b411b363SPhilipp Reisner int ok; 1246b411b363SPhilipp Reisner 1247b411b363SPhilipp Reisner if (unlikely(cancel)) { 12488554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 1249b411b363SPhilipp Reisner return 1; 1250b411b363SPhilipp Reisner } 1251b411b363SPhilipp Reisner 1252b411b363SPhilipp Reisner ok = drbd_send_dblock(mdev, req); 12538554df1cSAndreas Gruenbacher req_mod(req, ok ? HANDED_OVER_TO_NETWORK : SEND_FAILED); 1254b411b363SPhilipp Reisner 1255b411b363SPhilipp Reisner return ok; 1256b411b363SPhilipp Reisner } 1257b411b363SPhilipp Reisner 1258b411b363SPhilipp Reisner /** 1259b411b363SPhilipp Reisner * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 1260b411b363SPhilipp Reisner * @mdev: DRBD device. 1261b411b363SPhilipp Reisner * @w: work object. 1262b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1263b411b363SPhilipp Reisner */ 1264b411b363SPhilipp Reisner int w_send_read_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1265b411b363SPhilipp Reisner { 1266b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 1267b411b363SPhilipp Reisner int ok; 1268b411b363SPhilipp Reisner 1269b411b363SPhilipp Reisner if (unlikely(cancel)) { 12708554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 1271b411b363SPhilipp Reisner return 1; 1272b411b363SPhilipp Reisner } 1273b411b363SPhilipp Reisner 1274ace652acSAndreas Gruenbacher ok = drbd_send_drequest(mdev, P_DATA_REQUEST, req->i.sector, req->i.size, 1275b411b363SPhilipp Reisner (unsigned long)req); 1276b411b363SPhilipp Reisner 1277b411b363SPhilipp Reisner if (!ok) { 1278b411b363SPhilipp Reisner /* ?? we set C_TIMEOUT or C_BROKEN_PIPE in drbd_send(); 1279b411b363SPhilipp Reisner * so this is probably redundant */ 1280b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED) 1281b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 1282b411b363SPhilipp Reisner } 12838554df1cSAndreas Gruenbacher req_mod(req, ok ? HANDED_OVER_TO_NETWORK : SEND_FAILED); 1284b411b363SPhilipp Reisner 1285b411b363SPhilipp Reisner return ok; 1286b411b363SPhilipp Reisner } 1287b411b363SPhilipp Reisner 1288265be2d0SPhilipp Reisner int w_restart_disk_io(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1289265be2d0SPhilipp Reisner { 1290265be2d0SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 1291265be2d0SPhilipp Reisner 12920778286aSPhilipp Reisner if (bio_data_dir(req->master_bio) == WRITE && req->rq_state & RQ_IN_ACT_LOG) 1293ace652acSAndreas Gruenbacher drbd_al_begin_io(mdev, req->i.sector); 1294265be2d0SPhilipp Reisner /* Calling drbd_al_begin_io() out of the worker might deadlocks 1295265be2d0SPhilipp Reisner theoretically. Practically it can not deadlock, since this is 1296265be2d0SPhilipp Reisner only used when unfreezing IOs. All the extents of the requests 1297265be2d0SPhilipp Reisner that made it into the TL are already active */ 1298265be2d0SPhilipp Reisner 1299265be2d0SPhilipp Reisner drbd_req_make_private_bio(req, req->master_bio); 1300265be2d0SPhilipp Reisner req->private_bio->bi_bdev = mdev->ldev->backing_bdev; 1301265be2d0SPhilipp Reisner generic_make_request(req->private_bio); 1302265be2d0SPhilipp Reisner 1303265be2d0SPhilipp Reisner return 1; 1304265be2d0SPhilipp Reisner } 1305265be2d0SPhilipp Reisner 1306b411b363SPhilipp Reisner static int _drbd_may_sync_now(struct drbd_conf *mdev) 1307b411b363SPhilipp Reisner { 1308b411b363SPhilipp Reisner struct drbd_conf *odev = mdev; 1309b411b363SPhilipp Reisner 1310b411b363SPhilipp Reisner while (1) { 1311b411b363SPhilipp Reisner if (odev->sync_conf.after == -1) 1312b411b363SPhilipp Reisner return 1; 1313b411b363SPhilipp Reisner odev = minor_to_mdev(odev->sync_conf.after); 1314841ce241SAndreas Gruenbacher if (!expect(odev)) 1315841ce241SAndreas Gruenbacher return 1; 1316b411b363SPhilipp Reisner if ((odev->state.conn >= C_SYNC_SOURCE && 1317b411b363SPhilipp Reisner odev->state.conn <= C_PAUSED_SYNC_T) || 1318b411b363SPhilipp Reisner odev->state.aftr_isp || odev->state.peer_isp || 1319b411b363SPhilipp Reisner odev->state.user_isp) 1320b411b363SPhilipp Reisner return 0; 1321b411b363SPhilipp Reisner } 1322b411b363SPhilipp Reisner } 1323b411b363SPhilipp Reisner 1324b411b363SPhilipp Reisner /** 1325b411b363SPhilipp Reisner * _drbd_pause_after() - Pause resync on all devices that may not resync now 1326b411b363SPhilipp Reisner * @mdev: DRBD device. 1327b411b363SPhilipp Reisner * 1328b411b363SPhilipp Reisner * Called from process context only (admin command and after_state_ch). 1329b411b363SPhilipp Reisner */ 1330b411b363SPhilipp Reisner static int _drbd_pause_after(struct drbd_conf *mdev) 1331b411b363SPhilipp Reisner { 1332b411b363SPhilipp Reisner struct drbd_conf *odev; 1333b411b363SPhilipp Reisner int i, rv = 0; 1334b411b363SPhilipp Reisner 1335b411b363SPhilipp Reisner for (i = 0; i < minor_count; i++) { 1336b411b363SPhilipp Reisner odev = minor_to_mdev(i); 1337b411b363SPhilipp Reisner if (!odev) 1338b411b363SPhilipp Reisner continue; 1339b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1340b411b363SPhilipp Reisner continue; 1341b411b363SPhilipp Reisner if (!_drbd_may_sync_now(odev)) 1342b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 1), CS_HARD, NULL) 1343b411b363SPhilipp Reisner != SS_NOTHING_TO_DO); 1344b411b363SPhilipp Reisner } 1345b411b363SPhilipp Reisner 1346b411b363SPhilipp Reisner return rv; 1347b411b363SPhilipp Reisner } 1348b411b363SPhilipp Reisner 1349b411b363SPhilipp Reisner /** 1350b411b363SPhilipp Reisner * _drbd_resume_next() - Resume resync on all devices that may resync now 1351b411b363SPhilipp Reisner * @mdev: DRBD device. 1352b411b363SPhilipp Reisner * 1353b411b363SPhilipp Reisner * Called from process context only (admin command and worker). 1354b411b363SPhilipp Reisner */ 1355b411b363SPhilipp Reisner static int _drbd_resume_next(struct drbd_conf *mdev) 1356b411b363SPhilipp Reisner { 1357b411b363SPhilipp Reisner struct drbd_conf *odev; 1358b411b363SPhilipp Reisner int i, rv = 0; 1359b411b363SPhilipp Reisner 1360b411b363SPhilipp Reisner for (i = 0; i < minor_count; i++) { 1361b411b363SPhilipp Reisner odev = minor_to_mdev(i); 1362b411b363SPhilipp Reisner if (!odev) 1363b411b363SPhilipp Reisner continue; 1364b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1365b411b363SPhilipp Reisner continue; 1366b411b363SPhilipp Reisner if (odev->state.aftr_isp) { 1367b411b363SPhilipp Reisner if (_drbd_may_sync_now(odev)) 1368b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 0), 1369b411b363SPhilipp Reisner CS_HARD, NULL) 1370b411b363SPhilipp Reisner != SS_NOTHING_TO_DO) ; 1371b411b363SPhilipp Reisner } 1372b411b363SPhilipp Reisner } 1373b411b363SPhilipp Reisner return rv; 1374b411b363SPhilipp Reisner } 1375b411b363SPhilipp Reisner 1376b411b363SPhilipp Reisner void resume_next_sg(struct drbd_conf *mdev) 1377b411b363SPhilipp Reisner { 1378b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1379b411b363SPhilipp Reisner _drbd_resume_next(mdev); 1380b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1381b411b363SPhilipp Reisner } 1382b411b363SPhilipp Reisner 1383b411b363SPhilipp Reisner void suspend_other_sg(struct drbd_conf *mdev) 1384b411b363SPhilipp Reisner { 1385b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1386b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1387b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1388b411b363SPhilipp Reisner } 1389b411b363SPhilipp Reisner 1390b411b363SPhilipp Reisner static int sync_after_error(struct drbd_conf *mdev, int o_minor) 1391b411b363SPhilipp Reisner { 1392b411b363SPhilipp Reisner struct drbd_conf *odev; 1393b411b363SPhilipp Reisner 1394b411b363SPhilipp Reisner if (o_minor == -1) 1395b411b363SPhilipp Reisner return NO_ERROR; 1396b411b363SPhilipp Reisner if (o_minor < -1 || minor_to_mdev(o_minor) == NULL) 1397b411b363SPhilipp Reisner return ERR_SYNC_AFTER; 1398b411b363SPhilipp Reisner 1399b411b363SPhilipp Reisner /* check for loops */ 1400b411b363SPhilipp Reisner odev = minor_to_mdev(o_minor); 1401b411b363SPhilipp Reisner while (1) { 1402b411b363SPhilipp Reisner if (odev == mdev) 1403b411b363SPhilipp Reisner return ERR_SYNC_AFTER_CYCLE; 1404b411b363SPhilipp Reisner 1405b411b363SPhilipp Reisner /* dependency chain ends here, no cycles. */ 1406b411b363SPhilipp Reisner if (odev->sync_conf.after == -1) 1407b411b363SPhilipp Reisner return NO_ERROR; 1408b411b363SPhilipp Reisner 1409b411b363SPhilipp Reisner /* follow the dependency chain */ 1410b411b363SPhilipp Reisner odev = minor_to_mdev(odev->sync_conf.after); 1411b411b363SPhilipp Reisner } 1412b411b363SPhilipp Reisner } 1413b411b363SPhilipp Reisner 1414b411b363SPhilipp Reisner int drbd_alter_sa(struct drbd_conf *mdev, int na) 1415b411b363SPhilipp Reisner { 1416b411b363SPhilipp Reisner int changes; 1417b411b363SPhilipp Reisner int retcode; 1418b411b363SPhilipp Reisner 1419b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1420b411b363SPhilipp Reisner retcode = sync_after_error(mdev, na); 1421b411b363SPhilipp Reisner if (retcode == NO_ERROR) { 1422b411b363SPhilipp Reisner mdev->sync_conf.after = na; 1423b411b363SPhilipp Reisner do { 1424b411b363SPhilipp Reisner changes = _drbd_pause_after(mdev); 1425b411b363SPhilipp Reisner changes |= _drbd_resume_next(mdev); 1426b411b363SPhilipp Reisner } while (changes); 1427b411b363SPhilipp Reisner } 1428b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1429b411b363SPhilipp Reisner return retcode; 1430b411b363SPhilipp Reisner } 1431b411b363SPhilipp Reisner 14329bd28d3cSLars Ellenberg void drbd_rs_controller_reset(struct drbd_conf *mdev) 14339bd28d3cSLars Ellenberg { 14349bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_in, 0); 14359bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_ev, 0); 14369bd28d3cSLars Ellenberg mdev->rs_in_flight = 0; 14379bd28d3cSLars Ellenberg mdev->rs_planed = 0; 14389bd28d3cSLars Ellenberg spin_lock(&mdev->peer_seq_lock); 14399bd28d3cSLars Ellenberg fifo_set(&mdev->rs_plan_s, 0); 14409bd28d3cSLars Ellenberg spin_unlock(&mdev->peer_seq_lock); 14419bd28d3cSLars Ellenberg } 14429bd28d3cSLars Ellenberg 14431f04af33SPhilipp Reisner void start_resync_timer_fn(unsigned long data) 14441f04af33SPhilipp Reisner { 14451f04af33SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 14461f04af33SPhilipp Reisner 14471f04af33SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->start_resync_work); 14481f04af33SPhilipp Reisner } 14491f04af33SPhilipp Reisner 14501f04af33SPhilipp Reisner int w_start_resync(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 14511f04af33SPhilipp Reisner { 14521f04af33SPhilipp Reisner if (atomic_read(&mdev->unacked_cnt) || atomic_read(&mdev->rs_pending_cnt)) { 14531f04af33SPhilipp Reisner dev_warn(DEV, "w_start_resync later...\n"); 14541f04af33SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/10; 14551f04af33SPhilipp Reisner add_timer(&mdev->start_resync_timer); 14561f04af33SPhilipp Reisner return 1; 14571f04af33SPhilipp Reisner } 14581f04af33SPhilipp Reisner 14591f04af33SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 14601f04af33SPhilipp Reisner clear_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags); 14611f04af33SPhilipp Reisner return 1; 14621f04af33SPhilipp Reisner } 14631f04af33SPhilipp Reisner 1464b411b363SPhilipp Reisner /** 1465b411b363SPhilipp Reisner * drbd_start_resync() - Start the resync process 1466b411b363SPhilipp Reisner * @mdev: DRBD device. 1467b411b363SPhilipp Reisner * @side: Either C_SYNC_SOURCE or C_SYNC_TARGET 1468b411b363SPhilipp Reisner * 1469b411b363SPhilipp Reisner * This function might bring you directly into one of the 1470b411b363SPhilipp Reisner * C_PAUSED_SYNC_* states. 1471b411b363SPhilipp Reisner */ 1472b411b363SPhilipp Reisner void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side) 1473b411b363SPhilipp Reisner { 1474b411b363SPhilipp Reisner union drbd_state ns; 1475b411b363SPhilipp Reisner int r; 1476b411b363SPhilipp Reisner 1477c4752ef1SPhilipp Reisner if (mdev->state.conn >= C_SYNC_SOURCE && mdev->state.conn < C_AHEAD) { 1478b411b363SPhilipp Reisner dev_err(DEV, "Resync already running!\n"); 1479b411b363SPhilipp Reisner return; 1480b411b363SPhilipp Reisner } 1481b411b363SPhilipp Reisner 148259817f4fSPhilipp Reisner if (mdev->state.conn < C_AHEAD) { 1483b411b363SPhilipp Reisner /* In case a previous resync run was aborted by an IO error/detach on the peer. */ 1484b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 148559817f4fSPhilipp Reisner /* This should be done when we abort the resync. We definitely do not 148659817f4fSPhilipp Reisner want to have this for connections going back and forth between 148759817f4fSPhilipp Reisner Ahead/Behind and SyncSource/SyncTarget */ 148859817f4fSPhilipp Reisner } 1489b411b363SPhilipp Reisner 1490e64a3294SPhilipp Reisner if (!test_bit(B_RS_H_DONE, &mdev->flags)) { 1491b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1492b411b363SPhilipp Reisner /* Since application IO was locked out during C_WF_BITMAP_T and 1493b411b363SPhilipp Reisner C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET 1494b411b363SPhilipp Reisner we check that we might make the data inconsistent. */ 1495b411b363SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-target"); 1496b411b363SPhilipp Reisner r = (r >> 8) & 0xff; 1497b411b363SPhilipp Reisner if (r > 0) { 1498b411b363SPhilipp Reisner dev_info(DEV, "before-resync-target handler returned %d, " 1499b411b363SPhilipp Reisner "dropping connection.\n", r); 1500b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 1501b411b363SPhilipp Reisner return; 1502b411b363SPhilipp Reisner } 150309b9e797SPhilipp Reisner } else /* C_SYNC_SOURCE */ { 150409b9e797SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-source"); 150509b9e797SPhilipp Reisner r = (r >> 8) & 0xff; 150609b9e797SPhilipp Reisner if (r > 0) { 150709b9e797SPhilipp Reisner if (r == 3) { 150809b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 150909b9e797SPhilipp Reisner "ignoring. Old userland tools?", r); 151009b9e797SPhilipp Reisner } else { 151109b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 151209b9e797SPhilipp Reisner "dropping connection.\n", r); 151309b9e797SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 151409b9e797SPhilipp Reisner return; 151509b9e797SPhilipp Reisner } 151609b9e797SPhilipp Reisner } 1517b411b363SPhilipp Reisner } 1518e64a3294SPhilipp Reisner } 1519b411b363SPhilipp Reisner 1520e64a3294SPhilipp Reisner if (current == mdev->tconn->worker.task) { 1521e64a3294SPhilipp Reisner /* The worker should not sleep waiting for drbd_state_lock(), 1522e64a3294SPhilipp Reisner that can take long */ 1523e64a3294SPhilipp Reisner if (test_and_set_bit(CLUSTER_ST_CHANGE, &mdev->flags)) { 1524e64a3294SPhilipp Reisner set_bit(B_RS_H_DONE, &mdev->flags); 1525e64a3294SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/5; 1526e64a3294SPhilipp Reisner add_timer(&mdev->start_resync_timer); 1527e64a3294SPhilipp Reisner return; 1528e64a3294SPhilipp Reisner } 1529e64a3294SPhilipp Reisner } else { 1530b411b363SPhilipp Reisner drbd_state_lock(mdev); 1531e64a3294SPhilipp Reisner } 1532e64a3294SPhilipp Reisner clear_bit(B_RS_H_DONE, &mdev->flags); 1533b411b363SPhilipp Reisner 1534b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_NEGOTIATING)) { 1535b411b363SPhilipp Reisner drbd_state_unlock(mdev); 1536b411b363SPhilipp Reisner return; 1537b411b363SPhilipp Reisner } 1538b411b363SPhilipp Reisner 1539b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1540b411b363SPhilipp Reisner ns = mdev->state; 1541b411b363SPhilipp Reisner 1542b411b363SPhilipp Reisner ns.aftr_isp = !_drbd_may_sync_now(mdev); 1543b411b363SPhilipp Reisner 1544b411b363SPhilipp Reisner ns.conn = side; 1545b411b363SPhilipp Reisner 1546b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) 1547b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 1548b411b363SPhilipp Reisner else /* side == C_SYNC_SOURCE */ 1549b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 1550b411b363SPhilipp Reisner 1551b411b363SPhilipp Reisner r = __drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 1552b411b363SPhilipp Reisner ns = mdev->state; 1553b411b363SPhilipp Reisner 1554b411b363SPhilipp Reisner if (ns.conn < C_CONNECTED) 1555b411b363SPhilipp Reisner r = SS_UNKNOWN_ERROR; 1556b411b363SPhilipp Reisner 1557b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 15581d7734a0SLars Ellenberg unsigned long tw = drbd_bm_total_weight(mdev); 15591d7734a0SLars Ellenberg unsigned long now = jiffies; 15601d7734a0SLars Ellenberg int i; 15611d7734a0SLars Ellenberg 1562b411b363SPhilipp Reisner mdev->rs_failed = 0; 1563b411b363SPhilipp Reisner mdev->rs_paused = 0; 1564b411b363SPhilipp Reisner mdev->rs_same_csum = 0; 15650f0601f4SLars Ellenberg mdev->rs_last_events = 0; 15660f0601f4SLars Ellenberg mdev->rs_last_sect_ev = 0; 15671d7734a0SLars Ellenberg mdev->rs_total = tw; 15681d7734a0SLars Ellenberg mdev->rs_start = now; 15691d7734a0SLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 15701d7734a0SLars Ellenberg mdev->rs_mark_left[i] = tw; 15711d7734a0SLars Ellenberg mdev->rs_mark_time[i] = now; 15721d7734a0SLars Ellenberg } 1573b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1574b411b363SPhilipp Reisner } 1575b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 15765a22db89SLars Ellenberg 15776c922ed5SLars Ellenberg if (r == SS_SUCCESS) { 15786c922ed5SLars Ellenberg dev_info(DEV, "Began resync as %s (will sync %lu KB [%lu bits set]).\n", 15796c922ed5SLars Ellenberg drbd_conn_str(ns.conn), 15806c922ed5SLars Ellenberg (unsigned long) mdev->rs_total << (BM_BLOCK_SHIFT-10), 15816c922ed5SLars Ellenberg (unsigned long) mdev->rs_total); 15825a22db89SLars Ellenberg if (side == C_SYNC_TARGET) 15835a22db89SLars Ellenberg mdev->bm_resync_fo = 0; 15845a22db89SLars Ellenberg 15855a22db89SLars Ellenberg /* Since protocol 96, we must serialize drbd_gen_and_send_sync_uuid 15865a22db89SLars Ellenberg * with w_send_oos, or the sync target will get confused as to 15875a22db89SLars Ellenberg * how much bits to resync. We cannot do that always, because for an 15885a22db89SLars Ellenberg * empty resync and protocol < 95, we need to do it here, as we call 15895a22db89SLars Ellenberg * drbd_resync_finished from here in that case. 15905a22db89SLars Ellenberg * We drbd_gen_and_send_sync_uuid here for protocol < 96, 15915a22db89SLars Ellenberg * and from after_state_ch otherwise. */ 159231890f4aSPhilipp Reisner if (side == C_SYNC_SOURCE && mdev->tconn->agreed_pro_version < 96) 15935a22db89SLars Ellenberg drbd_gen_and_send_sync_uuid(mdev); 1594b411b363SPhilipp Reisner 159531890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 95 && mdev->rs_total == 0) { 1596af85e8e8SLars Ellenberg /* This still has a race (about when exactly the peers 1597af85e8e8SLars Ellenberg * detect connection loss) that can lead to a full sync 1598af85e8e8SLars Ellenberg * on next handshake. In 8.3.9 we fixed this with explicit 1599af85e8e8SLars Ellenberg * resync-finished notifications, but the fix 1600af85e8e8SLars Ellenberg * introduces a protocol change. Sleeping for some 1601af85e8e8SLars Ellenberg * time longer than the ping interval + timeout on the 1602af85e8e8SLars Ellenberg * SyncSource, to give the SyncTarget the chance to 1603af85e8e8SLars Ellenberg * detect connection loss, then waiting for a ping 1604af85e8e8SLars Ellenberg * response (implicit in drbd_resync_finished) reduces 1605af85e8e8SLars Ellenberg * the race considerably, but does not solve it. */ 1606af85e8e8SLars Ellenberg if (side == C_SYNC_SOURCE) 1607af85e8e8SLars Ellenberg schedule_timeout_interruptible( 160889e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_int * HZ + 160989e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_timeo*HZ/9); 1610b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1611b411b363SPhilipp Reisner } 1612b411b363SPhilipp Reisner 16139bd28d3cSLars Ellenberg drbd_rs_controller_reset(mdev); 1614b411b363SPhilipp Reisner /* ns.conn may already be != mdev->state.conn, 1615b411b363SPhilipp Reisner * we may have been paused in between, or become paused until 1616b411b363SPhilipp Reisner * the timer triggers. 1617b411b363SPhilipp Reisner * No matter, that is handled in resync_timer_fn() */ 1618b411b363SPhilipp Reisner if (ns.conn == C_SYNC_TARGET) 1619b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies); 1620b411b363SPhilipp Reisner 1621b411b363SPhilipp Reisner drbd_md_sync(mdev); 1622b411b363SPhilipp Reisner } 16235a22db89SLars Ellenberg put_ldev(mdev); 1624d0c3f60fSPhilipp Reisner drbd_state_unlock(mdev); 1625b411b363SPhilipp Reisner } 1626b411b363SPhilipp Reisner 1627b411b363SPhilipp Reisner int drbd_worker(struct drbd_thread *thi) 1628b411b363SPhilipp Reisner { 1629b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 1630b411b363SPhilipp Reisner struct drbd_work *w = NULL; 1631b411b363SPhilipp Reisner LIST_HEAD(work_list); 1632b411b363SPhilipp Reisner int intr = 0, i; 1633b411b363SPhilipp Reisner 1634b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_worker", mdev_to_minor(mdev)); 1635b411b363SPhilipp Reisner 1636e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 163780822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 1638b411b363SPhilipp Reisner 1639e42325a5SPhilipp Reisner if (down_trylock(&mdev->tconn->data.work.s)) { 1640e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 1641e42325a5SPhilipp Reisner if (mdev->tconn->data.socket && !mdev->tconn->net_conf->no_cork) 1642e42325a5SPhilipp Reisner drbd_tcp_uncork(mdev->tconn->data.socket); 1643e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 1644b411b363SPhilipp Reisner 1645e42325a5SPhilipp Reisner intr = down_interruptible(&mdev->tconn->data.work.s); 1646b411b363SPhilipp Reisner 1647e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 1648e42325a5SPhilipp Reisner if (mdev->tconn->data.socket && !mdev->tconn->net_conf->no_cork) 1649e42325a5SPhilipp Reisner drbd_tcp_cork(mdev->tconn->data.socket); 1650e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 1651b411b363SPhilipp Reisner } 1652b411b363SPhilipp Reisner 1653b411b363SPhilipp Reisner if (intr) { 1654b411b363SPhilipp Reisner D_ASSERT(intr == -EINTR); 1655b411b363SPhilipp Reisner flush_signals(current); 1656841ce241SAndreas Gruenbacher if (!expect(get_t_state(thi) != RUNNING)) 1657b411b363SPhilipp Reisner continue; 1658b411b363SPhilipp Reisner break; 1659b411b363SPhilipp Reisner } 1660b411b363SPhilipp Reisner 1661e77a0a5cSAndreas Gruenbacher if (get_t_state(thi) != RUNNING) 1662b411b363SPhilipp Reisner break; 1663b411b363SPhilipp Reisner /* With this break, we have done a down() but not consumed 1664b411b363SPhilipp Reisner the entry from the list. The cleanup code takes care of 1665b411b363SPhilipp Reisner this... */ 1666b411b363SPhilipp Reisner 1667b411b363SPhilipp Reisner w = NULL; 1668e42325a5SPhilipp Reisner spin_lock_irq(&mdev->tconn->data.work.q_lock); 1669e42325a5SPhilipp Reisner if (!expect(!list_empty(&mdev->tconn->data.work.q))) { 1670b411b363SPhilipp Reisner /* something terribly wrong in our logic. 1671b411b363SPhilipp Reisner * we were able to down() the semaphore, 1672b411b363SPhilipp Reisner * but the list is empty... doh. 1673b411b363SPhilipp Reisner * 1674b411b363SPhilipp Reisner * what is the best thing to do now? 1675b411b363SPhilipp Reisner * try again from scratch, restarting the receiver, 1676b411b363SPhilipp Reisner * asender, whatnot? could break even more ugly, 1677b411b363SPhilipp Reisner * e.g. when we are primary, but no good local data. 1678b411b363SPhilipp Reisner * 1679b411b363SPhilipp Reisner * I'll try to get away just starting over this loop. 1680b411b363SPhilipp Reisner */ 1681e42325a5SPhilipp Reisner spin_unlock_irq(&mdev->tconn->data.work.q_lock); 1682b411b363SPhilipp Reisner continue; 1683b411b363SPhilipp Reisner } 1684e42325a5SPhilipp Reisner w = list_entry(mdev->tconn->data.work.q.next, struct drbd_work, list); 1685b411b363SPhilipp Reisner list_del_init(&w->list); 1686e42325a5SPhilipp Reisner spin_unlock_irq(&mdev->tconn->data.work.q_lock); 1687b411b363SPhilipp Reisner 1688b411b363SPhilipp Reisner if (!w->cb(mdev, w, mdev->state.conn < C_CONNECTED)) { 1689b411b363SPhilipp Reisner /* dev_warn(DEV, "worker: a callback failed! \n"); */ 1690b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED) 1691b411b363SPhilipp Reisner drbd_force_state(mdev, 1692b411b363SPhilipp Reisner NS(conn, C_NETWORK_FAILURE)); 1693b411b363SPhilipp Reisner } 1694b411b363SPhilipp Reisner } 1695b411b363SPhilipp Reisner D_ASSERT(test_bit(DEVICE_DYING, &mdev->flags)); 1696b411b363SPhilipp Reisner D_ASSERT(test_bit(CONFIG_PENDING, &mdev->flags)); 1697b411b363SPhilipp Reisner 1698e42325a5SPhilipp Reisner spin_lock_irq(&mdev->tconn->data.work.q_lock); 1699b411b363SPhilipp Reisner i = 0; 1700e42325a5SPhilipp Reisner while (!list_empty(&mdev->tconn->data.work.q)) { 1701e42325a5SPhilipp Reisner list_splice_init(&mdev->tconn->data.work.q, &work_list); 1702e42325a5SPhilipp Reisner spin_unlock_irq(&mdev->tconn->data.work.q_lock); 1703b411b363SPhilipp Reisner 1704b411b363SPhilipp Reisner while (!list_empty(&work_list)) { 1705b411b363SPhilipp Reisner w = list_entry(work_list.next, struct drbd_work, list); 1706b411b363SPhilipp Reisner list_del_init(&w->list); 1707b411b363SPhilipp Reisner w->cb(mdev, w, 1); 1708b411b363SPhilipp Reisner i++; /* dead debugging code */ 1709b411b363SPhilipp Reisner } 1710b411b363SPhilipp Reisner 1711e42325a5SPhilipp Reisner spin_lock_irq(&mdev->tconn->data.work.q_lock); 1712b411b363SPhilipp Reisner } 1713e42325a5SPhilipp Reisner sema_init(&mdev->tconn->data.work.s, 0); 1714b411b363SPhilipp Reisner /* DANGEROUS race: if someone did queue his work within the spinlock, 1715b411b363SPhilipp Reisner * but up() ed outside the spinlock, we could get an up() on the 1716b411b363SPhilipp Reisner * semaphore without corresponding list entry. 1717b411b363SPhilipp Reisner * So don't do that. 1718b411b363SPhilipp Reisner */ 1719e42325a5SPhilipp Reisner spin_unlock_irq(&mdev->tconn->data.work.q_lock); 1720b411b363SPhilipp Reisner 1721b411b363SPhilipp Reisner D_ASSERT(mdev->state.disk == D_DISKLESS && mdev->state.conn == C_STANDALONE); 1722b411b363SPhilipp Reisner /* _drbd_set_state only uses stop_nowait. 1723e6b3ea83SPhilipp Reisner * wait here for the exiting receiver. */ 1724e6b3ea83SPhilipp Reisner drbd_thread_stop(&mdev->tconn->receiver); 1725b411b363SPhilipp Reisner drbd_mdev_cleanup(mdev); 1726b411b363SPhilipp Reisner 1727b411b363SPhilipp Reisner dev_info(DEV, "worker terminated\n"); 1728b411b363SPhilipp Reisner 1729b411b363SPhilipp Reisner clear_bit(DEVICE_DYING, &mdev->flags); 1730b411b363SPhilipp Reisner clear_bit(CONFIG_PENDING, &mdev->flags); 1731b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 1732b411b363SPhilipp Reisner 1733b411b363SPhilipp Reisner return 0; 1734b411b363SPhilipp Reisner } 1735