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