1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_worker.c 3b411b363SPhilipp Reisner 4b411b363SPhilipp Reisner This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5b411b363SPhilipp Reisner 6b411b363SPhilipp Reisner Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7b411b363SPhilipp Reisner Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8b411b363SPhilipp Reisner Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9b411b363SPhilipp Reisner 10b411b363SPhilipp Reisner drbd is free software; you can redistribute it and/or modify 11b411b363SPhilipp Reisner it under the terms of the GNU General Public License as published by 12b411b363SPhilipp Reisner the Free Software Foundation; either version 2, or (at your option) 13b411b363SPhilipp Reisner any later version. 14b411b363SPhilipp Reisner 15b411b363SPhilipp Reisner drbd is distributed in the hope that it will be useful, 16b411b363SPhilipp Reisner but WITHOUT ANY WARRANTY; without even the implied warranty of 17b411b363SPhilipp Reisner MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18b411b363SPhilipp Reisner GNU General Public License for more details. 19b411b363SPhilipp Reisner 20b411b363SPhilipp Reisner You should have received a copy of the GNU General Public License 21b411b363SPhilipp Reisner along with drbd; see the file COPYING. If not, write to 22b411b363SPhilipp Reisner the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23b411b363SPhilipp Reisner 24b411b363SPhilipp Reisner */ 25b411b363SPhilipp Reisner 26b411b363SPhilipp Reisner #include <linux/module.h> 27b411b363SPhilipp Reisner #include <linux/drbd.h> 28b411b363SPhilipp Reisner #include <linux/sched.h> 29b411b363SPhilipp Reisner #include <linux/wait.h> 30b411b363SPhilipp Reisner #include <linux/mm.h> 31b411b363SPhilipp Reisner #include <linux/memcontrol.h> 32b411b363SPhilipp Reisner #include <linux/mm_inline.h> 33b411b363SPhilipp Reisner #include <linux/slab.h> 34b411b363SPhilipp Reisner #include <linux/random.h> 35b411b363SPhilipp Reisner #include <linux/string.h> 36b411b363SPhilipp Reisner #include <linux/scatterlist.h> 37b411b363SPhilipp Reisner 38b411b363SPhilipp Reisner #include "drbd_int.h" 39b411b363SPhilipp Reisner #include "drbd_req.h" 40b411b363SPhilipp Reisner 4100d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel); 4200d56944SPhilipp Reisner static int w_make_resync_request(struct drbd_work *w, int cancel); 43b411b363SPhilipp Reisner 44b411b363SPhilipp Reisner 45b411b363SPhilipp Reisner 46c5a91619SAndreas Gruenbacher /* endio handlers: 47c5a91619SAndreas Gruenbacher * drbd_md_io_complete (defined here) 48fcefa62eSAndreas Gruenbacher * drbd_request_endio (defined here) 49fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio (defined here) 50c5a91619SAndreas Gruenbacher * bm_async_io_complete (defined in drbd_bitmap.c) 51c5a91619SAndreas Gruenbacher * 52b411b363SPhilipp Reisner * For all these callbacks, note the following: 53b411b363SPhilipp Reisner * The callbacks will be called in irq context by the IDE drivers, 54b411b363SPhilipp Reisner * and in Softirqs/Tasklets/BH context by the SCSI drivers. 55b411b363SPhilipp Reisner * Try to get the locking right :) 56b411b363SPhilipp Reisner * 57b411b363SPhilipp Reisner */ 58b411b363SPhilipp Reisner 59b411b363SPhilipp Reisner 60b411b363SPhilipp Reisner /* About the global_state_lock 61b411b363SPhilipp Reisner Each state transition on an device holds a read lock. In case we have 62b411b363SPhilipp Reisner to evaluate the sync after dependencies, we grab a write lock, because 63b411b363SPhilipp Reisner we need stable states on all devices for that. */ 64b411b363SPhilipp Reisner rwlock_t global_state_lock; 65b411b363SPhilipp Reisner 66b411b363SPhilipp Reisner /* used for synchronous meta data and bitmap IO 67b411b363SPhilipp Reisner * submitted by drbd_md_sync_page_io() 68b411b363SPhilipp Reisner */ 69b411b363SPhilipp Reisner void drbd_md_io_complete(struct bio *bio, int error) 70b411b363SPhilipp Reisner { 71b411b363SPhilipp Reisner struct drbd_md_io *md_io; 72b411b363SPhilipp Reisner 73b411b363SPhilipp Reisner md_io = (struct drbd_md_io *)bio->bi_private; 74b411b363SPhilipp Reisner md_io->error = error; 75b411b363SPhilipp Reisner 76b411b363SPhilipp Reisner complete(&md_io->event); 77b411b363SPhilipp Reisner } 78b411b363SPhilipp Reisner 79b411b363SPhilipp Reisner /* reads on behalf of the partner, 80b411b363SPhilipp Reisner * "submitted" by the receiver 81b411b363SPhilipp Reisner */ 82db830c46SAndreas Gruenbacher void drbd_endio_read_sec_final(struct drbd_peer_request *peer_req) __releases(local) 83b411b363SPhilipp Reisner { 84b411b363SPhilipp Reisner unsigned long flags = 0; 85a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 86b411b363SPhilipp Reisner 8787eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 88db830c46SAndreas Gruenbacher mdev->read_cnt += peer_req->i.size >> 9; 89db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 90b411b363SPhilipp Reisner if (list_empty(&mdev->read_ee)) 91b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 92db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 9381e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 9487eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 95b411b363SPhilipp Reisner 96db830c46SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &peer_req->w); 97b411b363SPhilipp Reisner put_ldev(mdev); 98b411b363SPhilipp Reisner } 99b411b363SPhilipp Reisner 100b411b363SPhilipp Reisner /* writes on behalf of the partner, or resync writes, 10145bb912bSLars Ellenberg * "submitted" by the receiver, final stage. */ 102db830c46SAndreas Gruenbacher static void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(local) 103b411b363SPhilipp Reisner { 104b411b363SPhilipp Reisner unsigned long flags = 0; 105a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 106b411b363SPhilipp Reisner sector_t e_sector; 107b411b363SPhilipp Reisner int do_wake; 108579b57edSAndreas Gruenbacher u64 block_id; 109b411b363SPhilipp Reisner int do_al_complete_io; 110b411b363SPhilipp Reisner 111db830c46SAndreas Gruenbacher /* after we moved peer_req to done_ee, 112b411b363SPhilipp Reisner * we may no longer access it, 113b411b363SPhilipp Reisner * it may be freed/reused already! 114b411b363SPhilipp Reisner * (as soon as we release the req_lock) */ 115db830c46SAndreas Gruenbacher e_sector = peer_req->i.sector; 116db830c46SAndreas Gruenbacher do_al_complete_io = peer_req->flags & EE_CALL_AL_COMPLETE_IO; 117db830c46SAndreas Gruenbacher block_id = peer_req->block_id; 118b411b363SPhilipp Reisner 11987eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 120db830c46SAndreas Gruenbacher mdev->writ_cnt += peer_req->i.size >> 9; 121db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); /* has been on active_ee or sync_ee */ 122db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 123b411b363SPhilipp Reisner 124bb3bfe96SAndreas Gruenbacher /* 1255e472264SAndreas Gruenbacher * Do not remove from the write_requests tree here: we did not send the 126bb3bfe96SAndreas Gruenbacher * Ack yet and did not wake possibly waiting conflicting requests. 127bb3bfe96SAndreas Gruenbacher * Removed from the tree from "drbd_process_done_ee" within the 128bb3bfe96SAndreas Gruenbacher * appropriate w.cb (e_end_block/e_end_resync_block) or from 129bb3bfe96SAndreas Gruenbacher * _drbd_clear_done_ee. 130bb3bfe96SAndreas Gruenbacher */ 131b411b363SPhilipp Reisner 132579b57edSAndreas Gruenbacher do_wake = list_empty(block_id == ID_SYNCER ? &mdev->sync_ee : &mdev->active_ee); 133b411b363SPhilipp Reisner 134db830c46SAndreas Gruenbacher if (test_bit(__EE_WAS_ERROR, &peer_req->flags)) 13581e84650SAndreas Gruenbacher __drbd_chk_io_error(mdev, false); 13687eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 137b411b363SPhilipp Reisner 138579b57edSAndreas Gruenbacher if (block_id == ID_SYNCER) 139b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, e_sector); 140b411b363SPhilipp Reisner 141b411b363SPhilipp Reisner if (do_wake) 142b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 143b411b363SPhilipp Reisner 144b411b363SPhilipp Reisner if (do_al_complete_io) 145b411b363SPhilipp Reisner drbd_al_complete_io(mdev, e_sector); 146b411b363SPhilipp Reisner 1470625ac19SPhilipp Reisner wake_asender(mdev->tconn); 148b411b363SPhilipp Reisner put_ldev(mdev); 14945bb912bSLars Ellenberg } 150b411b363SPhilipp Reisner 15145bb912bSLars Ellenberg /* writes on behalf of the partner, or resync writes, 15245bb912bSLars Ellenberg * "submitted" by the receiver. 15345bb912bSLars Ellenberg */ 154fcefa62eSAndreas Gruenbacher void drbd_peer_request_endio(struct bio *bio, int error) 15545bb912bSLars Ellenberg { 156db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = bio->bi_private; 157a21e9298SPhilipp Reisner struct drbd_conf *mdev = peer_req->w.mdev; 15845bb912bSLars Ellenberg int uptodate = bio_flagged(bio, BIO_UPTODATE); 15945bb912bSLars Ellenberg int is_write = bio_data_dir(bio) == WRITE; 16045bb912bSLars Ellenberg 16107194272SLars Ellenberg if (error && __ratelimit(&drbd_ratelimit_state)) 16245bb912bSLars Ellenberg dev_warn(DEV, "%s: error=%d s=%llus\n", 16345bb912bSLars Ellenberg is_write ? "write" : "read", error, 164db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 16545bb912bSLars Ellenberg if (!error && !uptodate) { 16607194272SLars Ellenberg if (__ratelimit(&drbd_ratelimit_state)) 16745bb912bSLars Ellenberg dev_warn(DEV, "%s: setting error to -EIO s=%llus\n", 16845bb912bSLars Ellenberg is_write ? "write" : "read", 169db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 17045bb912bSLars Ellenberg /* strange behavior of some lower level drivers... 17145bb912bSLars Ellenberg * fail the request by clearing the uptodate flag, 17245bb912bSLars Ellenberg * but do not return any error?! */ 17345bb912bSLars Ellenberg error = -EIO; 17445bb912bSLars Ellenberg } 17545bb912bSLars Ellenberg 17645bb912bSLars Ellenberg if (error) 177db830c46SAndreas Gruenbacher set_bit(__EE_WAS_ERROR, &peer_req->flags); 17845bb912bSLars Ellenberg 17945bb912bSLars Ellenberg bio_put(bio); /* no need for the bio anymore */ 180db830c46SAndreas Gruenbacher if (atomic_dec_and_test(&peer_req->pending_bios)) { 18145bb912bSLars Ellenberg if (is_write) 182db830c46SAndreas Gruenbacher drbd_endio_write_sec_final(peer_req); 18345bb912bSLars Ellenberg else 184db830c46SAndreas Gruenbacher drbd_endio_read_sec_final(peer_req); 18545bb912bSLars Ellenberg } 186b411b363SPhilipp Reisner } 187b411b363SPhilipp Reisner 188b411b363SPhilipp Reisner /* read, readA or write requests on R_PRIMARY coming from drbd_make_request 189b411b363SPhilipp Reisner */ 190fcefa62eSAndreas Gruenbacher void drbd_request_endio(struct bio *bio, int error) 191b411b363SPhilipp Reisner { 192a115413dSLars Ellenberg unsigned long flags; 193b411b363SPhilipp Reisner struct drbd_request *req = bio->bi_private; 194a21e9298SPhilipp Reisner struct drbd_conf *mdev = req->w.mdev; 195a115413dSLars Ellenberg struct bio_and_error m; 196b411b363SPhilipp Reisner enum drbd_req_event what; 197b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 198b411b363SPhilipp Reisner 199b411b363SPhilipp Reisner if (!error && !uptodate) { 200b411b363SPhilipp Reisner dev_warn(DEV, "p %s: setting error to -EIO\n", 201b411b363SPhilipp Reisner bio_data_dir(bio) == WRITE ? "write" : "read"); 202b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 203b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 204b411b363SPhilipp Reisner * but do not return any error?! */ 205b411b363SPhilipp Reisner error = -EIO; 206b411b363SPhilipp Reisner } 207b411b363SPhilipp Reisner 208b411b363SPhilipp Reisner /* to avoid recursion in __req_mod */ 209b411b363SPhilipp Reisner if (unlikely(error)) { 210b411b363SPhilipp Reisner what = (bio_data_dir(bio) == WRITE) 2118554df1cSAndreas Gruenbacher ? WRITE_COMPLETED_WITH_ERROR 2125c3c7e64SLars Ellenberg : (bio_rw(bio) == READ) 2138554df1cSAndreas Gruenbacher ? READ_COMPLETED_WITH_ERROR 2148554df1cSAndreas Gruenbacher : READ_AHEAD_COMPLETED_WITH_ERROR; 215b411b363SPhilipp Reisner } else 2168554df1cSAndreas Gruenbacher what = COMPLETED_OK; 217b411b363SPhilipp Reisner 218b411b363SPhilipp Reisner bio_put(req->private_bio); 219b411b363SPhilipp Reisner req->private_bio = ERR_PTR(error); 220b411b363SPhilipp Reisner 221a115413dSLars Ellenberg /* not req_mod(), we need irqsave here! */ 22287eeee41SPhilipp Reisner spin_lock_irqsave(&mdev->tconn->req_lock, flags); 223a115413dSLars Ellenberg __req_mod(req, what, &m); 22487eeee41SPhilipp Reisner spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 225a115413dSLars Ellenberg 226a115413dSLars Ellenberg if (m.bio) 227a115413dSLars Ellenberg complete_master_bio(mdev, &m); 228b411b363SPhilipp Reisner } 229b411b363SPhilipp Reisner 23000d56944SPhilipp Reisner int w_read_retry_remote(struct drbd_work *w, int cancel) 231b411b363SPhilipp Reisner { 232b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 23300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 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 24700d56944SPhilipp Reisner return w_send_read_req(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 2989676c760SLars Ellenberg /* MAYBE merge common code with w_e_end_ov_req */ 29900d56944SPhilipp Reisner static int w_e_send_csum(struct drbd_work *w, int cancel) 300b411b363SPhilipp Reisner { 30100d56944SPhilipp Reisner struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 30200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 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 3109676c760SLars Ellenberg if (unlikely((peer_req->flags & EE_WAS_ERROR) != 0)) 31153ea4331SLars Ellenberg goto out; 31253ea4331SLars Ellenberg 313f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->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; 318f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 3199676c760SLars Ellenberg /* Free peer_req 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); 369fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(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 38600d56944SPhilipp Reisner int w_resync_timer(struct drbd_work *w, int cancel) 387794abb75SPhilipp Reisner { 38800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 389794abb75SPhilipp Reisner switch (mdev->state.conn) { 390794abb75SPhilipp Reisner case C_VERIFY_S: 39100d56944SPhilipp Reisner w_make_ov_request(w, cancel); 392794abb75SPhilipp Reisner break; 393794abb75SPhilipp Reisner case C_SYNC_TARGET: 39400d56944SPhilipp Reisner w_make_resync_request(w, cancel); 395794abb75SPhilipp Reisner break; 396794abb75SPhilipp Reisner } 397794abb75SPhilipp Reisner 398794abb75SPhilipp Reisner return 1; 399794abb75SPhilipp Reisner } 400794abb75SPhilipp Reisner 401b411b363SPhilipp Reisner void resync_timer_fn(unsigned long data) 402b411b363SPhilipp Reisner { 403b411b363SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 404b411b363SPhilipp Reisner 405794abb75SPhilipp Reisner if (list_empty(&mdev->resync_work.list)) 406e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->resync_work); 407b411b363SPhilipp Reisner } 408b411b363SPhilipp Reisner 409778f271dSPhilipp Reisner static void fifo_set(struct fifo_buffer *fb, int value) 410778f271dSPhilipp Reisner { 411778f271dSPhilipp Reisner int i; 412778f271dSPhilipp Reisner 413778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 414f10f2623SPhilipp Reisner fb->values[i] = value; 415778f271dSPhilipp Reisner } 416778f271dSPhilipp Reisner 417778f271dSPhilipp Reisner static int fifo_push(struct fifo_buffer *fb, int value) 418778f271dSPhilipp Reisner { 419778f271dSPhilipp Reisner int ov; 420778f271dSPhilipp Reisner 421778f271dSPhilipp Reisner ov = fb->values[fb->head_index]; 422778f271dSPhilipp Reisner fb->values[fb->head_index++] = value; 423778f271dSPhilipp Reisner 424778f271dSPhilipp Reisner if (fb->head_index >= fb->size) 425778f271dSPhilipp Reisner fb->head_index = 0; 426778f271dSPhilipp Reisner 427778f271dSPhilipp Reisner return ov; 428778f271dSPhilipp Reisner } 429778f271dSPhilipp Reisner 430778f271dSPhilipp Reisner static void fifo_add_val(struct fifo_buffer *fb, int value) 431778f271dSPhilipp Reisner { 432778f271dSPhilipp Reisner int i; 433778f271dSPhilipp Reisner 434778f271dSPhilipp Reisner for (i = 0; i < fb->size; i++) 435778f271dSPhilipp Reisner fb->values[i] += value; 436778f271dSPhilipp Reisner } 437778f271dSPhilipp Reisner 4389d77a5feSPhilipp Reisner static int drbd_rs_controller(struct drbd_conf *mdev) 439778f271dSPhilipp Reisner { 440778f271dSPhilipp Reisner unsigned int sect_in; /* Number of sectors that came in since the last turn */ 441778f271dSPhilipp Reisner unsigned int want; /* The number of sectors we want in the proxy */ 442778f271dSPhilipp Reisner int req_sect; /* Number of sectors to request in this turn */ 443778f271dSPhilipp Reisner int correction; /* Number of sectors more we need in the proxy*/ 444778f271dSPhilipp Reisner int cps; /* correction per invocation of drbd_rs_controller() */ 445778f271dSPhilipp Reisner int steps; /* Number of time steps to plan ahead */ 446778f271dSPhilipp Reisner int curr_corr; 447778f271dSPhilipp Reisner int max_sect; 448778f271dSPhilipp Reisner 449778f271dSPhilipp Reisner sect_in = atomic_xchg(&mdev->rs_sect_in, 0); /* Number of sectors that came in */ 450778f271dSPhilipp Reisner mdev->rs_in_flight -= sect_in; 451778f271dSPhilipp Reisner 452778f271dSPhilipp Reisner spin_lock(&mdev->peer_seq_lock); /* get an atomic view on mdev->rs_plan_s */ 453778f271dSPhilipp Reisner 454f399002eSLars Ellenberg steps = mdev->rs_plan_s.size; /* (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; */ 455778f271dSPhilipp Reisner 456778f271dSPhilipp Reisner if (mdev->rs_in_flight + sect_in == 0) { /* At start of resync */ 457f399002eSLars Ellenberg want = ((mdev->ldev->dc.resync_rate * 2 * SLEEP_TIME) / HZ) * steps; 458778f271dSPhilipp Reisner } else { /* normal path */ 459f399002eSLars Ellenberg want = mdev->ldev->dc.c_fill_target ? mdev->ldev->dc.c_fill_target : 460f399002eSLars Ellenberg sect_in * mdev->ldev->dc.c_delay_target * HZ / (SLEEP_TIME * 10); 461778f271dSPhilipp Reisner } 462778f271dSPhilipp Reisner 463778f271dSPhilipp Reisner correction = want - mdev->rs_in_flight - mdev->rs_planed; 464778f271dSPhilipp Reisner 465778f271dSPhilipp Reisner /* Plan ahead */ 466778f271dSPhilipp Reisner cps = correction / steps; 467778f271dSPhilipp Reisner fifo_add_val(&mdev->rs_plan_s, cps); 468778f271dSPhilipp Reisner mdev->rs_planed += cps * steps; 469778f271dSPhilipp Reisner 470778f271dSPhilipp Reisner /* What we do in this step */ 471778f271dSPhilipp Reisner curr_corr = fifo_push(&mdev->rs_plan_s, 0); 472778f271dSPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 473778f271dSPhilipp Reisner mdev->rs_planed -= curr_corr; 474778f271dSPhilipp Reisner 475778f271dSPhilipp Reisner req_sect = sect_in + curr_corr; 476778f271dSPhilipp Reisner if (req_sect < 0) 477778f271dSPhilipp Reisner req_sect = 0; 478778f271dSPhilipp Reisner 479f399002eSLars Ellenberg max_sect = (mdev->ldev->dc.c_max_rate * 2 * SLEEP_TIME) / HZ; 480778f271dSPhilipp Reisner if (req_sect > max_sect) 481778f271dSPhilipp Reisner req_sect = max_sect; 482778f271dSPhilipp Reisner 483778f271dSPhilipp Reisner /* 484778f271dSPhilipp Reisner dev_warn(DEV, "si=%u if=%d wa=%u co=%d st=%d cps=%d pl=%d cc=%d rs=%d\n", 485778f271dSPhilipp Reisner sect_in, mdev->rs_in_flight, want, correction, 486778f271dSPhilipp Reisner steps, cps, mdev->rs_planed, curr_corr, req_sect); 487778f271dSPhilipp Reisner */ 488778f271dSPhilipp Reisner 489778f271dSPhilipp Reisner return req_sect; 490778f271dSPhilipp Reisner } 491778f271dSPhilipp Reisner 4929d77a5feSPhilipp Reisner static int drbd_rs_number_requests(struct drbd_conf *mdev) 493e65f440dSLars Ellenberg { 494e65f440dSLars Ellenberg int number; 495f399002eSLars Ellenberg if (mdev->rs_plan_s.size) { /* mdev->ldev->dc.c_plan_ahead */ 496e65f440dSLars Ellenberg number = drbd_rs_controller(mdev) >> (BM_BLOCK_SHIFT - 9); 497e65f440dSLars Ellenberg mdev->c_sync_rate = number * HZ * (BM_BLOCK_SIZE / 1024) / SLEEP_TIME; 498e65f440dSLars Ellenberg } else { 499f399002eSLars Ellenberg mdev->c_sync_rate = mdev->ldev->dc.resync_rate; 500e65f440dSLars Ellenberg number = SLEEP_TIME * mdev->c_sync_rate / ((BM_BLOCK_SIZE / 1024) * HZ); 501e65f440dSLars Ellenberg } 502e65f440dSLars Ellenberg 503e65f440dSLars Ellenberg /* ignore the amount of pending requests, the resync controller should 504e65f440dSLars Ellenberg * throttle down to incoming reply rate soon enough anyways. */ 505e65f440dSLars Ellenberg return number; 506e65f440dSLars Ellenberg } 507e65f440dSLars Ellenberg 50800d56944SPhilipp Reisner static int w_make_resync_request(struct drbd_work *w, int cancel) 509b411b363SPhilipp Reisner { 51000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 511b411b363SPhilipp Reisner unsigned long bit; 512b411b363SPhilipp Reisner sector_t sector; 513b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 5141816a2b4SLars Ellenberg int max_bio_size; 515e65f440dSLars Ellenberg int number, rollback_i, size; 516b411b363SPhilipp Reisner int align, queued, sndbuf; 5170f0601f4SLars Ellenberg int i = 0; 518b411b363SPhilipp Reisner 519b411b363SPhilipp Reisner if (unlikely(cancel)) 520b411b363SPhilipp Reisner return 1; 521b411b363SPhilipp Reisner 522af85e8e8SLars Ellenberg if (mdev->rs_total == 0) { 523af85e8e8SLars Ellenberg /* empty resync? */ 524af85e8e8SLars Ellenberg drbd_resync_finished(mdev); 525af85e8e8SLars Ellenberg return 1; 526af85e8e8SLars Ellenberg } 527af85e8e8SLars Ellenberg 528b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 529b411b363SPhilipp Reisner /* Since we only need to access mdev->rsync a 530b411b363SPhilipp Reisner get_ldev_if_state(mdev,D_FAILED) would be sufficient, but 531b411b363SPhilipp Reisner to continue resync with a broken disk makes no sense at 532b411b363SPhilipp Reisner all */ 533b411b363SPhilipp Reisner dev_err(DEV, "Disk broke down during resync!\n"); 534b411b363SPhilipp Reisner return 1; 535b411b363SPhilipp Reisner } 536b411b363SPhilipp Reisner 5370cfdd247SPhilipp Reisner max_bio_size = queue_max_hw_sectors(mdev->rq_queue) << 9; 538e65f440dSLars Ellenberg number = drbd_rs_number_requests(mdev); 539e65f440dSLars Ellenberg if (number == 0) 5400f0601f4SLars Ellenberg goto requeue; 541b411b363SPhilipp Reisner 542b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 543b411b363SPhilipp Reisner /* Stop generating RS requests, when half of the send buffer is filled */ 544e42325a5SPhilipp Reisner mutex_lock(&mdev->tconn->data.mutex); 545e42325a5SPhilipp Reisner if (mdev->tconn->data.socket) { 546e42325a5SPhilipp Reisner queued = mdev->tconn->data.socket->sk->sk_wmem_queued; 547e42325a5SPhilipp Reisner sndbuf = mdev->tconn->data.socket->sk->sk_sndbuf; 548b411b363SPhilipp Reisner } else { 549b411b363SPhilipp Reisner queued = 1; 550b411b363SPhilipp Reisner sndbuf = 0; 551b411b363SPhilipp Reisner } 552e42325a5SPhilipp Reisner mutex_unlock(&mdev->tconn->data.mutex); 553b411b363SPhilipp Reisner if (queued > sndbuf / 2) 554b411b363SPhilipp Reisner goto requeue; 555b411b363SPhilipp Reisner 556b411b363SPhilipp Reisner next_sector: 557b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 558b411b363SPhilipp Reisner bit = drbd_bm_find_next(mdev, mdev->bm_resync_fo); 559b411b363SPhilipp Reisner 5604b0715f0SLars Ellenberg if (bit == DRBD_END_OF_BITMAP) { 561b411b363SPhilipp Reisner mdev->bm_resync_fo = drbd_bm_bits(mdev); 562b411b363SPhilipp Reisner put_ldev(mdev); 563b411b363SPhilipp Reisner return 1; 564b411b363SPhilipp Reisner } 565b411b363SPhilipp Reisner 566b411b363SPhilipp Reisner sector = BM_BIT_TO_SECT(bit); 567b411b363SPhilipp Reisner 568e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 569e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 570b411b363SPhilipp Reisner mdev->bm_resync_fo = bit; 571b411b363SPhilipp Reisner goto requeue; 572b411b363SPhilipp Reisner } 573b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 574b411b363SPhilipp Reisner 575b411b363SPhilipp Reisner if (unlikely(drbd_bm_test_bit(mdev, bit) == 0)) { 576b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 577b411b363SPhilipp Reisner goto next_sector; 578b411b363SPhilipp Reisner } 579b411b363SPhilipp Reisner 5801816a2b4SLars Ellenberg #if DRBD_MAX_BIO_SIZE > BM_BLOCK_SIZE 581b411b363SPhilipp Reisner /* try to find some adjacent bits. 582b411b363SPhilipp Reisner * we stop if we have already the maximum req size. 583b411b363SPhilipp Reisner * 584b411b363SPhilipp Reisner * Additionally always align bigger requests, in order to 585b411b363SPhilipp Reisner * be prepared for all stripe sizes of software RAIDs. 586b411b363SPhilipp Reisner */ 587b411b363SPhilipp Reisner align = 1; 588d207450cSPhilipp Reisner rollback_i = i; 589b411b363SPhilipp Reisner for (;;) { 5901816a2b4SLars Ellenberg if (size + BM_BLOCK_SIZE > max_bio_size) 591b411b363SPhilipp Reisner break; 592b411b363SPhilipp Reisner 593b411b363SPhilipp Reisner /* Be always aligned */ 594b411b363SPhilipp Reisner if (sector & ((1<<(align+3))-1)) 595b411b363SPhilipp Reisner break; 596b411b363SPhilipp Reisner 597b411b363SPhilipp Reisner /* do not cross extent boundaries */ 598b411b363SPhilipp Reisner if (((bit+1) & BM_BLOCKS_PER_BM_EXT_MASK) == 0) 599b411b363SPhilipp Reisner break; 600b411b363SPhilipp Reisner /* now, is it actually dirty, after all? 601b411b363SPhilipp Reisner * caution, drbd_bm_test_bit is tri-state for some 602b411b363SPhilipp Reisner * obscure reason; ( b == 0 ) would get the out-of-band 603b411b363SPhilipp Reisner * only accidentally right because of the "oddly sized" 604b411b363SPhilipp Reisner * adjustment below */ 605b411b363SPhilipp Reisner if (drbd_bm_test_bit(mdev, bit+1) != 1) 606b411b363SPhilipp Reisner break; 607b411b363SPhilipp Reisner bit++; 608b411b363SPhilipp Reisner size += BM_BLOCK_SIZE; 609b411b363SPhilipp Reisner if ((BM_BLOCK_SIZE << align) <= size) 610b411b363SPhilipp Reisner align++; 611b411b363SPhilipp Reisner i++; 612b411b363SPhilipp Reisner } 613b411b363SPhilipp Reisner /* if we merged some, 614b411b363SPhilipp Reisner * reset the offset to start the next drbd_bm_find_next from */ 615b411b363SPhilipp Reisner if (size > BM_BLOCK_SIZE) 616b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 617b411b363SPhilipp Reisner #endif 618b411b363SPhilipp Reisner 619b411b363SPhilipp Reisner /* adjust very last sectors, in case we are oddly sized */ 620b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 621b411b363SPhilipp Reisner size = (capacity-sector)<<9; 622f399002eSLars Ellenberg if (mdev->tconn->agreed_pro_version >= 89 && mdev->tconn->csums_tfm) { 623b411b363SPhilipp Reisner switch (read_for_csum(mdev, sector, size)) { 62480a40e43SLars Ellenberg case -EIO: /* Disk failure */ 625b411b363SPhilipp Reisner put_ldev(mdev); 626b411b363SPhilipp Reisner return 0; 62780a40e43SLars Ellenberg case -EAGAIN: /* allocation failed, or ldev busy */ 628b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 629b411b363SPhilipp Reisner mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 630d207450cSPhilipp Reisner i = rollback_i; 631b411b363SPhilipp Reisner goto requeue; 63280a40e43SLars Ellenberg case 0: 63380a40e43SLars Ellenberg /* everything ok */ 63480a40e43SLars Ellenberg break; 63580a40e43SLars Ellenberg default: 63680a40e43SLars Ellenberg BUG(); 637b411b363SPhilipp Reisner } 638b411b363SPhilipp Reisner } else { 639b411b363SPhilipp Reisner inc_rs_pending(mdev); 640b411b363SPhilipp Reisner if (!drbd_send_drequest(mdev, P_RS_DATA_REQUEST, 641b411b363SPhilipp Reisner sector, size, ID_SYNCER)) { 642b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest() failed, aborting...\n"); 643b411b363SPhilipp Reisner dec_rs_pending(mdev); 644b411b363SPhilipp Reisner put_ldev(mdev); 645b411b363SPhilipp Reisner return 0; 646b411b363SPhilipp Reisner } 647b411b363SPhilipp Reisner } 648b411b363SPhilipp Reisner } 649b411b363SPhilipp Reisner 650b411b363SPhilipp Reisner if (mdev->bm_resync_fo >= drbd_bm_bits(mdev)) { 651b411b363SPhilipp Reisner /* last syncer _request_ was sent, 652b411b363SPhilipp Reisner * but the P_RS_DATA_REPLY not yet received. sync will end (and 653b411b363SPhilipp Reisner * next sync group will resume), as soon as we receive the last 654b411b363SPhilipp Reisner * resync data block, and the last bit is cleared. 655b411b363SPhilipp Reisner * until then resync "work" is "inactive" ... 656b411b363SPhilipp Reisner */ 657b411b363SPhilipp Reisner put_ldev(mdev); 658b411b363SPhilipp Reisner return 1; 659b411b363SPhilipp Reisner } 660b411b363SPhilipp Reisner 661b411b363SPhilipp Reisner requeue: 662778f271dSPhilipp Reisner mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 663b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 664b411b363SPhilipp Reisner put_ldev(mdev); 665b411b363SPhilipp Reisner return 1; 666b411b363SPhilipp Reisner } 667b411b363SPhilipp Reisner 66800d56944SPhilipp Reisner static int w_make_ov_request(struct drbd_work *w, int cancel) 669b411b363SPhilipp Reisner { 67000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 671b411b363SPhilipp Reisner int number, i, size; 672b411b363SPhilipp Reisner sector_t sector; 673b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 674b411b363SPhilipp Reisner 675b411b363SPhilipp Reisner if (unlikely(cancel)) 676b411b363SPhilipp Reisner return 1; 677b411b363SPhilipp Reisner 6782649f080SLars Ellenberg number = drbd_rs_number_requests(mdev); 679b411b363SPhilipp Reisner 680b411b363SPhilipp Reisner sector = mdev->ov_position; 681b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 682b411b363SPhilipp Reisner if (sector >= capacity) { 683b411b363SPhilipp Reisner return 1; 684b411b363SPhilipp Reisner } 685b411b363SPhilipp Reisner 686b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 687b411b363SPhilipp Reisner 688e3555d85SPhilipp Reisner if (drbd_rs_should_slow_down(mdev, sector) || 689e3555d85SPhilipp Reisner drbd_try_rs_begin_io(mdev, sector)) { 690b411b363SPhilipp Reisner mdev->ov_position = sector; 691b411b363SPhilipp Reisner goto requeue; 692b411b363SPhilipp Reisner } 693b411b363SPhilipp Reisner 694b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 695b411b363SPhilipp Reisner size = (capacity-sector)<<9; 696b411b363SPhilipp Reisner 697b411b363SPhilipp Reisner inc_rs_pending(mdev); 6985b9f499cSAndreas Gruenbacher if (drbd_send_ov_request(mdev, sector, size)) { 699b411b363SPhilipp Reisner dec_rs_pending(mdev); 700b411b363SPhilipp Reisner return 0; 701b411b363SPhilipp Reisner } 702b411b363SPhilipp Reisner sector += BM_SECT_PER_BIT; 703b411b363SPhilipp Reisner } 704b411b363SPhilipp Reisner mdev->ov_position = sector; 705b411b363SPhilipp Reisner 706b411b363SPhilipp Reisner requeue: 7072649f080SLars Ellenberg mdev->rs_in_flight += (i << (BM_BLOCK_SHIFT - 9)); 708b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 709b411b363SPhilipp Reisner return 1; 710b411b363SPhilipp Reisner } 711b411b363SPhilipp Reisner 71200d56944SPhilipp Reisner int w_ov_finished(struct drbd_work *w, int cancel) 713b411b363SPhilipp Reisner { 71400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 715b411b363SPhilipp Reisner kfree(w); 716b411b363SPhilipp Reisner ov_oos_print(mdev); 717b411b363SPhilipp Reisner drbd_resync_finished(mdev); 718b411b363SPhilipp Reisner 719b411b363SPhilipp Reisner return 1; 720b411b363SPhilipp Reisner } 721b411b363SPhilipp Reisner 72200d56944SPhilipp Reisner static int w_resync_finished(struct drbd_work *w, int cancel) 723b411b363SPhilipp Reisner { 72400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 725b411b363SPhilipp Reisner kfree(w); 726b411b363SPhilipp Reisner 727b411b363SPhilipp Reisner drbd_resync_finished(mdev); 728b411b363SPhilipp Reisner 729b411b363SPhilipp Reisner return 1; 730b411b363SPhilipp Reisner } 731b411b363SPhilipp Reisner 732af85e8e8SLars Ellenberg static void ping_peer(struct drbd_conf *mdev) 733af85e8e8SLars Ellenberg { 7342a67d8b9SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 7352a67d8b9SPhilipp Reisner 7362a67d8b9SPhilipp Reisner clear_bit(GOT_PING_ACK, &tconn->flags); 7372a67d8b9SPhilipp Reisner request_ping(tconn); 7382a67d8b9SPhilipp Reisner wait_event(tconn->ping_wait, 7392a67d8b9SPhilipp Reisner test_bit(GOT_PING_ACK, &tconn->flags) || mdev->state.conn < C_CONNECTED); 740af85e8e8SLars Ellenberg } 741af85e8e8SLars Ellenberg 742b411b363SPhilipp Reisner int drbd_resync_finished(struct drbd_conf *mdev) 743b411b363SPhilipp Reisner { 744b411b363SPhilipp Reisner unsigned long db, dt, dbdt; 745b411b363SPhilipp Reisner unsigned long n_oos; 746b411b363SPhilipp Reisner union drbd_state os, ns; 747b411b363SPhilipp Reisner struct drbd_work *w; 748b411b363SPhilipp Reisner char *khelper_cmd = NULL; 74926525618SLars Ellenberg int verify_done = 0; 750b411b363SPhilipp Reisner 751b411b363SPhilipp Reisner /* Remove all elements from the resync LRU. Since future actions 752b411b363SPhilipp Reisner * might set bits in the (main) bitmap, then the entries in the 753b411b363SPhilipp Reisner * resync LRU would be wrong. */ 754b411b363SPhilipp Reisner if (drbd_rs_del_all(mdev)) { 755b411b363SPhilipp Reisner /* In case this is not possible now, most probably because 756b411b363SPhilipp Reisner * there are P_RS_DATA_REPLY Packets lingering on the worker's 757b411b363SPhilipp Reisner * queue (or even the read operations for those packets 758b411b363SPhilipp Reisner * is not finished by now). Retry in 100ms. */ 759b411b363SPhilipp Reisner 76020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 761b411b363SPhilipp Reisner w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC); 762b411b363SPhilipp Reisner if (w) { 763b411b363SPhilipp Reisner w->cb = w_resync_finished; 764e42325a5SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, w); 765b411b363SPhilipp Reisner return 1; 766b411b363SPhilipp Reisner } 767b411b363SPhilipp Reisner dev_err(DEV, "Warn failed to drbd_rs_del_all() and to kmalloc(w).\n"); 768b411b363SPhilipp Reisner } 769b411b363SPhilipp Reisner 770b411b363SPhilipp Reisner dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ; 771b411b363SPhilipp Reisner if (dt <= 0) 772b411b363SPhilipp Reisner dt = 1; 773b411b363SPhilipp Reisner db = mdev->rs_total; 774b411b363SPhilipp Reisner dbdt = Bit2KB(db/dt); 775b411b363SPhilipp Reisner mdev->rs_paused /= HZ; 776b411b363SPhilipp Reisner 777b411b363SPhilipp Reisner if (!get_ldev(mdev)) 778b411b363SPhilipp Reisner goto out; 779b411b363SPhilipp Reisner 780af85e8e8SLars Ellenberg ping_peer(mdev); 781af85e8e8SLars Ellenberg 78287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 783b411b363SPhilipp Reisner os = mdev->state; 784b411b363SPhilipp Reisner 78526525618SLars Ellenberg verify_done = (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T); 78626525618SLars Ellenberg 787b411b363SPhilipp Reisner /* This protects us against multiple calls (that can happen in the presence 788b411b363SPhilipp Reisner of application IO), and against connectivity loss just before we arrive here. */ 789b411b363SPhilipp Reisner if (os.conn <= C_CONNECTED) 790b411b363SPhilipp Reisner goto out_unlock; 791b411b363SPhilipp Reisner 792b411b363SPhilipp Reisner ns = os; 793b411b363SPhilipp Reisner ns.conn = C_CONNECTED; 794b411b363SPhilipp Reisner 795b411b363SPhilipp Reisner dev_info(DEV, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n", 79626525618SLars Ellenberg verify_done ? "Online verify " : "Resync", 797b411b363SPhilipp Reisner dt + mdev->rs_paused, mdev->rs_paused, dbdt); 798b411b363SPhilipp Reisner 799b411b363SPhilipp Reisner n_oos = drbd_bm_total_weight(mdev); 800b411b363SPhilipp Reisner 801b411b363SPhilipp Reisner if (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) { 802b411b363SPhilipp Reisner if (n_oos) { 803b411b363SPhilipp Reisner dev_alert(DEV, "Online verify found %lu %dk block out of sync!\n", 804b411b363SPhilipp Reisner n_oos, Bit2KB(1)); 805b411b363SPhilipp Reisner khelper_cmd = "out-of-sync"; 806b411b363SPhilipp Reisner } 807b411b363SPhilipp Reisner } else { 808b411b363SPhilipp Reisner D_ASSERT((n_oos - mdev->rs_failed) == 0); 809b411b363SPhilipp Reisner 810b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) 811b411b363SPhilipp Reisner khelper_cmd = "after-resync-target"; 812b411b363SPhilipp Reisner 813f399002eSLars Ellenberg if (mdev->tconn->csums_tfm && mdev->rs_total) { 814b411b363SPhilipp Reisner const unsigned long s = mdev->rs_same_csum; 815b411b363SPhilipp Reisner const unsigned long t = mdev->rs_total; 816b411b363SPhilipp Reisner const int ratio = 817b411b363SPhilipp Reisner (t == 0) ? 0 : 818b411b363SPhilipp Reisner (t < 100000) ? ((s*100)/t) : (s/(t/100)); 819b411b363SPhilipp Reisner dev_info(DEV, "%u %% had equal checksums, eliminated: %luK; " 820b411b363SPhilipp Reisner "transferred %luK total %luK\n", 821b411b363SPhilipp Reisner ratio, 822b411b363SPhilipp Reisner Bit2KB(mdev->rs_same_csum), 823b411b363SPhilipp Reisner Bit2KB(mdev->rs_total - mdev->rs_same_csum), 824b411b363SPhilipp Reisner Bit2KB(mdev->rs_total)); 825b411b363SPhilipp Reisner } 826b411b363SPhilipp Reisner } 827b411b363SPhilipp Reisner 828b411b363SPhilipp Reisner if (mdev->rs_failed) { 829b411b363SPhilipp Reisner dev_info(DEV, " %lu failed blocks\n", mdev->rs_failed); 830b411b363SPhilipp Reisner 831b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 832b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 833b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 834b411b363SPhilipp Reisner } else { 835b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 836b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 837b411b363SPhilipp Reisner } 838b411b363SPhilipp Reisner } else { 839b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 840b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 841b411b363SPhilipp Reisner 842b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 843b411b363SPhilipp Reisner if (mdev->p_uuid) { 844b411b363SPhilipp Reisner int i; 845b411b363SPhilipp Reisner for (i = UI_BITMAP ; i <= UI_HISTORY_END ; i++) 846b411b363SPhilipp Reisner _drbd_uuid_set(mdev, i, mdev->p_uuid[i]); 847b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_CURRENT]); 848b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, mdev->p_uuid[UI_CURRENT]); 849b411b363SPhilipp Reisner } else { 850b411b363SPhilipp Reisner dev_err(DEV, "mdev->p_uuid is NULL! BUG\n"); 851b411b363SPhilipp Reisner } 852b411b363SPhilipp Reisner } 853b411b363SPhilipp Reisner 85462b0da3aSLars Ellenberg if (!(os.conn == C_VERIFY_S || os.conn == C_VERIFY_T)) { 85562b0da3aSLars Ellenberg /* for verify runs, we don't update uuids here, 85662b0da3aSLars Ellenberg * so there would be nothing to report. */ 857b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 85862b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated UUIDs"); 859b411b363SPhilipp Reisner if (mdev->p_uuid) { 860b411b363SPhilipp Reisner /* Now the two UUID sets are equal, update what we 861b411b363SPhilipp Reisner * know of the peer. */ 862b411b363SPhilipp Reisner int i; 863b411b363SPhilipp Reisner for (i = UI_CURRENT ; i <= UI_HISTORY_END ; i++) 864b411b363SPhilipp Reisner mdev->p_uuid[i] = mdev->ldev->md.uuid[i]; 865b411b363SPhilipp Reisner } 866b411b363SPhilipp Reisner } 86762b0da3aSLars Ellenberg } 868b411b363SPhilipp Reisner 869b411b363SPhilipp Reisner _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 870b411b363SPhilipp Reisner out_unlock: 87187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 872b411b363SPhilipp Reisner put_ldev(mdev); 873b411b363SPhilipp Reisner out: 874b411b363SPhilipp Reisner mdev->rs_total = 0; 875b411b363SPhilipp Reisner mdev->rs_failed = 0; 876b411b363SPhilipp Reisner mdev->rs_paused = 0; 87726525618SLars Ellenberg if (verify_done) 878b411b363SPhilipp Reisner mdev->ov_start_sector = 0; 879b411b363SPhilipp Reisner 88013d42685SLars Ellenberg drbd_md_sync(mdev); 88113d42685SLars Ellenberg 882b411b363SPhilipp Reisner if (khelper_cmd) 883b411b363SPhilipp Reisner drbd_khelper(mdev, khelper_cmd); 884b411b363SPhilipp Reisner 885b411b363SPhilipp Reisner return 1; 886b411b363SPhilipp Reisner } 887b411b363SPhilipp Reisner 888b411b363SPhilipp Reisner /* helper */ 889db830c46SAndreas Gruenbacher static void move_to_net_ee_or_free(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 890b411b363SPhilipp Reisner { 891db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) { 892b411b363SPhilipp Reisner /* This might happen if sendpage() has not finished */ 893db830c46SAndreas Gruenbacher int i = (peer_req->i.size + PAGE_SIZE -1) >> PAGE_SHIFT; 894435f0740SLars Ellenberg atomic_add(i, &mdev->pp_in_use_by_net); 895435f0740SLars Ellenberg atomic_sub(i, &mdev->pp_in_use); 89687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 897db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->net_ee); 89887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 899435f0740SLars Ellenberg wake_up(&drbd_pp_wait); 900b411b363SPhilipp Reisner } else 901db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 902b411b363SPhilipp Reisner } 903b411b363SPhilipp Reisner 904b411b363SPhilipp Reisner /** 905b411b363SPhilipp Reisner * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 906b411b363SPhilipp Reisner * @mdev: DRBD device. 907b411b363SPhilipp Reisner * @w: work object. 908b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 909b411b363SPhilipp Reisner */ 91000d56944SPhilipp Reisner int w_e_end_data_req(struct drbd_work *w, int cancel) 911b411b363SPhilipp Reisner { 912db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 91300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 914b411b363SPhilipp Reisner int ok; 915b411b363SPhilipp Reisner 916b411b363SPhilipp Reisner if (unlikely(cancel)) { 917db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 918b411b363SPhilipp Reisner dec_unacked(mdev); 919b411b363SPhilipp Reisner return 1; 920b411b363SPhilipp Reisner } 921b411b363SPhilipp Reisner 922db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 923db830c46SAndreas Gruenbacher ok = drbd_send_block(mdev, P_DATA_REPLY, peer_req); 924b411b363SPhilipp Reisner } else { 925b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 926b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. sector=%llus.\n", 927db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 928b411b363SPhilipp Reisner 929dd516121SAndreas Gruenbacher ok = !drbd_send_ack(mdev, P_NEG_DREPLY, peer_req); 930b411b363SPhilipp Reisner } 931b411b363SPhilipp Reisner 932b411b363SPhilipp Reisner dec_unacked(mdev); 933b411b363SPhilipp Reisner 934db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 935b411b363SPhilipp Reisner 936b411b363SPhilipp Reisner if (unlikely(!ok)) 937b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 938b411b363SPhilipp Reisner return ok; 939b411b363SPhilipp Reisner } 940b411b363SPhilipp Reisner 941b411b363SPhilipp Reisner /** 942b411b363SPhilipp Reisner * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUESTRS 943b411b363SPhilipp Reisner * @mdev: DRBD device. 944b411b363SPhilipp Reisner * @w: work object. 945b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 946b411b363SPhilipp Reisner */ 94700d56944SPhilipp Reisner int w_e_end_rsdata_req(struct drbd_work *w, int cancel) 948b411b363SPhilipp Reisner { 949db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 95000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 951b411b363SPhilipp Reisner int ok; 952b411b363SPhilipp Reisner 953b411b363SPhilipp Reisner if (unlikely(cancel)) { 954db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 955b411b363SPhilipp Reisner dec_unacked(mdev); 956b411b363SPhilipp Reisner return 1; 957b411b363SPhilipp Reisner } 958b411b363SPhilipp Reisner 959b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 960db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 961b411b363SPhilipp Reisner put_ldev(mdev); 962b411b363SPhilipp Reisner } 963b411b363SPhilipp Reisner 964d612d309SPhilipp Reisner if (mdev->state.conn == C_AHEAD) { 965dd516121SAndreas Gruenbacher ok = !drbd_send_ack(mdev, P_RS_CANCEL, peer_req); 966db830c46SAndreas Gruenbacher } else if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 967b411b363SPhilipp Reisner if (likely(mdev->state.pdsk >= D_INCONSISTENT)) { 968b411b363SPhilipp Reisner inc_rs_pending(mdev); 969db830c46SAndreas Gruenbacher ok = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 970b411b363SPhilipp Reisner } else { 971b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 972b411b363SPhilipp Reisner dev_err(DEV, "Not sending RSDataReply, " 973b411b363SPhilipp Reisner "partner DISKLESS!\n"); 974b411b363SPhilipp Reisner ok = 1; 975b411b363SPhilipp Reisner } 976b411b363SPhilipp Reisner } else { 977b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 978b411b363SPhilipp Reisner dev_err(DEV, "Sending NegRSDReply. sector %llus.\n", 979db830c46SAndreas Gruenbacher (unsigned long long)peer_req->i.sector); 980b411b363SPhilipp Reisner 981dd516121SAndreas Gruenbacher ok = !drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 982b411b363SPhilipp Reisner 983b411b363SPhilipp Reisner /* update resync data with failure */ 984db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, peer_req->i.sector, peer_req->i.size); 985b411b363SPhilipp Reisner } 986b411b363SPhilipp Reisner 987b411b363SPhilipp Reisner dec_unacked(mdev); 988b411b363SPhilipp Reisner 989db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 990b411b363SPhilipp Reisner 991b411b363SPhilipp Reisner if (unlikely(!ok)) 992b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 993b411b363SPhilipp Reisner return ok; 994b411b363SPhilipp Reisner } 995b411b363SPhilipp Reisner 99600d56944SPhilipp Reisner int w_e_end_csum_rs_req(struct drbd_work *w, int cancel) 997b411b363SPhilipp Reisner { 998db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 99900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1000b411b363SPhilipp Reisner struct digest_info *di; 1001b411b363SPhilipp Reisner int digest_size; 1002b411b363SPhilipp Reisner void *digest = NULL; 1003b411b363SPhilipp Reisner int ok, eq = 0; 1004b411b363SPhilipp Reisner 1005b411b363SPhilipp Reisner if (unlikely(cancel)) { 1006db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1007b411b363SPhilipp Reisner dec_unacked(mdev); 1008b411b363SPhilipp Reisner return 1; 1009b411b363SPhilipp Reisner } 1010b411b363SPhilipp Reisner 10111d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1012db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 10131d53f09eSLars Ellenberg put_ldev(mdev); 10141d53f09eSLars Ellenberg } 1015b411b363SPhilipp Reisner 1016db830c46SAndreas Gruenbacher di = peer_req->digest; 1017b411b363SPhilipp Reisner 1018db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1019b411b363SPhilipp Reisner /* quick hack to try to avoid a race against reconfiguration. 1020b411b363SPhilipp Reisner * a real fix would be much more involved, 1021b411b363SPhilipp Reisner * introducing more locking mechanisms */ 1022f399002eSLars Ellenberg if (mdev->tconn->csums_tfm) { 1023f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->csums_tfm); 1024b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1025b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1026b411b363SPhilipp Reisner } 1027b411b363SPhilipp Reisner if (digest) { 1028f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->csums_tfm, peer_req, digest); 1029b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1030b411b363SPhilipp Reisner kfree(digest); 1031b411b363SPhilipp Reisner } 1032b411b363SPhilipp Reisner 1033b411b363SPhilipp Reisner if (eq) { 1034db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, peer_req->i.sector, peer_req->i.size); 1035676396d5SLars Ellenberg /* rs_same_csums unit is BM_BLOCK_SIZE */ 1036db830c46SAndreas Gruenbacher mdev->rs_same_csum += peer_req->i.size >> BM_BLOCK_SHIFT; 1037dd516121SAndreas Gruenbacher ok = !drbd_send_ack(mdev, P_RS_IS_IN_SYNC, peer_req); 1038b411b363SPhilipp Reisner } else { 1039b411b363SPhilipp Reisner inc_rs_pending(mdev); 1040db830c46SAndreas Gruenbacher peer_req->block_id = ID_SYNCER; /* By setting block_id, digest pointer becomes invalid! */ 1041db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_HAS_DIGEST; /* This peer request no longer has a digest pointer */ 1042204bba99SPhilipp Reisner kfree(di); 1043db830c46SAndreas Gruenbacher ok = drbd_send_block(mdev, P_RS_DATA_REPLY, peer_req); 1044b411b363SPhilipp Reisner } 1045b411b363SPhilipp Reisner } else { 1046dd516121SAndreas Gruenbacher ok = !drbd_send_ack(mdev, P_NEG_RS_DREPLY, peer_req); 1047b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1048b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 1049b411b363SPhilipp Reisner } 1050b411b363SPhilipp Reisner 1051b411b363SPhilipp Reisner dec_unacked(mdev); 1052db830c46SAndreas Gruenbacher move_to_net_ee_or_free(mdev, peer_req); 1053b411b363SPhilipp Reisner 1054b411b363SPhilipp Reisner if (unlikely(!ok)) 1055b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block/ack() failed\n"); 1056b411b363SPhilipp Reisner return ok; 1057b411b363SPhilipp Reisner } 1058b411b363SPhilipp Reisner 105900d56944SPhilipp Reisner int w_e_end_ov_req(struct drbd_work *w, int cancel) 1060b411b363SPhilipp Reisner { 1061db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 106200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1063db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1064db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 1065b411b363SPhilipp Reisner int digest_size; 1066b411b363SPhilipp Reisner void *digest; 1067b411b363SPhilipp Reisner int ok = 1; 1068b411b363SPhilipp Reisner 1069b411b363SPhilipp Reisner if (unlikely(cancel)) 1070b411b363SPhilipp Reisner goto out; 1071b411b363SPhilipp Reisner 1072f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1073b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 10748f21420eSPhilipp Reisner if (!digest) { 10758f21420eSPhilipp Reisner ok = 0; /* terminate the connection in case the allocation failed */ 10768f21420eSPhilipp Reisner goto out; 10778f21420eSPhilipp Reisner } 10788f21420eSPhilipp Reisner 1079db830c46SAndreas Gruenbacher if (likely(!(peer_req->flags & EE_WAS_ERROR))) 1080f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 10818f21420eSPhilipp Reisner else 10828f21420eSPhilipp Reisner memset(digest, 0, digest_size); 10838f21420eSPhilipp Reisner 108453ea4331SLars Ellenberg /* Free e and pages before send. 108553ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 108653ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 108753ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 108853ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 1089db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1090db830c46SAndreas Gruenbacher peer_req = NULL; 1091b411b363SPhilipp Reisner inc_rs_pending(mdev); 109253ea4331SLars Ellenberg ok = drbd_send_drequest_csum(mdev, sector, size, 109353ea4331SLars Ellenberg digest, digest_size, 109453ea4331SLars Ellenberg P_OV_REPLY); 1095b411b363SPhilipp Reisner if (!ok) 1096b411b363SPhilipp Reisner dec_rs_pending(mdev); 1097b411b363SPhilipp Reisner kfree(digest); 1098b411b363SPhilipp Reisner 1099b411b363SPhilipp Reisner out: 1100db830c46SAndreas Gruenbacher if (peer_req) 1101db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1102b411b363SPhilipp Reisner dec_unacked(mdev); 1103b411b363SPhilipp Reisner return ok; 1104b411b363SPhilipp Reisner } 1105b411b363SPhilipp Reisner 1106b411b363SPhilipp Reisner void drbd_ov_oos_found(struct drbd_conf *mdev, sector_t sector, int size) 1107b411b363SPhilipp Reisner { 1108b411b363SPhilipp Reisner if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) { 1109b411b363SPhilipp Reisner mdev->ov_last_oos_size += size>>9; 1110b411b363SPhilipp Reisner } else { 1111b411b363SPhilipp Reisner mdev->ov_last_oos_start = sector; 1112b411b363SPhilipp Reisner mdev->ov_last_oos_size = size>>9; 1113b411b363SPhilipp Reisner } 1114b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 1115b411b363SPhilipp Reisner } 1116b411b363SPhilipp Reisner 111700d56944SPhilipp Reisner int w_e_end_ov_reply(struct drbd_work *w, int cancel) 1118b411b363SPhilipp Reisner { 1119db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req = container_of(w, struct drbd_peer_request, w); 112000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1121b411b363SPhilipp Reisner struct digest_info *di; 1122b411b363SPhilipp Reisner void *digest; 1123db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1124db830c46SAndreas Gruenbacher unsigned int size = peer_req->i.size; 112553ea4331SLars Ellenberg int digest_size; 1126b411b363SPhilipp Reisner int ok, eq = 0; 1127b411b363SPhilipp Reisner 1128b411b363SPhilipp Reisner if (unlikely(cancel)) { 1129db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1130b411b363SPhilipp Reisner dec_unacked(mdev); 1131b411b363SPhilipp Reisner return 1; 1132b411b363SPhilipp Reisner } 1133b411b363SPhilipp Reisner 1134b411b363SPhilipp Reisner /* after "cancel", because after drbd_disconnect/drbd_rs_cancel_all 1135b411b363SPhilipp Reisner * the resync lru has been cleaned up already */ 11361d53f09eSLars Ellenberg if (get_ldev(mdev)) { 1137db830c46SAndreas Gruenbacher drbd_rs_complete_io(mdev, peer_req->i.sector); 11381d53f09eSLars Ellenberg put_ldev(mdev); 11391d53f09eSLars Ellenberg } 1140b411b363SPhilipp Reisner 1141db830c46SAndreas Gruenbacher di = peer_req->digest; 1142b411b363SPhilipp Reisner 1143db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1144f399002eSLars Ellenberg digest_size = crypto_hash_digestsize(mdev->tconn->verify_tfm); 1145b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1146b411b363SPhilipp Reisner if (digest) { 1147f399002eSLars Ellenberg drbd_csum_ee(mdev, mdev->tconn->verify_tfm, peer_req, digest); 1148b411b363SPhilipp Reisner 1149b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1150b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1151b411b363SPhilipp Reisner kfree(digest); 1152b411b363SPhilipp Reisner } 1153b411b363SPhilipp Reisner } 1154b411b363SPhilipp Reisner 11559676c760SLars Ellenberg /* Free peer_req and pages before send. 115653ea4331SLars Ellenberg * In case we block on congestion, we could otherwise run into 115753ea4331SLars Ellenberg * some distributed deadlock, if the other side blocks on 115853ea4331SLars Ellenberg * congestion as well, because our receiver blocks in 115953ea4331SLars Ellenberg * drbd_pp_alloc due to pp_in_use > max_buffers. */ 1160db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1161b411b363SPhilipp Reisner if (!eq) 116253ea4331SLars Ellenberg drbd_ov_oos_found(mdev, sector, size); 1163b411b363SPhilipp Reisner else 1164b411b363SPhilipp Reisner ov_oos_print(mdev); 1165b411b363SPhilipp Reisner 1166fa79abd8SAndreas Gruenbacher ok = !drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, 1167b411b363SPhilipp Reisner eq ? ID_IN_SYNC : ID_OUT_OF_SYNC); 1168b411b363SPhilipp Reisner 116953ea4331SLars Ellenberg dec_unacked(mdev); 1170b411b363SPhilipp Reisner 1171ea5442afSLars Ellenberg --mdev->ov_left; 1172ea5442afSLars Ellenberg 1173ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 1174ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 1175ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 1176ea5442afSLars Ellenberg 1177ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 1178b411b363SPhilipp Reisner ov_oos_print(mdev); 1179b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1180b411b363SPhilipp Reisner } 1181b411b363SPhilipp Reisner 1182b411b363SPhilipp Reisner return ok; 1183b411b363SPhilipp Reisner } 1184b411b363SPhilipp Reisner 118500d56944SPhilipp Reisner int w_prev_work_done(struct drbd_work *w, int cancel) 1186b411b363SPhilipp Reisner { 1187b411b363SPhilipp Reisner struct drbd_wq_barrier *b = container_of(w, struct drbd_wq_barrier, w); 118800d56944SPhilipp Reisner 1189b411b363SPhilipp Reisner complete(&b->done); 1190b411b363SPhilipp Reisner return 1; 1191b411b363SPhilipp Reisner } 1192b411b363SPhilipp Reisner 119300d56944SPhilipp Reisner int w_send_barrier(struct drbd_work *w, int cancel) 1194b411b363SPhilipp Reisner { 1195b411b363SPhilipp Reisner struct drbd_tl_epoch *b = container_of(w, struct drbd_tl_epoch, w); 119600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1197e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.sbuf.barrier; 1198b411b363SPhilipp Reisner int ok = 1; 1199b411b363SPhilipp Reisner 1200b411b363SPhilipp Reisner /* really avoid racing with tl_clear. w.cb may have been referenced 1201b411b363SPhilipp Reisner * just before it was reassigned and re-queued, so double check that. 1202b411b363SPhilipp Reisner * actually, this race was harmless, since we only try to send the 1203b411b363SPhilipp Reisner * barrier packet here, and otherwise do nothing with the object. 1204b411b363SPhilipp Reisner * but compare with the head of w_clear_epoch */ 120587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1206b411b363SPhilipp Reisner if (w->cb != w_send_barrier || mdev->state.conn < C_CONNECTED) 1207b411b363SPhilipp Reisner cancel = 1; 120887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1209b411b363SPhilipp Reisner if (cancel) 1210b411b363SPhilipp Reisner return 1; 1211b411b363SPhilipp Reisner 121211b0be28SAndreas Gruenbacher if (drbd_get_data_sock(mdev->tconn)) 1213b411b363SPhilipp Reisner return 0; 1214b411b363SPhilipp Reisner p->barrier = b->br_number; 1215b411b363SPhilipp Reisner /* inc_ap_pending was done where this was queued. 1216b411b363SPhilipp Reisner * dec_ap_pending will be done in got_BarrierAck 1217b411b363SPhilipp Reisner * or (on connection loss) in w_clear_epoch. */ 121804dfa137SAndreas Gruenbacher ok = !_drbd_send_cmd(mdev, mdev->tconn->data.socket, P_BARRIER, 1219c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 122061120870SPhilipp Reisner drbd_put_data_sock(mdev->tconn); 1221b411b363SPhilipp Reisner 1222b411b363SPhilipp Reisner return ok; 1223b411b363SPhilipp Reisner } 1224b411b363SPhilipp Reisner 122500d56944SPhilipp Reisner int w_send_write_hint(struct drbd_work *w, int cancel) 1226b411b363SPhilipp Reisner { 122700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1228b411b363SPhilipp Reisner if (cancel) 1229b411b363SPhilipp Reisner return 1; 1230b411b363SPhilipp Reisner return drbd_send_short_cmd(mdev, P_UNPLUG_REMOTE); 1231b411b363SPhilipp Reisner } 1232b411b363SPhilipp Reisner 123300d56944SPhilipp Reisner int w_send_oos(struct drbd_work *w, int cancel) 123473a01a18SPhilipp Reisner { 123573a01a18SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 123600d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 123773a01a18SPhilipp Reisner int ok; 123873a01a18SPhilipp Reisner 123973a01a18SPhilipp Reisner if (unlikely(cancel)) { 12408554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 124173a01a18SPhilipp Reisner return 1; 124273a01a18SPhilipp Reisner } 124373a01a18SPhilipp Reisner 124473a01a18SPhilipp Reisner ok = drbd_send_oos(mdev, req); 12458554df1cSAndreas Gruenbacher req_mod(req, OOS_HANDED_TO_NETWORK); 124673a01a18SPhilipp Reisner 124773a01a18SPhilipp Reisner return ok; 124873a01a18SPhilipp Reisner } 124973a01a18SPhilipp Reisner 1250b411b363SPhilipp Reisner /** 1251b411b363SPhilipp Reisner * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1252b411b363SPhilipp Reisner * @mdev: DRBD device. 1253b411b363SPhilipp Reisner * @w: work object. 1254b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1255b411b363SPhilipp Reisner */ 125600d56944SPhilipp Reisner int w_send_dblock(struct drbd_work *w, int cancel) 1257b411b363SPhilipp Reisner { 1258b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 125900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1260b411b363SPhilipp Reisner int ok; 1261b411b363SPhilipp Reisner 1262b411b363SPhilipp Reisner if (unlikely(cancel)) { 12638554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 1264b411b363SPhilipp Reisner return 1; 1265b411b363SPhilipp Reisner } 1266b411b363SPhilipp Reisner 1267b411b363SPhilipp Reisner ok = drbd_send_dblock(mdev, req); 12688554df1cSAndreas Gruenbacher req_mod(req, ok ? HANDED_OVER_TO_NETWORK : SEND_FAILED); 1269b411b363SPhilipp Reisner 1270b411b363SPhilipp Reisner return ok; 1271b411b363SPhilipp Reisner } 1272b411b363SPhilipp Reisner 1273b411b363SPhilipp Reisner /** 1274b411b363SPhilipp Reisner * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 1275b411b363SPhilipp Reisner * @mdev: DRBD device. 1276b411b363SPhilipp Reisner * @w: work object. 1277b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1278b411b363SPhilipp Reisner */ 127900d56944SPhilipp Reisner int w_send_read_req(struct drbd_work *w, int cancel) 1280b411b363SPhilipp Reisner { 1281b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 128200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1283b411b363SPhilipp Reisner int ok; 1284b411b363SPhilipp Reisner 1285b411b363SPhilipp Reisner if (unlikely(cancel)) { 12868554df1cSAndreas Gruenbacher req_mod(req, SEND_CANCELED); 1287b411b363SPhilipp Reisner return 1; 1288b411b363SPhilipp Reisner } 1289b411b363SPhilipp Reisner 1290ace652acSAndreas Gruenbacher ok = drbd_send_drequest(mdev, P_DATA_REQUEST, req->i.sector, req->i.size, 1291b411b363SPhilipp Reisner (unsigned long)req); 1292b411b363SPhilipp Reisner 12938554df1cSAndreas Gruenbacher req_mod(req, ok ? HANDED_OVER_TO_NETWORK : SEND_FAILED); 1294b411b363SPhilipp Reisner 1295b411b363SPhilipp Reisner return ok; 1296b411b363SPhilipp Reisner } 1297b411b363SPhilipp Reisner 129800d56944SPhilipp Reisner int w_restart_disk_io(struct drbd_work *w, int cancel) 1299265be2d0SPhilipp Reisner { 1300265be2d0SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 130100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1302265be2d0SPhilipp Reisner 13030778286aSPhilipp Reisner if (bio_data_dir(req->master_bio) == WRITE && req->rq_state & RQ_IN_ACT_LOG) 1304ace652acSAndreas Gruenbacher drbd_al_begin_io(mdev, req->i.sector); 1305265be2d0SPhilipp Reisner /* Calling drbd_al_begin_io() out of the worker might deadlocks 1306265be2d0SPhilipp Reisner theoretically. Practically it can not deadlock, since this is 1307265be2d0SPhilipp Reisner only used when unfreezing IOs. All the extents of the requests 1308265be2d0SPhilipp Reisner that made it into the TL are already active */ 1309265be2d0SPhilipp Reisner 1310265be2d0SPhilipp Reisner drbd_req_make_private_bio(req, req->master_bio); 1311265be2d0SPhilipp Reisner req->private_bio->bi_bdev = mdev->ldev->backing_bdev; 1312265be2d0SPhilipp Reisner generic_make_request(req->private_bio); 1313265be2d0SPhilipp Reisner 1314265be2d0SPhilipp Reisner return 1; 1315265be2d0SPhilipp Reisner } 1316265be2d0SPhilipp Reisner 1317b411b363SPhilipp Reisner static int _drbd_may_sync_now(struct drbd_conf *mdev) 1318b411b363SPhilipp Reisner { 1319b411b363SPhilipp Reisner struct drbd_conf *odev = mdev; 1320b411b363SPhilipp Reisner 1321b411b363SPhilipp Reisner while (1) { 1322f399002eSLars Ellenberg if (odev->ldev->dc.resync_after == -1) 1323b411b363SPhilipp Reisner return 1; 1324f399002eSLars Ellenberg odev = minor_to_mdev(odev->ldev->dc.resync_after); 1325841ce241SAndreas Gruenbacher if (!expect(odev)) 1326841ce241SAndreas Gruenbacher return 1; 1327b411b363SPhilipp Reisner if ((odev->state.conn >= C_SYNC_SOURCE && 1328b411b363SPhilipp Reisner odev->state.conn <= C_PAUSED_SYNC_T) || 1329b411b363SPhilipp Reisner odev->state.aftr_isp || odev->state.peer_isp || 1330b411b363SPhilipp Reisner odev->state.user_isp) 1331b411b363SPhilipp Reisner return 0; 1332b411b363SPhilipp Reisner } 1333b411b363SPhilipp Reisner } 1334b411b363SPhilipp Reisner 1335b411b363SPhilipp Reisner /** 1336b411b363SPhilipp Reisner * _drbd_pause_after() - Pause resync on all devices that may not resync now 1337b411b363SPhilipp Reisner * @mdev: DRBD device. 1338b411b363SPhilipp Reisner * 1339b411b363SPhilipp Reisner * Called from process context only (admin command and after_state_ch). 1340b411b363SPhilipp Reisner */ 1341b411b363SPhilipp Reisner static int _drbd_pause_after(struct drbd_conf *mdev) 1342b411b363SPhilipp Reisner { 1343b411b363SPhilipp Reisner struct drbd_conf *odev; 1344b411b363SPhilipp Reisner int i, rv = 0; 1345b411b363SPhilipp Reisner 134681a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1347b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1348b411b363SPhilipp Reisner continue; 1349b411b363SPhilipp Reisner if (!_drbd_may_sync_now(odev)) 1350b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 1), CS_HARD, NULL) 1351b411b363SPhilipp Reisner != SS_NOTHING_TO_DO); 1352b411b363SPhilipp Reisner } 1353b411b363SPhilipp Reisner 1354b411b363SPhilipp Reisner return rv; 1355b411b363SPhilipp Reisner } 1356b411b363SPhilipp Reisner 1357b411b363SPhilipp Reisner /** 1358b411b363SPhilipp Reisner * _drbd_resume_next() - Resume resync on all devices that may resync now 1359b411b363SPhilipp Reisner * @mdev: DRBD device. 1360b411b363SPhilipp Reisner * 1361b411b363SPhilipp Reisner * Called from process context only (admin command and worker). 1362b411b363SPhilipp Reisner */ 1363b411b363SPhilipp Reisner static int _drbd_resume_next(struct drbd_conf *mdev) 1364b411b363SPhilipp Reisner { 1365b411b363SPhilipp Reisner struct drbd_conf *odev; 1366b411b363SPhilipp Reisner int i, rv = 0; 1367b411b363SPhilipp Reisner 136881a5d60eSPhilipp Reisner idr_for_each_entry(&minors, odev, i) { 1369b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1370b411b363SPhilipp Reisner continue; 1371b411b363SPhilipp Reisner if (odev->state.aftr_isp) { 1372b411b363SPhilipp Reisner if (_drbd_may_sync_now(odev)) 1373b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 0), 1374b411b363SPhilipp Reisner CS_HARD, NULL) 1375b411b363SPhilipp Reisner != SS_NOTHING_TO_DO) ; 1376b411b363SPhilipp Reisner } 1377b411b363SPhilipp Reisner } 1378b411b363SPhilipp Reisner return rv; 1379b411b363SPhilipp Reisner } 1380b411b363SPhilipp Reisner 1381b411b363SPhilipp Reisner void resume_next_sg(struct drbd_conf *mdev) 1382b411b363SPhilipp Reisner { 1383b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1384b411b363SPhilipp Reisner _drbd_resume_next(mdev); 1385b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1386b411b363SPhilipp Reisner } 1387b411b363SPhilipp Reisner 1388b411b363SPhilipp Reisner void suspend_other_sg(struct drbd_conf *mdev) 1389b411b363SPhilipp Reisner { 1390b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1391b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1392b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1393b411b363SPhilipp Reisner } 1394b411b363SPhilipp Reisner 1395b411b363SPhilipp Reisner static int sync_after_error(struct drbd_conf *mdev, int o_minor) 1396b411b363SPhilipp Reisner { 1397b411b363SPhilipp Reisner struct drbd_conf *odev; 1398b411b363SPhilipp Reisner 1399b411b363SPhilipp Reisner if (o_minor == -1) 1400b411b363SPhilipp Reisner return NO_ERROR; 1401b411b363SPhilipp Reisner if (o_minor < -1 || minor_to_mdev(o_minor) == NULL) 1402b411b363SPhilipp Reisner return ERR_SYNC_AFTER; 1403b411b363SPhilipp Reisner 1404b411b363SPhilipp Reisner /* check for loops */ 1405b411b363SPhilipp Reisner odev = minor_to_mdev(o_minor); 1406b411b363SPhilipp Reisner while (1) { 1407b411b363SPhilipp Reisner if (odev == mdev) 1408b411b363SPhilipp Reisner return ERR_SYNC_AFTER_CYCLE; 1409b411b363SPhilipp Reisner 1410b411b363SPhilipp Reisner /* dependency chain ends here, no cycles. */ 1411f399002eSLars Ellenberg if (odev->ldev->dc.resync_after == -1) 1412b411b363SPhilipp Reisner return NO_ERROR; 1413b411b363SPhilipp Reisner 1414b411b363SPhilipp Reisner /* follow the dependency chain */ 1415f399002eSLars Ellenberg odev = minor_to_mdev(odev->ldev->dc.resync_after); 1416b411b363SPhilipp Reisner } 1417b411b363SPhilipp Reisner } 1418b411b363SPhilipp Reisner 1419b411b363SPhilipp Reisner int drbd_alter_sa(struct drbd_conf *mdev, int na) 1420b411b363SPhilipp Reisner { 1421b411b363SPhilipp Reisner int changes; 1422b411b363SPhilipp Reisner int retcode; 1423b411b363SPhilipp Reisner 1424b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1425b411b363SPhilipp Reisner retcode = sync_after_error(mdev, na); 1426b411b363SPhilipp Reisner if (retcode == NO_ERROR) { 1427f399002eSLars Ellenberg mdev->ldev->dc.resync_after = na; 1428b411b363SPhilipp Reisner do { 1429b411b363SPhilipp Reisner changes = _drbd_pause_after(mdev); 1430b411b363SPhilipp Reisner changes |= _drbd_resume_next(mdev); 1431b411b363SPhilipp Reisner } while (changes); 1432b411b363SPhilipp Reisner } 1433b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1434b411b363SPhilipp Reisner return retcode; 1435b411b363SPhilipp Reisner } 1436b411b363SPhilipp Reisner 14379bd28d3cSLars Ellenberg void drbd_rs_controller_reset(struct drbd_conf *mdev) 14389bd28d3cSLars Ellenberg { 14399bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_in, 0); 14409bd28d3cSLars Ellenberg atomic_set(&mdev->rs_sect_ev, 0); 14419bd28d3cSLars Ellenberg mdev->rs_in_flight = 0; 14429bd28d3cSLars Ellenberg mdev->rs_planed = 0; 14439bd28d3cSLars Ellenberg spin_lock(&mdev->peer_seq_lock); 14449bd28d3cSLars Ellenberg fifo_set(&mdev->rs_plan_s, 0); 14459bd28d3cSLars Ellenberg spin_unlock(&mdev->peer_seq_lock); 14469bd28d3cSLars Ellenberg } 14479bd28d3cSLars Ellenberg 14481f04af33SPhilipp Reisner void start_resync_timer_fn(unsigned long data) 14491f04af33SPhilipp Reisner { 14501f04af33SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 14511f04af33SPhilipp Reisner 14521f04af33SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &mdev->start_resync_work); 14531f04af33SPhilipp Reisner } 14541f04af33SPhilipp Reisner 145500d56944SPhilipp Reisner int w_start_resync(struct drbd_work *w, int cancel) 14561f04af33SPhilipp Reisner { 145700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 145800d56944SPhilipp Reisner 14591f04af33SPhilipp Reisner if (atomic_read(&mdev->unacked_cnt) || atomic_read(&mdev->rs_pending_cnt)) { 14601f04af33SPhilipp Reisner dev_warn(DEV, "w_start_resync later...\n"); 14611f04af33SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/10; 14621f04af33SPhilipp Reisner add_timer(&mdev->start_resync_timer); 14631f04af33SPhilipp Reisner return 1; 14641f04af33SPhilipp Reisner } 14651f04af33SPhilipp Reisner 14661f04af33SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 14671f04af33SPhilipp Reisner clear_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags); 14681f04af33SPhilipp Reisner return 1; 14691f04af33SPhilipp Reisner } 14701f04af33SPhilipp Reisner 1471b411b363SPhilipp Reisner /** 1472b411b363SPhilipp Reisner * drbd_start_resync() - Start the resync process 1473b411b363SPhilipp Reisner * @mdev: DRBD device. 1474b411b363SPhilipp Reisner * @side: Either C_SYNC_SOURCE or C_SYNC_TARGET 1475b411b363SPhilipp Reisner * 1476b411b363SPhilipp Reisner * This function might bring you directly into one of the 1477b411b363SPhilipp Reisner * C_PAUSED_SYNC_* states. 1478b411b363SPhilipp Reisner */ 1479b411b363SPhilipp Reisner void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side) 1480b411b363SPhilipp Reisner { 1481b411b363SPhilipp Reisner union drbd_state ns; 1482b411b363SPhilipp Reisner int r; 1483b411b363SPhilipp Reisner 1484c4752ef1SPhilipp Reisner if (mdev->state.conn >= C_SYNC_SOURCE && mdev->state.conn < C_AHEAD) { 1485b411b363SPhilipp Reisner dev_err(DEV, "Resync already running!\n"); 1486b411b363SPhilipp Reisner return; 1487b411b363SPhilipp Reisner } 1488b411b363SPhilipp Reisner 148959817f4fSPhilipp Reisner if (mdev->state.conn < C_AHEAD) { 1490b411b363SPhilipp Reisner /* In case a previous resync run was aborted by an IO error/detach on the peer. */ 1491b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 149259817f4fSPhilipp Reisner /* This should be done when we abort the resync. We definitely do not 149359817f4fSPhilipp Reisner want to have this for connections going back and forth between 149459817f4fSPhilipp Reisner Ahead/Behind and SyncSource/SyncTarget */ 149559817f4fSPhilipp Reisner } 1496b411b363SPhilipp Reisner 1497e64a3294SPhilipp Reisner if (!test_bit(B_RS_H_DONE, &mdev->flags)) { 1498b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1499b411b363SPhilipp Reisner /* Since application IO was locked out during C_WF_BITMAP_T and 1500b411b363SPhilipp Reisner C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET 1501b411b363SPhilipp Reisner we check that we might make the data inconsistent. */ 1502b411b363SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-target"); 1503b411b363SPhilipp Reisner r = (r >> 8) & 0xff; 1504b411b363SPhilipp Reisner if (r > 0) { 1505b411b363SPhilipp Reisner dev_info(DEV, "before-resync-target handler returned %d, " 1506b411b363SPhilipp Reisner "dropping connection.\n", r); 150738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 1508b411b363SPhilipp Reisner return; 1509b411b363SPhilipp Reisner } 151009b9e797SPhilipp Reisner } else /* C_SYNC_SOURCE */ { 151109b9e797SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-source"); 151209b9e797SPhilipp Reisner r = (r >> 8) & 0xff; 151309b9e797SPhilipp Reisner if (r > 0) { 151409b9e797SPhilipp Reisner if (r == 3) { 151509b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 151609b9e797SPhilipp Reisner "ignoring. Old userland tools?", r); 151709b9e797SPhilipp Reisner } else { 151809b9e797SPhilipp Reisner dev_info(DEV, "before-resync-source handler returned %d, " 151909b9e797SPhilipp Reisner "dropping connection.\n", r); 152038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 152109b9e797SPhilipp Reisner return; 152209b9e797SPhilipp Reisner } 152309b9e797SPhilipp Reisner } 1524b411b363SPhilipp Reisner } 1525e64a3294SPhilipp Reisner } 1526b411b363SPhilipp Reisner 1527e64a3294SPhilipp Reisner if (current == mdev->tconn->worker.task) { 1528dad20554SPhilipp Reisner /* The worker should not sleep waiting for state_mutex, 1529e64a3294SPhilipp Reisner that can take long */ 15308410da8fSPhilipp Reisner if (!mutex_trylock(mdev->state_mutex)) { 1531e64a3294SPhilipp Reisner set_bit(B_RS_H_DONE, &mdev->flags); 1532e64a3294SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ/5; 1533e64a3294SPhilipp Reisner add_timer(&mdev->start_resync_timer); 1534e64a3294SPhilipp Reisner return; 1535e64a3294SPhilipp Reisner } 1536e64a3294SPhilipp Reisner } else { 15378410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 1538e64a3294SPhilipp Reisner } 1539e64a3294SPhilipp Reisner clear_bit(B_RS_H_DONE, &mdev->flags); 1540b411b363SPhilipp Reisner 1541b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_NEGOTIATING)) { 15428410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1543b411b363SPhilipp Reisner return; 1544b411b363SPhilipp Reisner } 1545b411b363SPhilipp Reisner 1546b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1547b411b363SPhilipp Reisner ns = mdev->state; 1548b411b363SPhilipp Reisner 1549b411b363SPhilipp Reisner ns.aftr_isp = !_drbd_may_sync_now(mdev); 1550b411b363SPhilipp Reisner 1551b411b363SPhilipp Reisner ns.conn = side; 1552b411b363SPhilipp Reisner 1553b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) 1554b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 1555b411b363SPhilipp Reisner else /* side == C_SYNC_SOURCE */ 1556b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 1557b411b363SPhilipp Reisner 1558b411b363SPhilipp Reisner r = __drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 1559b411b363SPhilipp Reisner ns = mdev->state; 1560b411b363SPhilipp Reisner 1561b411b363SPhilipp Reisner if (ns.conn < C_CONNECTED) 1562b411b363SPhilipp Reisner r = SS_UNKNOWN_ERROR; 1563b411b363SPhilipp Reisner 1564b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 15651d7734a0SLars Ellenberg unsigned long tw = drbd_bm_total_weight(mdev); 15661d7734a0SLars Ellenberg unsigned long now = jiffies; 15671d7734a0SLars Ellenberg int i; 15681d7734a0SLars Ellenberg 1569b411b363SPhilipp Reisner mdev->rs_failed = 0; 1570b411b363SPhilipp Reisner mdev->rs_paused = 0; 1571b411b363SPhilipp Reisner mdev->rs_same_csum = 0; 15720f0601f4SLars Ellenberg mdev->rs_last_events = 0; 15730f0601f4SLars Ellenberg mdev->rs_last_sect_ev = 0; 15741d7734a0SLars Ellenberg mdev->rs_total = tw; 15751d7734a0SLars Ellenberg mdev->rs_start = now; 15761d7734a0SLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 15771d7734a0SLars Ellenberg mdev->rs_mark_left[i] = tw; 15781d7734a0SLars Ellenberg mdev->rs_mark_time[i] = now; 15791d7734a0SLars Ellenberg } 1580b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1581b411b363SPhilipp Reisner } 1582b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 15835a22db89SLars Ellenberg 15846c922ed5SLars Ellenberg if (r == SS_SUCCESS) { 15856c922ed5SLars Ellenberg dev_info(DEV, "Began resync as %s (will sync %lu KB [%lu bits set]).\n", 15866c922ed5SLars Ellenberg drbd_conn_str(ns.conn), 15876c922ed5SLars Ellenberg (unsigned long) mdev->rs_total << (BM_BLOCK_SHIFT-10), 15886c922ed5SLars Ellenberg (unsigned long) mdev->rs_total); 15895a22db89SLars Ellenberg if (side == C_SYNC_TARGET) 15905a22db89SLars Ellenberg mdev->bm_resync_fo = 0; 15915a22db89SLars Ellenberg 15925a22db89SLars Ellenberg /* Since protocol 96, we must serialize drbd_gen_and_send_sync_uuid 15935a22db89SLars Ellenberg * with w_send_oos, or the sync target will get confused as to 15945a22db89SLars Ellenberg * how much bits to resync. We cannot do that always, because for an 15955a22db89SLars Ellenberg * empty resync and protocol < 95, we need to do it here, as we call 15965a22db89SLars Ellenberg * drbd_resync_finished from here in that case. 15975a22db89SLars Ellenberg * We drbd_gen_and_send_sync_uuid here for protocol < 96, 15985a22db89SLars Ellenberg * and from after_state_ch otherwise. */ 159931890f4aSPhilipp Reisner if (side == C_SYNC_SOURCE && mdev->tconn->agreed_pro_version < 96) 16005a22db89SLars Ellenberg drbd_gen_and_send_sync_uuid(mdev); 1601b411b363SPhilipp Reisner 160231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 95 && mdev->rs_total == 0) { 1603af85e8e8SLars Ellenberg /* This still has a race (about when exactly the peers 1604af85e8e8SLars Ellenberg * detect connection loss) that can lead to a full sync 1605af85e8e8SLars Ellenberg * on next handshake. In 8.3.9 we fixed this with explicit 1606af85e8e8SLars Ellenberg * resync-finished notifications, but the fix 1607af85e8e8SLars Ellenberg * introduces a protocol change. Sleeping for some 1608af85e8e8SLars Ellenberg * time longer than the ping interval + timeout on the 1609af85e8e8SLars Ellenberg * SyncSource, to give the SyncTarget the chance to 1610af85e8e8SLars Ellenberg * detect connection loss, then waiting for a ping 1611af85e8e8SLars Ellenberg * response (implicit in drbd_resync_finished) reduces 1612af85e8e8SLars Ellenberg * the race considerably, but does not solve it. */ 1613af85e8e8SLars Ellenberg if (side == C_SYNC_SOURCE) 1614af85e8e8SLars Ellenberg schedule_timeout_interruptible( 161589e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_int * HZ + 161689e58e75SPhilipp Reisner mdev->tconn->net_conf->ping_timeo*HZ/9); 1617b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1618b411b363SPhilipp Reisner } 1619b411b363SPhilipp Reisner 16209bd28d3cSLars Ellenberg drbd_rs_controller_reset(mdev); 1621b411b363SPhilipp Reisner /* ns.conn may already be != mdev->state.conn, 1622b411b363SPhilipp Reisner * we may have been paused in between, or become paused until 1623b411b363SPhilipp Reisner * the timer triggers. 1624b411b363SPhilipp Reisner * No matter, that is handled in resync_timer_fn() */ 1625b411b363SPhilipp Reisner if (ns.conn == C_SYNC_TARGET) 1626b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies); 1627b411b363SPhilipp Reisner 1628b411b363SPhilipp Reisner drbd_md_sync(mdev); 1629b411b363SPhilipp Reisner } 16305a22db89SLars Ellenberg put_ldev(mdev); 16318410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 1632b411b363SPhilipp Reisner } 1633b411b363SPhilipp Reisner 1634b411b363SPhilipp Reisner int drbd_worker(struct drbd_thread *thi) 1635b411b363SPhilipp Reisner { 1636392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 1637b411b363SPhilipp Reisner struct drbd_work *w = NULL; 16380e29d163SPhilipp Reisner struct drbd_conf *mdev; 1639b411b363SPhilipp Reisner LIST_HEAD(work_list); 1640f399002eSLars Ellenberg int vnr, intr = 0; 1641b411b363SPhilipp Reisner 1642e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 164380822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 1644b411b363SPhilipp Reisner 164519393e10SPhilipp Reisner if (down_trylock(&tconn->data.work.s)) { 164619393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 164719393e10SPhilipp Reisner if (tconn->data.socket && !tconn->net_conf->no_cork) 164819393e10SPhilipp Reisner drbd_tcp_uncork(tconn->data.socket); 164919393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1650b411b363SPhilipp Reisner 165119393e10SPhilipp Reisner intr = down_interruptible(&tconn->data.work.s); 1652b411b363SPhilipp Reisner 165319393e10SPhilipp Reisner mutex_lock(&tconn->data.mutex); 165419393e10SPhilipp Reisner if (tconn->data.socket && !tconn->net_conf->no_cork) 165519393e10SPhilipp Reisner drbd_tcp_cork(tconn->data.socket); 165619393e10SPhilipp Reisner mutex_unlock(&tconn->data.mutex); 1657b411b363SPhilipp Reisner } 1658b411b363SPhilipp Reisner 1659b411b363SPhilipp Reisner if (intr) { 1660b411b363SPhilipp Reisner flush_signals(current); 166119393e10SPhilipp Reisner if (get_t_state(thi) == RUNNING) { 166219393e10SPhilipp Reisner conn_warn(tconn, "Worker got an unexpected signal\n"); 1663b411b363SPhilipp Reisner continue; 166419393e10SPhilipp Reisner } 1665b411b363SPhilipp Reisner break; 1666b411b363SPhilipp Reisner } 1667b411b363SPhilipp Reisner 1668e77a0a5cSAndreas Gruenbacher if (get_t_state(thi) != RUNNING) 1669b411b363SPhilipp Reisner break; 1670b411b363SPhilipp Reisner /* With this break, we have done a down() but not consumed 1671b411b363SPhilipp Reisner the entry from the list. The cleanup code takes care of 1672b411b363SPhilipp Reisner this... */ 1673b411b363SPhilipp Reisner 1674b411b363SPhilipp Reisner w = NULL; 167519393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 167619393e10SPhilipp Reisner if (list_empty(&tconn->data.work.q)) { 1677b411b363SPhilipp Reisner /* something terribly wrong in our logic. 1678b411b363SPhilipp Reisner * we were able to down() the semaphore, 1679b411b363SPhilipp Reisner * but the list is empty... doh. 1680b411b363SPhilipp Reisner * 1681b411b363SPhilipp Reisner * what is the best thing to do now? 1682b411b363SPhilipp Reisner * try again from scratch, restarting the receiver, 1683b411b363SPhilipp Reisner * asender, whatnot? could break even more ugly, 1684b411b363SPhilipp Reisner * e.g. when we are primary, but no good local data. 1685b411b363SPhilipp Reisner * 1686b411b363SPhilipp Reisner * I'll try to get away just starting over this loop. 1687b411b363SPhilipp Reisner */ 168819393e10SPhilipp Reisner conn_warn(tconn, "Work list unexpectedly empty\n"); 168919393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1690b411b363SPhilipp Reisner continue; 1691b411b363SPhilipp Reisner } 169219393e10SPhilipp Reisner w = list_entry(tconn->data.work.q.next, struct drbd_work, list); 1693b411b363SPhilipp Reisner list_del_init(&w->list); 169419393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1695b411b363SPhilipp Reisner 1696bbeb641cSPhilipp Reisner if (!w->cb(w, tconn->cstate < C_WF_REPORT_PARAMS)) { 1697b411b363SPhilipp Reisner /* dev_warn(DEV, "worker: a callback failed! \n"); */ 1698bbeb641cSPhilipp Reisner if (tconn->cstate >= C_WF_REPORT_PARAMS) 1699bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 1700b411b363SPhilipp Reisner } 1701b411b363SPhilipp Reisner } 1702b411b363SPhilipp Reisner 170319393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 170419393e10SPhilipp Reisner while (!list_empty(&tconn->data.work.q)) { 170519393e10SPhilipp Reisner list_splice_init(&tconn->data.work.q, &work_list); 170619393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1707b411b363SPhilipp Reisner 1708b411b363SPhilipp Reisner while (!list_empty(&work_list)) { 1709b411b363SPhilipp Reisner w = list_entry(work_list.next, struct drbd_work, list); 1710b411b363SPhilipp Reisner list_del_init(&w->list); 171100d56944SPhilipp Reisner w->cb(w, 1); 1712b411b363SPhilipp Reisner } 1713b411b363SPhilipp Reisner 171419393e10SPhilipp Reisner spin_lock_irq(&tconn->data.work.q_lock); 1715b411b363SPhilipp Reisner } 171619393e10SPhilipp Reisner sema_init(&tconn->data.work.s, 0); 1717b411b363SPhilipp Reisner /* DANGEROUS race: if someone did queue his work within the spinlock, 1718b411b363SPhilipp Reisner * but up() ed outside the spinlock, we could get an up() on the 1719b411b363SPhilipp Reisner * semaphore without corresponding list entry. 1720b411b363SPhilipp Reisner * So don't do that. 1721b411b363SPhilipp Reisner */ 172219393e10SPhilipp Reisner spin_unlock_irq(&tconn->data.work.q_lock); 1723b411b363SPhilipp Reisner 17240e29d163SPhilipp Reisner drbd_thread_stop(&tconn->receiver); 1725f399002eSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 17260e29d163SPhilipp Reisner D_ASSERT(mdev->state.disk == D_DISKLESS && mdev->state.conn == C_STANDALONE); 17270e29d163SPhilipp Reisner /* _drbd_set_state only uses stop_nowait. 17280e29d163SPhilipp Reisner * wait here for the exiting receiver. */ 17290e29d163SPhilipp Reisner drbd_mdev_cleanup(mdev); 17300e29d163SPhilipp Reisner } 17310e29d163SPhilipp Reisner clear_bit(OBJECT_DYING, &tconn->flags); 17320e29d163SPhilipp Reisner clear_bit(CONFIG_PENDING, &tconn->flags); 17330e29d163SPhilipp Reisner wake_up(&tconn->ping_wait); 1734b411b363SPhilipp Reisner 1735b411b363SPhilipp Reisner return 0; 1736b411b363SPhilipp Reisner } 1737