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/autoconf.h> 27b411b363SPhilipp Reisner #include <linux/module.h> 28b411b363SPhilipp Reisner #include <linux/version.h> 29b411b363SPhilipp Reisner #include <linux/drbd.h> 30b411b363SPhilipp Reisner #include <linux/sched.h> 31b411b363SPhilipp Reisner #include <linux/smp_lock.h> 32b411b363SPhilipp Reisner #include <linux/wait.h> 33b411b363SPhilipp Reisner #include <linux/mm.h> 34b411b363SPhilipp Reisner #include <linux/memcontrol.h> 35b411b363SPhilipp Reisner #include <linux/mm_inline.h> 36b411b363SPhilipp Reisner #include <linux/slab.h> 37b411b363SPhilipp Reisner #include <linux/random.h> 38b411b363SPhilipp Reisner #include <linux/mm.h> 39b411b363SPhilipp Reisner #include <linux/string.h> 40b411b363SPhilipp Reisner #include <linux/scatterlist.h> 41b411b363SPhilipp Reisner 42b411b363SPhilipp Reisner #include "drbd_int.h" 43b411b363SPhilipp Reisner #include "drbd_req.h" 44b411b363SPhilipp Reisner #include "drbd_tracing.h" 45b411b363SPhilipp Reisner 46b411b363SPhilipp Reisner #define SLEEP_TIME (HZ/10) 47b411b363SPhilipp Reisner 48b411b363SPhilipp Reisner static int w_make_ov_request(struct drbd_conf *mdev, struct drbd_work *w, int cancel); 49b411b363SPhilipp Reisner 50b411b363SPhilipp Reisner 51b411b363SPhilipp Reisner 52b411b363SPhilipp Reisner /* defined here: 53b411b363SPhilipp Reisner drbd_md_io_complete 54b411b363SPhilipp Reisner drbd_endio_write_sec 55b411b363SPhilipp Reisner drbd_endio_read_sec 56b411b363SPhilipp Reisner drbd_endio_pri 57b411b363SPhilipp Reisner 58b411b363SPhilipp Reisner * more endio handlers: 59b411b363SPhilipp Reisner atodb_endio in drbd_actlog.c 60b411b363SPhilipp Reisner drbd_bm_async_io_complete in drbd_bitmap.c 61b411b363SPhilipp Reisner 62b411b363SPhilipp Reisner * For all these callbacks, note the following: 63b411b363SPhilipp Reisner * The callbacks will be called in irq context by the IDE drivers, 64b411b363SPhilipp Reisner * and in Softirqs/Tasklets/BH context by the SCSI drivers. 65b411b363SPhilipp Reisner * Try to get the locking right :) 66b411b363SPhilipp Reisner * 67b411b363SPhilipp Reisner */ 68b411b363SPhilipp Reisner 69b411b363SPhilipp Reisner 70b411b363SPhilipp Reisner /* About the global_state_lock 71b411b363SPhilipp Reisner Each state transition on an device holds a read lock. In case we have 72b411b363SPhilipp Reisner to evaluate the sync after dependencies, we grab a write lock, because 73b411b363SPhilipp Reisner we need stable states on all devices for that. */ 74b411b363SPhilipp Reisner rwlock_t global_state_lock; 75b411b363SPhilipp Reisner 76b411b363SPhilipp Reisner /* used for synchronous meta data and bitmap IO 77b411b363SPhilipp Reisner * submitted by drbd_md_sync_page_io() 78b411b363SPhilipp Reisner */ 79b411b363SPhilipp Reisner void drbd_md_io_complete(struct bio *bio, int error) 80b411b363SPhilipp Reisner { 81b411b363SPhilipp Reisner struct drbd_md_io *md_io; 82b411b363SPhilipp Reisner 83b411b363SPhilipp Reisner md_io = (struct drbd_md_io *)bio->bi_private; 84b411b363SPhilipp Reisner md_io->error = error; 85b411b363SPhilipp Reisner 86b411b363SPhilipp Reisner trace_drbd_bio(md_io->mdev, "Md", bio, 1, NULL); 87b411b363SPhilipp Reisner 88b411b363SPhilipp Reisner complete(&md_io->event); 89b411b363SPhilipp Reisner } 90b411b363SPhilipp Reisner 91b411b363SPhilipp Reisner /* reads on behalf of the partner, 92b411b363SPhilipp Reisner * "submitted" by the receiver 93b411b363SPhilipp Reisner */ 94b411b363SPhilipp Reisner void drbd_endio_read_sec(struct bio *bio, int error) __releases(local) 95b411b363SPhilipp Reisner { 96b411b363SPhilipp Reisner unsigned long flags = 0; 97b411b363SPhilipp Reisner struct drbd_epoch_entry *e = NULL; 98b411b363SPhilipp Reisner struct drbd_conf *mdev; 99b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 100b411b363SPhilipp Reisner 101b411b363SPhilipp Reisner e = bio->bi_private; 102b411b363SPhilipp Reisner mdev = e->mdev; 103b411b363SPhilipp Reisner 104b411b363SPhilipp Reisner if (error) 105b411b363SPhilipp Reisner dev_warn(DEV, "read: error=%d s=%llus\n", error, 106b411b363SPhilipp Reisner (unsigned long long)e->sector); 107b411b363SPhilipp Reisner if (!error && !uptodate) { 108b411b363SPhilipp Reisner dev_warn(DEV, "read: setting error to -EIO s=%llus\n", 109b411b363SPhilipp Reisner (unsigned long long)e->sector); 110b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 111b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 112b411b363SPhilipp Reisner * but do not return any error?! */ 113b411b363SPhilipp Reisner error = -EIO; 114b411b363SPhilipp Reisner } 115b411b363SPhilipp Reisner 116b411b363SPhilipp Reisner D_ASSERT(e->block_id != ID_VACANT); 117b411b363SPhilipp Reisner 118b411b363SPhilipp Reisner trace_drbd_bio(mdev, "Sec", bio, 1, NULL); 119b411b363SPhilipp Reisner 120b411b363SPhilipp Reisner spin_lock_irqsave(&mdev->req_lock, flags); 121b411b363SPhilipp Reisner mdev->read_cnt += e->size >> 9; 122b411b363SPhilipp Reisner list_del(&e->w.list); 123b411b363SPhilipp Reisner if (list_empty(&mdev->read_ee)) 124b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 125b411b363SPhilipp Reisner spin_unlock_irqrestore(&mdev->req_lock, flags); 126b411b363SPhilipp Reisner 127b411b363SPhilipp Reisner drbd_chk_io_error(mdev, error, FALSE); 128b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &e->w); 129b411b363SPhilipp Reisner put_ldev(mdev); 130b411b363SPhilipp Reisner 131b411b363SPhilipp Reisner trace_drbd_ee(mdev, e, "read completed"); 132b411b363SPhilipp Reisner } 133b411b363SPhilipp Reisner 134b411b363SPhilipp Reisner /* writes on behalf of the partner, or resync writes, 135b411b363SPhilipp Reisner * "submitted" by the receiver. 136b411b363SPhilipp Reisner */ 137b411b363SPhilipp Reisner void drbd_endio_write_sec(struct bio *bio, int error) __releases(local) 138b411b363SPhilipp Reisner { 139b411b363SPhilipp Reisner unsigned long flags = 0; 140b411b363SPhilipp Reisner struct drbd_epoch_entry *e = NULL; 141b411b363SPhilipp Reisner struct drbd_conf *mdev; 142b411b363SPhilipp Reisner sector_t e_sector; 143b411b363SPhilipp Reisner int do_wake; 144b411b363SPhilipp Reisner int is_syncer_req; 145b411b363SPhilipp Reisner int do_al_complete_io; 146b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 147b411b363SPhilipp Reisner int is_barrier = bio_rw_flagged(bio, BIO_RW_BARRIER); 148b411b363SPhilipp Reisner 149b411b363SPhilipp Reisner e = bio->bi_private; 150b411b363SPhilipp Reisner mdev = e->mdev; 151b411b363SPhilipp Reisner 152b411b363SPhilipp Reisner if (error) 153b411b363SPhilipp Reisner dev_warn(DEV, "write: error=%d s=%llus\n", error, 154b411b363SPhilipp Reisner (unsigned long long)e->sector); 155b411b363SPhilipp Reisner if (!error && !uptodate) { 156b411b363SPhilipp Reisner dev_warn(DEV, "write: setting error to -EIO s=%llus\n", 157b411b363SPhilipp Reisner (unsigned long long)e->sector); 158b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 159b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 160b411b363SPhilipp Reisner * but do not return any error?! */ 161b411b363SPhilipp Reisner error = -EIO; 162b411b363SPhilipp Reisner } 163b411b363SPhilipp Reisner 164b411b363SPhilipp Reisner /* error == -ENOTSUPP would be a better test, 165b411b363SPhilipp Reisner * alas it is not reliable */ 166b411b363SPhilipp Reisner if (error && is_barrier && e->flags & EE_IS_BARRIER) { 167b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_bdev_flush); 168b411b363SPhilipp Reisner spin_lock_irqsave(&mdev->req_lock, flags); 169b411b363SPhilipp Reisner list_del(&e->w.list); 170b411b363SPhilipp Reisner e->w.cb = w_e_reissue; 171b411b363SPhilipp Reisner /* put_ldev actually happens below, once we come here again. */ 172b411b363SPhilipp Reisner __release(local); 173b411b363SPhilipp Reisner spin_unlock_irqrestore(&mdev->req_lock, flags); 174b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &e->w); 175b411b363SPhilipp Reisner return; 176b411b363SPhilipp Reisner } 177b411b363SPhilipp Reisner 178b411b363SPhilipp Reisner D_ASSERT(e->block_id != ID_VACANT); 179b411b363SPhilipp Reisner 180b411b363SPhilipp Reisner trace_drbd_bio(mdev, "Sec", bio, 1, NULL); 181b411b363SPhilipp Reisner 182b411b363SPhilipp Reisner spin_lock_irqsave(&mdev->req_lock, flags); 183b411b363SPhilipp Reisner mdev->writ_cnt += e->size >> 9; 184b411b363SPhilipp Reisner is_syncer_req = is_syncer_block_id(e->block_id); 185b411b363SPhilipp Reisner 186b411b363SPhilipp Reisner /* after we moved e to done_ee, 187b411b363SPhilipp Reisner * we may no longer access it, 188b411b363SPhilipp Reisner * it may be freed/reused already! 189b411b363SPhilipp Reisner * (as soon as we release the req_lock) */ 190b411b363SPhilipp Reisner e_sector = e->sector; 191b411b363SPhilipp Reisner do_al_complete_io = e->flags & EE_CALL_AL_COMPLETE_IO; 192b411b363SPhilipp Reisner 193b411b363SPhilipp Reisner list_del(&e->w.list); /* has been on active_ee or sync_ee */ 194b411b363SPhilipp Reisner list_add_tail(&e->w.list, &mdev->done_ee); 195b411b363SPhilipp Reisner 196b411b363SPhilipp Reisner trace_drbd_ee(mdev, e, "write completed"); 197b411b363SPhilipp Reisner 198b411b363SPhilipp Reisner /* No hlist_del_init(&e->colision) here, we did not send the Ack yet, 199b411b363SPhilipp Reisner * neither did we wake possibly waiting conflicting requests. 200b411b363SPhilipp Reisner * done from "drbd_process_done_ee" within the appropriate w.cb 201b411b363SPhilipp Reisner * (e_end_block/e_end_resync_block) or from _drbd_clear_done_ee */ 202b411b363SPhilipp Reisner 203b411b363SPhilipp Reisner do_wake = is_syncer_req 204b411b363SPhilipp Reisner ? list_empty(&mdev->sync_ee) 205b411b363SPhilipp Reisner : list_empty(&mdev->active_ee); 206b411b363SPhilipp Reisner 207b411b363SPhilipp Reisner if (error) 208b411b363SPhilipp Reisner __drbd_chk_io_error(mdev, FALSE); 209b411b363SPhilipp Reisner spin_unlock_irqrestore(&mdev->req_lock, flags); 210b411b363SPhilipp Reisner 211b411b363SPhilipp Reisner if (is_syncer_req) 212b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, e_sector); 213b411b363SPhilipp Reisner 214b411b363SPhilipp Reisner if (do_wake) 215b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 216b411b363SPhilipp Reisner 217b411b363SPhilipp Reisner if (do_al_complete_io) 218b411b363SPhilipp Reisner drbd_al_complete_io(mdev, e_sector); 219b411b363SPhilipp Reisner 220b411b363SPhilipp Reisner wake_asender(mdev); 221b411b363SPhilipp Reisner put_ldev(mdev); 222b411b363SPhilipp Reisner 223b411b363SPhilipp Reisner } 224b411b363SPhilipp Reisner 225b411b363SPhilipp Reisner /* read, readA or write requests on R_PRIMARY coming from drbd_make_request 226b411b363SPhilipp Reisner */ 227b411b363SPhilipp Reisner void drbd_endio_pri(struct bio *bio, int error) 228b411b363SPhilipp Reisner { 229b411b363SPhilipp Reisner unsigned long flags; 230b411b363SPhilipp Reisner struct drbd_request *req = bio->bi_private; 231b411b363SPhilipp Reisner struct drbd_conf *mdev = req->mdev; 232b411b363SPhilipp Reisner struct bio_and_error m; 233b411b363SPhilipp Reisner enum drbd_req_event what; 234b411b363SPhilipp Reisner int uptodate = bio_flagged(bio, BIO_UPTODATE); 235b411b363SPhilipp Reisner 236b411b363SPhilipp Reisner if (error) 237b411b363SPhilipp Reisner dev_warn(DEV, "p %s: error=%d\n", 238b411b363SPhilipp Reisner bio_data_dir(bio) == WRITE ? "write" : "read", error); 239b411b363SPhilipp Reisner if (!error && !uptodate) { 240b411b363SPhilipp Reisner dev_warn(DEV, "p %s: setting error to -EIO\n", 241b411b363SPhilipp Reisner bio_data_dir(bio) == WRITE ? "write" : "read"); 242b411b363SPhilipp Reisner /* strange behavior of some lower level drivers... 243b411b363SPhilipp Reisner * fail the request by clearing the uptodate flag, 244b411b363SPhilipp Reisner * but do not return any error?! */ 245b411b363SPhilipp Reisner error = -EIO; 246b411b363SPhilipp Reisner } 247b411b363SPhilipp Reisner 248b411b363SPhilipp Reisner trace_drbd_bio(mdev, "Pri", bio, 1, NULL); 249b411b363SPhilipp Reisner 250b411b363SPhilipp Reisner /* to avoid recursion in __req_mod */ 251b411b363SPhilipp Reisner if (unlikely(error)) { 252b411b363SPhilipp Reisner what = (bio_data_dir(bio) == WRITE) 253b411b363SPhilipp Reisner ? write_completed_with_error 254b411b363SPhilipp Reisner : (bio_rw(bio) == READA) 255b411b363SPhilipp Reisner ? read_completed_with_error 256b411b363SPhilipp Reisner : read_ahead_completed_with_error; 257b411b363SPhilipp Reisner } else 258b411b363SPhilipp Reisner what = completed_ok; 259b411b363SPhilipp Reisner 260b411b363SPhilipp Reisner bio_put(req->private_bio); 261b411b363SPhilipp Reisner req->private_bio = ERR_PTR(error); 262b411b363SPhilipp Reisner 263b411b363SPhilipp Reisner spin_lock_irqsave(&mdev->req_lock, flags); 264b411b363SPhilipp Reisner __req_mod(req, what, &m); 265b411b363SPhilipp Reisner spin_unlock_irqrestore(&mdev->req_lock, flags); 266b411b363SPhilipp Reisner 267b411b363SPhilipp Reisner if (m.bio) 268b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 269b411b363SPhilipp Reisner } 270b411b363SPhilipp Reisner 271b411b363SPhilipp Reisner int w_io_error(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 272b411b363SPhilipp Reisner { 273b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 274b411b363SPhilipp Reisner 275b411b363SPhilipp Reisner /* NOTE: mdev->ldev can be NULL by the time we get here! */ 276b411b363SPhilipp Reisner /* D_ASSERT(mdev->ldev->dc.on_io_error != EP_PASS_ON); */ 277b411b363SPhilipp Reisner 278b411b363SPhilipp Reisner /* the only way this callback is scheduled is from _req_may_be_done, 279b411b363SPhilipp Reisner * when it is done and had a local write error, see comments there */ 280b411b363SPhilipp Reisner drbd_req_free(req); 281b411b363SPhilipp Reisner 282b411b363SPhilipp Reisner return TRUE; 283b411b363SPhilipp Reisner } 284b411b363SPhilipp Reisner 285b411b363SPhilipp Reisner int w_read_retry_remote(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 286b411b363SPhilipp Reisner { 287b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 288b411b363SPhilipp Reisner 289b411b363SPhilipp Reisner /* We should not detach for read io-error, 290b411b363SPhilipp Reisner * but try to WRITE the P_DATA_REPLY to the failed location, 291b411b363SPhilipp Reisner * to give the disk the chance to relocate that block */ 292b411b363SPhilipp Reisner 293b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 294b411b363SPhilipp Reisner if (cancel || 295b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 296b411b363SPhilipp Reisner mdev->state.pdsk <= D_INCONSISTENT) { 297b411b363SPhilipp Reisner _req_mod(req, send_canceled); 298b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 299b411b363SPhilipp Reisner dev_alert(DEV, "WE ARE LOST. Local IO failure, no peer.\n"); 300b411b363SPhilipp Reisner return 1; 301b411b363SPhilipp Reisner } 302b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 303b411b363SPhilipp Reisner 304b411b363SPhilipp Reisner return w_send_read_req(mdev, w, 0); 305b411b363SPhilipp Reisner } 306b411b363SPhilipp Reisner 307b411b363SPhilipp Reisner int w_resync_inactive(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 308b411b363SPhilipp Reisner { 309b411b363SPhilipp Reisner ERR_IF(cancel) return 1; 310b411b363SPhilipp Reisner dev_err(DEV, "resync inactive, but callback triggered??\n"); 311b411b363SPhilipp Reisner return 1; /* Simply ignore this! */ 312b411b363SPhilipp Reisner } 313b411b363SPhilipp Reisner 314b411b363SPhilipp Reisner void drbd_csum(struct drbd_conf *mdev, struct crypto_hash *tfm, struct bio *bio, void *digest) 315b411b363SPhilipp Reisner { 316b411b363SPhilipp Reisner struct hash_desc desc; 317b411b363SPhilipp Reisner struct scatterlist sg; 318b411b363SPhilipp Reisner struct bio_vec *bvec; 319b411b363SPhilipp Reisner int i; 320b411b363SPhilipp Reisner 321b411b363SPhilipp Reisner desc.tfm = tfm; 322b411b363SPhilipp Reisner desc.flags = 0; 323b411b363SPhilipp Reisner 324b411b363SPhilipp Reisner sg_init_table(&sg, 1); 325b411b363SPhilipp Reisner crypto_hash_init(&desc); 326b411b363SPhilipp Reisner 327b411b363SPhilipp Reisner __bio_for_each_segment(bvec, bio, i, 0) { 328b411b363SPhilipp Reisner sg_set_page(&sg, bvec->bv_page, bvec->bv_len, bvec->bv_offset); 329b411b363SPhilipp Reisner crypto_hash_update(&desc, &sg, sg.length); 330b411b363SPhilipp Reisner } 331b411b363SPhilipp Reisner crypto_hash_final(&desc, digest); 332b411b363SPhilipp Reisner } 333b411b363SPhilipp Reisner 334b411b363SPhilipp Reisner static int w_e_send_csum(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 335b411b363SPhilipp Reisner { 336b411b363SPhilipp Reisner struct drbd_epoch_entry *e = container_of(w, struct drbd_epoch_entry, w); 337b411b363SPhilipp Reisner int digest_size; 338b411b363SPhilipp Reisner void *digest; 339b411b363SPhilipp Reisner int ok; 340b411b363SPhilipp Reisner 341b411b363SPhilipp Reisner D_ASSERT(e->block_id == DRBD_MAGIC + 0xbeef); 342b411b363SPhilipp Reisner 343b411b363SPhilipp Reisner if (unlikely(cancel)) { 344b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 345b411b363SPhilipp Reisner return 1; 346b411b363SPhilipp Reisner } 347b411b363SPhilipp Reisner 348b411b363SPhilipp Reisner if (likely(drbd_bio_uptodate(e->private_bio))) { 349b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->csums_tfm); 350b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 351b411b363SPhilipp Reisner if (digest) { 352b411b363SPhilipp Reisner drbd_csum(mdev, mdev->csums_tfm, e->private_bio, digest); 353b411b363SPhilipp Reisner 354b411b363SPhilipp Reisner inc_rs_pending(mdev); 355b411b363SPhilipp Reisner ok = drbd_send_drequest_csum(mdev, 356b411b363SPhilipp Reisner e->sector, 357b411b363SPhilipp Reisner e->size, 358b411b363SPhilipp Reisner digest, 359b411b363SPhilipp Reisner digest_size, 360b411b363SPhilipp Reisner P_CSUM_RS_REQUEST); 361b411b363SPhilipp Reisner kfree(digest); 362b411b363SPhilipp Reisner } else { 363b411b363SPhilipp Reisner dev_err(DEV, "kmalloc() of digest failed.\n"); 364b411b363SPhilipp Reisner ok = 0; 365b411b363SPhilipp Reisner } 366b411b363SPhilipp Reisner } else 367b411b363SPhilipp Reisner ok = 1; 368b411b363SPhilipp Reisner 369b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 370b411b363SPhilipp Reisner 371b411b363SPhilipp Reisner if (unlikely(!ok)) 372b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest(..., csum) failed\n"); 373b411b363SPhilipp Reisner return ok; 374b411b363SPhilipp Reisner } 375b411b363SPhilipp Reisner 376b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 377b411b363SPhilipp Reisner 378b411b363SPhilipp Reisner static int read_for_csum(struct drbd_conf *mdev, sector_t sector, int size) 379b411b363SPhilipp Reisner { 380b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 381b411b363SPhilipp Reisner 382b411b363SPhilipp Reisner if (!get_ldev(mdev)) 383b411b363SPhilipp Reisner return 0; 384b411b363SPhilipp Reisner 385b411b363SPhilipp Reisner /* GFP_TRY, because if there is no memory available right now, this may 386b411b363SPhilipp Reisner * be rescheduled for later. It is "only" background resync, after all. */ 387b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, DRBD_MAGIC+0xbeef, sector, size, GFP_TRY); 388b411b363SPhilipp Reisner if (!e) { 389b411b363SPhilipp Reisner put_ldev(mdev); 390b411b363SPhilipp Reisner return 2; 391b411b363SPhilipp Reisner } 392b411b363SPhilipp Reisner 393b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 394b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->read_ee); 395b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 396b411b363SPhilipp Reisner 397b411b363SPhilipp Reisner e->private_bio->bi_end_io = drbd_endio_read_sec; 398b411b363SPhilipp Reisner e->private_bio->bi_rw = READ; 399b411b363SPhilipp Reisner e->w.cb = w_e_send_csum; 400b411b363SPhilipp Reisner 401b411b363SPhilipp Reisner mdev->read_cnt += size >> 9; 402b411b363SPhilipp Reisner drbd_generic_make_request(mdev, DRBD_FAULT_RS_RD, e->private_bio); 403b411b363SPhilipp Reisner 404b411b363SPhilipp Reisner return 1; 405b411b363SPhilipp Reisner } 406b411b363SPhilipp Reisner 407b411b363SPhilipp Reisner void resync_timer_fn(unsigned long data) 408b411b363SPhilipp Reisner { 409b411b363SPhilipp Reisner unsigned long flags; 410b411b363SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *) data; 411b411b363SPhilipp Reisner int queue; 412b411b363SPhilipp Reisner 413b411b363SPhilipp Reisner spin_lock_irqsave(&mdev->req_lock, flags); 414b411b363SPhilipp Reisner 415b411b363SPhilipp Reisner if (likely(!test_and_clear_bit(STOP_SYNC_TIMER, &mdev->flags))) { 416b411b363SPhilipp Reisner queue = 1; 417b411b363SPhilipp Reisner if (mdev->state.conn == C_VERIFY_S) 418b411b363SPhilipp Reisner mdev->resync_work.cb = w_make_ov_request; 419b411b363SPhilipp Reisner else 420b411b363SPhilipp Reisner mdev->resync_work.cb = w_make_resync_request; 421b411b363SPhilipp Reisner } else { 422b411b363SPhilipp Reisner queue = 0; 423b411b363SPhilipp Reisner mdev->resync_work.cb = w_resync_inactive; 424b411b363SPhilipp Reisner } 425b411b363SPhilipp Reisner 426b411b363SPhilipp Reisner spin_unlock_irqrestore(&mdev->req_lock, flags); 427b411b363SPhilipp Reisner 428b411b363SPhilipp Reisner /* harmless race: list_empty outside data.work.q_lock */ 429b411b363SPhilipp Reisner if (list_empty(&mdev->resync_work.list) && queue) 430b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &mdev->resync_work); 431b411b363SPhilipp Reisner } 432b411b363SPhilipp Reisner 433b411b363SPhilipp Reisner int w_make_resync_request(struct drbd_conf *mdev, 434b411b363SPhilipp Reisner struct drbd_work *w, int cancel) 435b411b363SPhilipp Reisner { 436b411b363SPhilipp Reisner unsigned long bit; 437b411b363SPhilipp Reisner sector_t sector; 438b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 439b411b363SPhilipp Reisner int max_segment_size = queue_max_segment_size(mdev->rq_queue); 440b411b363SPhilipp Reisner int number, i, size, pe, mx; 441b411b363SPhilipp Reisner int align, queued, sndbuf; 442b411b363SPhilipp Reisner 443b411b363SPhilipp Reisner if (unlikely(cancel)) 444b411b363SPhilipp Reisner return 1; 445b411b363SPhilipp Reisner 446b411b363SPhilipp Reisner if (unlikely(mdev->state.conn < C_CONNECTED)) { 447b411b363SPhilipp Reisner dev_err(DEV, "Confused in w_make_resync_request()! cstate < Connected"); 448b411b363SPhilipp Reisner return 0; 449b411b363SPhilipp Reisner } 450b411b363SPhilipp Reisner 451b411b363SPhilipp Reisner if (mdev->state.conn != C_SYNC_TARGET) 452b411b363SPhilipp Reisner dev_err(DEV, "%s in w_make_resync_request\n", 453b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 454b411b363SPhilipp Reisner 455b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 456b411b363SPhilipp Reisner /* Since we only need to access mdev->rsync a 457b411b363SPhilipp Reisner get_ldev_if_state(mdev,D_FAILED) would be sufficient, but 458b411b363SPhilipp Reisner to continue resync with a broken disk makes no sense at 459b411b363SPhilipp Reisner all */ 460b411b363SPhilipp Reisner dev_err(DEV, "Disk broke down during resync!\n"); 461b411b363SPhilipp Reisner mdev->resync_work.cb = w_resync_inactive; 462b411b363SPhilipp Reisner return 1; 463b411b363SPhilipp Reisner } 464b411b363SPhilipp Reisner 465b411b363SPhilipp Reisner number = SLEEP_TIME * mdev->sync_conf.rate / ((BM_BLOCK_SIZE/1024)*HZ); 466b411b363SPhilipp Reisner pe = atomic_read(&mdev->rs_pending_cnt); 467b411b363SPhilipp Reisner 468b411b363SPhilipp Reisner mutex_lock(&mdev->data.mutex); 469b411b363SPhilipp Reisner if (mdev->data.socket) 470b411b363SPhilipp Reisner mx = mdev->data.socket->sk->sk_rcvbuf / sizeof(struct p_block_req); 471b411b363SPhilipp Reisner else 472b411b363SPhilipp Reisner mx = 1; 473b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 474b411b363SPhilipp Reisner 475b411b363SPhilipp Reisner /* For resync rates >160MB/sec, allow more pending RS requests */ 476b411b363SPhilipp Reisner if (number > mx) 477b411b363SPhilipp Reisner mx = number; 478b411b363SPhilipp Reisner 479b411b363SPhilipp Reisner /* Limit the number of pending RS requests to no more than the peer's receive buffer */ 480b411b363SPhilipp Reisner if ((pe + number) > mx) { 481b411b363SPhilipp Reisner number = mx - pe; 482b411b363SPhilipp Reisner } 483b411b363SPhilipp Reisner 484b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 485b411b363SPhilipp Reisner /* Stop generating RS requests, when half of the send buffer is filled */ 486b411b363SPhilipp Reisner mutex_lock(&mdev->data.mutex); 487b411b363SPhilipp Reisner if (mdev->data.socket) { 488b411b363SPhilipp Reisner queued = mdev->data.socket->sk->sk_wmem_queued; 489b411b363SPhilipp Reisner sndbuf = mdev->data.socket->sk->sk_sndbuf; 490b411b363SPhilipp Reisner } else { 491b411b363SPhilipp Reisner queued = 1; 492b411b363SPhilipp Reisner sndbuf = 0; 493b411b363SPhilipp Reisner } 494b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 495b411b363SPhilipp Reisner if (queued > sndbuf / 2) 496b411b363SPhilipp Reisner goto requeue; 497b411b363SPhilipp Reisner 498b411b363SPhilipp Reisner next_sector: 499b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 500b411b363SPhilipp Reisner bit = drbd_bm_find_next(mdev, mdev->bm_resync_fo); 501b411b363SPhilipp Reisner 502b411b363SPhilipp Reisner if (bit == -1UL) { 503b411b363SPhilipp Reisner mdev->bm_resync_fo = drbd_bm_bits(mdev); 504b411b363SPhilipp Reisner mdev->resync_work.cb = w_resync_inactive; 505b411b363SPhilipp Reisner put_ldev(mdev); 506b411b363SPhilipp Reisner return 1; 507b411b363SPhilipp Reisner } 508b411b363SPhilipp Reisner 509b411b363SPhilipp Reisner sector = BM_BIT_TO_SECT(bit); 510b411b363SPhilipp Reisner 511b411b363SPhilipp Reisner if (drbd_try_rs_begin_io(mdev, sector)) { 512b411b363SPhilipp Reisner mdev->bm_resync_fo = bit; 513b411b363SPhilipp Reisner goto requeue; 514b411b363SPhilipp Reisner } 515b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 516b411b363SPhilipp Reisner 517b411b363SPhilipp Reisner if (unlikely(drbd_bm_test_bit(mdev, bit) == 0)) { 518b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 519b411b363SPhilipp Reisner goto next_sector; 520b411b363SPhilipp Reisner } 521b411b363SPhilipp Reisner 522b411b363SPhilipp Reisner #if DRBD_MAX_SEGMENT_SIZE > BM_BLOCK_SIZE 523b411b363SPhilipp Reisner /* try to find some adjacent bits. 524b411b363SPhilipp Reisner * we stop if we have already the maximum req size. 525b411b363SPhilipp Reisner * 526b411b363SPhilipp Reisner * Additionally always align bigger requests, in order to 527b411b363SPhilipp Reisner * be prepared for all stripe sizes of software RAIDs. 528b411b363SPhilipp Reisner * 529b411b363SPhilipp Reisner * we _do_ care about the agreed-upon q->max_segment_size 530b411b363SPhilipp Reisner * here, as splitting up the requests on the other side is more 531b411b363SPhilipp Reisner * difficult. the consequence is, that on lvm and md and other 532b411b363SPhilipp Reisner * "indirect" devices, this is dead code, since 533b411b363SPhilipp Reisner * q->max_segment_size will be PAGE_SIZE. 534b411b363SPhilipp Reisner */ 535b411b363SPhilipp Reisner align = 1; 536b411b363SPhilipp Reisner for (;;) { 537b411b363SPhilipp Reisner if (size + BM_BLOCK_SIZE > max_segment_size) 538b411b363SPhilipp Reisner break; 539b411b363SPhilipp Reisner 540b411b363SPhilipp Reisner /* Be always aligned */ 541b411b363SPhilipp Reisner if (sector & ((1<<(align+3))-1)) 542b411b363SPhilipp Reisner break; 543b411b363SPhilipp Reisner 544b411b363SPhilipp Reisner /* do not cross extent boundaries */ 545b411b363SPhilipp Reisner if (((bit+1) & BM_BLOCKS_PER_BM_EXT_MASK) == 0) 546b411b363SPhilipp Reisner break; 547b411b363SPhilipp Reisner /* now, is it actually dirty, after all? 548b411b363SPhilipp Reisner * caution, drbd_bm_test_bit is tri-state for some 549b411b363SPhilipp Reisner * obscure reason; ( b == 0 ) would get the out-of-band 550b411b363SPhilipp Reisner * only accidentally right because of the "oddly sized" 551b411b363SPhilipp Reisner * adjustment below */ 552b411b363SPhilipp Reisner if (drbd_bm_test_bit(mdev, bit+1) != 1) 553b411b363SPhilipp Reisner break; 554b411b363SPhilipp Reisner bit++; 555b411b363SPhilipp Reisner size += BM_BLOCK_SIZE; 556b411b363SPhilipp Reisner if ((BM_BLOCK_SIZE << align) <= size) 557b411b363SPhilipp Reisner align++; 558b411b363SPhilipp Reisner i++; 559b411b363SPhilipp Reisner } 560b411b363SPhilipp Reisner /* if we merged some, 561b411b363SPhilipp Reisner * reset the offset to start the next drbd_bm_find_next from */ 562b411b363SPhilipp Reisner if (size > BM_BLOCK_SIZE) 563b411b363SPhilipp Reisner mdev->bm_resync_fo = bit + 1; 564b411b363SPhilipp Reisner #endif 565b411b363SPhilipp Reisner 566b411b363SPhilipp Reisner /* adjust very last sectors, in case we are oddly sized */ 567b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 568b411b363SPhilipp Reisner size = (capacity-sector)<<9; 569b411b363SPhilipp Reisner if (mdev->agreed_pro_version >= 89 && mdev->csums_tfm) { 570b411b363SPhilipp Reisner switch (read_for_csum(mdev, sector, size)) { 571b411b363SPhilipp Reisner case 0: /* Disk failure*/ 572b411b363SPhilipp Reisner put_ldev(mdev); 573b411b363SPhilipp Reisner return 0; 574b411b363SPhilipp Reisner case 2: /* Allocation failed */ 575b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 576b411b363SPhilipp Reisner mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 577b411b363SPhilipp Reisner goto requeue; 578b411b363SPhilipp Reisner /* case 1: everything ok */ 579b411b363SPhilipp Reisner } 580b411b363SPhilipp Reisner } else { 581b411b363SPhilipp Reisner inc_rs_pending(mdev); 582b411b363SPhilipp Reisner if (!drbd_send_drequest(mdev, P_RS_DATA_REQUEST, 583b411b363SPhilipp Reisner sector, size, ID_SYNCER)) { 584b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_drequest() failed, aborting...\n"); 585b411b363SPhilipp Reisner dec_rs_pending(mdev); 586b411b363SPhilipp Reisner put_ldev(mdev); 587b411b363SPhilipp Reisner return 0; 588b411b363SPhilipp Reisner } 589b411b363SPhilipp Reisner } 590b411b363SPhilipp Reisner } 591b411b363SPhilipp Reisner 592b411b363SPhilipp Reisner if (mdev->bm_resync_fo >= drbd_bm_bits(mdev)) { 593b411b363SPhilipp Reisner /* last syncer _request_ was sent, 594b411b363SPhilipp Reisner * but the P_RS_DATA_REPLY not yet received. sync will end (and 595b411b363SPhilipp Reisner * next sync group will resume), as soon as we receive the last 596b411b363SPhilipp Reisner * resync data block, and the last bit is cleared. 597b411b363SPhilipp Reisner * until then resync "work" is "inactive" ... 598b411b363SPhilipp Reisner */ 599b411b363SPhilipp Reisner mdev->resync_work.cb = w_resync_inactive; 600b411b363SPhilipp Reisner put_ldev(mdev); 601b411b363SPhilipp Reisner return 1; 602b411b363SPhilipp Reisner } 603b411b363SPhilipp Reisner 604b411b363SPhilipp Reisner requeue: 605b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 606b411b363SPhilipp Reisner put_ldev(mdev); 607b411b363SPhilipp Reisner return 1; 608b411b363SPhilipp Reisner } 609b411b363SPhilipp Reisner 610b411b363SPhilipp Reisner static int w_make_ov_request(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 611b411b363SPhilipp Reisner { 612b411b363SPhilipp Reisner int number, i, size; 613b411b363SPhilipp Reisner sector_t sector; 614b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 615b411b363SPhilipp Reisner 616b411b363SPhilipp Reisner if (unlikely(cancel)) 617b411b363SPhilipp Reisner return 1; 618b411b363SPhilipp Reisner 619b411b363SPhilipp Reisner if (unlikely(mdev->state.conn < C_CONNECTED)) { 620b411b363SPhilipp Reisner dev_err(DEV, "Confused in w_make_ov_request()! cstate < Connected"); 621b411b363SPhilipp Reisner return 0; 622b411b363SPhilipp Reisner } 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner number = SLEEP_TIME*mdev->sync_conf.rate / ((BM_BLOCK_SIZE/1024)*HZ); 625b411b363SPhilipp Reisner if (atomic_read(&mdev->rs_pending_cnt) > number) 626b411b363SPhilipp Reisner goto requeue; 627b411b363SPhilipp Reisner 628b411b363SPhilipp Reisner number -= atomic_read(&mdev->rs_pending_cnt); 629b411b363SPhilipp Reisner 630b411b363SPhilipp Reisner sector = mdev->ov_position; 631b411b363SPhilipp Reisner for (i = 0; i < number; i++) { 632b411b363SPhilipp Reisner if (sector >= capacity) { 633b411b363SPhilipp Reisner mdev->resync_work.cb = w_resync_inactive; 634b411b363SPhilipp Reisner return 1; 635b411b363SPhilipp Reisner } 636b411b363SPhilipp Reisner 637b411b363SPhilipp Reisner size = BM_BLOCK_SIZE; 638b411b363SPhilipp Reisner 639b411b363SPhilipp Reisner if (drbd_try_rs_begin_io(mdev, sector)) { 640b411b363SPhilipp Reisner mdev->ov_position = sector; 641b411b363SPhilipp Reisner goto requeue; 642b411b363SPhilipp Reisner } 643b411b363SPhilipp Reisner 644b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) 645b411b363SPhilipp Reisner size = (capacity-sector)<<9; 646b411b363SPhilipp Reisner 647b411b363SPhilipp Reisner inc_rs_pending(mdev); 648b411b363SPhilipp Reisner if (!drbd_send_ov_request(mdev, sector, size)) { 649b411b363SPhilipp Reisner dec_rs_pending(mdev); 650b411b363SPhilipp Reisner return 0; 651b411b363SPhilipp Reisner } 652b411b363SPhilipp Reisner sector += BM_SECT_PER_BIT; 653b411b363SPhilipp Reisner } 654b411b363SPhilipp Reisner mdev->ov_position = sector; 655b411b363SPhilipp Reisner 656b411b363SPhilipp Reisner requeue: 657b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies + SLEEP_TIME); 658b411b363SPhilipp Reisner return 1; 659b411b363SPhilipp Reisner } 660b411b363SPhilipp Reisner 661b411b363SPhilipp Reisner 662b411b363SPhilipp Reisner int w_ov_finished(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 663b411b363SPhilipp Reisner { 664b411b363SPhilipp Reisner kfree(w); 665b411b363SPhilipp Reisner ov_oos_print(mdev); 666b411b363SPhilipp Reisner drbd_resync_finished(mdev); 667b411b363SPhilipp Reisner 668b411b363SPhilipp Reisner return 1; 669b411b363SPhilipp Reisner } 670b411b363SPhilipp Reisner 671b411b363SPhilipp Reisner static int w_resync_finished(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 672b411b363SPhilipp Reisner { 673b411b363SPhilipp Reisner kfree(w); 674b411b363SPhilipp Reisner 675b411b363SPhilipp Reisner drbd_resync_finished(mdev); 676b411b363SPhilipp Reisner 677b411b363SPhilipp Reisner return 1; 678b411b363SPhilipp Reisner } 679b411b363SPhilipp Reisner 680b411b363SPhilipp Reisner int drbd_resync_finished(struct drbd_conf *mdev) 681b411b363SPhilipp Reisner { 682b411b363SPhilipp Reisner unsigned long db, dt, dbdt; 683b411b363SPhilipp Reisner unsigned long n_oos; 684b411b363SPhilipp Reisner union drbd_state os, ns; 685b411b363SPhilipp Reisner struct drbd_work *w; 686b411b363SPhilipp Reisner char *khelper_cmd = NULL; 687b411b363SPhilipp Reisner 688b411b363SPhilipp Reisner /* Remove all elements from the resync LRU. Since future actions 689b411b363SPhilipp Reisner * might set bits in the (main) bitmap, then the entries in the 690b411b363SPhilipp Reisner * resync LRU would be wrong. */ 691b411b363SPhilipp Reisner if (drbd_rs_del_all(mdev)) { 692b411b363SPhilipp Reisner /* In case this is not possible now, most probably because 693b411b363SPhilipp Reisner * there are P_RS_DATA_REPLY Packets lingering on the worker's 694b411b363SPhilipp Reisner * queue (or even the read operations for those packets 695b411b363SPhilipp Reisner * is not finished by now). Retry in 100ms. */ 696b411b363SPhilipp Reisner 697b411b363SPhilipp Reisner drbd_kick_lo(mdev); 698b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 699b411b363SPhilipp Reisner schedule_timeout(HZ / 10); 700b411b363SPhilipp Reisner w = kmalloc(sizeof(struct drbd_work), GFP_ATOMIC); 701b411b363SPhilipp Reisner if (w) { 702b411b363SPhilipp Reisner w->cb = w_resync_finished; 703b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, w); 704b411b363SPhilipp Reisner return 1; 705b411b363SPhilipp Reisner } 706b411b363SPhilipp Reisner dev_err(DEV, "Warn failed to drbd_rs_del_all() and to kmalloc(w).\n"); 707b411b363SPhilipp Reisner } 708b411b363SPhilipp Reisner 709b411b363SPhilipp Reisner dt = (jiffies - mdev->rs_start - mdev->rs_paused) / HZ; 710b411b363SPhilipp Reisner if (dt <= 0) 711b411b363SPhilipp Reisner dt = 1; 712b411b363SPhilipp Reisner db = mdev->rs_total; 713b411b363SPhilipp Reisner dbdt = Bit2KB(db/dt); 714b411b363SPhilipp Reisner mdev->rs_paused /= HZ; 715b411b363SPhilipp Reisner 716b411b363SPhilipp Reisner if (!get_ldev(mdev)) 717b411b363SPhilipp Reisner goto out; 718b411b363SPhilipp Reisner 719b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 720b411b363SPhilipp Reisner os = mdev->state; 721b411b363SPhilipp Reisner 722b411b363SPhilipp Reisner /* This protects us against multiple calls (that can happen in the presence 723b411b363SPhilipp Reisner of application IO), and against connectivity loss just before we arrive here. */ 724b411b363SPhilipp Reisner if (os.conn <= C_CONNECTED) 725b411b363SPhilipp Reisner goto out_unlock; 726b411b363SPhilipp Reisner 727b411b363SPhilipp Reisner ns = os; 728b411b363SPhilipp Reisner ns.conn = C_CONNECTED; 729b411b363SPhilipp Reisner 730b411b363SPhilipp Reisner dev_info(DEV, "%s done (total %lu sec; paused %lu sec; %lu K/sec)\n", 731b411b363SPhilipp Reisner (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) ? 732b411b363SPhilipp Reisner "Online verify " : "Resync", 733b411b363SPhilipp Reisner dt + mdev->rs_paused, mdev->rs_paused, dbdt); 734b411b363SPhilipp Reisner 735b411b363SPhilipp Reisner n_oos = drbd_bm_total_weight(mdev); 736b411b363SPhilipp Reisner 737b411b363SPhilipp Reisner if (os.conn == C_VERIFY_S || os.conn == C_VERIFY_T) { 738b411b363SPhilipp Reisner if (n_oos) { 739b411b363SPhilipp Reisner dev_alert(DEV, "Online verify found %lu %dk block out of sync!\n", 740b411b363SPhilipp Reisner n_oos, Bit2KB(1)); 741b411b363SPhilipp Reisner khelper_cmd = "out-of-sync"; 742b411b363SPhilipp Reisner } 743b411b363SPhilipp Reisner } else { 744b411b363SPhilipp Reisner D_ASSERT((n_oos - mdev->rs_failed) == 0); 745b411b363SPhilipp Reisner 746b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) 747b411b363SPhilipp Reisner khelper_cmd = "after-resync-target"; 748b411b363SPhilipp Reisner 749b411b363SPhilipp Reisner if (mdev->csums_tfm && mdev->rs_total) { 750b411b363SPhilipp Reisner const unsigned long s = mdev->rs_same_csum; 751b411b363SPhilipp Reisner const unsigned long t = mdev->rs_total; 752b411b363SPhilipp Reisner const int ratio = 753b411b363SPhilipp Reisner (t == 0) ? 0 : 754b411b363SPhilipp Reisner (t < 100000) ? ((s*100)/t) : (s/(t/100)); 755b411b363SPhilipp Reisner dev_info(DEV, "%u %% had equal check sums, eliminated: %luK; " 756b411b363SPhilipp Reisner "transferred %luK total %luK\n", 757b411b363SPhilipp Reisner ratio, 758b411b363SPhilipp Reisner Bit2KB(mdev->rs_same_csum), 759b411b363SPhilipp Reisner Bit2KB(mdev->rs_total - mdev->rs_same_csum), 760b411b363SPhilipp Reisner Bit2KB(mdev->rs_total)); 761b411b363SPhilipp Reisner } 762b411b363SPhilipp Reisner } 763b411b363SPhilipp Reisner 764b411b363SPhilipp Reisner if (mdev->rs_failed) { 765b411b363SPhilipp Reisner dev_info(DEV, " %lu failed blocks\n", mdev->rs_failed); 766b411b363SPhilipp Reisner 767b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 768b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 769b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 770b411b363SPhilipp Reisner } else { 771b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 772b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 773b411b363SPhilipp Reisner } 774b411b363SPhilipp Reisner } else { 775b411b363SPhilipp Reisner ns.disk = D_UP_TO_DATE; 776b411b363SPhilipp Reisner ns.pdsk = D_UP_TO_DATE; 777b411b363SPhilipp Reisner 778b411b363SPhilipp Reisner if (os.conn == C_SYNC_TARGET || os.conn == C_PAUSED_SYNC_T) { 779b411b363SPhilipp Reisner if (mdev->p_uuid) { 780b411b363SPhilipp Reisner int i; 781b411b363SPhilipp Reisner for (i = UI_BITMAP ; i <= UI_HISTORY_END ; i++) 782b411b363SPhilipp Reisner _drbd_uuid_set(mdev, i, mdev->p_uuid[i]); 783b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_CURRENT]); 784b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, mdev->p_uuid[UI_CURRENT]); 785b411b363SPhilipp Reisner } else { 786b411b363SPhilipp Reisner dev_err(DEV, "mdev->p_uuid is NULL! BUG\n"); 787b411b363SPhilipp Reisner } 788b411b363SPhilipp Reisner } 789b411b363SPhilipp Reisner 790b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 791b411b363SPhilipp Reisner 792b411b363SPhilipp Reisner if (mdev->p_uuid) { 793b411b363SPhilipp Reisner /* Now the two UUID sets are equal, update what we 794b411b363SPhilipp Reisner * know of the peer. */ 795b411b363SPhilipp Reisner int i; 796b411b363SPhilipp Reisner for (i = UI_CURRENT ; i <= UI_HISTORY_END ; i++) 797b411b363SPhilipp Reisner mdev->p_uuid[i] = mdev->ldev->md.uuid[i]; 798b411b363SPhilipp Reisner } 799b411b363SPhilipp Reisner } 800b411b363SPhilipp Reisner 801b411b363SPhilipp Reisner _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 802b411b363SPhilipp Reisner out_unlock: 803b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 804b411b363SPhilipp Reisner put_ldev(mdev); 805b411b363SPhilipp Reisner out: 806b411b363SPhilipp Reisner mdev->rs_total = 0; 807b411b363SPhilipp Reisner mdev->rs_failed = 0; 808b411b363SPhilipp Reisner mdev->rs_paused = 0; 809b411b363SPhilipp Reisner mdev->ov_start_sector = 0; 810b411b363SPhilipp Reisner 811b411b363SPhilipp Reisner if (test_and_clear_bit(WRITE_BM_AFTER_RESYNC, &mdev->flags)) { 812b411b363SPhilipp Reisner dev_warn(DEV, "Writing the whole bitmap, due to failed kmalloc\n"); 813b411b363SPhilipp Reisner drbd_queue_bitmap_io(mdev, &drbd_bm_write, NULL, "write from resync_finished"); 814b411b363SPhilipp Reisner } 815b411b363SPhilipp Reisner 816b411b363SPhilipp Reisner if (khelper_cmd) 817b411b363SPhilipp Reisner drbd_khelper(mdev, khelper_cmd); 818b411b363SPhilipp Reisner 819b411b363SPhilipp Reisner return 1; 820b411b363SPhilipp Reisner } 821b411b363SPhilipp Reisner 822b411b363SPhilipp Reisner /* helper */ 823b411b363SPhilipp Reisner static void move_to_net_ee_or_free(struct drbd_conf *mdev, struct drbd_epoch_entry *e) 824b411b363SPhilipp Reisner { 825b411b363SPhilipp Reisner if (drbd_bio_has_active_page(e->private_bio)) { 826b411b363SPhilipp Reisner /* This might happen if sendpage() has not finished */ 827b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 828b411b363SPhilipp Reisner list_add_tail(&e->w.list, &mdev->net_ee); 829b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 830b411b363SPhilipp Reisner } else 831b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 832b411b363SPhilipp Reisner } 833b411b363SPhilipp Reisner 834b411b363SPhilipp Reisner /** 835b411b363SPhilipp Reisner * w_e_end_data_req() - Worker callback, to send a P_DATA_REPLY packet in response to a P_DATA_REQUEST 836b411b363SPhilipp Reisner * @mdev: DRBD device. 837b411b363SPhilipp Reisner * @w: work object. 838b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 839b411b363SPhilipp Reisner */ 840b411b363SPhilipp Reisner int w_e_end_data_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 841b411b363SPhilipp Reisner { 842b411b363SPhilipp Reisner struct drbd_epoch_entry *e = container_of(w, struct drbd_epoch_entry, w); 843b411b363SPhilipp Reisner int ok; 844b411b363SPhilipp Reisner 845b411b363SPhilipp Reisner if (unlikely(cancel)) { 846b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 847b411b363SPhilipp Reisner dec_unacked(mdev); 848b411b363SPhilipp Reisner return 1; 849b411b363SPhilipp Reisner } 850b411b363SPhilipp Reisner 851b411b363SPhilipp Reisner if (likely(drbd_bio_uptodate(e->private_bio))) { 852b411b363SPhilipp Reisner ok = drbd_send_block(mdev, P_DATA_REPLY, e); 853b411b363SPhilipp Reisner } else { 854b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 855b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. sector=%llus.\n", 856b411b363SPhilipp Reisner (unsigned long long)e->sector); 857b411b363SPhilipp Reisner 858b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_DREPLY, e); 859b411b363SPhilipp Reisner } 860b411b363SPhilipp Reisner 861b411b363SPhilipp Reisner dec_unacked(mdev); 862b411b363SPhilipp Reisner 863b411b363SPhilipp Reisner move_to_net_ee_or_free(mdev, e); 864b411b363SPhilipp Reisner 865b411b363SPhilipp Reisner if (unlikely(!ok)) 866b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 867b411b363SPhilipp Reisner return ok; 868b411b363SPhilipp Reisner } 869b411b363SPhilipp Reisner 870b411b363SPhilipp Reisner /** 871b411b363SPhilipp Reisner * w_e_end_rsdata_req() - Worker callback to send a P_RS_DATA_REPLY packet in response to a P_RS_DATA_REQUESTRS 872b411b363SPhilipp Reisner * @mdev: DRBD device. 873b411b363SPhilipp Reisner * @w: work object. 874b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 875b411b363SPhilipp Reisner */ 876b411b363SPhilipp Reisner int w_e_end_rsdata_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 877b411b363SPhilipp Reisner { 878b411b363SPhilipp Reisner struct drbd_epoch_entry *e = container_of(w, struct drbd_epoch_entry, w); 879b411b363SPhilipp Reisner int ok; 880b411b363SPhilipp Reisner 881b411b363SPhilipp Reisner if (unlikely(cancel)) { 882b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 883b411b363SPhilipp Reisner dec_unacked(mdev); 884b411b363SPhilipp Reisner return 1; 885b411b363SPhilipp Reisner } 886b411b363SPhilipp Reisner 887b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 888b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, e->sector); 889b411b363SPhilipp Reisner put_ldev(mdev); 890b411b363SPhilipp Reisner } 891b411b363SPhilipp Reisner 892b411b363SPhilipp Reisner if (likely(drbd_bio_uptodate(e->private_bio))) { 893b411b363SPhilipp Reisner if (likely(mdev->state.pdsk >= D_INCONSISTENT)) { 894b411b363SPhilipp Reisner inc_rs_pending(mdev); 895b411b363SPhilipp Reisner ok = drbd_send_block(mdev, P_RS_DATA_REPLY, e); 896b411b363SPhilipp Reisner } else { 897b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 898b411b363SPhilipp Reisner dev_err(DEV, "Not sending RSDataReply, " 899b411b363SPhilipp Reisner "partner DISKLESS!\n"); 900b411b363SPhilipp Reisner ok = 1; 901b411b363SPhilipp Reisner } 902b411b363SPhilipp Reisner } else { 903b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 904b411b363SPhilipp Reisner dev_err(DEV, "Sending NegRSDReply. sector %llus.\n", 905b411b363SPhilipp Reisner (unsigned long long)e->sector); 906b411b363SPhilipp Reisner 907b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_RS_DREPLY, e); 908b411b363SPhilipp Reisner 909b411b363SPhilipp Reisner /* update resync data with failure */ 910b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, e->sector, e->size); 911b411b363SPhilipp Reisner } 912b411b363SPhilipp Reisner 913b411b363SPhilipp Reisner dec_unacked(mdev); 914b411b363SPhilipp Reisner 915b411b363SPhilipp Reisner move_to_net_ee_or_free(mdev, e); 916b411b363SPhilipp Reisner 917b411b363SPhilipp Reisner if (unlikely(!ok)) 918b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block() failed\n"); 919b411b363SPhilipp Reisner return ok; 920b411b363SPhilipp Reisner } 921b411b363SPhilipp Reisner 922b411b363SPhilipp Reisner int w_e_end_csum_rs_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 923b411b363SPhilipp Reisner { 924b411b363SPhilipp Reisner struct drbd_epoch_entry *e = container_of(w, struct drbd_epoch_entry, w); 925b411b363SPhilipp Reisner struct digest_info *di; 926b411b363SPhilipp Reisner int digest_size; 927b411b363SPhilipp Reisner void *digest = NULL; 928b411b363SPhilipp Reisner int ok, eq = 0; 929b411b363SPhilipp Reisner 930b411b363SPhilipp Reisner if (unlikely(cancel)) { 931b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 932b411b363SPhilipp Reisner dec_unacked(mdev); 933b411b363SPhilipp Reisner return 1; 934b411b363SPhilipp Reisner } 935b411b363SPhilipp Reisner 936b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, e->sector); 937b411b363SPhilipp Reisner 938b411b363SPhilipp Reisner di = (struct digest_info *)(unsigned long)e->block_id; 939b411b363SPhilipp Reisner 940b411b363SPhilipp Reisner if (likely(drbd_bio_uptodate(e->private_bio))) { 941b411b363SPhilipp Reisner /* quick hack to try to avoid a race against reconfiguration. 942b411b363SPhilipp Reisner * a real fix would be much more involved, 943b411b363SPhilipp Reisner * introducing more locking mechanisms */ 944b411b363SPhilipp Reisner if (mdev->csums_tfm) { 945b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->csums_tfm); 946b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 947b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 948b411b363SPhilipp Reisner } 949b411b363SPhilipp Reisner if (digest) { 950b411b363SPhilipp Reisner drbd_csum(mdev, mdev->csums_tfm, e->private_bio, digest); 951b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 952b411b363SPhilipp Reisner kfree(digest); 953b411b363SPhilipp Reisner } 954b411b363SPhilipp Reisner 955b411b363SPhilipp Reisner if (eq) { 956b411b363SPhilipp Reisner drbd_set_in_sync(mdev, e->sector, e->size); 957b411b363SPhilipp Reisner mdev->rs_same_csum++; 958b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_RS_IS_IN_SYNC, e); 959b411b363SPhilipp Reisner } else { 960b411b363SPhilipp Reisner inc_rs_pending(mdev); 961b411b363SPhilipp Reisner e->block_id = ID_SYNCER; 962b411b363SPhilipp Reisner ok = drbd_send_block(mdev, P_RS_DATA_REPLY, e); 963b411b363SPhilipp Reisner } 964b411b363SPhilipp Reisner } else { 965b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_RS_DREPLY, e); 966b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 967b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 968b411b363SPhilipp Reisner } 969b411b363SPhilipp Reisner 970b411b363SPhilipp Reisner dec_unacked(mdev); 971b411b363SPhilipp Reisner 972b411b363SPhilipp Reisner kfree(di); 973b411b363SPhilipp Reisner 974b411b363SPhilipp Reisner move_to_net_ee_or_free(mdev, e); 975b411b363SPhilipp Reisner 976b411b363SPhilipp Reisner if (unlikely(!ok)) 977b411b363SPhilipp Reisner dev_err(DEV, "drbd_send_block/ack() failed\n"); 978b411b363SPhilipp Reisner return ok; 979b411b363SPhilipp Reisner } 980b411b363SPhilipp Reisner 981b411b363SPhilipp Reisner int w_e_end_ov_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 982b411b363SPhilipp Reisner { 983b411b363SPhilipp Reisner struct drbd_epoch_entry *e = container_of(w, struct drbd_epoch_entry, w); 984b411b363SPhilipp Reisner int digest_size; 985b411b363SPhilipp Reisner void *digest; 986b411b363SPhilipp Reisner int ok = 1; 987b411b363SPhilipp Reisner 988b411b363SPhilipp Reisner if (unlikely(cancel)) 989b411b363SPhilipp Reisner goto out; 990b411b363SPhilipp Reisner 991b411b363SPhilipp Reisner if (unlikely(!drbd_bio_uptodate(e->private_bio))) 992b411b363SPhilipp Reisner goto out; 993b411b363SPhilipp Reisner 994b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->verify_tfm); 995b411b363SPhilipp Reisner /* FIXME if this allocation fails, online verify will not terminate! */ 996b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 997b411b363SPhilipp Reisner if (digest) { 998b411b363SPhilipp Reisner drbd_csum(mdev, mdev->verify_tfm, e->private_bio, digest); 999b411b363SPhilipp Reisner inc_rs_pending(mdev); 1000b411b363SPhilipp Reisner ok = drbd_send_drequest_csum(mdev, e->sector, e->size, 1001b411b363SPhilipp Reisner digest, digest_size, P_OV_REPLY); 1002b411b363SPhilipp Reisner if (!ok) 1003b411b363SPhilipp Reisner dec_rs_pending(mdev); 1004b411b363SPhilipp Reisner kfree(digest); 1005b411b363SPhilipp Reisner } 1006b411b363SPhilipp Reisner 1007b411b363SPhilipp Reisner out: 1008b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1009b411b363SPhilipp Reisner 1010b411b363SPhilipp Reisner dec_unacked(mdev); 1011b411b363SPhilipp Reisner 1012b411b363SPhilipp Reisner return ok; 1013b411b363SPhilipp Reisner } 1014b411b363SPhilipp Reisner 1015b411b363SPhilipp Reisner void drbd_ov_oos_found(struct drbd_conf *mdev, sector_t sector, int size) 1016b411b363SPhilipp Reisner { 1017b411b363SPhilipp Reisner if (mdev->ov_last_oos_start + mdev->ov_last_oos_size == sector) { 1018b411b363SPhilipp Reisner mdev->ov_last_oos_size += size>>9; 1019b411b363SPhilipp Reisner } else { 1020b411b363SPhilipp Reisner mdev->ov_last_oos_start = sector; 1021b411b363SPhilipp Reisner mdev->ov_last_oos_size = size>>9; 1022b411b363SPhilipp Reisner } 1023b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, sector, size); 1024b411b363SPhilipp Reisner set_bit(WRITE_BM_AFTER_RESYNC, &mdev->flags); 1025b411b363SPhilipp Reisner } 1026b411b363SPhilipp Reisner 1027b411b363SPhilipp Reisner int w_e_end_ov_reply(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1028b411b363SPhilipp Reisner { 1029b411b363SPhilipp Reisner struct drbd_epoch_entry *e = container_of(w, struct drbd_epoch_entry, w); 1030b411b363SPhilipp Reisner struct digest_info *di; 1031b411b363SPhilipp Reisner int digest_size; 1032b411b363SPhilipp Reisner void *digest; 1033b411b363SPhilipp Reisner int ok, eq = 0; 1034b411b363SPhilipp Reisner 1035b411b363SPhilipp Reisner if (unlikely(cancel)) { 1036b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1037b411b363SPhilipp Reisner dec_unacked(mdev); 1038b411b363SPhilipp Reisner return 1; 1039b411b363SPhilipp Reisner } 1040b411b363SPhilipp Reisner 1041b411b363SPhilipp Reisner /* after "cancel", because after drbd_disconnect/drbd_rs_cancel_all 1042b411b363SPhilipp Reisner * the resync lru has been cleaned up already */ 1043b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, e->sector); 1044b411b363SPhilipp Reisner 1045b411b363SPhilipp Reisner di = (struct digest_info *)(unsigned long)e->block_id; 1046b411b363SPhilipp Reisner 1047b411b363SPhilipp Reisner if (likely(drbd_bio_uptodate(e->private_bio))) { 1048b411b363SPhilipp Reisner digest_size = crypto_hash_digestsize(mdev->verify_tfm); 1049b411b363SPhilipp Reisner digest = kmalloc(digest_size, GFP_NOIO); 1050b411b363SPhilipp Reisner if (digest) { 1051b411b363SPhilipp Reisner drbd_csum(mdev, mdev->verify_tfm, e->private_bio, digest); 1052b411b363SPhilipp Reisner 1053b411b363SPhilipp Reisner D_ASSERT(digest_size == di->digest_size); 1054b411b363SPhilipp Reisner eq = !memcmp(digest, di->digest, digest_size); 1055b411b363SPhilipp Reisner kfree(digest); 1056b411b363SPhilipp Reisner } 1057b411b363SPhilipp Reisner } else { 1058b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_RS_DREPLY, e); 1059b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1060b411b363SPhilipp Reisner dev_err(DEV, "Sending NegDReply. I guess it gets messy.\n"); 1061b411b363SPhilipp Reisner } 1062b411b363SPhilipp Reisner 1063b411b363SPhilipp Reisner dec_unacked(mdev); 1064b411b363SPhilipp Reisner 1065b411b363SPhilipp Reisner kfree(di); 1066b411b363SPhilipp Reisner 1067b411b363SPhilipp Reisner if (!eq) 1068b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, e->sector, e->size); 1069b411b363SPhilipp Reisner else 1070b411b363SPhilipp Reisner ov_oos_print(mdev); 1071b411b363SPhilipp Reisner 1072b411b363SPhilipp Reisner ok = drbd_send_ack_ex(mdev, P_OV_RESULT, e->sector, e->size, 1073b411b363SPhilipp Reisner eq ? ID_IN_SYNC : ID_OUT_OF_SYNC); 1074b411b363SPhilipp Reisner 1075b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1076b411b363SPhilipp Reisner 1077b411b363SPhilipp Reisner if (--mdev->ov_left == 0) { 1078b411b363SPhilipp Reisner ov_oos_print(mdev); 1079b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1080b411b363SPhilipp Reisner } 1081b411b363SPhilipp Reisner 1082b411b363SPhilipp Reisner return ok; 1083b411b363SPhilipp Reisner } 1084b411b363SPhilipp Reisner 1085b411b363SPhilipp Reisner int w_prev_work_done(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1086b411b363SPhilipp Reisner { 1087b411b363SPhilipp Reisner struct drbd_wq_barrier *b = container_of(w, struct drbd_wq_barrier, w); 1088b411b363SPhilipp Reisner complete(&b->done); 1089b411b363SPhilipp Reisner return 1; 1090b411b363SPhilipp Reisner } 1091b411b363SPhilipp Reisner 1092b411b363SPhilipp Reisner int w_send_barrier(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1093b411b363SPhilipp Reisner { 1094b411b363SPhilipp Reisner struct drbd_tl_epoch *b = container_of(w, struct drbd_tl_epoch, w); 1095b411b363SPhilipp Reisner struct p_barrier *p = &mdev->data.sbuf.barrier; 1096b411b363SPhilipp Reisner int ok = 1; 1097b411b363SPhilipp Reisner 1098b411b363SPhilipp Reisner /* really avoid racing with tl_clear. w.cb may have been referenced 1099b411b363SPhilipp Reisner * just before it was reassigned and re-queued, so double check that. 1100b411b363SPhilipp Reisner * actually, this race was harmless, since we only try to send the 1101b411b363SPhilipp Reisner * barrier packet here, and otherwise do nothing with the object. 1102b411b363SPhilipp Reisner * but compare with the head of w_clear_epoch */ 1103b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1104b411b363SPhilipp Reisner if (w->cb != w_send_barrier || mdev->state.conn < C_CONNECTED) 1105b411b363SPhilipp Reisner cancel = 1; 1106b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1107b411b363SPhilipp Reisner if (cancel) 1108b411b363SPhilipp Reisner return 1; 1109b411b363SPhilipp Reisner 1110b411b363SPhilipp Reisner if (!drbd_get_data_sock(mdev)) 1111b411b363SPhilipp Reisner return 0; 1112b411b363SPhilipp Reisner p->barrier = b->br_number; 1113b411b363SPhilipp Reisner /* inc_ap_pending was done where this was queued. 1114b411b363SPhilipp Reisner * dec_ap_pending will be done in got_BarrierAck 1115b411b363SPhilipp Reisner * or (on connection loss) in w_clear_epoch. */ 1116b411b363SPhilipp Reisner ok = _drbd_send_cmd(mdev, mdev->data.socket, P_BARRIER, 1117b411b363SPhilipp Reisner (struct p_header *)p, sizeof(*p), 0); 1118b411b363SPhilipp Reisner drbd_put_data_sock(mdev); 1119b411b363SPhilipp Reisner 1120b411b363SPhilipp Reisner return ok; 1121b411b363SPhilipp Reisner } 1122b411b363SPhilipp Reisner 1123b411b363SPhilipp Reisner int w_send_write_hint(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1124b411b363SPhilipp Reisner { 1125b411b363SPhilipp Reisner if (cancel) 1126b411b363SPhilipp Reisner return 1; 1127b411b363SPhilipp Reisner return drbd_send_short_cmd(mdev, P_UNPLUG_REMOTE); 1128b411b363SPhilipp Reisner } 1129b411b363SPhilipp Reisner 1130b411b363SPhilipp Reisner /** 1131b411b363SPhilipp Reisner * w_send_dblock() - Worker callback to send a P_DATA packet in order to mirror a write request 1132b411b363SPhilipp Reisner * @mdev: DRBD device. 1133b411b363SPhilipp Reisner * @w: work object. 1134b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1135b411b363SPhilipp Reisner */ 1136b411b363SPhilipp Reisner int w_send_dblock(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1137b411b363SPhilipp Reisner { 1138b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 1139b411b363SPhilipp Reisner int ok; 1140b411b363SPhilipp Reisner 1141b411b363SPhilipp Reisner if (unlikely(cancel)) { 1142b411b363SPhilipp Reisner req_mod(req, send_canceled); 1143b411b363SPhilipp Reisner return 1; 1144b411b363SPhilipp Reisner } 1145b411b363SPhilipp Reisner 1146b411b363SPhilipp Reisner ok = drbd_send_dblock(mdev, req); 1147b411b363SPhilipp Reisner req_mod(req, ok ? handed_over_to_network : send_failed); 1148b411b363SPhilipp Reisner 1149b411b363SPhilipp Reisner return ok; 1150b411b363SPhilipp Reisner } 1151b411b363SPhilipp Reisner 1152b411b363SPhilipp Reisner /** 1153b411b363SPhilipp Reisner * w_send_read_req() - Worker callback to send a read request (P_DATA_REQUEST) packet 1154b411b363SPhilipp Reisner * @mdev: DRBD device. 1155b411b363SPhilipp Reisner * @w: work object. 1156b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways 1157b411b363SPhilipp Reisner */ 1158b411b363SPhilipp Reisner int w_send_read_req(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1159b411b363SPhilipp Reisner { 1160b411b363SPhilipp Reisner struct drbd_request *req = container_of(w, struct drbd_request, w); 1161b411b363SPhilipp Reisner int ok; 1162b411b363SPhilipp Reisner 1163b411b363SPhilipp Reisner if (unlikely(cancel)) { 1164b411b363SPhilipp Reisner req_mod(req, send_canceled); 1165b411b363SPhilipp Reisner return 1; 1166b411b363SPhilipp Reisner } 1167b411b363SPhilipp Reisner 1168b411b363SPhilipp Reisner ok = drbd_send_drequest(mdev, P_DATA_REQUEST, req->sector, req->size, 1169b411b363SPhilipp Reisner (unsigned long)req); 1170b411b363SPhilipp Reisner 1171b411b363SPhilipp Reisner if (!ok) { 1172b411b363SPhilipp Reisner /* ?? we set C_TIMEOUT or C_BROKEN_PIPE in drbd_send(); 1173b411b363SPhilipp Reisner * so this is probably redundant */ 1174b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED) 1175b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 1176b411b363SPhilipp Reisner } 1177b411b363SPhilipp Reisner req_mod(req, ok ? handed_over_to_network : send_failed); 1178b411b363SPhilipp Reisner 1179b411b363SPhilipp Reisner return ok; 1180b411b363SPhilipp Reisner } 1181b411b363SPhilipp Reisner 1182b411b363SPhilipp Reisner static int _drbd_may_sync_now(struct drbd_conf *mdev) 1183b411b363SPhilipp Reisner { 1184b411b363SPhilipp Reisner struct drbd_conf *odev = mdev; 1185b411b363SPhilipp Reisner 1186b411b363SPhilipp Reisner while (1) { 1187b411b363SPhilipp Reisner if (odev->sync_conf.after == -1) 1188b411b363SPhilipp Reisner return 1; 1189b411b363SPhilipp Reisner odev = minor_to_mdev(odev->sync_conf.after); 1190b411b363SPhilipp Reisner ERR_IF(!odev) return 1; 1191b411b363SPhilipp Reisner if ((odev->state.conn >= C_SYNC_SOURCE && 1192b411b363SPhilipp Reisner odev->state.conn <= C_PAUSED_SYNC_T) || 1193b411b363SPhilipp Reisner odev->state.aftr_isp || odev->state.peer_isp || 1194b411b363SPhilipp Reisner odev->state.user_isp) 1195b411b363SPhilipp Reisner return 0; 1196b411b363SPhilipp Reisner } 1197b411b363SPhilipp Reisner } 1198b411b363SPhilipp Reisner 1199b411b363SPhilipp Reisner /** 1200b411b363SPhilipp Reisner * _drbd_pause_after() - Pause resync on all devices that may not resync now 1201b411b363SPhilipp Reisner * @mdev: DRBD device. 1202b411b363SPhilipp Reisner * 1203b411b363SPhilipp Reisner * Called from process context only (admin command and after_state_ch). 1204b411b363SPhilipp Reisner */ 1205b411b363SPhilipp Reisner static int _drbd_pause_after(struct drbd_conf *mdev) 1206b411b363SPhilipp Reisner { 1207b411b363SPhilipp Reisner struct drbd_conf *odev; 1208b411b363SPhilipp Reisner int i, rv = 0; 1209b411b363SPhilipp Reisner 1210b411b363SPhilipp Reisner for (i = 0; i < minor_count; i++) { 1211b411b363SPhilipp Reisner odev = minor_to_mdev(i); 1212b411b363SPhilipp Reisner if (!odev) 1213b411b363SPhilipp Reisner continue; 1214b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1215b411b363SPhilipp Reisner continue; 1216b411b363SPhilipp Reisner if (!_drbd_may_sync_now(odev)) 1217b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 1), CS_HARD, NULL) 1218b411b363SPhilipp Reisner != SS_NOTHING_TO_DO); 1219b411b363SPhilipp Reisner } 1220b411b363SPhilipp Reisner 1221b411b363SPhilipp Reisner return rv; 1222b411b363SPhilipp Reisner } 1223b411b363SPhilipp Reisner 1224b411b363SPhilipp Reisner /** 1225b411b363SPhilipp Reisner * _drbd_resume_next() - Resume resync on all devices that may resync now 1226b411b363SPhilipp Reisner * @mdev: DRBD device. 1227b411b363SPhilipp Reisner * 1228b411b363SPhilipp Reisner * Called from process context only (admin command and worker). 1229b411b363SPhilipp Reisner */ 1230b411b363SPhilipp Reisner static int _drbd_resume_next(struct drbd_conf *mdev) 1231b411b363SPhilipp Reisner { 1232b411b363SPhilipp Reisner struct drbd_conf *odev; 1233b411b363SPhilipp Reisner int i, rv = 0; 1234b411b363SPhilipp Reisner 1235b411b363SPhilipp Reisner for (i = 0; i < minor_count; i++) { 1236b411b363SPhilipp Reisner odev = minor_to_mdev(i); 1237b411b363SPhilipp Reisner if (!odev) 1238b411b363SPhilipp Reisner continue; 1239b411b363SPhilipp Reisner if (odev->state.conn == C_STANDALONE && odev->state.disk == D_DISKLESS) 1240b411b363SPhilipp Reisner continue; 1241b411b363SPhilipp Reisner if (odev->state.aftr_isp) { 1242b411b363SPhilipp Reisner if (_drbd_may_sync_now(odev)) 1243b411b363SPhilipp Reisner rv |= (__drbd_set_state(_NS(odev, aftr_isp, 0), 1244b411b363SPhilipp Reisner CS_HARD, NULL) 1245b411b363SPhilipp Reisner != SS_NOTHING_TO_DO) ; 1246b411b363SPhilipp Reisner } 1247b411b363SPhilipp Reisner } 1248b411b363SPhilipp Reisner return rv; 1249b411b363SPhilipp Reisner } 1250b411b363SPhilipp Reisner 1251b411b363SPhilipp Reisner void resume_next_sg(struct drbd_conf *mdev) 1252b411b363SPhilipp Reisner { 1253b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1254b411b363SPhilipp Reisner _drbd_resume_next(mdev); 1255b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1256b411b363SPhilipp Reisner } 1257b411b363SPhilipp Reisner 1258b411b363SPhilipp Reisner void suspend_other_sg(struct drbd_conf *mdev) 1259b411b363SPhilipp Reisner { 1260b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1261b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1262b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1263b411b363SPhilipp Reisner } 1264b411b363SPhilipp Reisner 1265b411b363SPhilipp Reisner static int sync_after_error(struct drbd_conf *mdev, int o_minor) 1266b411b363SPhilipp Reisner { 1267b411b363SPhilipp Reisner struct drbd_conf *odev; 1268b411b363SPhilipp Reisner 1269b411b363SPhilipp Reisner if (o_minor == -1) 1270b411b363SPhilipp Reisner return NO_ERROR; 1271b411b363SPhilipp Reisner if (o_minor < -1 || minor_to_mdev(o_minor) == NULL) 1272b411b363SPhilipp Reisner return ERR_SYNC_AFTER; 1273b411b363SPhilipp Reisner 1274b411b363SPhilipp Reisner /* check for loops */ 1275b411b363SPhilipp Reisner odev = minor_to_mdev(o_minor); 1276b411b363SPhilipp Reisner while (1) { 1277b411b363SPhilipp Reisner if (odev == mdev) 1278b411b363SPhilipp Reisner return ERR_SYNC_AFTER_CYCLE; 1279b411b363SPhilipp Reisner 1280b411b363SPhilipp Reisner /* dependency chain ends here, no cycles. */ 1281b411b363SPhilipp Reisner if (odev->sync_conf.after == -1) 1282b411b363SPhilipp Reisner return NO_ERROR; 1283b411b363SPhilipp Reisner 1284b411b363SPhilipp Reisner /* follow the dependency chain */ 1285b411b363SPhilipp Reisner odev = minor_to_mdev(odev->sync_conf.after); 1286b411b363SPhilipp Reisner } 1287b411b363SPhilipp Reisner } 1288b411b363SPhilipp Reisner 1289b411b363SPhilipp Reisner int drbd_alter_sa(struct drbd_conf *mdev, int na) 1290b411b363SPhilipp Reisner { 1291b411b363SPhilipp Reisner int changes; 1292b411b363SPhilipp Reisner int retcode; 1293b411b363SPhilipp Reisner 1294b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1295b411b363SPhilipp Reisner retcode = sync_after_error(mdev, na); 1296b411b363SPhilipp Reisner if (retcode == NO_ERROR) { 1297b411b363SPhilipp Reisner mdev->sync_conf.after = na; 1298b411b363SPhilipp Reisner do { 1299b411b363SPhilipp Reisner changes = _drbd_pause_after(mdev); 1300b411b363SPhilipp Reisner changes |= _drbd_resume_next(mdev); 1301b411b363SPhilipp Reisner } while (changes); 1302b411b363SPhilipp Reisner } 1303b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1304b411b363SPhilipp Reisner return retcode; 1305b411b363SPhilipp Reisner } 1306b411b363SPhilipp Reisner 1307b411b363SPhilipp Reisner /** 1308b411b363SPhilipp Reisner * drbd_start_resync() - Start the resync process 1309b411b363SPhilipp Reisner * @mdev: DRBD device. 1310b411b363SPhilipp Reisner * @side: Either C_SYNC_SOURCE or C_SYNC_TARGET 1311b411b363SPhilipp Reisner * 1312b411b363SPhilipp Reisner * This function might bring you directly into one of the 1313b411b363SPhilipp Reisner * C_PAUSED_SYNC_* states. 1314b411b363SPhilipp Reisner */ 1315b411b363SPhilipp Reisner void drbd_start_resync(struct drbd_conf *mdev, enum drbd_conns side) 1316b411b363SPhilipp Reisner { 1317b411b363SPhilipp Reisner union drbd_state ns; 1318b411b363SPhilipp Reisner int r; 1319b411b363SPhilipp Reisner 1320b411b363SPhilipp Reisner if (mdev->state.conn >= C_SYNC_SOURCE) { 1321b411b363SPhilipp Reisner dev_err(DEV, "Resync already running!\n"); 1322b411b363SPhilipp Reisner return; 1323b411b363SPhilipp Reisner } 1324b411b363SPhilipp Reisner 1325b411b363SPhilipp Reisner trace_drbd_resync(mdev, TRACE_LVL_SUMMARY, "Resync starting: side=%s\n", 1326b411b363SPhilipp Reisner side == C_SYNC_TARGET ? "SyncTarget" : "SyncSource"); 1327b411b363SPhilipp Reisner 1328b411b363SPhilipp Reisner /* In case a previous resync run was aborted by an IO error/detach on the peer. */ 1329b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 1330b411b363SPhilipp Reisner 1331b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1332b411b363SPhilipp Reisner /* Since application IO was locked out during C_WF_BITMAP_T and 1333b411b363SPhilipp Reisner C_WF_SYNC_UUID we are still unmodified. Before going to C_SYNC_TARGET 1334b411b363SPhilipp Reisner we check that we might make the data inconsistent. */ 1335b411b363SPhilipp Reisner r = drbd_khelper(mdev, "before-resync-target"); 1336b411b363SPhilipp Reisner r = (r >> 8) & 0xff; 1337b411b363SPhilipp Reisner if (r > 0) { 1338b411b363SPhilipp Reisner dev_info(DEV, "before-resync-target handler returned %d, " 1339b411b363SPhilipp Reisner "dropping connection.\n", r); 1340b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 1341b411b363SPhilipp Reisner return; 1342b411b363SPhilipp Reisner } 1343b411b363SPhilipp Reisner } 1344b411b363SPhilipp Reisner 1345b411b363SPhilipp Reisner drbd_state_lock(mdev); 1346b411b363SPhilipp Reisner 1347b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_NEGOTIATING)) { 1348b411b363SPhilipp Reisner drbd_state_unlock(mdev); 1349b411b363SPhilipp Reisner return; 1350b411b363SPhilipp Reisner } 1351b411b363SPhilipp Reisner 1352b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) { 1353b411b363SPhilipp Reisner mdev->bm_resync_fo = 0; 1354b411b363SPhilipp Reisner } else /* side == C_SYNC_SOURCE */ { 1355b411b363SPhilipp Reisner u64 uuid; 1356b411b363SPhilipp Reisner 1357b411b363SPhilipp Reisner get_random_bytes(&uuid, sizeof(u64)); 1358b411b363SPhilipp Reisner drbd_uuid_set(mdev, UI_BITMAP, uuid); 1359b411b363SPhilipp Reisner drbd_send_sync_uuid(mdev, uuid); 1360b411b363SPhilipp Reisner 1361b411b363SPhilipp Reisner D_ASSERT(mdev->state.disk == D_UP_TO_DATE); 1362b411b363SPhilipp Reisner } 1363b411b363SPhilipp Reisner 1364b411b363SPhilipp Reisner write_lock_irq(&global_state_lock); 1365b411b363SPhilipp Reisner ns = mdev->state; 1366b411b363SPhilipp Reisner 1367b411b363SPhilipp Reisner ns.aftr_isp = !_drbd_may_sync_now(mdev); 1368b411b363SPhilipp Reisner 1369b411b363SPhilipp Reisner ns.conn = side; 1370b411b363SPhilipp Reisner 1371b411b363SPhilipp Reisner if (side == C_SYNC_TARGET) 1372b411b363SPhilipp Reisner ns.disk = D_INCONSISTENT; 1373b411b363SPhilipp Reisner else /* side == C_SYNC_SOURCE */ 1374b411b363SPhilipp Reisner ns.pdsk = D_INCONSISTENT; 1375b411b363SPhilipp Reisner 1376b411b363SPhilipp Reisner r = __drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 1377b411b363SPhilipp Reisner ns = mdev->state; 1378b411b363SPhilipp Reisner 1379b411b363SPhilipp Reisner if (ns.conn < C_CONNECTED) 1380b411b363SPhilipp Reisner r = SS_UNKNOWN_ERROR; 1381b411b363SPhilipp Reisner 1382b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 1383b411b363SPhilipp Reisner mdev->rs_total = 1384b411b363SPhilipp Reisner mdev->rs_mark_left = drbd_bm_total_weight(mdev); 1385b411b363SPhilipp Reisner mdev->rs_failed = 0; 1386b411b363SPhilipp Reisner mdev->rs_paused = 0; 1387b411b363SPhilipp Reisner mdev->rs_start = 1388b411b363SPhilipp Reisner mdev->rs_mark_time = jiffies; 1389b411b363SPhilipp Reisner mdev->rs_same_csum = 0; 1390b411b363SPhilipp Reisner _drbd_pause_after(mdev); 1391b411b363SPhilipp Reisner } 1392b411b363SPhilipp Reisner write_unlock_irq(&global_state_lock); 1393b411b363SPhilipp Reisner drbd_state_unlock(mdev); 1394b411b363SPhilipp Reisner put_ldev(mdev); 1395b411b363SPhilipp Reisner 1396b411b363SPhilipp Reisner if (r == SS_SUCCESS) { 1397b411b363SPhilipp Reisner dev_info(DEV, "Began resync as %s (will sync %lu KB [%lu bits set]).\n", 1398b411b363SPhilipp Reisner drbd_conn_str(ns.conn), 1399b411b363SPhilipp Reisner (unsigned long) mdev->rs_total << (BM_BLOCK_SHIFT-10), 1400b411b363SPhilipp Reisner (unsigned long) mdev->rs_total); 1401b411b363SPhilipp Reisner 1402b411b363SPhilipp Reisner if (mdev->rs_total == 0) { 1403b411b363SPhilipp Reisner /* Peer still reachable? Beware of failing before-resync-target handlers! */ 1404b411b363SPhilipp Reisner request_ping(mdev); 1405b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 1406b411b363SPhilipp Reisner schedule_timeout(mdev->net_conf->ping_timeo*HZ/9); /* 9 instead 10 */ 1407b411b363SPhilipp Reisner drbd_resync_finished(mdev); 1408b411b363SPhilipp Reisner return; 1409b411b363SPhilipp Reisner } 1410b411b363SPhilipp Reisner 1411b411b363SPhilipp Reisner /* ns.conn may already be != mdev->state.conn, 1412b411b363SPhilipp Reisner * we may have been paused in between, or become paused until 1413b411b363SPhilipp Reisner * the timer triggers. 1414b411b363SPhilipp Reisner * No matter, that is handled in resync_timer_fn() */ 1415b411b363SPhilipp Reisner if (ns.conn == C_SYNC_TARGET) 1416b411b363SPhilipp Reisner mod_timer(&mdev->resync_timer, jiffies); 1417b411b363SPhilipp Reisner 1418b411b363SPhilipp Reisner drbd_md_sync(mdev); 1419b411b363SPhilipp Reisner } 1420b411b363SPhilipp Reisner } 1421b411b363SPhilipp Reisner 1422b411b363SPhilipp Reisner int drbd_worker(struct drbd_thread *thi) 1423b411b363SPhilipp Reisner { 1424b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 1425b411b363SPhilipp Reisner struct drbd_work *w = NULL; 1426b411b363SPhilipp Reisner LIST_HEAD(work_list); 1427b411b363SPhilipp Reisner int intr = 0, i; 1428b411b363SPhilipp Reisner 1429b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_worker", mdev_to_minor(mdev)); 1430b411b363SPhilipp Reisner 1431b411b363SPhilipp Reisner while (get_t_state(thi) == Running) { 1432b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 1433b411b363SPhilipp Reisner 1434b411b363SPhilipp Reisner if (down_trylock(&mdev->data.work.s)) { 1435b411b363SPhilipp Reisner mutex_lock(&mdev->data.mutex); 1436b411b363SPhilipp Reisner if (mdev->data.socket && !mdev->net_conf->no_cork) 1437b411b363SPhilipp Reisner drbd_tcp_uncork(mdev->data.socket); 1438b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 1439b411b363SPhilipp Reisner 1440b411b363SPhilipp Reisner intr = down_interruptible(&mdev->data.work.s); 1441b411b363SPhilipp Reisner 1442b411b363SPhilipp Reisner mutex_lock(&mdev->data.mutex); 1443b411b363SPhilipp Reisner if (mdev->data.socket && !mdev->net_conf->no_cork) 1444b411b363SPhilipp Reisner drbd_tcp_cork(mdev->data.socket); 1445b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 1446b411b363SPhilipp Reisner } 1447b411b363SPhilipp Reisner 1448b411b363SPhilipp Reisner if (intr) { 1449b411b363SPhilipp Reisner D_ASSERT(intr == -EINTR); 1450b411b363SPhilipp Reisner flush_signals(current); 1451b411b363SPhilipp Reisner ERR_IF (get_t_state(thi) == Running) 1452b411b363SPhilipp Reisner continue; 1453b411b363SPhilipp Reisner break; 1454b411b363SPhilipp Reisner } 1455b411b363SPhilipp Reisner 1456b411b363SPhilipp Reisner if (get_t_state(thi) != Running) 1457b411b363SPhilipp Reisner break; 1458b411b363SPhilipp Reisner /* With this break, we have done a down() but not consumed 1459b411b363SPhilipp Reisner the entry from the list. The cleanup code takes care of 1460b411b363SPhilipp Reisner this... */ 1461b411b363SPhilipp Reisner 1462b411b363SPhilipp Reisner w = NULL; 1463b411b363SPhilipp Reisner spin_lock_irq(&mdev->data.work.q_lock); 1464b411b363SPhilipp Reisner ERR_IF(list_empty(&mdev->data.work.q)) { 1465b411b363SPhilipp Reisner /* something terribly wrong in our logic. 1466b411b363SPhilipp Reisner * we were able to down() the semaphore, 1467b411b363SPhilipp Reisner * but the list is empty... doh. 1468b411b363SPhilipp Reisner * 1469b411b363SPhilipp Reisner * what is the best thing to do now? 1470b411b363SPhilipp Reisner * try again from scratch, restarting the receiver, 1471b411b363SPhilipp Reisner * asender, whatnot? could break even more ugly, 1472b411b363SPhilipp Reisner * e.g. when we are primary, but no good local data. 1473b411b363SPhilipp Reisner * 1474b411b363SPhilipp Reisner * I'll try to get away just starting over this loop. 1475b411b363SPhilipp Reisner */ 1476b411b363SPhilipp Reisner spin_unlock_irq(&mdev->data.work.q_lock); 1477b411b363SPhilipp Reisner continue; 1478b411b363SPhilipp Reisner } 1479b411b363SPhilipp Reisner w = list_entry(mdev->data.work.q.next, struct drbd_work, list); 1480b411b363SPhilipp Reisner list_del_init(&w->list); 1481b411b363SPhilipp Reisner spin_unlock_irq(&mdev->data.work.q_lock); 1482b411b363SPhilipp Reisner 1483b411b363SPhilipp Reisner if (!w->cb(mdev, w, mdev->state.conn < C_CONNECTED)) { 1484b411b363SPhilipp Reisner /* dev_warn(DEV, "worker: a callback failed! \n"); */ 1485b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED) 1486b411b363SPhilipp Reisner drbd_force_state(mdev, 1487b411b363SPhilipp Reisner NS(conn, C_NETWORK_FAILURE)); 1488b411b363SPhilipp Reisner } 1489b411b363SPhilipp Reisner } 1490b411b363SPhilipp Reisner D_ASSERT(test_bit(DEVICE_DYING, &mdev->flags)); 1491b411b363SPhilipp Reisner D_ASSERT(test_bit(CONFIG_PENDING, &mdev->flags)); 1492b411b363SPhilipp Reisner 1493b411b363SPhilipp Reisner spin_lock_irq(&mdev->data.work.q_lock); 1494b411b363SPhilipp Reisner i = 0; 1495b411b363SPhilipp Reisner while (!list_empty(&mdev->data.work.q)) { 1496b411b363SPhilipp Reisner list_splice_init(&mdev->data.work.q, &work_list); 1497b411b363SPhilipp Reisner spin_unlock_irq(&mdev->data.work.q_lock); 1498b411b363SPhilipp Reisner 1499b411b363SPhilipp Reisner while (!list_empty(&work_list)) { 1500b411b363SPhilipp Reisner w = list_entry(work_list.next, struct drbd_work, list); 1501b411b363SPhilipp Reisner list_del_init(&w->list); 1502b411b363SPhilipp Reisner w->cb(mdev, w, 1); 1503b411b363SPhilipp Reisner i++; /* dead debugging code */ 1504b411b363SPhilipp Reisner } 1505b411b363SPhilipp Reisner 1506b411b363SPhilipp Reisner spin_lock_irq(&mdev->data.work.q_lock); 1507b411b363SPhilipp Reisner } 1508b411b363SPhilipp Reisner sema_init(&mdev->data.work.s, 0); 1509b411b363SPhilipp Reisner /* DANGEROUS race: if someone did queue his work within the spinlock, 1510b411b363SPhilipp Reisner * but up() ed outside the spinlock, we could get an up() on the 1511b411b363SPhilipp Reisner * semaphore without corresponding list entry. 1512b411b363SPhilipp Reisner * So don't do that. 1513b411b363SPhilipp Reisner */ 1514b411b363SPhilipp Reisner spin_unlock_irq(&mdev->data.work.q_lock); 1515b411b363SPhilipp Reisner 1516b411b363SPhilipp Reisner D_ASSERT(mdev->state.disk == D_DISKLESS && mdev->state.conn == C_STANDALONE); 1517b411b363SPhilipp Reisner /* _drbd_set_state only uses stop_nowait. 1518b411b363SPhilipp Reisner * wait here for the Exiting receiver. */ 1519b411b363SPhilipp Reisner drbd_thread_stop(&mdev->receiver); 1520b411b363SPhilipp Reisner drbd_mdev_cleanup(mdev); 1521b411b363SPhilipp Reisner 1522b411b363SPhilipp Reisner dev_info(DEV, "worker terminated\n"); 1523b411b363SPhilipp Reisner 1524b411b363SPhilipp Reisner clear_bit(DEVICE_DYING, &mdev->flags); 1525b411b363SPhilipp Reisner clear_bit(CONFIG_PENDING, &mdev->flags); 1526b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 1527b411b363SPhilipp Reisner 1528b411b363SPhilipp Reisner return 0; 1529b411b363SPhilipp Reisner } 1530