1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_receiver.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 28b411b363SPhilipp Reisner #include <asm/uaccess.h> 29b411b363SPhilipp Reisner #include <net/sock.h> 30b411b363SPhilipp Reisner 31b411b363SPhilipp Reisner #include <linux/drbd.h> 32b411b363SPhilipp Reisner #include <linux/fs.h> 33b411b363SPhilipp Reisner #include <linux/file.h> 34b411b363SPhilipp Reisner #include <linux/in.h> 35b411b363SPhilipp Reisner #include <linux/mm.h> 36b411b363SPhilipp Reisner #include <linux/memcontrol.h> 37b411b363SPhilipp Reisner #include <linux/mm_inline.h> 38b411b363SPhilipp Reisner #include <linux/slab.h> 39b411b363SPhilipp Reisner #include <linux/smp_lock.h> 40b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 41b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 42b411b363SPhilipp Reisner #include <linux/unistd.h> 43b411b363SPhilipp Reisner #include <linux/vmalloc.h> 44b411b363SPhilipp Reisner #include <linux/random.h> 45b411b363SPhilipp Reisner #include <linux/mm.h> 46b411b363SPhilipp Reisner #include <linux/string.h> 47b411b363SPhilipp Reisner #include <linux/scatterlist.h> 48b411b363SPhilipp Reisner #include "drbd_int.h" 49b411b363SPhilipp Reisner #include "drbd_req.h" 50b411b363SPhilipp Reisner 51b411b363SPhilipp Reisner #include "drbd_vli.h" 52b411b363SPhilipp Reisner 53b411b363SPhilipp Reisner struct flush_work { 54b411b363SPhilipp Reisner struct drbd_work w; 55b411b363SPhilipp Reisner struct drbd_epoch *epoch; 56b411b363SPhilipp Reisner }; 57b411b363SPhilipp Reisner 58b411b363SPhilipp Reisner enum finish_epoch { 59b411b363SPhilipp Reisner FE_STILL_LIVE, 60b411b363SPhilipp Reisner FE_DESTROYED, 61b411b363SPhilipp Reisner FE_RECYCLED, 62b411b363SPhilipp Reisner }; 63b411b363SPhilipp Reisner 64b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev); 65b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev); 66b411b363SPhilipp Reisner 67b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 68b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *, struct drbd_work *, int); 69b411b363SPhilipp Reisner 70b411b363SPhilipp Reisner static struct drbd_epoch *previous_epoch(struct drbd_conf *mdev, struct drbd_epoch *epoch) 71b411b363SPhilipp Reisner { 72b411b363SPhilipp Reisner struct drbd_epoch *prev; 73b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 74b411b363SPhilipp Reisner prev = list_entry(epoch->list.prev, struct drbd_epoch, list); 75b411b363SPhilipp Reisner if (prev == epoch || prev == mdev->current_epoch) 76b411b363SPhilipp Reisner prev = NULL; 77b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 78b411b363SPhilipp Reisner return prev; 79b411b363SPhilipp Reisner } 80b411b363SPhilipp Reisner 81b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 82b411b363SPhilipp Reisner 83b411b363SPhilipp Reisner static struct page *drbd_pp_first_page_or_try_alloc(struct drbd_conf *mdev) 84b411b363SPhilipp Reisner { 85b411b363SPhilipp Reisner struct page *page = NULL; 86b411b363SPhilipp Reisner 87b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 88b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 89b411b363SPhilipp Reisner if (drbd_pp_vacant > 0) { 90b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 91b411b363SPhilipp Reisner page = drbd_pp_pool; 92b411b363SPhilipp Reisner if (page) { 93b411b363SPhilipp Reisner drbd_pp_pool = (struct page *)page_private(page); 94b411b363SPhilipp Reisner set_page_private(page, 0); /* just to be polite */ 95b411b363SPhilipp Reisner drbd_pp_vacant--; 96b411b363SPhilipp Reisner } 97b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 98b411b363SPhilipp Reisner } 99b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 100b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 101b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 102b411b363SPhilipp Reisner if (!page) 103b411b363SPhilipp Reisner page = alloc_page(GFP_TRY); 104b411b363SPhilipp Reisner if (page) 105b411b363SPhilipp Reisner atomic_inc(&mdev->pp_in_use); 106b411b363SPhilipp Reisner return page; 107b411b363SPhilipp Reisner } 108b411b363SPhilipp Reisner 109b411b363SPhilipp Reisner /* kick lower level device, if we have more than (arbitrary number) 110b411b363SPhilipp Reisner * reference counts on it, which typically are locally submitted io 111b411b363SPhilipp Reisner * requests. don't use unacked_cnt, so we speed up proto A and B, too. */ 112b411b363SPhilipp Reisner static void maybe_kick_lo(struct drbd_conf *mdev) 113b411b363SPhilipp Reisner { 114b411b363SPhilipp Reisner if (atomic_read(&mdev->local_cnt) >= mdev->net_conf->unplug_watermark) 115b411b363SPhilipp Reisner drbd_kick_lo(mdev); 116b411b363SPhilipp Reisner } 117b411b363SPhilipp Reisner 118b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 119b411b363SPhilipp Reisner { 120b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 121b411b363SPhilipp Reisner struct list_head *le, *tle; 122b411b363SPhilipp Reisner 123b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 124b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 125b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 126b411b363SPhilipp Reisner stop to examine the list... */ 127b411b363SPhilipp Reisner 128b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 129b411b363SPhilipp Reisner e = list_entry(le, struct drbd_epoch_entry, w.list); 130b411b363SPhilipp Reisner if (drbd_bio_has_active_page(e->private_bio)) 131b411b363SPhilipp Reisner break; 132b411b363SPhilipp Reisner list_move(le, to_be_freed); 133b411b363SPhilipp Reisner } 134b411b363SPhilipp Reisner } 135b411b363SPhilipp Reisner 136b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 137b411b363SPhilipp Reisner { 138b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 139b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 140b411b363SPhilipp Reisner 141b411b363SPhilipp Reisner maybe_kick_lo(mdev); 142b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 143b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 144b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 145b411b363SPhilipp Reisner 146b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &reclaimed, w.list) 147b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 148b411b363SPhilipp Reisner } 149b411b363SPhilipp Reisner 150b411b363SPhilipp Reisner /** 151b411b363SPhilipp Reisner * drbd_pp_alloc() - Returns a page, fails only if a signal comes in 152b411b363SPhilipp Reisner * @mdev: DRBD device. 153b411b363SPhilipp Reisner * @retry: whether or not to retry allocation forever (or until signalled) 154b411b363SPhilipp Reisner * 155b411b363SPhilipp Reisner * Tries to allocate a page, first from our own page pool, then from the 156b411b363SPhilipp Reisner * kernel, unless this allocation would exceed the max_buffers setting. 157b411b363SPhilipp Reisner * If @retry is non-zero, retry until DRBD frees a page somewhere else. 158b411b363SPhilipp Reisner */ 159b411b363SPhilipp Reisner static struct page *drbd_pp_alloc(struct drbd_conf *mdev, int retry) 160b411b363SPhilipp Reisner { 161b411b363SPhilipp Reisner struct page *page = NULL; 162b411b363SPhilipp Reisner DEFINE_WAIT(wait); 163b411b363SPhilipp Reisner 164b411b363SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers) { 165b411b363SPhilipp Reisner page = drbd_pp_first_page_or_try_alloc(mdev); 166b411b363SPhilipp Reisner if (page) 167b411b363SPhilipp Reisner return page; 168b411b363SPhilipp Reisner } 169b411b363SPhilipp Reisner 170b411b363SPhilipp Reisner for (;;) { 171b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 172b411b363SPhilipp Reisner 173b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 174b411b363SPhilipp Reisner 175b411b363SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers) { 176b411b363SPhilipp Reisner page = drbd_pp_first_page_or_try_alloc(mdev); 177b411b363SPhilipp Reisner if (page) 178b411b363SPhilipp Reisner break; 179b411b363SPhilipp Reisner } 180b411b363SPhilipp Reisner 181b411b363SPhilipp Reisner if (!retry) 182b411b363SPhilipp Reisner break; 183b411b363SPhilipp Reisner 184b411b363SPhilipp Reisner if (signal_pending(current)) { 185b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 186b411b363SPhilipp Reisner break; 187b411b363SPhilipp Reisner } 188b411b363SPhilipp Reisner 189b411b363SPhilipp Reisner schedule(); 190b411b363SPhilipp Reisner } 191b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 192b411b363SPhilipp Reisner 193b411b363SPhilipp Reisner return page; 194b411b363SPhilipp Reisner } 195b411b363SPhilipp Reisner 196b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 197b411b363SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->req_lock) */ 198b411b363SPhilipp Reisner static void drbd_pp_free(struct drbd_conf *mdev, struct page *page) 199b411b363SPhilipp Reisner { 200b411b363SPhilipp Reisner int free_it; 201b411b363SPhilipp Reisner 202b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 203b411b363SPhilipp Reisner if (drbd_pp_vacant > (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE)*minor_count) { 204b411b363SPhilipp Reisner free_it = 1; 205b411b363SPhilipp Reisner } else { 206b411b363SPhilipp Reisner set_page_private(page, (unsigned long)drbd_pp_pool); 207b411b363SPhilipp Reisner drbd_pp_pool = page; 208b411b363SPhilipp Reisner drbd_pp_vacant++; 209b411b363SPhilipp Reisner free_it = 0; 210b411b363SPhilipp Reisner } 211b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 212b411b363SPhilipp Reisner 213b411b363SPhilipp Reisner atomic_dec(&mdev->pp_in_use); 214b411b363SPhilipp Reisner 215b411b363SPhilipp Reisner if (free_it) 216b411b363SPhilipp Reisner __free_page(page); 217b411b363SPhilipp Reisner 218b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 219b411b363SPhilipp Reisner } 220b411b363SPhilipp Reisner 221b411b363SPhilipp Reisner static void drbd_pp_free_bio_pages(struct drbd_conf *mdev, struct bio *bio) 222b411b363SPhilipp Reisner { 223b411b363SPhilipp Reisner struct page *p_to_be_freed = NULL; 224b411b363SPhilipp Reisner struct page *page; 225b411b363SPhilipp Reisner struct bio_vec *bvec; 226b411b363SPhilipp Reisner int i; 227b411b363SPhilipp Reisner 228b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 229b411b363SPhilipp Reisner __bio_for_each_segment(bvec, bio, i, 0) { 230b411b363SPhilipp Reisner if (drbd_pp_vacant > (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE)*minor_count) { 231b411b363SPhilipp Reisner set_page_private(bvec->bv_page, (unsigned long)p_to_be_freed); 232b411b363SPhilipp Reisner p_to_be_freed = bvec->bv_page; 233b411b363SPhilipp Reisner } else { 234b411b363SPhilipp Reisner set_page_private(bvec->bv_page, (unsigned long)drbd_pp_pool); 235b411b363SPhilipp Reisner drbd_pp_pool = bvec->bv_page; 236b411b363SPhilipp Reisner drbd_pp_vacant++; 237b411b363SPhilipp Reisner } 238b411b363SPhilipp Reisner } 239b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 240b411b363SPhilipp Reisner atomic_sub(bio->bi_vcnt, &mdev->pp_in_use); 241b411b363SPhilipp Reisner 242b411b363SPhilipp Reisner while (p_to_be_freed) { 243b411b363SPhilipp Reisner page = p_to_be_freed; 244b411b363SPhilipp Reisner p_to_be_freed = (struct page *)page_private(page); 245b411b363SPhilipp Reisner set_page_private(page, 0); /* just to be polite */ 246b411b363SPhilipp Reisner put_page(page); 247b411b363SPhilipp Reisner } 248b411b363SPhilipp Reisner 249b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 250b411b363SPhilipp Reisner } 251b411b363SPhilipp Reisner 252b411b363SPhilipp Reisner /* 253b411b363SPhilipp Reisner You need to hold the req_lock: 254b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 255b411b363SPhilipp Reisner 256b411b363SPhilipp Reisner You must not have the req_lock: 257b411b363SPhilipp Reisner drbd_free_ee() 258b411b363SPhilipp Reisner drbd_alloc_ee() 259b411b363SPhilipp Reisner drbd_init_ee() 260b411b363SPhilipp Reisner drbd_release_ee() 261b411b363SPhilipp Reisner drbd_ee_fix_bhs() 262b411b363SPhilipp Reisner drbd_process_done_ee() 263b411b363SPhilipp Reisner drbd_clear_done_ee() 264b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 265b411b363SPhilipp Reisner */ 266b411b363SPhilipp Reisner 267b411b363SPhilipp Reisner struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev, 268b411b363SPhilipp Reisner u64 id, 269b411b363SPhilipp Reisner sector_t sector, 270b411b363SPhilipp Reisner unsigned int data_size, 271b411b363SPhilipp Reisner gfp_t gfp_mask) __must_hold(local) 272b411b363SPhilipp Reisner { 273b411b363SPhilipp Reisner struct request_queue *q; 274b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 275b411b363SPhilipp Reisner struct page *page; 276b411b363SPhilipp Reisner struct bio *bio; 277b411b363SPhilipp Reisner unsigned int ds; 278b411b363SPhilipp Reisner 279b411b363SPhilipp Reisner if (FAULT_ACTIVE(mdev, DRBD_FAULT_AL_EE)) 280b411b363SPhilipp Reisner return NULL; 281b411b363SPhilipp Reisner 282b411b363SPhilipp Reisner e = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 283b411b363SPhilipp Reisner if (!e) { 284b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 285b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 286b411b363SPhilipp Reisner return NULL; 287b411b363SPhilipp Reisner } 288b411b363SPhilipp Reisner 289b411b363SPhilipp Reisner bio = bio_alloc(gfp_mask & ~__GFP_HIGHMEM, div_ceil(data_size, PAGE_SIZE)); 290b411b363SPhilipp Reisner if (!bio) { 291b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 292b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of a bio failed\n"); 293b411b363SPhilipp Reisner goto fail1; 294b411b363SPhilipp Reisner } 295b411b363SPhilipp Reisner 296b411b363SPhilipp Reisner bio->bi_bdev = mdev->ldev->backing_bdev; 297b411b363SPhilipp Reisner bio->bi_sector = sector; 298b411b363SPhilipp Reisner 299b411b363SPhilipp Reisner ds = data_size; 300b411b363SPhilipp Reisner while (ds) { 301b411b363SPhilipp Reisner page = drbd_pp_alloc(mdev, (gfp_mask & __GFP_WAIT)); 302b411b363SPhilipp Reisner if (!page) { 303b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 304b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of a page failed\n"); 305b411b363SPhilipp Reisner goto fail2; 306b411b363SPhilipp Reisner } 307b411b363SPhilipp Reisner if (!bio_add_page(bio, page, min_t(int, ds, PAGE_SIZE), 0)) { 308b411b363SPhilipp Reisner drbd_pp_free(mdev, page); 309b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: bio_add_page(s=%llu," 310b411b363SPhilipp Reisner "data_size=%u,ds=%u) failed\n", 311b411b363SPhilipp Reisner (unsigned long long)sector, data_size, ds); 312b411b363SPhilipp Reisner 313b411b363SPhilipp Reisner q = bdev_get_queue(bio->bi_bdev); 314b411b363SPhilipp Reisner if (q->merge_bvec_fn) { 315b411b363SPhilipp Reisner struct bvec_merge_data bvm = { 316b411b363SPhilipp Reisner .bi_bdev = bio->bi_bdev, 317b411b363SPhilipp Reisner .bi_sector = bio->bi_sector, 318b411b363SPhilipp Reisner .bi_size = bio->bi_size, 319b411b363SPhilipp Reisner .bi_rw = bio->bi_rw, 320b411b363SPhilipp Reisner }; 321b411b363SPhilipp Reisner int l = q->merge_bvec_fn(q, &bvm, 322b411b363SPhilipp Reisner &bio->bi_io_vec[bio->bi_vcnt]); 323b411b363SPhilipp Reisner dev_err(DEV, "merge_bvec_fn() = %d\n", l); 324b411b363SPhilipp Reisner } 325b411b363SPhilipp Reisner 326b411b363SPhilipp Reisner /* dump more of the bio. */ 327b411b363SPhilipp Reisner dev_err(DEV, "bio->bi_max_vecs = %d\n", bio->bi_max_vecs); 328b411b363SPhilipp Reisner dev_err(DEV, "bio->bi_vcnt = %d\n", bio->bi_vcnt); 329b411b363SPhilipp Reisner dev_err(DEV, "bio->bi_size = %d\n", bio->bi_size); 330b411b363SPhilipp Reisner dev_err(DEV, "bio->bi_phys_segments = %d\n", bio->bi_phys_segments); 331b411b363SPhilipp Reisner 332b411b363SPhilipp Reisner goto fail2; 333b411b363SPhilipp Reisner break; 334b411b363SPhilipp Reisner } 335b411b363SPhilipp Reisner ds -= min_t(int, ds, PAGE_SIZE); 336b411b363SPhilipp Reisner } 337b411b363SPhilipp Reisner 338b411b363SPhilipp Reisner D_ASSERT(data_size == bio->bi_size); 339b411b363SPhilipp Reisner 340b411b363SPhilipp Reisner bio->bi_private = e; 341b411b363SPhilipp Reisner e->mdev = mdev; 342b411b363SPhilipp Reisner e->sector = sector; 343b411b363SPhilipp Reisner e->size = bio->bi_size; 344b411b363SPhilipp Reisner 345b411b363SPhilipp Reisner e->private_bio = bio; 346b411b363SPhilipp Reisner e->block_id = id; 347b411b363SPhilipp Reisner INIT_HLIST_NODE(&e->colision); 348b411b363SPhilipp Reisner e->epoch = NULL; 349b411b363SPhilipp Reisner e->flags = 0; 350b411b363SPhilipp Reisner 351b411b363SPhilipp Reisner return e; 352b411b363SPhilipp Reisner 353b411b363SPhilipp Reisner fail2: 354b411b363SPhilipp Reisner drbd_pp_free_bio_pages(mdev, bio); 355b411b363SPhilipp Reisner bio_put(bio); 356b411b363SPhilipp Reisner fail1: 357b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 358b411b363SPhilipp Reisner 359b411b363SPhilipp Reisner return NULL; 360b411b363SPhilipp Reisner } 361b411b363SPhilipp Reisner 362b411b363SPhilipp Reisner void drbd_free_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e) 363b411b363SPhilipp Reisner { 364b411b363SPhilipp Reisner struct bio *bio = e->private_bio; 365b411b363SPhilipp Reisner drbd_pp_free_bio_pages(mdev, bio); 366b411b363SPhilipp Reisner bio_put(bio); 367b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 368b411b363SPhilipp Reisner mempool_free(e, drbd_ee_mempool); 369b411b363SPhilipp Reisner } 370b411b363SPhilipp Reisner 371b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 372b411b363SPhilipp Reisner { 373b411b363SPhilipp Reisner LIST_HEAD(work_list); 374b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 375b411b363SPhilipp Reisner int count = 0; 376b411b363SPhilipp Reisner 377b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 378b411b363SPhilipp Reisner list_splice_init(list, &work_list); 379b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 380b411b363SPhilipp Reisner 381b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 382b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 383b411b363SPhilipp Reisner count++; 384b411b363SPhilipp Reisner } 385b411b363SPhilipp Reisner return count; 386b411b363SPhilipp Reisner } 387b411b363SPhilipp Reisner 388b411b363SPhilipp Reisner 389b411b363SPhilipp Reisner /* 390b411b363SPhilipp Reisner * This function is called from _asender only_ 391b411b363SPhilipp Reisner * but see also comments in _req_mod(,barrier_acked) 392b411b363SPhilipp Reisner * and receive_Barrier. 393b411b363SPhilipp Reisner * 394b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 395b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 396b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 397b411b363SPhilipp Reisner */ 398b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 399b411b363SPhilipp Reisner { 400b411b363SPhilipp Reisner LIST_HEAD(work_list); 401b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 402b411b363SPhilipp Reisner struct drbd_epoch_entry *e, *t; 403b411b363SPhilipp Reisner int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS); 404b411b363SPhilipp Reisner 405b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 406b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 407b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 408b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 409b411b363SPhilipp Reisner 410b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &reclaimed, w.list) 411b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 412b411b363SPhilipp Reisner 413b411b363SPhilipp Reisner /* possible callbacks here: 414b411b363SPhilipp Reisner * e_end_block, and e_end_resync_block, e_send_discard_ack. 415b411b363SPhilipp Reisner * all ignore the last argument. 416b411b363SPhilipp Reisner */ 417b411b363SPhilipp Reisner list_for_each_entry_safe(e, t, &work_list, w.list) { 418b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 419b411b363SPhilipp Reisner ok = e->w.cb(mdev, &e->w, !ok) && ok; 420b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 421b411b363SPhilipp Reisner } 422b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 423b411b363SPhilipp Reisner 424b411b363SPhilipp Reisner return ok; 425b411b363SPhilipp Reisner } 426b411b363SPhilipp Reisner 427b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 428b411b363SPhilipp Reisner { 429b411b363SPhilipp Reisner DEFINE_WAIT(wait); 430b411b363SPhilipp Reisner 431b411b363SPhilipp Reisner /* avoids spin_lock/unlock 432b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 433b411b363SPhilipp Reisner while (!list_empty(head)) { 434b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 435b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 436b411b363SPhilipp Reisner drbd_kick_lo(mdev); 437b411b363SPhilipp Reisner schedule(); 438b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 439b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 440b411b363SPhilipp Reisner } 441b411b363SPhilipp Reisner } 442b411b363SPhilipp Reisner 443b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 444b411b363SPhilipp Reisner { 445b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 446b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 447b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 448b411b363SPhilipp Reisner } 449b411b363SPhilipp Reisner 450b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 451b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 452b411b363SPhilipp Reisner static int drbd_accept(struct drbd_conf *mdev, const char **what, 453b411b363SPhilipp Reisner struct socket *sock, struct socket **newsock) 454b411b363SPhilipp Reisner { 455b411b363SPhilipp Reisner struct sock *sk = sock->sk; 456b411b363SPhilipp Reisner int err = 0; 457b411b363SPhilipp Reisner 458b411b363SPhilipp Reisner *what = "listen"; 459b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 460b411b363SPhilipp Reisner if (err < 0) 461b411b363SPhilipp Reisner goto out; 462b411b363SPhilipp Reisner 463b411b363SPhilipp Reisner *what = "sock_create_lite"; 464b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 465b411b363SPhilipp Reisner newsock); 466b411b363SPhilipp Reisner if (err < 0) 467b411b363SPhilipp Reisner goto out; 468b411b363SPhilipp Reisner 469b411b363SPhilipp Reisner *what = "accept"; 470b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 471b411b363SPhilipp Reisner if (err < 0) { 472b411b363SPhilipp Reisner sock_release(*newsock); 473b411b363SPhilipp Reisner *newsock = NULL; 474b411b363SPhilipp Reisner goto out; 475b411b363SPhilipp Reisner } 476b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 477b411b363SPhilipp Reisner 478b411b363SPhilipp Reisner out: 479b411b363SPhilipp Reisner return err; 480b411b363SPhilipp Reisner } 481b411b363SPhilipp Reisner 482b411b363SPhilipp Reisner static int drbd_recv_short(struct drbd_conf *mdev, struct socket *sock, 483b411b363SPhilipp Reisner void *buf, size_t size, int flags) 484b411b363SPhilipp Reisner { 485b411b363SPhilipp Reisner mm_segment_t oldfs; 486b411b363SPhilipp Reisner struct kvec iov = { 487b411b363SPhilipp Reisner .iov_base = buf, 488b411b363SPhilipp Reisner .iov_len = size, 489b411b363SPhilipp Reisner }; 490b411b363SPhilipp Reisner struct msghdr msg = { 491b411b363SPhilipp Reisner .msg_iovlen = 1, 492b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 493b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 494b411b363SPhilipp Reisner }; 495b411b363SPhilipp Reisner int rv; 496b411b363SPhilipp Reisner 497b411b363SPhilipp Reisner oldfs = get_fs(); 498b411b363SPhilipp Reisner set_fs(KERNEL_DS); 499b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 500b411b363SPhilipp Reisner set_fs(oldfs); 501b411b363SPhilipp Reisner 502b411b363SPhilipp Reisner return rv; 503b411b363SPhilipp Reisner } 504b411b363SPhilipp Reisner 505b411b363SPhilipp Reisner static int drbd_recv(struct drbd_conf *mdev, void *buf, size_t size) 506b411b363SPhilipp Reisner { 507b411b363SPhilipp Reisner mm_segment_t oldfs; 508b411b363SPhilipp Reisner struct kvec iov = { 509b411b363SPhilipp Reisner .iov_base = buf, 510b411b363SPhilipp Reisner .iov_len = size, 511b411b363SPhilipp Reisner }; 512b411b363SPhilipp Reisner struct msghdr msg = { 513b411b363SPhilipp Reisner .msg_iovlen = 1, 514b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 515b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 516b411b363SPhilipp Reisner }; 517b411b363SPhilipp Reisner int rv; 518b411b363SPhilipp Reisner 519b411b363SPhilipp Reisner oldfs = get_fs(); 520b411b363SPhilipp Reisner set_fs(KERNEL_DS); 521b411b363SPhilipp Reisner 522b411b363SPhilipp Reisner for (;;) { 523b411b363SPhilipp Reisner rv = sock_recvmsg(mdev->data.socket, &msg, size, msg.msg_flags); 524b411b363SPhilipp Reisner if (rv == size) 525b411b363SPhilipp Reisner break; 526b411b363SPhilipp Reisner 527b411b363SPhilipp Reisner /* Note: 528b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 529b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 530b411b363SPhilipp Reisner */ 531b411b363SPhilipp Reisner 532b411b363SPhilipp Reisner if (rv < 0) { 533b411b363SPhilipp Reisner if (rv == -ECONNRESET) 534b411b363SPhilipp Reisner dev_info(DEV, "sock was reset by peer\n"); 535b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 536b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 537b411b363SPhilipp Reisner break; 538b411b363SPhilipp Reisner } else if (rv == 0) { 539b411b363SPhilipp Reisner dev_info(DEV, "sock was shut down by peer\n"); 540b411b363SPhilipp Reisner break; 541b411b363SPhilipp Reisner } else { 542b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 543b411b363SPhilipp Reisner * after we read a partial message 544b411b363SPhilipp Reisner */ 545b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 546b411b363SPhilipp Reisner break; 547b411b363SPhilipp Reisner } 548b411b363SPhilipp Reisner }; 549b411b363SPhilipp Reisner 550b411b363SPhilipp Reisner set_fs(oldfs); 551b411b363SPhilipp Reisner 552b411b363SPhilipp Reisner if (rv != size) 553b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE)); 554b411b363SPhilipp Reisner 555b411b363SPhilipp Reisner return rv; 556b411b363SPhilipp Reisner } 557b411b363SPhilipp Reisner 558b411b363SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_conf *mdev) 559b411b363SPhilipp Reisner { 560b411b363SPhilipp Reisner const char *what; 561b411b363SPhilipp Reisner struct socket *sock; 562b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 563b411b363SPhilipp Reisner int err; 564b411b363SPhilipp Reisner int disconnect_on_error = 1; 565b411b363SPhilipp Reisner 566b411b363SPhilipp Reisner if (!get_net_conf(mdev)) 567b411b363SPhilipp Reisner return NULL; 568b411b363SPhilipp Reisner 569b411b363SPhilipp Reisner what = "sock_create_kern"; 570b411b363SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family, 571b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 572b411b363SPhilipp Reisner if (err < 0) { 573b411b363SPhilipp Reisner sock = NULL; 574b411b363SPhilipp Reisner goto out; 575b411b363SPhilipp Reisner } 576b411b363SPhilipp Reisner 577b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 578b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->net_conf->try_connect_int*HZ; 579b411b363SPhilipp Reisner 580b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 581b411b363SPhilipp Reisner * for the outgoing connections. 582b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 583b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 584b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 585b411b363SPhilipp Reisner * a free one dynamically. 586b411b363SPhilipp Reisner */ 587b411b363SPhilipp Reisner memcpy(&src_in6, mdev->net_conf->my_addr, 588b411b363SPhilipp Reisner min_t(int, mdev->net_conf->my_addr_len, sizeof(src_in6))); 589b411b363SPhilipp Reisner if (((struct sockaddr *)mdev->net_conf->my_addr)->sa_family == AF_INET6) 590b411b363SPhilipp Reisner src_in6.sin6_port = 0; 591b411b363SPhilipp Reisner else 592b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 593b411b363SPhilipp Reisner 594b411b363SPhilipp Reisner what = "bind before connect"; 595b411b363SPhilipp Reisner err = sock->ops->bind(sock, 596b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 597b411b363SPhilipp Reisner mdev->net_conf->my_addr_len); 598b411b363SPhilipp Reisner if (err < 0) 599b411b363SPhilipp Reisner goto out; 600b411b363SPhilipp Reisner 601b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 602b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 603b411b363SPhilipp Reisner disconnect_on_error = 0; 604b411b363SPhilipp Reisner what = "connect"; 605b411b363SPhilipp Reisner err = sock->ops->connect(sock, 606b411b363SPhilipp Reisner (struct sockaddr *)mdev->net_conf->peer_addr, 607b411b363SPhilipp Reisner mdev->net_conf->peer_addr_len, 0); 608b411b363SPhilipp Reisner 609b411b363SPhilipp Reisner out: 610b411b363SPhilipp Reisner if (err < 0) { 611b411b363SPhilipp Reisner if (sock) { 612b411b363SPhilipp Reisner sock_release(sock); 613b411b363SPhilipp Reisner sock = NULL; 614b411b363SPhilipp Reisner } 615b411b363SPhilipp Reisner switch (-err) { 616b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 617b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 618b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 619b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 620b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 621b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 622b411b363SPhilipp Reisner disconnect_on_error = 0; 623b411b363SPhilipp Reisner break; 624b411b363SPhilipp Reisner default: 625b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 626b411b363SPhilipp Reisner } 627b411b363SPhilipp Reisner if (disconnect_on_error) 628b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 629b411b363SPhilipp Reisner } 630b411b363SPhilipp Reisner put_net_conf(mdev); 631b411b363SPhilipp Reisner return sock; 632b411b363SPhilipp Reisner } 633b411b363SPhilipp Reisner 634b411b363SPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_conf *mdev) 635b411b363SPhilipp Reisner { 636b411b363SPhilipp Reisner int timeo, err; 637b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 638b411b363SPhilipp Reisner const char *what; 639b411b363SPhilipp Reisner 640b411b363SPhilipp Reisner if (!get_net_conf(mdev)) 641b411b363SPhilipp Reisner return NULL; 642b411b363SPhilipp Reisner 643b411b363SPhilipp Reisner what = "sock_create_kern"; 644b411b363SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family, 645b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 646b411b363SPhilipp Reisner if (err) { 647b411b363SPhilipp Reisner s_listen = NULL; 648b411b363SPhilipp Reisner goto out; 649b411b363SPhilipp Reisner } 650b411b363SPhilipp Reisner 651b411b363SPhilipp Reisner timeo = mdev->net_conf->try_connect_int * HZ; 652b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 653b411b363SPhilipp Reisner 654b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 655b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 656b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 657b411b363SPhilipp Reisner 658b411b363SPhilipp Reisner what = "bind before listen"; 659b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 660b411b363SPhilipp Reisner (struct sockaddr *) mdev->net_conf->my_addr, 661b411b363SPhilipp Reisner mdev->net_conf->my_addr_len); 662b411b363SPhilipp Reisner if (err < 0) 663b411b363SPhilipp Reisner goto out; 664b411b363SPhilipp Reisner 665b411b363SPhilipp Reisner err = drbd_accept(mdev, &what, s_listen, &s_estab); 666b411b363SPhilipp Reisner 667b411b363SPhilipp Reisner out: 668b411b363SPhilipp Reisner if (s_listen) 669b411b363SPhilipp Reisner sock_release(s_listen); 670b411b363SPhilipp Reisner if (err < 0) { 671b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 672b411b363SPhilipp Reisner dev_err(DEV, "%s failed, err = %d\n", what, err); 673b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 674b411b363SPhilipp Reisner } 675b411b363SPhilipp Reisner } 676b411b363SPhilipp Reisner put_net_conf(mdev); 677b411b363SPhilipp Reisner 678b411b363SPhilipp Reisner return s_estab; 679b411b363SPhilipp Reisner } 680b411b363SPhilipp Reisner 681b411b363SPhilipp Reisner static int drbd_send_fp(struct drbd_conf *mdev, 682b411b363SPhilipp Reisner struct socket *sock, enum drbd_packets cmd) 683b411b363SPhilipp Reisner { 684b411b363SPhilipp Reisner struct p_header *h = (struct p_header *) &mdev->data.sbuf.header; 685b411b363SPhilipp Reisner 686b411b363SPhilipp Reisner return _drbd_send_cmd(mdev, sock, cmd, h, sizeof(*h), 0); 687b411b363SPhilipp Reisner } 688b411b363SPhilipp Reisner 689b411b363SPhilipp Reisner static enum drbd_packets drbd_recv_fp(struct drbd_conf *mdev, struct socket *sock) 690b411b363SPhilipp Reisner { 691b411b363SPhilipp Reisner struct p_header *h = (struct p_header *) &mdev->data.sbuf.header; 692b411b363SPhilipp Reisner int rr; 693b411b363SPhilipp Reisner 694b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, sock, h, sizeof(*h), 0); 695b411b363SPhilipp Reisner 696b411b363SPhilipp Reisner if (rr == sizeof(*h) && h->magic == BE_DRBD_MAGIC) 697b411b363SPhilipp Reisner return be16_to_cpu(h->command); 698b411b363SPhilipp Reisner 699b411b363SPhilipp Reisner return 0xffff; 700b411b363SPhilipp Reisner } 701b411b363SPhilipp Reisner 702b411b363SPhilipp Reisner /** 703b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 704b411b363SPhilipp Reisner * @mdev: DRBD device. 705b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 706b411b363SPhilipp Reisner */ 707b411b363SPhilipp Reisner static int drbd_socket_okay(struct drbd_conf *mdev, struct socket **sock) 708b411b363SPhilipp Reisner { 709b411b363SPhilipp Reisner int rr; 710b411b363SPhilipp Reisner char tb[4]; 711b411b363SPhilipp Reisner 712b411b363SPhilipp Reisner if (!*sock) 713b411b363SPhilipp Reisner return FALSE; 714b411b363SPhilipp Reisner 715b411b363SPhilipp Reisner rr = drbd_recv_short(mdev, *sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 716b411b363SPhilipp Reisner 717b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 718b411b363SPhilipp Reisner return TRUE; 719b411b363SPhilipp Reisner } else { 720b411b363SPhilipp Reisner sock_release(*sock); 721b411b363SPhilipp Reisner *sock = NULL; 722b411b363SPhilipp Reisner return FALSE; 723b411b363SPhilipp Reisner } 724b411b363SPhilipp Reisner } 725b411b363SPhilipp Reisner 726b411b363SPhilipp Reisner /* 727b411b363SPhilipp Reisner * return values: 728b411b363SPhilipp Reisner * 1 yes, we have a valid connection 729b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 730b411b363SPhilipp Reisner * -1 peer talks different language, 731b411b363SPhilipp Reisner * no point in trying again, please go standalone. 732b411b363SPhilipp Reisner * -2 We do not have a network config... 733b411b363SPhilipp Reisner */ 734b411b363SPhilipp Reisner static int drbd_connect(struct drbd_conf *mdev) 735b411b363SPhilipp Reisner { 736b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 737b411b363SPhilipp Reisner int try, h, ok; 738b411b363SPhilipp Reisner 739b411b363SPhilipp Reisner D_ASSERT(!mdev->data.socket); 740b411b363SPhilipp Reisner 741b411b363SPhilipp Reisner if (test_and_clear_bit(CREATE_BARRIER, &mdev->flags)) 742b411b363SPhilipp Reisner dev_err(DEV, "CREATE_BARRIER flag was set in drbd_connect - now cleared!\n"); 743b411b363SPhilipp Reisner 744b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS) 745b411b363SPhilipp Reisner return -2; 746b411b363SPhilipp Reisner 747b411b363SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &mdev->flags); 748b411b363SPhilipp Reisner 749b411b363SPhilipp Reisner sock = NULL; 750b411b363SPhilipp Reisner msock = NULL; 751b411b363SPhilipp Reisner 752b411b363SPhilipp Reisner do { 753b411b363SPhilipp Reisner for (try = 0;;) { 754b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 755b411b363SPhilipp Reisner s = drbd_try_connect(mdev); 756b411b363SPhilipp Reisner if (s || ++try >= 3) 757b411b363SPhilipp Reisner break; 758b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 759b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 760b411b363SPhilipp Reisner schedule_timeout(HZ / 10); 761b411b363SPhilipp Reisner } 762b411b363SPhilipp Reisner 763b411b363SPhilipp Reisner if (s) { 764b411b363SPhilipp Reisner if (!sock) { 765b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_S); 766b411b363SPhilipp Reisner sock = s; 767b411b363SPhilipp Reisner s = NULL; 768b411b363SPhilipp Reisner } else if (!msock) { 769b411b363SPhilipp Reisner drbd_send_fp(mdev, s, P_HAND_SHAKE_M); 770b411b363SPhilipp Reisner msock = s; 771b411b363SPhilipp Reisner s = NULL; 772b411b363SPhilipp Reisner } else { 773b411b363SPhilipp Reisner dev_err(DEV, "Logic error in drbd_connect()\n"); 774b411b363SPhilipp Reisner goto out_release_sockets; 775b411b363SPhilipp Reisner } 776b411b363SPhilipp Reisner } 777b411b363SPhilipp Reisner 778b411b363SPhilipp Reisner if (sock && msock) { 779b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 780b411b363SPhilipp Reisner schedule_timeout(HZ / 10); 781b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 782b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 783b411b363SPhilipp Reisner if (ok) 784b411b363SPhilipp Reisner break; 785b411b363SPhilipp Reisner } 786b411b363SPhilipp Reisner 787b411b363SPhilipp Reisner retry: 788b411b363SPhilipp Reisner s = drbd_wait_for_connect(mdev); 789b411b363SPhilipp Reisner if (s) { 790b411b363SPhilipp Reisner try = drbd_recv_fp(mdev, s); 791b411b363SPhilipp Reisner drbd_socket_okay(mdev, &sock); 792b411b363SPhilipp Reisner drbd_socket_okay(mdev, &msock); 793b411b363SPhilipp Reisner switch (try) { 794b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 795b411b363SPhilipp Reisner if (sock) { 796b411b363SPhilipp Reisner dev_warn(DEV, "initial packet S crossed\n"); 797b411b363SPhilipp Reisner sock_release(sock); 798b411b363SPhilipp Reisner } 799b411b363SPhilipp Reisner sock = s; 800b411b363SPhilipp Reisner break; 801b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 802b411b363SPhilipp Reisner if (msock) { 803b411b363SPhilipp Reisner dev_warn(DEV, "initial packet M crossed\n"); 804b411b363SPhilipp Reisner sock_release(msock); 805b411b363SPhilipp Reisner } 806b411b363SPhilipp Reisner msock = s; 807b411b363SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &mdev->flags); 808b411b363SPhilipp Reisner break; 809b411b363SPhilipp Reisner default: 810b411b363SPhilipp Reisner dev_warn(DEV, "Error receiving initial packet\n"); 811b411b363SPhilipp Reisner sock_release(s); 812b411b363SPhilipp Reisner if (random32() & 1) 813b411b363SPhilipp Reisner goto retry; 814b411b363SPhilipp Reisner } 815b411b363SPhilipp Reisner } 816b411b363SPhilipp Reisner 817b411b363SPhilipp Reisner if (mdev->state.conn <= C_DISCONNECTING) 818b411b363SPhilipp Reisner goto out_release_sockets; 819b411b363SPhilipp Reisner if (signal_pending(current)) { 820b411b363SPhilipp Reisner flush_signals(current); 821b411b363SPhilipp Reisner smp_rmb(); 822b411b363SPhilipp Reisner if (get_t_state(&mdev->receiver) == Exiting) 823b411b363SPhilipp Reisner goto out_release_sockets; 824b411b363SPhilipp Reisner } 825b411b363SPhilipp Reisner 826b411b363SPhilipp Reisner if (sock && msock) { 827b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &sock); 828b411b363SPhilipp Reisner ok = drbd_socket_okay(mdev, &msock) && ok; 829b411b363SPhilipp Reisner if (ok) 830b411b363SPhilipp Reisner break; 831b411b363SPhilipp Reisner } 832b411b363SPhilipp Reisner } while (1); 833b411b363SPhilipp Reisner 834b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 835b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 836b411b363SPhilipp Reisner 837b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 838b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 839b411b363SPhilipp Reisner 840b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 841b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 842b411b363SPhilipp Reisner 843b411b363SPhilipp Reisner if (mdev->net_conf->sndbuf_size) { 844b411b363SPhilipp Reisner sock->sk->sk_sndbuf = mdev->net_conf->sndbuf_size; 845b411b363SPhilipp Reisner sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 846b411b363SPhilipp Reisner } 847b411b363SPhilipp Reisner 848b411b363SPhilipp Reisner if (mdev->net_conf->rcvbuf_size) { 849b411b363SPhilipp Reisner sock->sk->sk_rcvbuf = mdev->net_conf->rcvbuf_size; 850b411b363SPhilipp Reisner sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 851b411b363SPhilipp Reisner } 852b411b363SPhilipp Reisner 853b411b363SPhilipp Reisner /* NOT YET ... 854b411b363SPhilipp Reisner * sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 855b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 856b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 857b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 858b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 859b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = mdev->net_conf->ping_timeo*4*HZ/10; 860b411b363SPhilipp Reisner 861b411b363SPhilipp Reisner msock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 862b411b363SPhilipp Reisner msock->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ; 863b411b363SPhilipp Reisner 864b411b363SPhilipp Reisner /* we don't want delays. 865b411b363SPhilipp Reisner * we use TCP_CORK where apropriate, though */ 866b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 867b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 868b411b363SPhilipp Reisner 869b411b363SPhilipp Reisner mdev->data.socket = sock; 870b411b363SPhilipp Reisner mdev->meta.socket = msock; 871b411b363SPhilipp Reisner mdev->last_received = jiffies; 872b411b363SPhilipp Reisner 873b411b363SPhilipp Reisner D_ASSERT(mdev->asender.task == NULL); 874b411b363SPhilipp Reisner 875b411b363SPhilipp Reisner h = drbd_do_handshake(mdev); 876b411b363SPhilipp Reisner if (h <= 0) 877b411b363SPhilipp Reisner return h; 878b411b363SPhilipp Reisner 879b411b363SPhilipp Reisner if (mdev->cram_hmac_tfm) { 880b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 881b10d96cbSJohannes Thoma switch (drbd_do_auth(mdev)) { 882b10d96cbSJohannes Thoma case -1: 883b411b363SPhilipp Reisner dev_err(DEV, "Authentication of peer failed\n"); 884b411b363SPhilipp Reisner return -1; 885b10d96cbSJohannes Thoma case 0: 886b10d96cbSJohannes Thoma dev_err(DEV, "Authentication of peer failed, trying again.\n"); 887b10d96cbSJohannes Thoma return 0; 888b411b363SPhilipp Reisner } 889b411b363SPhilipp Reisner } 890b411b363SPhilipp Reisner 891b411b363SPhilipp Reisner if (drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS) 892b411b363SPhilipp Reisner return 0; 893b411b363SPhilipp Reisner 894b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10; 895b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 896b411b363SPhilipp Reisner 897b411b363SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 898b411b363SPhilipp Reisner mdev->peer_seq = 0; 899b411b363SPhilipp Reisner 900b411b363SPhilipp Reisner drbd_thread_start(&mdev->asender); 901b411b363SPhilipp Reisner 9027e2455c1SPhilipp Reisner if (!drbd_send_protocol(mdev)) 9037e2455c1SPhilipp Reisner return -1; 904b411b363SPhilipp Reisner drbd_send_sync_param(mdev, &mdev->sync_conf); 905e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, 0); 906b411b363SPhilipp Reisner drbd_send_uuids(mdev); 907b411b363SPhilipp Reisner drbd_send_state(mdev); 908b411b363SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 909b411b363SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 910b411b363SPhilipp Reisner 911b411b363SPhilipp Reisner return 1; 912b411b363SPhilipp Reisner 913b411b363SPhilipp Reisner out_release_sockets: 914b411b363SPhilipp Reisner if (sock) 915b411b363SPhilipp Reisner sock_release(sock); 916b411b363SPhilipp Reisner if (msock) 917b411b363SPhilipp Reisner sock_release(msock); 918b411b363SPhilipp Reisner return -1; 919b411b363SPhilipp Reisner } 920b411b363SPhilipp Reisner 921b411b363SPhilipp Reisner static int drbd_recv_header(struct drbd_conf *mdev, struct p_header *h) 922b411b363SPhilipp Reisner { 923b411b363SPhilipp Reisner int r; 924b411b363SPhilipp Reisner 925b411b363SPhilipp Reisner r = drbd_recv(mdev, h, sizeof(*h)); 926b411b363SPhilipp Reisner 927b411b363SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 928b411b363SPhilipp Reisner dev_err(DEV, "short read expecting header on sock: r=%d\n", r); 929b411b363SPhilipp Reisner return FALSE; 930b411b363SPhilipp Reisner }; 931b411b363SPhilipp Reisner h->command = be16_to_cpu(h->command); 932b411b363SPhilipp Reisner h->length = be16_to_cpu(h->length); 933b411b363SPhilipp Reisner if (unlikely(h->magic != BE_DRBD_MAGIC)) { 934b411b363SPhilipp Reisner dev_err(DEV, "magic?? on data m: 0x%lx c: %d l: %d\n", 935b411b363SPhilipp Reisner (long)be32_to_cpu(h->magic), 936b411b363SPhilipp Reisner h->command, h->length); 937b411b363SPhilipp Reisner return FALSE; 938b411b363SPhilipp Reisner } 939b411b363SPhilipp Reisner mdev->last_received = jiffies; 940b411b363SPhilipp Reisner 941b411b363SPhilipp Reisner return TRUE; 942b411b363SPhilipp Reisner } 943b411b363SPhilipp Reisner 944b411b363SPhilipp Reisner static enum finish_epoch drbd_flush_after_epoch(struct drbd_conf *mdev, struct drbd_epoch *epoch) 945b411b363SPhilipp Reisner { 946b411b363SPhilipp Reisner int rv; 947b411b363SPhilipp Reisner 948b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 949fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 950fbd9b09aSDmitry Monakhov NULL, BLKDEV_IFL_WAIT); 951b411b363SPhilipp Reisner if (rv) { 952b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 953b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 954b411b363SPhilipp Reisner * don't try again for ANY return value != 0 955b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 956b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 957b411b363SPhilipp Reisner } 958b411b363SPhilipp Reisner put_ldev(mdev); 959b411b363SPhilipp Reisner } 960b411b363SPhilipp Reisner 961b411b363SPhilipp Reisner return drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE); 962b411b363SPhilipp Reisner } 963b411b363SPhilipp Reisner 964b411b363SPhilipp Reisner static int w_flush(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 965b411b363SPhilipp Reisner { 966b411b363SPhilipp Reisner struct flush_work *fw = (struct flush_work *)w; 967b411b363SPhilipp Reisner struct drbd_epoch *epoch = fw->epoch; 968b411b363SPhilipp Reisner 969b411b363SPhilipp Reisner kfree(w); 970b411b363SPhilipp Reisner 971b411b363SPhilipp Reisner if (!test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags)) 972b411b363SPhilipp Reisner drbd_flush_after_epoch(mdev, epoch); 973b411b363SPhilipp Reisner 974b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_PUT | 975b411b363SPhilipp Reisner (mdev->state.conn < C_CONNECTED ? EV_CLEANUP : 0)); 976b411b363SPhilipp Reisner 977b411b363SPhilipp Reisner return 1; 978b411b363SPhilipp Reisner } 979b411b363SPhilipp Reisner 980b411b363SPhilipp Reisner /** 981b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 982b411b363SPhilipp Reisner * @mdev: DRBD device. 983b411b363SPhilipp Reisner * @epoch: Epoch object. 984b411b363SPhilipp Reisner * @ev: Epoch event. 985b411b363SPhilipp Reisner */ 986b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 987b411b363SPhilipp Reisner struct drbd_epoch *epoch, 988b411b363SPhilipp Reisner enum epoch_event ev) 989b411b363SPhilipp Reisner { 990b411b363SPhilipp Reisner int finish, epoch_size; 991b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 992b411b363SPhilipp Reisner int schedule_flush = 0; 993b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 994b411b363SPhilipp Reisner 995b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 996b411b363SPhilipp Reisner do { 997b411b363SPhilipp Reisner next_epoch = NULL; 998b411b363SPhilipp Reisner finish = 0; 999b411b363SPhilipp Reisner 1000b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1001b411b363SPhilipp Reisner 1002b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1003b411b363SPhilipp Reisner case EV_PUT: 1004b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1005b411b363SPhilipp Reisner break; 1006b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1007b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1008b411b363SPhilipp Reisner 1009b411b363SPhilipp Reisner /* Special case: If we just switched from WO_bio_barrier to 1010b411b363SPhilipp Reisner WO_bdev_flush we should not finish the current epoch */ 1011b411b363SPhilipp Reisner if (test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags) && epoch_size == 1 && 1012b411b363SPhilipp Reisner mdev->write_ordering != WO_bio_barrier && 1013b411b363SPhilipp Reisner epoch == mdev->current_epoch) 1014b411b363SPhilipp Reisner clear_bit(DE_CONTAINS_A_BARRIER, &epoch->flags); 1015b411b363SPhilipp Reisner break; 1016b411b363SPhilipp Reisner case EV_BARRIER_DONE: 1017b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_DONE, &epoch->flags); 1018b411b363SPhilipp Reisner break; 1019b411b363SPhilipp Reisner case EV_BECAME_LAST: 1020b411b363SPhilipp Reisner /* nothing to do*/ 1021b411b363SPhilipp Reisner break; 1022b411b363SPhilipp Reisner } 1023b411b363SPhilipp Reisner 1024b411b363SPhilipp Reisner if (epoch_size != 0 && 1025b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 1026b411b363SPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) && 1027b411b363SPhilipp Reisner epoch->list.prev == &mdev->current_epoch->list && 1028b411b363SPhilipp Reisner !test_bit(DE_IS_FINISHING, &epoch->flags)) { 1029b411b363SPhilipp Reisner /* Nearly all conditions are met to finish that epoch... */ 1030b411b363SPhilipp Reisner if (test_bit(DE_BARRIER_IN_NEXT_EPOCH_DONE, &epoch->flags) || 1031b411b363SPhilipp Reisner mdev->write_ordering == WO_none || 1032b411b363SPhilipp Reisner (epoch_size == 1 && test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags)) || 1033b411b363SPhilipp Reisner ev & EV_CLEANUP) { 1034b411b363SPhilipp Reisner finish = 1; 1035b411b363SPhilipp Reisner set_bit(DE_IS_FINISHING, &epoch->flags); 1036b411b363SPhilipp Reisner } else if (!test_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags) && 1037b411b363SPhilipp Reisner mdev->write_ordering == WO_bio_barrier) { 1038b411b363SPhilipp Reisner atomic_inc(&epoch->active); 1039b411b363SPhilipp Reisner schedule_flush = 1; 1040b411b363SPhilipp Reisner } 1041b411b363SPhilipp Reisner } 1042b411b363SPhilipp Reisner if (finish) { 1043b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1044b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1045b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1046b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1047b411b363SPhilipp Reisner } 1048b411b363SPhilipp Reisner dec_unacked(mdev); 1049b411b363SPhilipp Reisner 1050b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1051b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1052b411b363SPhilipp Reisner list_del(&epoch->list); 1053b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1054b411b363SPhilipp Reisner mdev->epochs--; 1055b411b363SPhilipp Reisner kfree(epoch); 1056b411b363SPhilipp Reisner 1057b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1058b411b363SPhilipp Reisner rv = FE_DESTROYED; 1059b411b363SPhilipp Reisner } else { 1060b411b363SPhilipp Reisner epoch->flags = 0; 1061b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1062b411b363SPhilipp Reisner /* atomic_set(&epoch->active, 0); is alrady zero */ 1063b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1064b411b363SPhilipp Reisner rv = FE_RECYCLED; 1065b411b363SPhilipp Reisner } 1066b411b363SPhilipp Reisner } 1067b411b363SPhilipp Reisner 1068b411b363SPhilipp Reisner if (!next_epoch) 1069b411b363SPhilipp Reisner break; 1070b411b363SPhilipp Reisner 1071b411b363SPhilipp Reisner epoch = next_epoch; 1072b411b363SPhilipp Reisner } while (1); 1073b411b363SPhilipp Reisner 1074b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1075b411b363SPhilipp Reisner 1076b411b363SPhilipp Reisner if (schedule_flush) { 1077b411b363SPhilipp Reisner struct flush_work *fw; 1078b411b363SPhilipp Reisner fw = kmalloc(sizeof(*fw), GFP_ATOMIC); 1079b411b363SPhilipp Reisner if (fw) { 1080b411b363SPhilipp Reisner fw->w.cb = w_flush; 1081b411b363SPhilipp Reisner fw->epoch = epoch; 1082b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &fw->w); 1083b411b363SPhilipp Reisner } else { 1084b411b363SPhilipp Reisner dev_warn(DEV, "Could not kmalloc a flush_work obj\n"); 1085b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags); 1086b411b363SPhilipp Reisner /* That is not a recursion, only one level */ 1087b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE); 1088b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_PUT); 1089b411b363SPhilipp Reisner } 1090b411b363SPhilipp Reisner } 1091b411b363SPhilipp Reisner 1092b411b363SPhilipp Reisner return rv; 1093b411b363SPhilipp Reisner } 1094b411b363SPhilipp Reisner 1095b411b363SPhilipp Reisner /** 1096b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1097b411b363SPhilipp Reisner * @mdev: DRBD device. 1098b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1099b411b363SPhilipp Reisner */ 1100b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1101b411b363SPhilipp Reisner { 1102b411b363SPhilipp Reisner enum write_ordering_e pwo; 1103b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1104b411b363SPhilipp Reisner [WO_none] = "none", 1105b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1106b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1107b411b363SPhilipp Reisner [WO_bio_barrier] = "barrier", 1108b411b363SPhilipp Reisner }; 1109b411b363SPhilipp Reisner 1110b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1111b411b363SPhilipp Reisner wo = min(pwo, wo); 1112b411b363SPhilipp Reisner if (wo == WO_bio_barrier && mdev->ldev->dc.no_disk_barrier) 1113b411b363SPhilipp Reisner wo = WO_bdev_flush; 1114b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1115b411b363SPhilipp Reisner wo = WO_drain_io; 1116b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1117b411b363SPhilipp Reisner wo = WO_none; 1118b411b363SPhilipp Reisner mdev->write_ordering = wo; 1119b411b363SPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bio_barrier) 1120b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1121b411b363SPhilipp Reisner } 1122b411b363SPhilipp Reisner 1123b411b363SPhilipp Reisner /** 1124b411b363SPhilipp Reisner * w_e_reissue() - Worker callback; Resubmit a bio, without BIO_RW_BARRIER set 1125b411b363SPhilipp Reisner * @mdev: DRBD device. 1126b411b363SPhilipp Reisner * @w: work object. 1127b411b363SPhilipp Reisner * @cancel: The connection will be closed anyways (unused in this callback) 1128b411b363SPhilipp Reisner */ 1129b411b363SPhilipp Reisner int w_e_reissue(struct drbd_conf *mdev, struct drbd_work *w, int cancel) __releases(local) 1130b411b363SPhilipp Reisner { 1131b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1132b411b363SPhilipp Reisner struct bio *bio = e->private_bio; 1133b411b363SPhilipp Reisner 1134b411b363SPhilipp Reisner /* We leave DE_CONTAINS_A_BARRIER and EE_IS_BARRIER in place, 1135b411b363SPhilipp Reisner (and DE_BARRIER_IN_NEXT_EPOCH_ISSUED in the previous Epoch) 1136b411b363SPhilipp Reisner so that we can finish that epoch in drbd_may_finish_epoch(). 1137b411b363SPhilipp Reisner That is necessary if we already have a long chain of Epochs, before 1138b411b363SPhilipp Reisner we realize that BIO_RW_BARRIER is actually not supported */ 1139b411b363SPhilipp Reisner 1140b411b363SPhilipp Reisner /* As long as the -ENOTSUPP on the barrier is reported immediately 1141b411b363SPhilipp Reisner that will never trigger. If it is reported late, we will just 1142b411b363SPhilipp Reisner print that warning and continue correctly for all future requests 1143b411b363SPhilipp Reisner with WO_bdev_flush */ 1144b411b363SPhilipp Reisner if (previous_epoch(mdev, e->epoch)) 1145b411b363SPhilipp Reisner dev_warn(DEV, "Write ordering was not enforced (one time event)\n"); 1146b411b363SPhilipp Reisner 1147b411b363SPhilipp Reisner /* prepare bio for re-submit, 1148b411b363SPhilipp Reisner * re-init volatile members */ 1149b411b363SPhilipp Reisner /* we still have a local reference, 1150b411b363SPhilipp Reisner * get_ldev was done in receive_Data. */ 1151b411b363SPhilipp Reisner bio->bi_bdev = mdev->ldev->backing_bdev; 1152b411b363SPhilipp Reisner bio->bi_sector = e->sector; 1153b411b363SPhilipp Reisner bio->bi_size = e->size; 1154b411b363SPhilipp Reisner bio->bi_idx = 0; 1155b411b363SPhilipp Reisner 1156b411b363SPhilipp Reisner bio->bi_flags &= ~(BIO_POOL_MASK - 1); 1157b411b363SPhilipp Reisner bio->bi_flags |= 1 << BIO_UPTODATE; 1158b411b363SPhilipp Reisner 1159b411b363SPhilipp Reisner /* don't know whether this is necessary: */ 1160b411b363SPhilipp Reisner bio->bi_phys_segments = 0; 1161b411b363SPhilipp Reisner bio->bi_next = NULL; 1162b411b363SPhilipp Reisner 1163b411b363SPhilipp Reisner /* these should be unchanged: */ 1164b411b363SPhilipp Reisner /* bio->bi_end_io = drbd_endio_write_sec; */ 1165b411b363SPhilipp Reisner /* bio->bi_vcnt = whatever; */ 1166b411b363SPhilipp Reisner 1167b411b363SPhilipp Reisner e->w.cb = e_end_block; 1168b411b363SPhilipp Reisner 1169b411b363SPhilipp Reisner /* This is no longer a barrier request. */ 1170b411b363SPhilipp Reisner bio->bi_rw &= ~(1UL << BIO_RW_BARRIER); 1171b411b363SPhilipp Reisner 1172b411b363SPhilipp Reisner drbd_generic_make_request(mdev, DRBD_FAULT_DT_WR, bio); 1173b411b363SPhilipp Reisner 1174b411b363SPhilipp Reisner return 1; 1175b411b363SPhilipp Reisner } 1176b411b363SPhilipp Reisner 1177b411b363SPhilipp Reisner static int receive_Barrier(struct drbd_conf *mdev, struct p_header *h) 1178b411b363SPhilipp Reisner { 1179b411b363SPhilipp Reisner int rv, issue_flush; 1180b411b363SPhilipp Reisner struct p_barrier *p = (struct p_barrier *)h; 1181b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1182b411b363SPhilipp Reisner 1183b411b363SPhilipp Reisner ERR_IF(h->length != (sizeof(*p)-sizeof(*h))) return FALSE; 1184b411b363SPhilipp Reisner 1185b411b363SPhilipp Reisner rv = drbd_recv(mdev, h->payload, h->length); 1186b411b363SPhilipp Reisner ERR_IF(rv != h->length) return FALSE; 1187b411b363SPhilipp Reisner 1188b411b363SPhilipp Reisner inc_unacked(mdev); 1189b411b363SPhilipp Reisner 1190b411b363SPhilipp Reisner if (mdev->net_conf->wire_protocol != DRBD_PROT_C) 1191b411b363SPhilipp Reisner drbd_kick_lo(mdev); 1192b411b363SPhilipp Reisner 1193b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1194b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1195b411b363SPhilipp Reisner 1196b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1197b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1198b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1199b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1200b411b363SPhilipp Reisner * completed. */ 1201b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1202b411b363SPhilipp Reisner case WO_bio_barrier: 1203b411b363SPhilipp Reisner case WO_none: 1204b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 1205b411b363SPhilipp Reisner return TRUE; 1206b411b363SPhilipp Reisner break; 1207b411b363SPhilipp Reisner 1208b411b363SPhilipp Reisner case WO_bdev_flush: 1209b411b363SPhilipp Reisner case WO_drain_io: 1210367a8d73SPhilipp Reisner if (rv == FE_STILL_LIVE) { 1211b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &mdev->current_epoch->flags); 1212b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 1213b411b363SPhilipp Reisner rv = drbd_flush_after_epoch(mdev, mdev->current_epoch); 1214367a8d73SPhilipp Reisner } 1215b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 1216b411b363SPhilipp Reisner return TRUE; 1217b411b363SPhilipp Reisner 1218b411b363SPhilipp Reisner /* The asender will send all the ACKs and barrier ACKs out, since 1219b411b363SPhilipp Reisner all EEs moved from the active_ee to the done_ee. We need to 1220b411b363SPhilipp Reisner provide a new epoch object for the EEs that come in soon */ 1221b411b363SPhilipp Reisner break; 1222b411b363SPhilipp Reisner } 1223b411b363SPhilipp Reisner 1224b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1225b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1226b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 1227b411b363SPhilipp Reisner if (!epoch) { 1228b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 1229d3db7b48SDan Carpenter issue_flush = !test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &mdev->current_epoch->flags); 1230b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 1231b411b363SPhilipp Reisner if (issue_flush) { 1232b411b363SPhilipp Reisner rv = drbd_flush_after_epoch(mdev, mdev->current_epoch); 1233b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 1234b411b363SPhilipp Reisner return TRUE; 1235b411b363SPhilipp Reisner } 1236b411b363SPhilipp Reisner 1237b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->done_ee); 1238b411b363SPhilipp Reisner 1239b411b363SPhilipp Reisner return TRUE; 1240b411b363SPhilipp Reisner } 1241b411b363SPhilipp Reisner 1242b411b363SPhilipp Reisner epoch->flags = 0; 1243b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1244b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1245b411b363SPhilipp Reisner 1246b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1247b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1248b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1249b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1250b411b363SPhilipp Reisner mdev->epochs++; 1251b411b363SPhilipp Reisner } else { 1252b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1253b411b363SPhilipp Reisner kfree(epoch); 1254b411b363SPhilipp Reisner } 1255b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1256b411b363SPhilipp Reisner 1257b411b363SPhilipp Reisner return TRUE; 1258b411b363SPhilipp Reisner } 1259b411b363SPhilipp Reisner 1260b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1261b411b363SPhilipp Reisner * and from receive_Data */ 1262b411b363SPhilipp Reisner static struct drbd_epoch_entry * 1263b411b363SPhilipp Reisner read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __must_hold(local) 1264b411b363SPhilipp Reisner { 12656666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1266b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1267b411b363SPhilipp Reisner struct bio_vec *bvec; 1268b411b363SPhilipp Reisner struct page *page; 1269b411b363SPhilipp Reisner struct bio *bio; 1270b411b363SPhilipp Reisner int dgs, ds, i, rr; 1271b411b363SPhilipp Reisner void *dig_in = mdev->int_dig_in; 1272b411b363SPhilipp Reisner void *dig_vv = mdev->int_dig_vv; 1273b411b363SPhilipp Reisner 1274b411b363SPhilipp Reisner dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ? 1275b411b363SPhilipp Reisner crypto_hash_digestsize(mdev->integrity_r_tfm) : 0; 1276b411b363SPhilipp Reisner 1277b411b363SPhilipp Reisner if (dgs) { 1278b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1279b411b363SPhilipp Reisner if (rr != dgs) { 1280b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data digest: read %d expected %d\n", 1281b411b363SPhilipp Reisner rr, dgs); 1282b411b363SPhilipp Reisner return NULL; 1283b411b363SPhilipp Reisner } 1284b411b363SPhilipp Reisner } 1285b411b363SPhilipp Reisner 1286b411b363SPhilipp Reisner data_size -= dgs; 1287b411b363SPhilipp Reisner 1288b411b363SPhilipp Reisner ERR_IF(data_size & 0x1ff) return NULL; 1289b411b363SPhilipp Reisner ERR_IF(data_size > DRBD_MAX_SEGMENT_SIZE) return NULL; 1290b411b363SPhilipp Reisner 12916666032aSLars Ellenberg /* even though we trust out peer, 12926666032aSLars Ellenberg * we sometimes have to double check. */ 12936666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 12946666032aSLars Ellenberg dev_err(DEV, "capacity: %llus < sector: %llus + size: %u\n", 12956666032aSLars Ellenberg (unsigned long long)capacity, 12966666032aSLars Ellenberg (unsigned long long)sector, data_size); 12976666032aSLars Ellenberg return NULL; 12986666032aSLars Ellenberg } 12996666032aSLars Ellenberg 1300b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1301b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1302b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1303b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1304b411b363SPhilipp Reisner if (!e) 1305b411b363SPhilipp Reisner return NULL; 1306b411b363SPhilipp Reisner bio = e->private_bio; 1307b411b363SPhilipp Reisner ds = data_size; 1308b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1309b411b363SPhilipp Reisner page = bvec->bv_page; 1310b411b363SPhilipp Reisner rr = drbd_recv(mdev, kmap(page), min_t(int, ds, PAGE_SIZE)); 1311b411b363SPhilipp Reisner kunmap(page); 1312b411b363SPhilipp Reisner if (rr != min_t(int, ds, PAGE_SIZE)) { 1313b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1314b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 1315b411b363SPhilipp Reisner rr, min_t(int, ds, PAGE_SIZE)); 1316b411b363SPhilipp Reisner return NULL; 1317b411b363SPhilipp Reisner } 1318b411b363SPhilipp Reisner ds -= rr; 1319b411b363SPhilipp Reisner } 1320b411b363SPhilipp Reisner 1321b411b363SPhilipp Reisner if (dgs) { 1322b411b363SPhilipp Reisner drbd_csum(mdev, mdev->integrity_r_tfm, bio, dig_vv); 1323b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1324b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED.\n"); 1325b411b363SPhilipp Reisner drbd_bcast_ee(mdev, "digest failed", 1326b411b363SPhilipp Reisner dgs, dig_in, dig_vv, e); 1327b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1328b411b363SPhilipp Reisner return NULL; 1329b411b363SPhilipp Reisner } 1330b411b363SPhilipp Reisner } 1331b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1332b411b363SPhilipp Reisner return e; 1333b411b363SPhilipp Reisner } 1334b411b363SPhilipp Reisner 1335b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1336b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1337b411b363SPhilipp Reisner */ 1338b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1339b411b363SPhilipp Reisner { 1340b411b363SPhilipp Reisner struct page *page; 1341b411b363SPhilipp Reisner int rr, rv = 1; 1342b411b363SPhilipp Reisner void *data; 1343b411b363SPhilipp Reisner 1344c3470cdeSLars Ellenberg if (!data_size) 1345c3470cdeSLars Ellenberg return TRUE; 1346c3470cdeSLars Ellenberg 1347b411b363SPhilipp Reisner page = drbd_pp_alloc(mdev, 1); 1348b411b363SPhilipp Reisner 1349b411b363SPhilipp Reisner data = kmap(page); 1350b411b363SPhilipp Reisner while (data_size) { 1351b411b363SPhilipp Reisner rr = drbd_recv(mdev, data, min_t(int, data_size, PAGE_SIZE)); 1352b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1353b411b363SPhilipp Reisner rv = 0; 1354b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 1355b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1356b411b363SPhilipp Reisner break; 1357b411b363SPhilipp Reisner } 1358b411b363SPhilipp Reisner data_size -= rr; 1359b411b363SPhilipp Reisner } 1360b411b363SPhilipp Reisner kunmap(page); 1361b411b363SPhilipp Reisner drbd_pp_free(mdev, page); 1362b411b363SPhilipp Reisner return rv; 1363b411b363SPhilipp Reisner } 1364b411b363SPhilipp Reisner 1365b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1366b411b363SPhilipp Reisner sector_t sector, int data_size) 1367b411b363SPhilipp Reisner { 1368b411b363SPhilipp Reisner struct bio_vec *bvec; 1369b411b363SPhilipp Reisner struct bio *bio; 1370b411b363SPhilipp Reisner int dgs, rr, i, expect; 1371b411b363SPhilipp Reisner void *dig_in = mdev->int_dig_in; 1372b411b363SPhilipp Reisner void *dig_vv = mdev->int_dig_vv; 1373b411b363SPhilipp Reisner 1374b411b363SPhilipp Reisner dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ? 1375b411b363SPhilipp Reisner crypto_hash_digestsize(mdev->integrity_r_tfm) : 0; 1376b411b363SPhilipp Reisner 1377b411b363SPhilipp Reisner if (dgs) { 1378b411b363SPhilipp Reisner rr = drbd_recv(mdev, dig_in, dgs); 1379b411b363SPhilipp Reisner if (rr != dgs) { 1380b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply digest: read %d expected %d\n", 1381b411b363SPhilipp Reisner rr, dgs); 1382b411b363SPhilipp Reisner return 0; 1383b411b363SPhilipp Reisner } 1384b411b363SPhilipp Reisner } 1385b411b363SPhilipp Reisner 1386b411b363SPhilipp Reisner data_size -= dgs; 1387b411b363SPhilipp Reisner 1388b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1389b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1390b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1391b411b363SPhilipp Reisner 1392b411b363SPhilipp Reisner bio = req->master_bio; 1393b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1394b411b363SPhilipp Reisner 1395b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1396b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1397b411b363SPhilipp Reisner rr = drbd_recv(mdev, 1398b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1399b411b363SPhilipp Reisner expect); 1400b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1401b411b363SPhilipp Reisner if (rr != expect) { 1402b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1403b411b363SPhilipp Reisner "read %d expected %d\n", 1404b411b363SPhilipp Reisner rr, expect); 1405b411b363SPhilipp Reisner return 0; 1406b411b363SPhilipp Reisner } 1407b411b363SPhilipp Reisner data_size -= rr; 1408b411b363SPhilipp Reisner } 1409b411b363SPhilipp Reisner 1410b411b363SPhilipp Reisner if (dgs) { 1411b411b363SPhilipp Reisner drbd_csum(mdev, mdev->integrity_r_tfm, bio, dig_vv); 1412b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1413b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1414b411b363SPhilipp Reisner return 0; 1415b411b363SPhilipp Reisner } 1416b411b363SPhilipp Reisner } 1417b411b363SPhilipp Reisner 1418b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1419b411b363SPhilipp Reisner return 1; 1420b411b363SPhilipp Reisner } 1421b411b363SPhilipp Reisner 1422b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1423b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 1424b411b363SPhilipp Reisner static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1425b411b363SPhilipp Reisner { 1426b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1427b411b363SPhilipp Reisner sector_t sector = e->sector; 1428b411b363SPhilipp Reisner int ok; 1429b411b363SPhilipp Reisner 1430b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 1431b411b363SPhilipp Reisner 1432b411b363SPhilipp Reisner if (likely(drbd_bio_uptodate(e->private_bio))) { 1433b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, e->size); 1434b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, e); 1435b411b363SPhilipp Reisner } else { 1436b411b363SPhilipp Reisner /* Record failure to sync */ 1437b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, e->size); 1438b411b363SPhilipp Reisner 1439b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1440b411b363SPhilipp Reisner } 1441b411b363SPhilipp Reisner dec_unacked(mdev); 1442b411b363SPhilipp Reisner 1443b411b363SPhilipp Reisner return ok; 1444b411b363SPhilipp Reisner } 1445b411b363SPhilipp Reisner 1446b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1447b411b363SPhilipp Reisner { 1448b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1449b411b363SPhilipp Reisner 1450b411b363SPhilipp Reisner e = read_in_block(mdev, ID_SYNCER, sector, data_size); 1451b411b363SPhilipp Reisner if (!e) { 1452b411b363SPhilipp Reisner put_ldev(mdev); 1453b411b363SPhilipp Reisner return FALSE; 1454b411b363SPhilipp Reisner } 1455b411b363SPhilipp Reisner 1456b411b363SPhilipp Reisner dec_rs_pending(mdev); 1457b411b363SPhilipp Reisner 1458b411b363SPhilipp Reisner e->private_bio->bi_end_io = drbd_endio_write_sec; 1459b411b363SPhilipp Reisner e->private_bio->bi_rw = WRITE; 1460b411b363SPhilipp Reisner e->w.cb = e_end_resync_block; 1461b411b363SPhilipp Reisner 1462b411b363SPhilipp Reisner inc_unacked(mdev); 1463b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1464b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1465b411b363SPhilipp Reisner 1466b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1467b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->sync_ee); 1468b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1469b411b363SPhilipp Reisner 1470b411b363SPhilipp Reisner drbd_generic_make_request(mdev, DRBD_FAULT_RS_WR, e->private_bio); 1471b411b363SPhilipp Reisner /* accounting done in endio */ 1472b411b363SPhilipp Reisner 1473b411b363SPhilipp Reisner maybe_kick_lo(mdev); 1474b411b363SPhilipp Reisner return TRUE; 1475b411b363SPhilipp Reisner } 1476b411b363SPhilipp Reisner 1477b411b363SPhilipp Reisner static int receive_DataReply(struct drbd_conf *mdev, struct p_header *h) 1478b411b363SPhilipp Reisner { 1479b411b363SPhilipp Reisner struct drbd_request *req; 1480b411b363SPhilipp Reisner sector_t sector; 1481b411b363SPhilipp Reisner unsigned int header_size, data_size; 1482b411b363SPhilipp Reisner int ok; 1483b411b363SPhilipp Reisner struct p_data *p = (struct p_data *)h; 1484b411b363SPhilipp Reisner 1485b411b363SPhilipp Reisner header_size = sizeof(*p) - sizeof(*h); 1486b411b363SPhilipp Reisner data_size = h->length - header_size; 1487b411b363SPhilipp Reisner 1488b411b363SPhilipp Reisner ERR_IF(data_size == 0) return FALSE; 1489b411b363SPhilipp Reisner 1490b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, header_size) != header_size) 1491b411b363SPhilipp Reisner return FALSE; 1492b411b363SPhilipp Reisner 1493b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1494b411b363SPhilipp Reisner 1495b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1496b411b363SPhilipp Reisner req = _ar_id_to_req(mdev, p->block_id, sector); 1497b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1498b411b363SPhilipp Reisner if (unlikely(!req)) { 1499b411b363SPhilipp Reisner dev_err(DEV, "Got a corrupt block_id/sector pair(1).\n"); 1500b411b363SPhilipp Reisner return FALSE; 1501b411b363SPhilipp Reisner } 1502b411b363SPhilipp Reisner 1503b411b363SPhilipp Reisner /* hlist_del(&req->colision) is done in _req_may_be_done, to avoid 1504b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1505b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1506b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1507b411b363SPhilipp Reisner 1508b411b363SPhilipp Reisner if (ok) 1509b411b363SPhilipp Reisner req_mod(req, data_received); 1510b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1511b411b363SPhilipp Reisner * I don't think we may complete this just yet 1512b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1513b411b363SPhilipp Reisner 1514b411b363SPhilipp Reisner return ok; 1515b411b363SPhilipp Reisner } 1516b411b363SPhilipp Reisner 1517b411b363SPhilipp Reisner static int receive_RSDataReply(struct drbd_conf *mdev, struct p_header *h) 1518b411b363SPhilipp Reisner { 1519b411b363SPhilipp Reisner sector_t sector; 1520b411b363SPhilipp Reisner unsigned int header_size, data_size; 1521b411b363SPhilipp Reisner int ok; 1522b411b363SPhilipp Reisner struct p_data *p = (struct p_data *)h; 1523b411b363SPhilipp Reisner 1524b411b363SPhilipp Reisner header_size = sizeof(*p) - sizeof(*h); 1525b411b363SPhilipp Reisner data_size = h->length - header_size; 1526b411b363SPhilipp Reisner 1527b411b363SPhilipp Reisner ERR_IF(data_size == 0) return FALSE; 1528b411b363SPhilipp Reisner 1529b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, header_size) != header_size) 1530b411b363SPhilipp Reisner return FALSE; 1531b411b363SPhilipp Reisner 1532b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1533b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1534b411b363SPhilipp Reisner 1535b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1536b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1537b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1538b411b363SPhilipp Reisner * or in drbd_endio_write_sec. */ 1539b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1540b411b363SPhilipp Reisner } else { 1541b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1542b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1543b411b363SPhilipp Reisner 1544b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1545b411b363SPhilipp Reisner 1546b411b363SPhilipp Reisner drbd_send_ack_dp(mdev, P_NEG_ACK, p); 1547b411b363SPhilipp Reisner } 1548b411b363SPhilipp Reisner 1549b411b363SPhilipp Reisner return ok; 1550b411b363SPhilipp Reisner } 1551b411b363SPhilipp Reisner 1552b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1553b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1554b411b363SPhilipp Reisner */ 1555b411b363SPhilipp Reisner static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel) 1556b411b363SPhilipp Reisner { 1557b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1558b411b363SPhilipp Reisner sector_t sector = e->sector; 1559b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1560b411b363SPhilipp Reisner int ok = 1, pcmd; 1561b411b363SPhilipp Reisner 1562b411b363SPhilipp Reisner if (e->flags & EE_IS_BARRIER) { 1563b411b363SPhilipp Reisner epoch = previous_epoch(mdev, e->epoch); 1564b411b363SPhilipp Reisner if (epoch) 1565b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE + (cancel ? EV_CLEANUP : 0)); 1566b411b363SPhilipp Reisner } 1567b411b363SPhilipp Reisner 1568b411b363SPhilipp Reisner if (mdev->net_conf->wire_protocol == DRBD_PROT_C) { 1569b411b363SPhilipp Reisner if (likely(drbd_bio_uptodate(e->private_bio))) { 1570b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1571b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1572b411b363SPhilipp Reisner e->flags & EE_MAY_SET_IN_SYNC) ? 1573b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1574b411b363SPhilipp Reisner ok &= drbd_send_ack(mdev, pcmd, e); 1575b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1576b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, e->size); 1577b411b363SPhilipp Reisner } else { 1578b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_NEG_ACK, e); 1579b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1580b411b363SPhilipp Reisner * maybe assert this? */ 1581b411b363SPhilipp Reisner } 1582b411b363SPhilipp Reisner dec_unacked(mdev); 1583b411b363SPhilipp Reisner } 1584b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1585b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1586b411b363SPhilipp Reisner if (mdev->net_conf->two_primaries) { 1587b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1588b411b363SPhilipp Reisner D_ASSERT(!hlist_unhashed(&e->colision)); 1589b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1590b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1591b411b363SPhilipp Reisner } else { 1592b411b363SPhilipp Reisner D_ASSERT(hlist_unhashed(&e->colision)); 1593b411b363SPhilipp Reisner } 1594b411b363SPhilipp Reisner 1595b411b363SPhilipp Reisner drbd_may_finish_epoch(mdev, e->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1596b411b363SPhilipp Reisner 1597b411b363SPhilipp Reisner return ok; 1598b411b363SPhilipp Reisner } 1599b411b363SPhilipp Reisner 1600b411b363SPhilipp Reisner static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused) 1601b411b363SPhilipp Reisner { 1602b411b363SPhilipp Reisner struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w; 1603b411b363SPhilipp Reisner int ok = 1; 1604b411b363SPhilipp Reisner 1605b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 1606b411b363SPhilipp Reisner ok = drbd_send_ack(mdev, P_DISCARD_ACK, e); 1607b411b363SPhilipp Reisner 1608b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1609b411b363SPhilipp Reisner D_ASSERT(!hlist_unhashed(&e->colision)); 1610b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1611b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1612b411b363SPhilipp Reisner 1613b411b363SPhilipp Reisner dec_unacked(mdev); 1614b411b363SPhilipp Reisner 1615b411b363SPhilipp Reisner return ok; 1616b411b363SPhilipp Reisner } 1617b411b363SPhilipp Reisner 1618b411b363SPhilipp Reisner /* Called from receive_Data. 1619b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1620b411b363SPhilipp Reisner * 1621b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1622b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1623b411b363SPhilipp Reisner * been sent. 1624b411b363SPhilipp Reisner * 1625b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1626b411b363SPhilipp Reisner * 1627b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1628b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1629b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1630b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1631b411b363SPhilipp Reisner * 1632b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1633b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1634b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1635b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1636b411b363SPhilipp Reisner * 1637b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1638b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1639b411b363SPhilipp Reisner static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq) 1640b411b363SPhilipp Reisner { 1641b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1642b411b363SPhilipp Reisner unsigned int p_seq; 1643b411b363SPhilipp Reisner long timeout; 1644b411b363SPhilipp Reisner int ret = 0; 1645b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1646b411b363SPhilipp Reisner for (;;) { 1647b411b363SPhilipp Reisner prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1648b411b363SPhilipp Reisner if (seq_le(packet_seq, mdev->peer_seq+1)) 1649b411b363SPhilipp Reisner break; 1650b411b363SPhilipp Reisner if (signal_pending(current)) { 1651b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1652b411b363SPhilipp Reisner break; 1653b411b363SPhilipp Reisner } 1654b411b363SPhilipp Reisner p_seq = mdev->peer_seq; 1655b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1656b411b363SPhilipp Reisner timeout = schedule_timeout(30*HZ); 1657b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1658b411b363SPhilipp Reisner if (timeout == 0 && p_seq == mdev->peer_seq) { 1659b411b363SPhilipp Reisner ret = -ETIMEDOUT; 1660b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n"); 1661b411b363SPhilipp Reisner break; 1662b411b363SPhilipp Reisner } 1663b411b363SPhilipp Reisner } 1664b411b363SPhilipp Reisner finish_wait(&mdev->seq_wait, &wait); 1665b411b363SPhilipp Reisner if (mdev->peer_seq+1 == packet_seq) 1666b411b363SPhilipp Reisner mdev->peer_seq++; 1667b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1668b411b363SPhilipp Reisner return ret; 1669b411b363SPhilipp Reisner } 1670b411b363SPhilipp Reisner 1671b411b363SPhilipp Reisner /* mirrored write */ 1672b411b363SPhilipp Reisner static int receive_Data(struct drbd_conf *mdev, struct p_header *h) 1673b411b363SPhilipp Reisner { 1674b411b363SPhilipp Reisner sector_t sector; 1675b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1676b411b363SPhilipp Reisner struct p_data *p = (struct p_data *)h; 1677b411b363SPhilipp Reisner int header_size, data_size; 1678b411b363SPhilipp Reisner int rw = WRITE; 1679b411b363SPhilipp Reisner u32 dp_flags; 1680b411b363SPhilipp Reisner 1681b411b363SPhilipp Reisner header_size = sizeof(*p) - sizeof(*h); 1682b411b363SPhilipp Reisner data_size = h->length - header_size; 1683b411b363SPhilipp Reisner 1684b411b363SPhilipp Reisner ERR_IF(data_size == 0) return FALSE; 1685b411b363SPhilipp Reisner 1686b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, header_size) != header_size) 1687b411b363SPhilipp Reisner return FALSE; 1688b411b363SPhilipp Reisner 1689b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 1690b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1691b411b363SPhilipp Reisner dev_err(DEV, "Can not write mirrored data block " 1692b411b363SPhilipp Reisner "to local disk.\n"); 1693b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1694b411b363SPhilipp Reisner if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num)) 1695b411b363SPhilipp Reisner mdev->peer_seq++; 1696b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1697b411b363SPhilipp Reisner 1698b411b363SPhilipp Reisner drbd_send_ack_dp(mdev, P_NEG_ACK, p); 1699b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1700b411b363SPhilipp Reisner return drbd_drain_block(mdev, data_size); 1701b411b363SPhilipp Reisner } 1702b411b363SPhilipp Reisner 1703b411b363SPhilipp Reisner /* get_ldev(mdev) successful. 1704b411b363SPhilipp Reisner * Corresponding put_ldev done either below (on various errors), 1705b411b363SPhilipp Reisner * or in drbd_endio_write_sec, if we successfully submit the data at 1706b411b363SPhilipp Reisner * the end of this function. */ 1707b411b363SPhilipp Reisner 1708b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1709b411b363SPhilipp Reisner e = read_in_block(mdev, p->block_id, sector, data_size); 1710b411b363SPhilipp Reisner if (!e) { 1711b411b363SPhilipp Reisner put_ldev(mdev); 1712b411b363SPhilipp Reisner return FALSE; 1713b411b363SPhilipp Reisner } 1714b411b363SPhilipp Reisner 1715b411b363SPhilipp Reisner e->private_bio->bi_end_io = drbd_endio_write_sec; 1716b411b363SPhilipp Reisner e->w.cb = e_end_block; 1717b411b363SPhilipp Reisner 1718b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1719b411b363SPhilipp Reisner e->epoch = mdev->current_epoch; 1720b411b363SPhilipp Reisner atomic_inc(&e->epoch->epoch_size); 1721b411b363SPhilipp Reisner atomic_inc(&e->epoch->active); 1722b411b363SPhilipp Reisner 1723b411b363SPhilipp Reisner if (mdev->write_ordering == WO_bio_barrier && atomic_read(&e->epoch->epoch_size) == 1) { 1724b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1725b411b363SPhilipp Reisner /* Issue a barrier if we start a new epoch, and the previous epoch 1726b411b363SPhilipp Reisner was not a epoch containing a single request which already was 1727b411b363SPhilipp Reisner a Barrier. */ 1728b411b363SPhilipp Reisner epoch = list_entry(e->epoch->list.prev, struct drbd_epoch, list); 1729b411b363SPhilipp Reisner if (epoch == e->epoch) { 1730b411b363SPhilipp Reisner set_bit(DE_CONTAINS_A_BARRIER, &e->epoch->flags); 1731b411b363SPhilipp Reisner rw |= (1<<BIO_RW_BARRIER); 1732b411b363SPhilipp Reisner e->flags |= EE_IS_BARRIER; 1733b411b363SPhilipp Reisner } else { 1734b411b363SPhilipp Reisner if (atomic_read(&epoch->epoch_size) > 1 || 1735b411b363SPhilipp Reisner !test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags)) { 1736b411b363SPhilipp Reisner set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags); 1737b411b363SPhilipp Reisner set_bit(DE_CONTAINS_A_BARRIER, &e->epoch->flags); 1738b411b363SPhilipp Reisner rw |= (1<<BIO_RW_BARRIER); 1739b411b363SPhilipp Reisner e->flags |= EE_IS_BARRIER; 1740b411b363SPhilipp Reisner } 1741b411b363SPhilipp Reisner } 1742b411b363SPhilipp Reisner } 1743b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1744b411b363SPhilipp Reisner 1745b411b363SPhilipp Reisner dp_flags = be32_to_cpu(p->dp_flags); 1746b411b363SPhilipp Reisner if (dp_flags & DP_HARDBARRIER) { 1747b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED would have submitted barrier request\n"); 1748b411b363SPhilipp Reisner /* rw |= (1<<BIO_RW_BARRIER); */ 1749b411b363SPhilipp Reisner } 1750b411b363SPhilipp Reisner if (dp_flags & DP_RW_SYNC) 1751b411b363SPhilipp Reisner rw |= (1<<BIO_RW_SYNCIO) | (1<<BIO_RW_UNPLUG); 1752b411b363SPhilipp Reisner if (dp_flags & DP_MAY_SET_IN_SYNC) 1753b411b363SPhilipp Reisner e->flags |= EE_MAY_SET_IN_SYNC; 1754b411b363SPhilipp Reisner 1755b411b363SPhilipp Reisner /* I'm the receiver, I do hold a net_cnt reference. */ 1756b411b363SPhilipp Reisner if (!mdev->net_conf->two_primaries) { 1757b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1758b411b363SPhilipp Reisner } else { 1759b411b363SPhilipp Reisner /* don't get the req_lock yet, 1760b411b363SPhilipp Reisner * we may sleep in drbd_wait_peer_seq */ 1761b411b363SPhilipp Reisner const int size = e->size; 1762b411b363SPhilipp Reisner const int discard = test_bit(DISCARD_CONCURRENT, &mdev->flags); 1763b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1764b411b363SPhilipp Reisner struct drbd_request *i; 1765b411b363SPhilipp Reisner struct hlist_node *n; 1766b411b363SPhilipp Reisner struct hlist_head *slot; 1767b411b363SPhilipp Reisner int first; 1768b411b363SPhilipp Reisner 1769b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 1770b411b363SPhilipp Reisner BUG_ON(mdev->ee_hash == NULL); 1771b411b363SPhilipp Reisner BUG_ON(mdev->tl_hash == NULL); 1772b411b363SPhilipp Reisner 1773b411b363SPhilipp Reisner /* conflict detection and handling: 1774b411b363SPhilipp Reisner * 1. wait on the sequence number, 1775b411b363SPhilipp Reisner * in case this data packet overtook ACK packets. 1776b411b363SPhilipp Reisner * 2. check our hash tables for conflicting requests. 1777b411b363SPhilipp Reisner * we only need to walk the tl_hash, since an ee can not 1778b411b363SPhilipp Reisner * have a conflict with an other ee: on the submitting 1779b411b363SPhilipp Reisner * node, the corresponding req had already been conflicting, 1780b411b363SPhilipp Reisner * and a conflicting req is never sent. 1781b411b363SPhilipp Reisner * 1782b411b363SPhilipp Reisner * Note: for two_primaries, we are protocol C, 1783b411b363SPhilipp Reisner * so there cannot be any request that is DONE 1784b411b363SPhilipp Reisner * but still on the transfer log. 1785b411b363SPhilipp Reisner * 1786b411b363SPhilipp Reisner * unconditionally add to the ee_hash. 1787b411b363SPhilipp Reisner * 1788b411b363SPhilipp Reisner * if no conflicting request is found: 1789b411b363SPhilipp Reisner * submit. 1790b411b363SPhilipp Reisner * 1791b411b363SPhilipp Reisner * if any conflicting request is found 1792b411b363SPhilipp Reisner * that has not yet been acked, 1793b411b363SPhilipp Reisner * AND I have the "discard concurrent writes" flag: 1794b411b363SPhilipp Reisner * queue (via done_ee) the P_DISCARD_ACK; OUT. 1795b411b363SPhilipp Reisner * 1796b411b363SPhilipp Reisner * if any conflicting request is found: 1797b411b363SPhilipp Reisner * block the receiver, waiting on misc_wait 1798b411b363SPhilipp Reisner * until no more conflicting requests are there, 1799b411b363SPhilipp Reisner * or we get interrupted (disconnect). 1800b411b363SPhilipp Reisner * 1801b411b363SPhilipp Reisner * we do not just write after local io completion of those 1802b411b363SPhilipp Reisner * requests, but only after req is done completely, i.e. 1803b411b363SPhilipp Reisner * we wait for the P_DISCARD_ACK to arrive! 1804b411b363SPhilipp Reisner * 1805b411b363SPhilipp Reisner * then proceed normally, i.e. submit. 1806b411b363SPhilipp Reisner */ 1807b411b363SPhilipp Reisner if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num))) 1808b411b363SPhilipp Reisner goto out_interrupted; 1809b411b363SPhilipp Reisner 1810b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1811b411b363SPhilipp Reisner 1812b411b363SPhilipp Reisner hlist_add_head(&e->colision, ee_hash_slot(mdev, sector)); 1813b411b363SPhilipp Reisner 1814b411b363SPhilipp Reisner #define OVERLAPS overlaps(i->sector, i->size, sector, size) 1815b411b363SPhilipp Reisner slot = tl_hash_slot(mdev, sector); 1816b411b363SPhilipp Reisner first = 1; 1817b411b363SPhilipp Reisner for (;;) { 1818b411b363SPhilipp Reisner int have_unacked = 0; 1819b411b363SPhilipp Reisner int have_conflict = 0; 1820b411b363SPhilipp Reisner prepare_to_wait(&mdev->misc_wait, &wait, 1821b411b363SPhilipp Reisner TASK_INTERRUPTIBLE); 1822b411b363SPhilipp Reisner hlist_for_each_entry(i, n, slot, colision) { 1823b411b363SPhilipp Reisner if (OVERLAPS) { 1824b411b363SPhilipp Reisner /* only ALERT on first iteration, 1825b411b363SPhilipp Reisner * we may be woken up early... */ 1826b411b363SPhilipp Reisner if (first) 1827b411b363SPhilipp Reisner dev_alert(DEV, "%s[%u] Concurrent local write detected!" 1828b411b363SPhilipp Reisner " new: %llus +%u; pending: %llus +%u\n", 1829b411b363SPhilipp Reisner current->comm, current->pid, 1830b411b363SPhilipp Reisner (unsigned long long)sector, size, 1831b411b363SPhilipp Reisner (unsigned long long)i->sector, i->size); 1832b411b363SPhilipp Reisner if (i->rq_state & RQ_NET_PENDING) 1833b411b363SPhilipp Reisner ++have_unacked; 1834b411b363SPhilipp Reisner ++have_conflict; 1835b411b363SPhilipp Reisner } 1836b411b363SPhilipp Reisner } 1837b411b363SPhilipp Reisner #undef OVERLAPS 1838b411b363SPhilipp Reisner if (!have_conflict) 1839b411b363SPhilipp Reisner break; 1840b411b363SPhilipp Reisner 1841b411b363SPhilipp Reisner /* Discard Ack only for the _first_ iteration */ 1842b411b363SPhilipp Reisner if (first && discard && have_unacked) { 1843b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n", 1844b411b363SPhilipp Reisner (unsigned long long)sector); 1845b411b363SPhilipp Reisner inc_unacked(mdev); 1846b411b363SPhilipp Reisner e->w.cb = e_send_discard_ack; 1847b411b363SPhilipp Reisner list_add_tail(&e->w.list, &mdev->done_ee); 1848b411b363SPhilipp Reisner 1849b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1850b411b363SPhilipp Reisner 1851b411b363SPhilipp Reisner /* we could probably send that P_DISCARD_ACK ourselves, 1852b411b363SPhilipp Reisner * but I don't like the receiver using the msock */ 1853b411b363SPhilipp Reisner 1854b411b363SPhilipp Reisner put_ldev(mdev); 1855b411b363SPhilipp Reisner wake_asender(mdev); 1856b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1857b411b363SPhilipp Reisner return TRUE; 1858b411b363SPhilipp Reisner } 1859b411b363SPhilipp Reisner 1860b411b363SPhilipp Reisner if (signal_pending(current)) { 1861b411b363SPhilipp Reisner hlist_del_init(&e->colision); 1862b411b363SPhilipp Reisner 1863b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1864b411b363SPhilipp Reisner 1865b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1866b411b363SPhilipp Reisner goto out_interrupted; 1867b411b363SPhilipp Reisner } 1868b411b363SPhilipp Reisner 1869b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1870b411b363SPhilipp Reisner if (first) { 1871b411b363SPhilipp Reisner first = 0; 1872b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [W AFTERWARDS] " 1873b411b363SPhilipp Reisner "sec=%llus\n", (unsigned long long)sector); 1874b411b363SPhilipp Reisner } else if (discard) { 1875b411b363SPhilipp Reisner /* we had none on the first iteration. 1876b411b363SPhilipp Reisner * there must be none now. */ 1877b411b363SPhilipp Reisner D_ASSERT(have_unacked == 0); 1878b411b363SPhilipp Reisner } 1879b411b363SPhilipp Reisner schedule(); 1880b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 1881b411b363SPhilipp Reisner } 1882b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1883b411b363SPhilipp Reisner } 1884b411b363SPhilipp Reisner 1885b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->active_ee); 1886b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 1887b411b363SPhilipp Reisner 1888b411b363SPhilipp Reisner switch (mdev->net_conf->wire_protocol) { 1889b411b363SPhilipp Reisner case DRBD_PROT_C: 1890b411b363SPhilipp Reisner inc_unacked(mdev); 1891b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 1892b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1893b411b363SPhilipp Reisner break; 1894b411b363SPhilipp Reisner case DRBD_PROT_B: 1895b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 1896b411b363SPhilipp Reisner * sends on the msock, but anyways */ 1897b411b363SPhilipp Reisner drbd_send_ack(mdev, P_RECV_ACK, e); 1898b411b363SPhilipp Reisner break; 1899b411b363SPhilipp Reisner case DRBD_PROT_A: 1900b411b363SPhilipp Reisner /* nothing to do */ 1901b411b363SPhilipp Reisner break; 1902b411b363SPhilipp Reisner } 1903b411b363SPhilipp Reisner 1904b411b363SPhilipp Reisner if (mdev->state.pdsk == D_DISKLESS) { 1905b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 1906b411b363SPhilipp Reisner drbd_set_out_of_sync(mdev, e->sector, e->size); 1907b411b363SPhilipp Reisner e->flags |= EE_CALL_AL_COMPLETE_IO; 1908b411b363SPhilipp Reisner drbd_al_begin_io(mdev, e->sector); 1909b411b363SPhilipp Reisner } 1910b411b363SPhilipp Reisner 1911b411b363SPhilipp Reisner e->private_bio->bi_rw = rw; 1912b411b363SPhilipp Reisner drbd_generic_make_request(mdev, DRBD_FAULT_DT_WR, e->private_bio); 1913b411b363SPhilipp Reisner /* accounting done in endio */ 1914b411b363SPhilipp Reisner 1915b411b363SPhilipp Reisner maybe_kick_lo(mdev); 1916b411b363SPhilipp Reisner return TRUE; 1917b411b363SPhilipp Reisner 1918b411b363SPhilipp Reisner out_interrupted: 1919b411b363SPhilipp Reisner /* yes, the epoch_size now is imbalanced. 1920b411b363SPhilipp Reisner * but we drop the connection anyways, so we don't have a chance to 1921b411b363SPhilipp Reisner * receive a barrier... atomic_inc(&mdev->epoch_size); */ 1922b411b363SPhilipp Reisner put_ldev(mdev); 1923b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 1924b411b363SPhilipp Reisner return FALSE; 1925b411b363SPhilipp Reisner } 1926b411b363SPhilipp Reisner 1927b411b363SPhilipp Reisner static int receive_DataRequest(struct drbd_conf *mdev, struct p_header *h) 1928b411b363SPhilipp Reisner { 1929b411b363SPhilipp Reisner sector_t sector; 1930b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1931b411b363SPhilipp Reisner struct drbd_epoch_entry *e; 1932b411b363SPhilipp Reisner struct digest_info *di = NULL; 1933b411b363SPhilipp Reisner int size, digest_size; 1934b411b363SPhilipp Reisner unsigned int fault_type; 1935b411b363SPhilipp Reisner struct p_block_req *p = 1936b411b363SPhilipp Reisner (struct p_block_req *)h; 1937b411b363SPhilipp Reisner const int brps = sizeof(*p)-sizeof(*h); 1938b411b363SPhilipp Reisner 1939b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, brps) != brps) 1940b411b363SPhilipp Reisner return FALSE; 1941b411b363SPhilipp Reisner 1942b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1943b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 1944b411b363SPhilipp Reisner 1945b411b363SPhilipp Reisner if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) { 1946b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 1947b411b363SPhilipp Reisner (unsigned long long)sector, size); 1948b411b363SPhilipp Reisner return FALSE; 1949b411b363SPhilipp Reisner } 1950b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 1951b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 1952b411b363SPhilipp Reisner (unsigned long long)sector, size); 1953b411b363SPhilipp Reisner return FALSE; 1954b411b363SPhilipp Reisner } 1955b411b363SPhilipp Reisner 1956b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 1957b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1958b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 1959b411b363SPhilipp Reisner "no local data.\n"); 1960b411b363SPhilipp Reisner drbd_send_ack_rp(mdev, h->command == P_DATA_REQUEST ? P_NEG_DREPLY : 1961b411b363SPhilipp Reisner P_NEG_RS_DREPLY , p); 1962c3470cdeSLars Ellenberg return drbd_drain_block(mdev, h->length - brps); 1963b411b363SPhilipp Reisner } 1964b411b363SPhilipp Reisner 1965b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1966b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1967b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1968b411b363SPhilipp Reisner e = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 1969b411b363SPhilipp Reisner if (!e) { 1970b411b363SPhilipp Reisner put_ldev(mdev); 1971b411b363SPhilipp Reisner return FALSE; 1972b411b363SPhilipp Reisner } 1973b411b363SPhilipp Reisner 1974b411b363SPhilipp Reisner e->private_bio->bi_rw = READ; 1975b411b363SPhilipp Reisner e->private_bio->bi_end_io = drbd_endio_read_sec; 1976b411b363SPhilipp Reisner 1977b411b363SPhilipp Reisner switch (h->command) { 1978b411b363SPhilipp Reisner case P_DATA_REQUEST: 1979b411b363SPhilipp Reisner e->w.cb = w_e_end_data_req; 1980b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 1981b411b363SPhilipp Reisner break; 1982b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 1983b411b363SPhilipp Reisner e->w.cb = w_e_end_rsdata_req; 1984b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 1985b411b363SPhilipp Reisner /* Eventually this should become asynchronously. Currently it 1986b411b363SPhilipp Reisner * blocks the whole receiver just to delay the reading of a 1987b411b363SPhilipp Reisner * resync data block. 1988b411b363SPhilipp Reisner * the drbd_work_queue mechanism is made for this... 1989b411b363SPhilipp Reisner */ 1990b411b363SPhilipp Reisner if (!drbd_rs_begin_io(mdev, sector)) { 1991b411b363SPhilipp Reisner /* we have been interrupted, 1992b411b363SPhilipp Reisner * probably connection lost! */ 1993b411b363SPhilipp Reisner D_ASSERT(signal_pending(current)); 1994b411b363SPhilipp Reisner goto out_free_e; 1995b411b363SPhilipp Reisner } 1996b411b363SPhilipp Reisner break; 1997b411b363SPhilipp Reisner 1998b411b363SPhilipp Reisner case P_OV_REPLY: 1999b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2000b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2001b411b363SPhilipp Reisner digest_size = h->length - brps ; 2002b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2003b411b363SPhilipp Reisner if (!di) 2004b411b363SPhilipp Reisner goto out_free_e; 2005b411b363SPhilipp Reisner 2006b411b363SPhilipp Reisner di->digest_size = digest_size; 2007b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2008b411b363SPhilipp Reisner 2009b411b363SPhilipp Reisner if (drbd_recv(mdev, di->digest, digest_size) != digest_size) 2010b411b363SPhilipp Reisner goto out_free_e; 2011b411b363SPhilipp Reisner 2012b411b363SPhilipp Reisner e->block_id = (u64)(unsigned long)di; 2013b411b363SPhilipp Reisner if (h->command == P_CSUM_RS_REQUEST) { 2014b411b363SPhilipp Reisner D_ASSERT(mdev->agreed_pro_version >= 89); 2015b411b363SPhilipp Reisner e->w.cb = w_e_end_csum_rs_req; 2016b411b363SPhilipp Reisner } else if (h->command == P_OV_REPLY) { 2017b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_reply; 2018b411b363SPhilipp Reisner dec_rs_pending(mdev); 2019b411b363SPhilipp Reisner break; 2020b411b363SPhilipp Reisner } 2021b411b363SPhilipp Reisner 2022b411b363SPhilipp Reisner if (!drbd_rs_begin_io(mdev, sector)) { 2023b411b363SPhilipp Reisner /* we have been interrupted, probably connection lost! */ 2024b411b363SPhilipp Reisner D_ASSERT(signal_pending(current)); 2025b411b363SPhilipp Reisner goto out_free_e; 2026b411b363SPhilipp Reisner } 2027b411b363SPhilipp Reisner break; 2028b411b363SPhilipp Reisner 2029b411b363SPhilipp Reisner case P_OV_REQUEST: 2030b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && 2031b411b363SPhilipp Reisner mdev->state.conn != C_VERIFY_T) 2032b411b363SPhilipp Reisner dev_warn(DEV, "ASSERT FAILED: got P_OV_REQUEST while being %s\n", 2033b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 2034b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 2035b411b363SPhilipp Reisner mdev->agreed_pro_version >= 90) { 2036b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2037b411b363SPhilipp Reisner mdev->ov_position = sector; 2038b411b363SPhilipp Reisner mdev->ov_left = mdev->rs_total - BM_SECT_TO_BIT(sector); 2039b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2040b411b363SPhilipp Reisner (unsigned long long)sector); 2041b411b363SPhilipp Reisner } 2042b411b363SPhilipp Reisner e->w.cb = w_e_end_ov_req; 2043b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2044b411b363SPhilipp Reisner /* Eventually this should become asynchronous. Currently it 2045b411b363SPhilipp Reisner * blocks the whole receiver just to delay the reading of a 2046b411b363SPhilipp Reisner * resync data block. 2047b411b363SPhilipp Reisner * the drbd_work_queue mechanism is made for this... 2048b411b363SPhilipp Reisner */ 2049b411b363SPhilipp Reisner if (!drbd_rs_begin_io(mdev, sector)) { 2050b411b363SPhilipp Reisner /* we have been interrupted, 2051b411b363SPhilipp Reisner * probably connection lost! */ 2052b411b363SPhilipp Reisner D_ASSERT(signal_pending(current)); 2053b411b363SPhilipp Reisner goto out_free_e; 2054b411b363SPhilipp Reisner } 2055b411b363SPhilipp Reisner break; 2056b411b363SPhilipp Reisner 2057b411b363SPhilipp Reisner 2058b411b363SPhilipp Reisner default: 2059b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2060b411b363SPhilipp Reisner cmdname(h->command)); 2061b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 2062b411b363SPhilipp Reisner } 2063b411b363SPhilipp Reisner 2064b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 2065b411b363SPhilipp Reisner list_add(&e->w.list, &mdev->read_ee); 2066b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 2067b411b363SPhilipp Reisner 2068b411b363SPhilipp Reisner inc_unacked(mdev); 2069b411b363SPhilipp Reisner 2070b411b363SPhilipp Reisner drbd_generic_make_request(mdev, fault_type, e->private_bio); 2071b411b363SPhilipp Reisner maybe_kick_lo(mdev); 2072b411b363SPhilipp Reisner 2073b411b363SPhilipp Reisner return TRUE; 2074b411b363SPhilipp Reisner 2075b411b363SPhilipp Reisner out_free_e: 2076b411b363SPhilipp Reisner kfree(di); 2077b411b363SPhilipp Reisner put_ldev(mdev); 2078b411b363SPhilipp Reisner drbd_free_ee(mdev, e); 2079b411b363SPhilipp Reisner return FALSE; 2080b411b363SPhilipp Reisner } 2081b411b363SPhilipp Reisner 2082b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2083b411b363SPhilipp Reisner { 2084b411b363SPhilipp Reisner int self, peer, rv = -100; 2085b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2086b411b363SPhilipp Reisner 2087b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2088b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2089b411b363SPhilipp Reisner 2090b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2091b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2092b411b363SPhilipp Reisner 2093b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_0p) { 2094b411b363SPhilipp Reisner case ASB_CONSENSUS: 2095b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2096b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2097b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2098b411b363SPhilipp Reisner break; 2099b411b363SPhilipp Reisner case ASB_DISCONNECT: 2100b411b363SPhilipp Reisner break; 2101b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2102b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2103b411b363SPhilipp Reisner rv = -1; 2104b411b363SPhilipp Reisner break; 2105b411b363SPhilipp Reisner } 2106b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2107b411b363SPhilipp Reisner rv = 1; 2108b411b363SPhilipp Reisner break; 2109b411b363SPhilipp Reisner } 2110b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2111b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2112b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2113b411b363SPhilipp Reisner rv = 1; 2114b411b363SPhilipp Reisner break; 2115b411b363SPhilipp Reisner } 2116b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2117b411b363SPhilipp Reisner rv = -1; 2118b411b363SPhilipp Reisner break; 2119b411b363SPhilipp Reisner } 2120b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2121ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2122b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2123b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2124b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2125b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2126b411b363SPhilipp Reisner ? -1 : 1; 2127b411b363SPhilipp Reisner break; 2128b411b363SPhilipp Reisner } else { 2129b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2130b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2131b411b363SPhilipp Reisner } 2132b411b363SPhilipp Reisner if (mdev->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2133b411b363SPhilipp Reisner break; 2134b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2135b411b363SPhilipp Reisner if (ch_self < ch_peer) 2136b411b363SPhilipp Reisner rv = -1; 2137b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2138b411b363SPhilipp Reisner rv = 1; 2139b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2140b411b363SPhilipp Reisner /* Well, then use something else. */ 2141b411b363SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->flags) 2142b411b363SPhilipp Reisner ? -1 : 1; 2143b411b363SPhilipp Reisner break; 2144b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2145b411b363SPhilipp Reisner rv = -1; 2146b411b363SPhilipp Reisner break; 2147b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2148b411b363SPhilipp Reisner rv = 1; 2149b411b363SPhilipp Reisner } 2150b411b363SPhilipp Reisner 2151b411b363SPhilipp Reisner return rv; 2152b411b363SPhilipp Reisner } 2153b411b363SPhilipp Reisner 2154b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2155b411b363SPhilipp Reisner { 2156b411b363SPhilipp Reisner int self, peer, hg, rv = -100; 2157b411b363SPhilipp Reisner 2158b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2159b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2160b411b363SPhilipp Reisner 2161b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_1p) { 2162b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2163b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2164b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2165b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2166b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2167b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2168b411b363SPhilipp Reisner break; 2169b411b363SPhilipp Reisner case ASB_DISCONNECT: 2170b411b363SPhilipp Reisner break; 2171b411b363SPhilipp Reisner case ASB_CONSENSUS: 2172b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2173b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2174b411b363SPhilipp Reisner rv = hg; 2175b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2176b411b363SPhilipp Reisner rv = hg; 2177b411b363SPhilipp Reisner break; 2178b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2179b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2180b411b363SPhilipp Reisner break; 2181b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2182b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2183b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2184b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2185b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2186b411b363SPhilipp Reisner self = drbd_set_role(mdev, R_SECONDARY, 0); 2187b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2188b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2189b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2190b411b363SPhilipp Reisner self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2191b411b363SPhilipp Reisner if (self != SS_SUCCESS) { 2192b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2193b411b363SPhilipp Reisner } else { 2194b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2195b411b363SPhilipp Reisner rv = hg; 2196b411b363SPhilipp Reisner } 2197b411b363SPhilipp Reisner } else 2198b411b363SPhilipp Reisner rv = hg; 2199b411b363SPhilipp Reisner } 2200b411b363SPhilipp Reisner 2201b411b363SPhilipp Reisner return rv; 2202b411b363SPhilipp Reisner } 2203b411b363SPhilipp Reisner 2204b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2205b411b363SPhilipp Reisner { 2206b411b363SPhilipp Reisner int self, peer, hg, rv = -100; 2207b411b363SPhilipp Reisner 2208b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2209b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2210b411b363SPhilipp Reisner 2211b411b363SPhilipp Reisner switch (mdev->net_conf->after_sb_2p) { 2212b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2213b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2214b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2215b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2216b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2217b411b363SPhilipp Reisner case ASB_CONSENSUS: 2218b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2219b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2220b411b363SPhilipp Reisner break; 2221b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2222b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2223b411b363SPhilipp Reisner break; 2224b411b363SPhilipp Reisner case ASB_DISCONNECT: 2225b411b363SPhilipp Reisner break; 2226b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2227b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2228b411b363SPhilipp Reisner if (hg == -1) { 2229b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2230b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2231b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2232b411b363SPhilipp Reisner self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2233b411b363SPhilipp Reisner if (self != SS_SUCCESS) { 2234b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2235b411b363SPhilipp Reisner } else { 2236b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2237b411b363SPhilipp Reisner rv = hg; 2238b411b363SPhilipp Reisner } 2239b411b363SPhilipp Reisner } else 2240b411b363SPhilipp Reisner rv = hg; 2241b411b363SPhilipp Reisner } 2242b411b363SPhilipp Reisner 2243b411b363SPhilipp Reisner return rv; 2244b411b363SPhilipp Reisner } 2245b411b363SPhilipp Reisner 2246b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2247b411b363SPhilipp Reisner u64 bits, u64 flags) 2248b411b363SPhilipp Reisner { 2249b411b363SPhilipp Reisner if (!uuid) { 2250b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2251b411b363SPhilipp Reisner return; 2252b411b363SPhilipp Reisner } 2253b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2254b411b363SPhilipp Reisner text, 2255b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2256b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2257b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2258b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2259b411b363SPhilipp Reisner (unsigned long long)bits, 2260b411b363SPhilipp Reisner (unsigned long long)flags); 2261b411b363SPhilipp Reisner } 2262b411b363SPhilipp Reisner 2263b411b363SPhilipp Reisner /* 2264b411b363SPhilipp Reisner 100 after split brain try auto recover 2265b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2266b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2267b411b363SPhilipp Reisner 0 no Sync 2268b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2269b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2270b411b363SPhilipp Reisner -100 after split brain, disconnect 2271b411b363SPhilipp Reisner -1000 unrelated data 2272b411b363SPhilipp Reisner */ 2273b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2274b411b363SPhilipp Reisner { 2275b411b363SPhilipp Reisner u64 self, peer; 2276b411b363SPhilipp Reisner int i, j; 2277b411b363SPhilipp Reisner 2278b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2279b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2280b411b363SPhilipp Reisner 2281b411b363SPhilipp Reisner *rule_nr = 10; 2282b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2283b411b363SPhilipp Reisner return 0; 2284b411b363SPhilipp Reisner 2285b411b363SPhilipp Reisner *rule_nr = 20; 2286b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2287b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2288b411b363SPhilipp Reisner return -2; 2289b411b363SPhilipp Reisner 2290b411b363SPhilipp Reisner *rule_nr = 30; 2291b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2292b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2293b411b363SPhilipp Reisner return 2; 2294b411b363SPhilipp Reisner 2295b411b363SPhilipp Reisner if (self == peer) { 2296b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2297b411b363SPhilipp Reisner 2298b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2299b411b363SPhilipp Reisner 2300b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2301b411b363SPhilipp Reisner return -1001; 2302b411b363SPhilipp Reisner 2303b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2304b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2305b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2306b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2307b411b363SPhilipp Reisner 2308b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2309b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2310b411b363SPhilipp Reisner *rule_nr = 34; 2311b411b363SPhilipp Reisner } else { 2312b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2313b411b363SPhilipp Reisner *rule_nr = 36; 2314b411b363SPhilipp Reisner } 2315b411b363SPhilipp Reisner 2316b411b363SPhilipp Reisner return 1; 2317b411b363SPhilipp Reisner } 2318b411b363SPhilipp Reisner 2319b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2320b411b363SPhilipp Reisner 2321b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2322b411b363SPhilipp Reisner return -1001; 2323b411b363SPhilipp Reisner 2324b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2325b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2326b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2327b411b363SPhilipp Reisner 2328b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2329b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2330b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2331b411b363SPhilipp Reisner 2332b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2333b411b363SPhilipp Reisner *rule_nr = 35; 2334b411b363SPhilipp Reisner } else { 2335b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2336b411b363SPhilipp Reisner *rule_nr = 37; 2337b411b363SPhilipp Reisner } 2338b411b363SPhilipp Reisner 2339b411b363SPhilipp Reisner return -1; 2340b411b363SPhilipp Reisner } 2341b411b363SPhilipp Reisner 2342b411b363SPhilipp Reisner /* Common power [off|failure] */ 2343b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2344b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2345b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2346b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2347b411b363SPhilipp Reisner *rule_nr = 40; 2348b411b363SPhilipp Reisner 2349b411b363SPhilipp Reisner switch (rct) { 2350b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2351b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2352b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2353b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2354b411b363SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->flags); 2355b411b363SPhilipp Reisner return dc ? -1 : 1; 2356b411b363SPhilipp Reisner } 2357b411b363SPhilipp Reisner } 2358b411b363SPhilipp Reisner 2359b411b363SPhilipp Reisner *rule_nr = 50; 2360b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2361b411b363SPhilipp Reisner if (self == peer) 2362b411b363SPhilipp Reisner return -1; 2363b411b363SPhilipp Reisner 2364b411b363SPhilipp Reisner *rule_nr = 51; 2365b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2366b411b363SPhilipp Reisner if (self == peer) { 2367b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2368b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1); 2369b411b363SPhilipp Reisner if (self == peer) { 2370b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2371b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2372b411b363SPhilipp Reisner 2373b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2374b411b363SPhilipp Reisner return -1001; 2375b411b363SPhilipp Reisner 2376b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2377b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 2378b411b363SPhilipp Reisner return -1; 2379b411b363SPhilipp Reisner } 2380b411b363SPhilipp Reisner } 2381b411b363SPhilipp Reisner 2382b411b363SPhilipp Reisner *rule_nr = 60; 2383b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2384b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2385b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2386b411b363SPhilipp Reisner if (self == peer) 2387b411b363SPhilipp Reisner return -2; 2388b411b363SPhilipp Reisner } 2389b411b363SPhilipp Reisner 2390b411b363SPhilipp Reisner *rule_nr = 70; 2391b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2392b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2393b411b363SPhilipp Reisner if (self == peer) 2394b411b363SPhilipp Reisner return 1; 2395b411b363SPhilipp Reisner 2396b411b363SPhilipp Reisner *rule_nr = 71; 2397b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2398b411b363SPhilipp Reisner if (self == peer) { 2399b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1); 2400b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2401b411b363SPhilipp Reisner if (self == peer) { 2402b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2403b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2404b411b363SPhilipp Reisner 2405b411b363SPhilipp Reisner if (mdev->agreed_pro_version < 91) 2406b411b363SPhilipp Reisner return -1001; 2407b411b363SPhilipp Reisner 2408b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2409b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2410b411b363SPhilipp Reisner 2411b411b363SPhilipp Reisner dev_info(DEV, "Undid last start of resync:\n"); 2412b411b363SPhilipp Reisner 2413b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2414b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2415b411b363SPhilipp Reisner 2416b411b363SPhilipp Reisner return 1; 2417b411b363SPhilipp Reisner } 2418b411b363SPhilipp Reisner } 2419b411b363SPhilipp Reisner 2420b411b363SPhilipp Reisner 2421b411b363SPhilipp Reisner *rule_nr = 80; 2422d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2423b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2424b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2425b411b363SPhilipp Reisner if (self == peer) 2426b411b363SPhilipp Reisner return 2; 2427b411b363SPhilipp Reisner } 2428b411b363SPhilipp Reisner 2429b411b363SPhilipp Reisner *rule_nr = 90; 2430b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2431b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2432b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2433b411b363SPhilipp Reisner return 100; 2434b411b363SPhilipp Reisner 2435b411b363SPhilipp Reisner *rule_nr = 100; 2436b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2437b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2438b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2439b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2440b411b363SPhilipp Reisner if (self == peer) 2441b411b363SPhilipp Reisner return -100; 2442b411b363SPhilipp Reisner } 2443b411b363SPhilipp Reisner } 2444b411b363SPhilipp Reisner 2445b411b363SPhilipp Reisner return -1000; 2446b411b363SPhilipp Reisner } 2447b411b363SPhilipp Reisner 2448b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2449b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2450b411b363SPhilipp Reisner */ 2451b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2452b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2453b411b363SPhilipp Reisner { 2454b411b363SPhilipp Reisner int hg, rule_nr; 2455b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2456b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2457b411b363SPhilipp Reisner 2458b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2459b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2460b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2461b411b363SPhilipp Reisner 2462b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2463b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2464b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2465b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2466b411b363SPhilipp Reisner 2467b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2468b411b363SPhilipp Reisner 2469b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2470b411b363SPhilipp Reisner 2471b411b363SPhilipp Reisner if (hg == -1000) { 2472b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2473b411b363SPhilipp Reisner return C_MASK; 2474b411b363SPhilipp Reisner } 2475b411b363SPhilipp Reisner if (hg == -1001) { 2476b411b363SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol\n"); 2477b411b363SPhilipp Reisner return C_MASK; 2478b411b363SPhilipp Reisner } 2479b411b363SPhilipp Reisner 2480b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2481b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2482b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2483b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2484b411b363SPhilipp Reisner if (f) 2485b411b363SPhilipp Reisner hg = hg*2; 2486b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2487b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2488b411b363SPhilipp Reisner } 2489b411b363SPhilipp Reisner 24903a11a487SAdam Gandelman if (abs(hg) == 100) 24913a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 24923a11a487SAdam Gandelman 2493b411b363SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->net_conf->always_asbp)) { 2494b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2495b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2496b411b363SPhilipp Reisner int forced = (hg == -100); 2497b411b363SPhilipp Reisner 2498b411b363SPhilipp Reisner switch (pcount) { 2499b411b363SPhilipp Reisner case 0: 2500b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2501b411b363SPhilipp Reisner break; 2502b411b363SPhilipp Reisner case 1: 2503b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2504b411b363SPhilipp Reisner break; 2505b411b363SPhilipp Reisner case 2: 2506b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2507b411b363SPhilipp Reisner break; 2508b411b363SPhilipp Reisner } 2509b411b363SPhilipp Reisner if (abs(hg) < 100) { 2510b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2511b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2512b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2513b411b363SPhilipp Reisner if (forced) { 2514b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2515b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2516b411b363SPhilipp Reisner hg = hg*2; 2517b411b363SPhilipp Reisner } 2518b411b363SPhilipp Reisner } 2519b411b363SPhilipp Reisner } 2520b411b363SPhilipp Reisner 2521b411b363SPhilipp Reisner if (hg == -100) { 2522b411b363SPhilipp Reisner if (mdev->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2523b411b363SPhilipp Reisner hg = -1; 2524b411b363SPhilipp Reisner if (!mdev->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2525b411b363SPhilipp Reisner hg = 1; 2526b411b363SPhilipp Reisner 2527b411b363SPhilipp Reisner if (abs(hg) < 100) 2528b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2529b411b363SPhilipp Reisner "Sync from %s node\n", 2530b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2531b411b363SPhilipp Reisner } 2532b411b363SPhilipp Reisner 2533b411b363SPhilipp Reisner if (hg == -100) { 2534580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2535580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2536580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2537580b9767SLars Ellenberg * to that disk, in a way... */ 25383a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2539b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2540b411b363SPhilipp Reisner return C_MASK; 2541b411b363SPhilipp Reisner } 2542b411b363SPhilipp Reisner 2543b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2544b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2545b411b363SPhilipp Reisner return C_MASK; 2546b411b363SPhilipp Reisner } 2547b411b363SPhilipp Reisner 2548b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2549b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 2550b411b363SPhilipp Reisner switch (mdev->net_conf->rr_conflict) { 2551b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2552b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2553b411b363SPhilipp Reisner /* fall through */ 2554b411b363SPhilipp Reisner case ASB_DISCONNECT: 2555b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2556b411b363SPhilipp Reisner return C_MASK; 2557b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2558b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2559b411b363SPhilipp Reisner "assumption\n"); 2560b411b363SPhilipp Reisner } 2561b411b363SPhilipp Reisner } 2562b411b363SPhilipp Reisner 2563cf14c2e9SPhilipp Reisner if (mdev->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) { 2564cf14c2e9SPhilipp Reisner if (hg == 0) 2565cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2566cf14c2e9SPhilipp Reisner else 2567cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2568cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2569cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2570cf14c2e9SPhilipp Reisner return C_MASK; 2571cf14c2e9SPhilipp Reisner } 2572cf14c2e9SPhilipp Reisner 2573b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2574b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 2575b411b363SPhilipp Reisner if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake")) 2576b411b363SPhilipp Reisner return C_MASK; 2577b411b363SPhilipp Reisner } 2578b411b363SPhilipp Reisner 2579b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2580b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2581b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2582b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2583b411b363SPhilipp Reisner } else { 2584b411b363SPhilipp Reisner rv = C_CONNECTED; 2585b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2586b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2587b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2588b411b363SPhilipp Reisner } 2589b411b363SPhilipp Reisner } 2590b411b363SPhilipp Reisner 2591b411b363SPhilipp Reisner return rv; 2592b411b363SPhilipp Reisner } 2593b411b363SPhilipp Reisner 2594b411b363SPhilipp Reisner /* returns 1 if invalid */ 2595b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2596b411b363SPhilipp Reisner { 2597b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2598b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2599b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2600b411b363SPhilipp Reisner return 0; 2601b411b363SPhilipp Reisner 2602b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2603b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2604b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2605b411b363SPhilipp Reisner return 1; 2606b411b363SPhilipp Reisner 2607b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2608b411b363SPhilipp Reisner if (peer == self) 2609b411b363SPhilipp Reisner return 0; 2610b411b363SPhilipp Reisner 2611b411b363SPhilipp Reisner /* everything es is invalid. */ 2612b411b363SPhilipp Reisner return 1; 2613b411b363SPhilipp Reisner } 2614b411b363SPhilipp Reisner 2615b411b363SPhilipp Reisner static int receive_protocol(struct drbd_conf *mdev, struct p_header *h) 2616b411b363SPhilipp Reisner { 2617b411b363SPhilipp Reisner struct p_protocol *p = (struct p_protocol *)h; 2618b411b363SPhilipp Reisner int header_size, data_size; 2619b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2620cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2621b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2622b411b363SPhilipp Reisner 2623b411b363SPhilipp Reisner header_size = sizeof(*p) - sizeof(*h); 2624b411b363SPhilipp Reisner data_size = h->length - header_size; 2625b411b363SPhilipp Reisner 2626b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, header_size) != header_size) 2627b411b363SPhilipp Reisner return FALSE; 2628b411b363SPhilipp Reisner 2629b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2630b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2631b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2632b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2633b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2634cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2635cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2636cf14c2e9SPhilipp Reisner 2637cf14c2e9SPhilipp Reisner clear_bit(CONN_DRY_RUN, &mdev->flags); 2638cf14c2e9SPhilipp Reisner 2639cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 2640cf14c2e9SPhilipp Reisner set_bit(CONN_DRY_RUN, &mdev->flags); 2641b411b363SPhilipp Reisner 2642b411b363SPhilipp Reisner if (p_proto != mdev->net_conf->wire_protocol) { 2643b411b363SPhilipp Reisner dev_err(DEV, "incompatible communication protocols\n"); 2644b411b363SPhilipp Reisner goto disconnect; 2645b411b363SPhilipp Reisner } 2646b411b363SPhilipp Reisner 2647b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, mdev->net_conf->after_sb_0p)) { 2648b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-0pri settings\n"); 2649b411b363SPhilipp Reisner goto disconnect; 2650b411b363SPhilipp Reisner } 2651b411b363SPhilipp Reisner 2652b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, mdev->net_conf->after_sb_1p)) { 2653b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-1pri settings\n"); 2654b411b363SPhilipp Reisner goto disconnect; 2655b411b363SPhilipp Reisner } 2656b411b363SPhilipp Reisner 2657b411b363SPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, mdev->net_conf->after_sb_2p)) { 2658b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-2pri settings\n"); 2659b411b363SPhilipp Reisner goto disconnect; 2660b411b363SPhilipp Reisner } 2661b411b363SPhilipp Reisner 2662b411b363SPhilipp Reisner if (p_want_lose && mdev->net_conf->want_lose) { 2663b411b363SPhilipp Reisner dev_err(DEV, "both sides have the 'want_lose' flag set\n"); 2664b411b363SPhilipp Reisner goto disconnect; 2665b411b363SPhilipp Reisner } 2666b411b363SPhilipp Reisner 2667b411b363SPhilipp Reisner if (p_two_primaries != mdev->net_conf->two_primaries) { 2668b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the two-primaries options\n"); 2669b411b363SPhilipp Reisner goto disconnect; 2670b411b363SPhilipp Reisner } 2671b411b363SPhilipp Reisner 2672b411b363SPhilipp Reisner if (mdev->agreed_pro_version >= 87) { 2673b411b363SPhilipp Reisner unsigned char *my_alg = mdev->net_conf->integrity_alg; 2674b411b363SPhilipp Reisner 2675b411b363SPhilipp Reisner if (drbd_recv(mdev, p_integrity_alg, data_size) != data_size) 2676b411b363SPhilipp Reisner return FALSE; 2677b411b363SPhilipp Reisner 2678b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2679b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 2680b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the data-integrity-alg\n"); 2681b411b363SPhilipp Reisner goto disconnect; 2682b411b363SPhilipp Reisner } 2683b411b363SPhilipp Reisner dev_info(DEV, "data-integrity-alg: %s\n", 2684b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2685b411b363SPhilipp Reisner } 2686b411b363SPhilipp Reisner 2687b411b363SPhilipp Reisner return TRUE; 2688b411b363SPhilipp Reisner 2689b411b363SPhilipp Reisner disconnect: 2690b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2691b411b363SPhilipp Reisner return FALSE; 2692b411b363SPhilipp Reisner } 2693b411b363SPhilipp Reisner 2694b411b363SPhilipp Reisner /* helper function 2695b411b363SPhilipp Reisner * input: alg name, feature name 2696b411b363SPhilipp Reisner * return: NULL (alg name was "") 2697b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2698b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2699b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2700b411b363SPhilipp Reisner const char *alg, const char *name) 2701b411b363SPhilipp Reisner { 2702b411b363SPhilipp Reisner struct crypto_hash *tfm; 2703b411b363SPhilipp Reisner 2704b411b363SPhilipp Reisner if (!alg[0]) 2705b411b363SPhilipp Reisner return NULL; 2706b411b363SPhilipp Reisner 2707b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2708b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2709b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2710b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2711b411b363SPhilipp Reisner return tfm; 2712b411b363SPhilipp Reisner } 2713b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2714b411b363SPhilipp Reisner crypto_free_hash(tfm); 2715b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2716b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2717b411b363SPhilipp Reisner } 2718b411b363SPhilipp Reisner return tfm; 2719b411b363SPhilipp Reisner } 2720b411b363SPhilipp Reisner 2721b411b363SPhilipp Reisner static int receive_SyncParam(struct drbd_conf *mdev, struct p_header *h) 2722b411b363SPhilipp Reisner { 2723b411b363SPhilipp Reisner int ok = TRUE; 2724b411b363SPhilipp Reisner struct p_rs_param_89 *p = (struct p_rs_param_89 *)h; 2725b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2726b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2727b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 2728b411b363SPhilipp Reisner const int apv = mdev->agreed_pro_version; 2729b411b363SPhilipp Reisner 2730b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2731b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2732b411b363SPhilipp Reisner + SHARED_SECRET_MAX 2733b411b363SPhilipp Reisner : /* 89 */ sizeof(struct p_rs_param_89); 2734b411b363SPhilipp Reisner 2735b411b363SPhilipp Reisner if (h->length > exp_max_sz) { 2736b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 2737b411b363SPhilipp Reisner h->length, exp_max_sz); 2738b411b363SPhilipp Reisner return FALSE; 2739b411b363SPhilipp Reisner } 2740b411b363SPhilipp Reisner 2741b411b363SPhilipp Reisner if (apv <= 88) { 2742b411b363SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(*h); 2743b411b363SPhilipp Reisner data_size = h->length - header_size; 2744b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2745b411b363SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(*h); 2746b411b363SPhilipp Reisner data_size = h->length - header_size; 2747b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2748b411b363SPhilipp Reisner } 2749b411b363SPhilipp Reisner 2750b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2751b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2752b411b363SPhilipp Reisner 2753b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, header_size) != header_size) 2754b411b363SPhilipp Reisner return FALSE; 2755b411b363SPhilipp Reisner 2756b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 2757b411b363SPhilipp Reisner 2758b411b363SPhilipp Reisner if (apv >= 88) { 2759b411b363SPhilipp Reisner if (apv == 88) { 2760b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 2761b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 2762b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 2763b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 2764b411b363SPhilipp Reisner return FALSE; 2765b411b363SPhilipp Reisner } 2766b411b363SPhilipp Reisner 2767b411b363SPhilipp Reisner if (drbd_recv(mdev, p->verify_alg, data_size) != data_size) 2768b411b363SPhilipp Reisner return FALSE; 2769b411b363SPhilipp Reisner 2770b411b363SPhilipp Reisner /* we expect NUL terminated string */ 2771b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2772b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 2773b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2776b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 2777b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2778b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 2779b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 2780b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 2781b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 2782b411b363SPhilipp Reisner } 2783b411b363SPhilipp Reisner 2784b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 2785b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2786b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 2787b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 2788b411b363SPhilipp Reisner goto disconnect; 2789b411b363SPhilipp Reisner } 2790b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 2791b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 2792b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 2793b411b363SPhilipp Reisner verify_tfm = NULL; 2794b411b363SPhilipp Reisner goto disconnect; 2795b411b363SPhilipp Reisner } 2796b411b363SPhilipp Reisner } 2797b411b363SPhilipp Reisner 2798b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 2799b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2800b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 2801b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 2802b411b363SPhilipp Reisner goto disconnect; 2803b411b363SPhilipp Reisner } 2804b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 2805b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 2806b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 2807b411b363SPhilipp Reisner csums_tfm = NULL; 2808b411b363SPhilipp Reisner goto disconnect; 2809b411b363SPhilipp Reisner } 2810b411b363SPhilipp Reisner } 2811b411b363SPhilipp Reisner 2812b411b363SPhilipp Reisner 2813b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 2814b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 2815b411b363SPhilipp Reisner if (verify_tfm) { 2816b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 2817b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 2818b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 2819b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 2820b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 2821b411b363SPhilipp Reisner } 2822b411b363SPhilipp Reisner if (csums_tfm) { 2823b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 2824b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 2825b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 2826b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 2827b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 2828b411b363SPhilipp Reisner } 2829b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 2830b411b363SPhilipp Reisner } 2831b411b363SPhilipp Reisner 2832b411b363SPhilipp Reisner return ok; 2833b411b363SPhilipp Reisner disconnect: 2834b411b363SPhilipp Reisner /* just for completeness: actually not needed, 2835b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 2836b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 2837b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 2838b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 2839b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2840b411b363SPhilipp Reisner return FALSE; 2841b411b363SPhilipp Reisner } 2842b411b363SPhilipp Reisner 2843b411b363SPhilipp Reisner static void drbd_setup_order_type(struct drbd_conf *mdev, int peer) 2844b411b363SPhilipp Reisner { 2845b411b363SPhilipp Reisner /* sorry, we currently have no working implementation 2846b411b363SPhilipp Reisner * of distributed TCQ */ 2847b411b363SPhilipp Reisner } 2848b411b363SPhilipp Reisner 2849b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 2850b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 2851b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 2852b411b363SPhilipp Reisner { 2853b411b363SPhilipp Reisner sector_t d; 2854b411b363SPhilipp Reisner if (a == 0 || b == 0) 2855b411b363SPhilipp Reisner return; 2856b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 2857b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 2858b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 2859b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 2860b411b363SPhilipp Reisner } 2861b411b363SPhilipp Reisner 2862b411b363SPhilipp Reisner static int receive_sizes(struct drbd_conf *mdev, struct p_header *h) 2863b411b363SPhilipp Reisner { 2864b411b363SPhilipp Reisner struct p_sizes *p = (struct p_sizes *)h; 2865b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 2866b411b363SPhilipp Reisner unsigned int max_seg_s; 2867b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 2868b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 2869e89b591cSPhilipp Reisner enum dds_flags ddsf; 2870b411b363SPhilipp Reisner 2871b411b363SPhilipp Reisner ERR_IF(h->length != (sizeof(*p)-sizeof(*h))) return FALSE; 2872b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, h->length) != h->length) 2873b411b363SPhilipp Reisner return FALSE; 2874b411b363SPhilipp Reisner 2875b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 2876b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 2877b411b363SPhilipp Reisner 2878b411b363SPhilipp Reisner if (p_size == 0 && mdev->state.disk == D_DISKLESS) { 2879b411b363SPhilipp Reisner dev_err(DEV, "some backing storage is needed\n"); 2880b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2881b411b363SPhilipp Reisner return FALSE; 2882b411b363SPhilipp Reisner } 2883b411b363SPhilipp Reisner 2884b411b363SPhilipp Reisner /* just store the peer's disk size for now. 2885b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 2886b411b363SPhilipp Reisner mdev->p_size = p_size; 2887b411b363SPhilipp Reisner 2888b411b363SPhilipp Reisner #define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r)) 2889b411b363SPhilipp Reisner if (get_ldev(mdev)) { 2890b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 2891b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 2892b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 2893b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 2894b411b363SPhilipp Reisner 2895b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 2896b411b363SPhilipp Reisner * param exchange, choose the minimum */ 2897b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 2898b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 2899b411b363SPhilipp Reisner p_usize); 2900b411b363SPhilipp Reisner 2901b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 2902b411b363SPhilipp Reisner 2903b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 2904b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 2905b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 2906b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 2907b411b363SPhilipp Reisner } 2908b411b363SPhilipp Reisner 2909b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 2910b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 2911a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 2912b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 2913b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 2914b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 2915b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 2916b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2917b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 2918b411b363SPhilipp Reisner put_ldev(mdev); 2919b411b363SPhilipp Reisner return FALSE; 2920b411b363SPhilipp Reisner } 2921b411b363SPhilipp Reisner put_ldev(mdev); 2922b411b363SPhilipp Reisner } 2923b411b363SPhilipp Reisner #undef min_not_zero 2924b411b363SPhilipp Reisner 2925e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 2926b411b363SPhilipp Reisner if (get_ldev(mdev)) { 2927e89b591cSPhilipp Reisner dd = drbd_determin_dev_size(mdev, ddsf); 2928b411b363SPhilipp Reisner put_ldev(mdev); 2929b411b363SPhilipp Reisner if (dd == dev_size_error) 2930b411b363SPhilipp Reisner return FALSE; 2931b411b363SPhilipp Reisner drbd_md_sync(mdev); 2932b411b363SPhilipp Reisner } else { 2933b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 2934b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 2935b411b363SPhilipp Reisner } 2936b411b363SPhilipp Reisner 2937b411b363SPhilipp Reisner if (get_ldev(mdev)) { 2938b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 2939b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 2940b411b363SPhilipp Reisner ldsc = 1; 2941b411b363SPhilipp Reisner } 2942b411b363SPhilipp Reisner 2943b411b363SPhilipp Reisner max_seg_s = be32_to_cpu(p->max_segment_size); 2944b411b363SPhilipp Reisner if (max_seg_s != queue_max_segment_size(mdev->rq_queue)) 2945b411b363SPhilipp Reisner drbd_setup_queue_param(mdev, max_seg_s); 2946b411b363SPhilipp Reisner 2947e89b591cSPhilipp Reisner drbd_setup_order_type(mdev, be16_to_cpu(p->queue_order_type)); 2948b411b363SPhilipp Reisner put_ldev(mdev); 2949b411b363SPhilipp Reisner } 2950b411b363SPhilipp Reisner 2951b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 2952b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 2953b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 2954b411b363SPhilipp Reisner /* we have different sizes, probably peer 2955b411b363SPhilipp Reisner * needs to know my new size... */ 2956e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 2957b411b363SPhilipp Reisner } 2958b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 2959b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 2960b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 2961e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 2962e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 2963e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 2964b411b363SPhilipp Reisner else 2965e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 2966e89b591cSPhilipp Reisner } else 2967b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 2968b411b363SPhilipp Reisner } 2969b411b363SPhilipp Reisner } 2970b411b363SPhilipp Reisner 2971b411b363SPhilipp Reisner return TRUE; 2972b411b363SPhilipp Reisner } 2973b411b363SPhilipp Reisner 2974b411b363SPhilipp Reisner static int receive_uuids(struct drbd_conf *mdev, struct p_header *h) 2975b411b363SPhilipp Reisner { 2976b411b363SPhilipp Reisner struct p_uuids *p = (struct p_uuids *)h; 2977b411b363SPhilipp Reisner u64 *p_uuid; 2978b411b363SPhilipp Reisner int i; 2979b411b363SPhilipp Reisner 2980b411b363SPhilipp Reisner ERR_IF(h->length != (sizeof(*p)-sizeof(*h))) return FALSE; 2981b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, h->length) != h->length) 2982b411b363SPhilipp Reisner return FALSE; 2983b411b363SPhilipp Reisner 2984b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 2985b411b363SPhilipp Reisner 2986b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 2987b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 2988b411b363SPhilipp Reisner 2989b411b363SPhilipp Reisner kfree(mdev->p_uuid); 2990b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 2991b411b363SPhilipp Reisner 2992b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 2993b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 2994b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 2995b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 2996b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 2997b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 2998b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 2999b411b363SPhilipp Reisner return FALSE; 3000b411b363SPhilipp Reisner } 3001b411b363SPhilipp Reisner 3002b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3003b411b363SPhilipp Reisner int skip_initial_sync = 3004b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 3005b411b363SPhilipp Reisner mdev->agreed_pro_version >= 90 && 3006b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3007b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3008b411b363SPhilipp Reisner if (skip_initial_sync) { 3009b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3010b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 3011b411b363SPhilipp Reisner "clear_n_write from receive_uuids"); 3012b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3013b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3014b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3015b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3016b411b363SPhilipp Reisner drbd_md_sync(mdev); 3017b411b363SPhilipp Reisner } 3018b411b363SPhilipp Reisner put_ldev(mdev); 3019b411b363SPhilipp Reisner } 3020b411b363SPhilipp Reisner 3021b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3022b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3023b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3024b411b363SPhilipp Reisner new disk state... */ 3025b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags)); 3026b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 3027b411b363SPhilipp Reisner drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3028b411b363SPhilipp Reisner 3029b411b363SPhilipp Reisner return TRUE; 3030b411b363SPhilipp Reisner } 3031b411b363SPhilipp Reisner 3032b411b363SPhilipp Reisner /** 3033b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3034b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3035b411b363SPhilipp Reisner */ 3036b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3037b411b363SPhilipp Reisner { 3038b411b363SPhilipp Reisner union drbd_state ms; 3039b411b363SPhilipp Reisner 3040b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3041b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3042b411b363SPhilipp Reisner 3043b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3044b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3045b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3046b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3047b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3048b411b363SPhilipp Reisner }; 3049b411b363SPhilipp Reisner 3050b411b363SPhilipp Reisner ms.i = ps.i; 3051b411b363SPhilipp Reisner 3052b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3053b411b363SPhilipp Reisner ms.peer = ps.role; 3054b411b363SPhilipp Reisner ms.role = ps.peer; 3055b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3056b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3057b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3058b411b363SPhilipp Reisner 3059b411b363SPhilipp Reisner return ms; 3060b411b363SPhilipp Reisner } 3061b411b363SPhilipp Reisner 3062b411b363SPhilipp Reisner static int receive_req_state(struct drbd_conf *mdev, struct p_header *h) 3063b411b363SPhilipp Reisner { 3064b411b363SPhilipp Reisner struct p_req_state *p = (struct p_req_state *)h; 3065b411b363SPhilipp Reisner union drbd_state mask, val; 3066b411b363SPhilipp Reisner int rv; 3067b411b363SPhilipp Reisner 3068b411b363SPhilipp Reisner ERR_IF(h->length != (sizeof(*p)-sizeof(*h))) return FALSE; 3069b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, h->length) != h->length) 3070b411b363SPhilipp Reisner return FALSE; 3071b411b363SPhilipp Reisner 3072b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3073b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3074b411b363SPhilipp Reisner 3075b411b363SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->flags) && 3076b411b363SPhilipp Reisner test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) { 3077b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 3078b411b363SPhilipp Reisner return TRUE; 3079b411b363SPhilipp Reisner } 3080b411b363SPhilipp Reisner 3081b411b363SPhilipp Reisner mask = convert_state(mask); 3082b411b363SPhilipp Reisner val = convert_state(val); 3083b411b363SPhilipp Reisner 3084b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3085b411b363SPhilipp Reisner 3086b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3087b411b363SPhilipp Reisner drbd_md_sync(mdev); 3088b411b363SPhilipp Reisner 3089b411b363SPhilipp Reisner return TRUE; 3090b411b363SPhilipp Reisner } 3091b411b363SPhilipp Reisner 3092b411b363SPhilipp Reisner static int receive_state(struct drbd_conf *mdev, struct p_header *h) 3093b411b363SPhilipp Reisner { 3094b411b363SPhilipp Reisner struct p_state *p = (struct p_state *)h; 3095b411b363SPhilipp Reisner enum drbd_conns nconn, oconn; 3096b411b363SPhilipp Reisner union drbd_state ns, peer_state; 3097b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 3098b411b363SPhilipp Reisner int rv; 3099b411b363SPhilipp Reisner 3100b411b363SPhilipp Reisner ERR_IF(h->length != (sizeof(*p)-sizeof(*h))) 3101b411b363SPhilipp Reisner return FALSE; 3102b411b363SPhilipp Reisner 3103b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, h->length) != h->length) 3104b411b363SPhilipp Reisner return FALSE; 3105b411b363SPhilipp Reisner 3106b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3107b411b363SPhilipp Reisner 3108b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3109b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3110b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3111b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3112b411b363SPhilipp Reisner } 3113b411b363SPhilipp Reisner 3114b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3115b411b363SPhilipp Reisner retry: 3116b411b363SPhilipp Reisner oconn = nconn = mdev->state.conn; 3117b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3118b411b363SPhilipp Reisner 3119b411b363SPhilipp Reisner if (nconn == C_WF_REPORT_PARAMS) 3120b411b363SPhilipp Reisner nconn = C_CONNECTED; 3121b411b363SPhilipp Reisner 3122b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3123b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3124b411b363SPhilipp Reisner int cr; /* consider resync */ 3125b411b363SPhilipp Reisner 3126b411b363SPhilipp Reisner /* if we established a new connection */ 3127b411b363SPhilipp Reisner cr = (oconn < C_CONNECTED); 3128b411b363SPhilipp Reisner /* if we had an established connection 3129b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 3130b411b363SPhilipp Reisner cr |= (oconn == C_CONNECTED && 3131b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 3132b411b363SPhilipp Reisner mdev->state.disk == D_NEGOTIATING)); 3133b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3134b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3135b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3136b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3137b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 3138b411b363SPhilipp Reisner cr |= (oconn == C_CONNECTED && 3139b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3140b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3141b411b363SPhilipp Reisner 3142b411b363SPhilipp Reisner if (cr) 3143b411b363SPhilipp Reisner nconn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3144b411b363SPhilipp Reisner 3145b411b363SPhilipp Reisner put_ldev(mdev); 3146b411b363SPhilipp Reisner if (nconn == C_MASK) { 3147580b9767SLars Ellenberg nconn = C_CONNECTED; 3148b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 3149b411b363SPhilipp Reisner drbd_force_state(mdev, NS(disk, D_DISKLESS)); 3150b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3151b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3152b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3153580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3154b411b363SPhilipp Reisner } else { 3155cf14c2e9SPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags)) 3156cf14c2e9SPhilipp Reisner return FALSE; 3157b411b363SPhilipp Reisner D_ASSERT(oconn == C_WF_REPORT_PARAMS); 3158b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3159b411b363SPhilipp Reisner return FALSE; 3160b411b363SPhilipp Reisner } 3161b411b363SPhilipp Reisner } 3162b411b363SPhilipp Reisner } 3163b411b363SPhilipp Reisner 3164b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3165b411b363SPhilipp Reisner if (mdev->state.conn != oconn) 3166b411b363SPhilipp Reisner goto retry; 3167b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3168b411b363SPhilipp Reisner ns.i = mdev->state.i; 3169b411b363SPhilipp Reisner ns.conn = nconn; 3170b411b363SPhilipp Reisner ns.peer = peer_state.role; 3171b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3172b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 3173b411b363SPhilipp Reisner if ((nconn == C_CONNECTED || nconn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3174b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 3175b411b363SPhilipp Reisner 3176b411b363SPhilipp Reisner rv = _drbd_set_state(mdev, ns, CS_VERBOSE | CS_HARD, NULL); 3177b411b363SPhilipp Reisner ns = mdev->state; 3178b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3179b411b363SPhilipp Reisner 3180b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 3181b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3182b411b363SPhilipp Reisner return FALSE; 3183b411b363SPhilipp Reisner } 3184b411b363SPhilipp Reisner 3185b411b363SPhilipp Reisner if (oconn > C_WF_REPORT_PARAMS) { 3186b411b363SPhilipp Reisner if (nconn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3187b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3188b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3189b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3190b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3191b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3192b411b363SPhilipp Reisner drbd_send_state(mdev); 3193b411b363SPhilipp Reisner } 3194b411b363SPhilipp Reisner } 3195b411b363SPhilipp Reisner 3196b411b363SPhilipp Reisner mdev->net_conf->want_lose = 0; 3197b411b363SPhilipp Reisner 3198b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3199b411b363SPhilipp Reisner 3200b411b363SPhilipp Reisner return TRUE; 3201b411b363SPhilipp Reisner } 3202b411b363SPhilipp Reisner 3203b411b363SPhilipp Reisner static int receive_sync_uuid(struct drbd_conf *mdev, struct p_header *h) 3204b411b363SPhilipp Reisner { 3205b411b363SPhilipp Reisner struct p_rs_uuid *p = (struct p_rs_uuid *)h; 3206b411b363SPhilipp Reisner 3207b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3208b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3209b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3210b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3211b411b363SPhilipp Reisner 3212b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3213b411b363SPhilipp Reisner 3214b411b363SPhilipp Reisner ERR_IF(h->length != (sizeof(*p)-sizeof(*h))) return FALSE; 3215b411b363SPhilipp Reisner if (drbd_recv(mdev, h->payload, h->length) != h->length) 3216b411b363SPhilipp Reisner return FALSE; 3217b411b363SPhilipp Reisner 3218b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3219b411b363SPhilipp Reisner _not_ be rotated into the history */ 3220b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3221b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3222b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3223b411b363SPhilipp Reisner 3224b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3225b411b363SPhilipp Reisner 3226b411b363SPhilipp Reisner put_ldev(mdev); 3227b411b363SPhilipp Reisner } else 3228b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3229b411b363SPhilipp Reisner 3230b411b363SPhilipp Reisner return TRUE; 3231b411b363SPhilipp Reisner } 3232b411b363SPhilipp Reisner 3233b411b363SPhilipp Reisner enum receive_bitmap_ret { OK, DONE, FAILED }; 3234b411b363SPhilipp Reisner 3235b411b363SPhilipp Reisner static enum receive_bitmap_ret 3236b411b363SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, struct p_header *h, 3237b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3238b411b363SPhilipp Reisner { 3239b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3240b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 3241b411b363SPhilipp Reisner 3242b411b363SPhilipp Reisner if (want != h->length) { 3243b411b363SPhilipp Reisner dev_err(DEV, "%s:want (%u) != h->length (%u)\n", __func__, want, h->length); 3244b411b363SPhilipp Reisner return FAILED; 3245b411b363SPhilipp Reisner } 3246b411b363SPhilipp Reisner if (want == 0) 3247b411b363SPhilipp Reisner return DONE; 3248b411b363SPhilipp Reisner if (drbd_recv(mdev, buffer, want) != want) 3249b411b363SPhilipp Reisner return FAILED; 3250b411b363SPhilipp Reisner 3251b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3252b411b363SPhilipp Reisner 3253b411b363SPhilipp Reisner c->word_offset += num_words; 3254b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3255b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3256b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3257b411b363SPhilipp Reisner 3258b411b363SPhilipp Reisner return OK; 3259b411b363SPhilipp Reisner } 3260b411b363SPhilipp Reisner 3261b411b363SPhilipp Reisner static enum receive_bitmap_ret 3262b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3263b411b363SPhilipp Reisner struct p_compressed_bm *p, 3264b411b363SPhilipp Reisner struct bm_xfer_ctx *c) 3265b411b363SPhilipp Reisner { 3266b411b363SPhilipp Reisner struct bitstream bs; 3267b411b363SPhilipp Reisner u64 look_ahead; 3268b411b363SPhilipp Reisner u64 rl; 3269b411b363SPhilipp Reisner u64 tmp; 3270b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3271b411b363SPhilipp Reisner unsigned long e; 3272b411b363SPhilipp Reisner int len = p->head.length - (sizeof(*p) - sizeof(p->head)); 3273b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3274b411b363SPhilipp Reisner int have; 3275b411b363SPhilipp Reisner int bits; 3276b411b363SPhilipp Reisner 3277b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3278b411b363SPhilipp Reisner 3279b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3280b411b363SPhilipp Reisner if (bits < 0) 3281b411b363SPhilipp Reisner return FAILED; 3282b411b363SPhilipp Reisner 3283b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3284b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3285b411b363SPhilipp Reisner if (bits <= 0) 3286b411b363SPhilipp Reisner return FAILED; 3287b411b363SPhilipp Reisner 3288b411b363SPhilipp Reisner if (toggle) { 3289b411b363SPhilipp Reisner e = s + rl -1; 3290b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3291b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 3292b411b363SPhilipp Reisner return FAILED; 3293b411b363SPhilipp Reisner } 3294b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3295b411b363SPhilipp Reisner } 3296b411b363SPhilipp Reisner 3297b411b363SPhilipp Reisner if (have < bits) { 3298b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3299b411b363SPhilipp Reisner have, bits, look_ahead, 3300b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3301b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 3302b411b363SPhilipp Reisner return FAILED; 3303b411b363SPhilipp Reisner } 3304b411b363SPhilipp Reisner look_ahead >>= bits; 3305b411b363SPhilipp Reisner have -= bits; 3306b411b363SPhilipp Reisner 3307b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3308b411b363SPhilipp Reisner if (bits < 0) 3309b411b363SPhilipp Reisner return FAILED; 3310b411b363SPhilipp Reisner look_ahead |= tmp << have; 3311b411b363SPhilipp Reisner have += bits; 3312b411b363SPhilipp Reisner } 3313b411b363SPhilipp Reisner 3314b411b363SPhilipp Reisner c->bit_offset = s; 3315b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3316b411b363SPhilipp Reisner 3317b411b363SPhilipp Reisner return (s == c->bm_bits) ? DONE : OK; 3318b411b363SPhilipp Reisner } 3319b411b363SPhilipp Reisner 3320b411b363SPhilipp Reisner static enum receive_bitmap_ret 3321b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3322b411b363SPhilipp Reisner struct p_compressed_bm *p, 3323b411b363SPhilipp Reisner struct bm_xfer_ctx *c) 3324b411b363SPhilipp Reisner { 3325b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3326b411b363SPhilipp Reisner return recv_bm_rle_bits(mdev, p, c); 3327b411b363SPhilipp Reisner 3328b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3329b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3330b411b363SPhilipp Reisner * during all our tests. */ 3331b411b363SPhilipp Reisner 3332b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 3333b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3334b411b363SPhilipp Reisner return FAILED; 3335b411b363SPhilipp Reisner } 3336b411b363SPhilipp Reisner 3337b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3338b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3339b411b363SPhilipp Reisner { 3340b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3341b411b363SPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3342b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3343b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3344b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3345b411b363SPhilipp Reisner unsigned r; 3346b411b363SPhilipp Reisner 3347b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3348b411b363SPhilipp Reisner if (total == 0) 3349b411b363SPhilipp Reisner return; 3350b411b363SPhilipp Reisner 3351b411b363SPhilipp Reisner /* don't report if not compressed */ 3352b411b363SPhilipp Reisner if (total >= plain) 3353b411b363SPhilipp Reisner return; 3354b411b363SPhilipp Reisner 3355b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3356b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3357b411b363SPhilipp Reisner : (1000 * total / plain); 3358b411b363SPhilipp Reisner 3359b411b363SPhilipp Reisner if (r > 1000) 3360b411b363SPhilipp Reisner r = 1000; 3361b411b363SPhilipp Reisner 3362b411b363SPhilipp Reisner r = 1000 - r; 3363b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3364b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3365b411b363SPhilipp Reisner direction, 3366b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3367b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3368b411b363SPhilipp Reisner total, r/10, r % 10); 3369b411b363SPhilipp Reisner } 3370b411b363SPhilipp Reisner 3371b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3372b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3373b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3374b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3375b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3376b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3377b411b363SPhilipp Reisner 3378b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3379b411b363SPhilipp Reisner static int receive_bitmap(struct drbd_conf *mdev, struct p_header *h) 3380b411b363SPhilipp Reisner { 3381b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3382b411b363SPhilipp Reisner void *buffer; 3383b411b363SPhilipp Reisner enum receive_bitmap_ret ret; 3384b411b363SPhilipp Reisner int ok = FALSE; 3385b411b363SPhilipp Reisner 3386b411b363SPhilipp Reisner wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt)); 3387b411b363SPhilipp Reisner 3388b411b363SPhilipp Reisner drbd_bm_lock(mdev, "receive bitmap"); 3389b411b363SPhilipp Reisner 3390b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3391b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3392b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3393b411b363SPhilipp Reisner if (!buffer) { 3394b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3395b411b363SPhilipp Reisner goto out; 3396b411b363SPhilipp Reisner } 3397b411b363SPhilipp Reisner 3398b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3399b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3400b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3401b411b363SPhilipp Reisner }; 3402b411b363SPhilipp Reisner 3403b411b363SPhilipp Reisner do { 3404b411b363SPhilipp Reisner if (h->command == P_BITMAP) { 3405b411b363SPhilipp Reisner ret = receive_bitmap_plain(mdev, h, buffer, &c); 3406b411b363SPhilipp Reisner } else if (h->command == P_COMPRESSED_BITMAP) { 3407b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3408b411b363SPhilipp Reisner * and the feature is enabled! */ 3409b411b363SPhilipp Reisner struct p_compressed_bm *p; 3410b411b363SPhilipp Reisner 3411b411b363SPhilipp Reisner if (h->length > BM_PACKET_PAYLOAD_BYTES) { 3412b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3413b411b363SPhilipp Reisner goto out; 3414b411b363SPhilipp Reisner } 3415b411b363SPhilipp Reisner /* use the page buff */ 3416b411b363SPhilipp Reisner p = buffer; 3417b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 3418b411b363SPhilipp Reisner if (drbd_recv(mdev, p->head.payload, h->length) != h->length) 3419b411b363SPhilipp Reisner goto out; 3420b411b363SPhilipp Reisner if (p->head.length <= (sizeof(*p) - sizeof(p->head))) { 3421b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", p->head.length); 3422b411b363SPhilipp Reisner return FAILED; 3423b411b363SPhilipp Reisner } 3424b411b363SPhilipp Reisner ret = decode_bitmap_c(mdev, p, &c); 3425b411b363SPhilipp Reisner } else { 3426b411b363SPhilipp Reisner dev_warn(DEV, "receive_bitmap: h->command neither ReportBitMap nor ReportCBitMap (is 0x%x)", h->command); 3427b411b363SPhilipp Reisner goto out; 3428b411b363SPhilipp Reisner } 3429b411b363SPhilipp Reisner 3430b411b363SPhilipp Reisner c.packets[h->command == P_BITMAP]++; 3431b411b363SPhilipp Reisner c.bytes[h->command == P_BITMAP] += sizeof(struct p_header) + h->length; 3432b411b363SPhilipp Reisner 3433b411b363SPhilipp Reisner if (ret != OK) 3434b411b363SPhilipp Reisner break; 3435b411b363SPhilipp Reisner 3436b411b363SPhilipp Reisner if (!drbd_recv_header(mdev, h)) 3437b411b363SPhilipp Reisner goto out; 3438b411b363SPhilipp Reisner } while (ret == OK); 3439b411b363SPhilipp Reisner if (ret == FAILED) 3440b411b363SPhilipp Reisner goto out; 3441b411b363SPhilipp Reisner 3442b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3443b411b363SPhilipp Reisner 3444b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3445b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3446b411b363SPhilipp Reisner if (!ok) 3447b411b363SPhilipp Reisner goto out; 3448b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3449b411b363SPhilipp Reisner ok = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3450b411b363SPhilipp Reisner D_ASSERT(ok == SS_SUCCESS); 3451b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3452b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3453b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3454b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3455b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3456b411b363SPhilipp Reisner } 3457b411b363SPhilipp Reisner 3458b411b363SPhilipp Reisner ok = TRUE; 3459b411b363SPhilipp Reisner out: 3460b411b363SPhilipp Reisner drbd_bm_unlock(mdev); 3461b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3462b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3463b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3464b411b363SPhilipp Reisner return ok; 3465b411b363SPhilipp Reisner } 3466b411b363SPhilipp Reisner 3467b411b363SPhilipp Reisner static int receive_skip(struct drbd_conf *mdev, struct p_header *h) 3468b411b363SPhilipp Reisner { 3469b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3470b411b363SPhilipp Reisner static char sink[128]; 3471b411b363SPhilipp Reisner int size, want, r; 3472b411b363SPhilipp Reisner 3473b411b363SPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 3474b411b363SPhilipp Reisner h->command, h->length); 3475b411b363SPhilipp Reisner 3476b411b363SPhilipp Reisner size = h->length; 3477b411b363SPhilipp Reisner while (size > 0) { 3478b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 3479b411b363SPhilipp Reisner r = drbd_recv(mdev, sink, want); 3480b411b363SPhilipp Reisner ERR_IF(r <= 0) break; 3481b411b363SPhilipp Reisner size -= r; 3482b411b363SPhilipp Reisner } 3483b411b363SPhilipp Reisner return size == 0; 3484b411b363SPhilipp Reisner } 3485b411b363SPhilipp Reisner 3486b411b363SPhilipp Reisner static int receive_UnplugRemote(struct drbd_conf *mdev, struct p_header *h) 3487b411b363SPhilipp Reisner { 3488b411b363SPhilipp Reisner if (mdev->state.disk >= D_INCONSISTENT) 3489b411b363SPhilipp Reisner drbd_kick_lo(mdev); 3490b411b363SPhilipp Reisner 3491b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3492b411b363SPhilipp Reisner * with the data requests being unplugged */ 3493b411b363SPhilipp Reisner drbd_tcp_quickack(mdev->data.socket); 3494b411b363SPhilipp Reisner 3495b411b363SPhilipp Reisner return TRUE; 3496b411b363SPhilipp Reisner } 3497b411b363SPhilipp Reisner 3498b411b363SPhilipp Reisner typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, struct p_header *); 3499b411b363SPhilipp Reisner 3500b411b363SPhilipp Reisner static drbd_cmd_handler_f drbd_default_handler[] = { 3501b411b363SPhilipp Reisner [P_DATA] = receive_Data, 3502b411b363SPhilipp Reisner [P_DATA_REPLY] = receive_DataReply, 3503b411b363SPhilipp Reisner [P_RS_DATA_REPLY] = receive_RSDataReply, 3504b411b363SPhilipp Reisner [P_BARRIER] = receive_Barrier, 3505b411b363SPhilipp Reisner [P_BITMAP] = receive_bitmap, 3506b411b363SPhilipp Reisner [P_COMPRESSED_BITMAP] = receive_bitmap, 3507b411b363SPhilipp Reisner [P_UNPLUG_REMOTE] = receive_UnplugRemote, 3508b411b363SPhilipp Reisner [P_DATA_REQUEST] = receive_DataRequest, 3509b411b363SPhilipp Reisner [P_RS_DATA_REQUEST] = receive_DataRequest, 3510b411b363SPhilipp Reisner [P_SYNC_PARAM] = receive_SyncParam, 3511b411b363SPhilipp Reisner [P_SYNC_PARAM89] = receive_SyncParam, 3512b411b363SPhilipp Reisner [P_PROTOCOL] = receive_protocol, 3513b411b363SPhilipp Reisner [P_UUIDS] = receive_uuids, 3514b411b363SPhilipp Reisner [P_SIZES] = receive_sizes, 3515b411b363SPhilipp Reisner [P_STATE] = receive_state, 3516b411b363SPhilipp Reisner [P_STATE_CHG_REQ] = receive_req_state, 3517b411b363SPhilipp Reisner [P_SYNC_UUID] = receive_sync_uuid, 3518b411b363SPhilipp Reisner [P_OV_REQUEST] = receive_DataRequest, 3519b411b363SPhilipp Reisner [P_OV_REPLY] = receive_DataRequest, 3520b411b363SPhilipp Reisner [P_CSUM_RS_REQUEST] = receive_DataRequest, 3521b411b363SPhilipp Reisner /* anything missing from this table is in 3522b411b363SPhilipp Reisner * the asender_tbl, see get_asender_cmd */ 3523b411b363SPhilipp Reisner [P_MAX_CMD] = NULL, 3524b411b363SPhilipp Reisner }; 3525b411b363SPhilipp Reisner 3526b411b363SPhilipp Reisner static drbd_cmd_handler_f *drbd_cmd_handler = drbd_default_handler; 3527b411b363SPhilipp Reisner static drbd_cmd_handler_f *drbd_opt_cmd_handler; 3528b411b363SPhilipp Reisner 3529b411b363SPhilipp Reisner static void drbdd(struct drbd_conf *mdev) 3530b411b363SPhilipp Reisner { 3531b411b363SPhilipp Reisner drbd_cmd_handler_f handler; 3532b411b363SPhilipp Reisner struct p_header *header = &mdev->data.rbuf.header; 3533b411b363SPhilipp Reisner 3534b411b363SPhilipp Reisner while (get_t_state(&mdev->receiver) == Running) { 3535b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 35360b33a916SLars Ellenberg if (!drbd_recv_header(mdev, header)) { 35370b33a916SLars Ellenberg drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3538b411b363SPhilipp Reisner break; 35390b33a916SLars Ellenberg } 3540b411b363SPhilipp Reisner 3541b411b363SPhilipp Reisner if (header->command < P_MAX_CMD) 3542b411b363SPhilipp Reisner handler = drbd_cmd_handler[header->command]; 3543b411b363SPhilipp Reisner else if (P_MAY_IGNORE < header->command 3544b411b363SPhilipp Reisner && header->command < P_MAX_OPT_CMD) 3545b411b363SPhilipp Reisner handler = drbd_opt_cmd_handler[header->command-P_MAY_IGNORE]; 3546b411b363SPhilipp Reisner else if (header->command > P_MAX_OPT_CMD) 3547b411b363SPhilipp Reisner handler = receive_skip; 3548b411b363SPhilipp Reisner else 3549b411b363SPhilipp Reisner handler = NULL; 3550b411b363SPhilipp Reisner 3551b411b363SPhilipp Reisner if (unlikely(!handler)) { 3552b411b363SPhilipp Reisner dev_err(DEV, "unknown packet type %d, l: %d!\n", 3553b411b363SPhilipp Reisner header->command, header->length); 3554b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3555b411b363SPhilipp Reisner break; 3556b411b363SPhilipp Reisner } 3557b411b363SPhilipp Reisner if (unlikely(!handler(mdev, header))) { 3558b411b363SPhilipp Reisner dev_err(DEV, "error receiving %s, l: %d!\n", 3559b411b363SPhilipp Reisner cmdname(header->command), header->length); 3560b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 3561b411b363SPhilipp Reisner break; 3562b411b363SPhilipp Reisner } 3563b411b363SPhilipp Reisner } 3564b411b363SPhilipp Reisner } 3565b411b363SPhilipp Reisner 3566b411b363SPhilipp Reisner static void drbd_fail_pending_reads(struct drbd_conf *mdev) 3567b411b363SPhilipp Reisner { 3568b411b363SPhilipp Reisner struct hlist_head *slot; 3569b411b363SPhilipp Reisner struct hlist_node *pos; 3570b411b363SPhilipp Reisner struct hlist_node *tmp; 3571b411b363SPhilipp Reisner struct drbd_request *req; 3572b411b363SPhilipp Reisner int i; 3573b411b363SPhilipp Reisner 3574b411b363SPhilipp Reisner /* 3575b411b363SPhilipp Reisner * Application READ requests 3576b411b363SPhilipp Reisner */ 3577b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3578b411b363SPhilipp Reisner for (i = 0; i < APP_R_HSIZE; i++) { 3579b411b363SPhilipp Reisner slot = mdev->app_reads_hash+i; 3580b411b363SPhilipp Reisner hlist_for_each_entry_safe(req, pos, tmp, slot, colision) { 3581b411b363SPhilipp Reisner /* it may (but should not any longer!) 3582b411b363SPhilipp Reisner * be on the work queue; if that assert triggers, 3583b411b363SPhilipp Reisner * we need to also grab the 3584b411b363SPhilipp Reisner * spin_lock_irq(&mdev->data.work.q_lock); 3585b411b363SPhilipp Reisner * and list_del_init here. */ 3586b411b363SPhilipp Reisner D_ASSERT(list_empty(&req->w.list)); 3587b411b363SPhilipp Reisner /* It would be nice to complete outside of spinlock. 3588b411b363SPhilipp Reisner * But this is easier for now. */ 3589b411b363SPhilipp Reisner _req_mod(req, connection_lost_while_pending); 3590b411b363SPhilipp Reisner } 3591b411b363SPhilipp Reisner } 3592b411b363SPhilipp Reisner for (i = 0; i < APP_R_HSIZE; i++) 3593b411b363SPhilipp Reisner if (!hlist_empty(mdev->app_reads_hash+i)) 3594b411b363SPhilipp Reisner dev_warn(DEV, "ASSERT FAILED: app_reads_hash[%d].first: " 3595b411b363SPhilipp Reisner "%p, should be NULL\n", i, mdev->app_reads_hash[i].first); 3596b411b363SPhilipp Reisner 3597b411b363SPhilipp Reisner memset(mdev->app_reads_hash, 0, APP_R_HSIZE*sizeof(void *)); 3598b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3599b411b363SPhilipp Reisner } 3600b411b363SPhilipp Reisner 3601b411b363SPhilipp Reisner void drbd_flush_workqueue(struct drbd_conf *mdev) 3602b411b363SPhilipp Reisner { 3603b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3604b411b363SPhilipp Reisner 3605b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 3606b411b363SPhilipp Reisner init_completion(&barr.done); 3607b411b363SPhilipp Reisner drbd_queue_work(&mdev->data.work, &barr.w); 3608b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3609b411b363SPhilipp Reisner } 3610b411b363SPhilipp Reisner 3611b411b363SPhilipp Reisner static void drbd_disconnect(struct drbd_conf *mdev) 3612b411b363SPhilipp Reisner { 3613b411b363SPhilipp Reisner enum drbd_fencing_p fp; 3614b411b363SPhilipp Reisner union drbd_state os, ns; 3615b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3616b411b363SPhilipp Reisner unsigned int i; 3617b411b363SPhilipp Reisner 3618b411b363SPhilipp Reisner if (mdev->state.conn == C_STANDALONE) 3619b411b363SPhilipp Reisner return; 3620b411b363SPhilipp Reisner if (mdev->state.conn >= C_WF_CONNECTION) 3621b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED cstate = %s, expected < WFConnection\n", 3622b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3623b411b363SPhilipp Reisner 3624b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3625b411b363SPhilipp Reisner drbd_thread_stop(&mdev->asender); 3626b411b363SPhilipp Reisner drbd_free_sock(mdev); 3627b411b363SPhilipp Reisner 3628b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3629b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 3630b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 3631b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 3632b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3633b411b363SPhilipp Reisner 3634b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 3635b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 3636b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 3637b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 3638b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 3639b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 3640b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 3641b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 3642b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 3643b411b363SPhilipp Reisner * on the fly. */ 3644b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 3645b411b363SPhilipp Reisner mdev->rs_total = 0; 3646b411b363SPhilipp Reisner mdev->rs_failed = 0; 3647b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 3648b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 3649b411b363SPhilipp Reisner 3650b411b363SPhilipp Reisner /* make sure syncer is stopped and w_resume_next_sg queued */ 3651b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 3652b411b363SPhilipp Reisner set_bit(STOP_SYNC_TIMER, &mdev->flags); 3653b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 3654b411b363SPhilipp Reisner 3655b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 3656b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 3657b411b363SPhilipp Reisner * to be "canceled" */ 3658b411b363SPhilipp Reisner drbd_flush_workqueue(mdev); 3659b411b363SPhilipp Reisner 3660b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 3661b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 3662b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 3663b411b363SPhilipp Reisner 3664b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3665b411b363SPhilipp Reisner mdev->p_uuid = NULL; 3666b411b363SPhilipp Reisner 3667b411b363SPhilipp Reisner if (!mdev->state.susp) 3668b411b363SPhilipp Reisner tl_clear(mdev); 3669b411b363SPhilipp Reisner 3670b411b363SPhilipp Reisner drbd_fail_pending_reads(mdev); 3671b411b363SPhilipp Reisner 3672b411b363SPhilipp Reisner dev_info(DEV, "Connection closed\n"); 3673b411b363SPhilipp Reisner 3674b411b363SPhilipp Reisner drbd_md_sync(mdev); 3675b411b363SPhilipp Reisner 3676b411b363SPhilipp Reisner fp = FP_DONT_CARE; 3677b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3678b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 3679b411b363SPhilipp Reisner put_ldev(mdev); 3680b411b363SPhilipp Reisner } 3681b411b363SPhilipp Reisner 3682b411b363SPhilipp Reisner if (mdev->state.role == R_PRIMARY) { 3683b411b363SPhilipp Reisner if (fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) { 3684b411b363SPhilipp Reisner enum drbd_disk_state nps = drbd_try_outdate_peer(mdev); 3685b411b363SPhilipp Reisner drbd_request_state(mdev, NS(pdsk, nps)); 3686b411b363SPhilipp Reisner } 3687b411b363SPhilipp Reisner } 3688b411b363SPhilipp Reisner 3689b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3690b411b363SPhilipp Reisner os = mdev->state; 3691b411b363SPhilipp Reisner if (os.conn >= C_UNCONNECTED) { 3692b411b363SPhilipp Reisner /* Do not restart in case we are C_DISCONNECTING */ 3693b411b363SPhilipp Reisner ns = os; 3694b411b363SPhilipp Reisner ns.conn = C_UNCONNECTED; 3695b411b363SPhilipp Reisner rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL); 3696b411b363SPhilipp Reisner } 3697b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3698b411b363SPhilipp Reisner 3699b411b363SPhilipp Reisner if (os.conn == C_DISCONNECTING) { 3700b411b363SPhilipp Reisner struct hlist_head *h; 3701b411b363SPhilipp Reisner wait_event(mdev->misc_wait, atomic_read(&mdev->net_cnt) == 0); 3702b411b363SPhilipp Reisner 3703b411b363SPhilipp Reisner /* we must not free the tl_hash 3704b411b363SPhilipp Reisner * while application io is still on the fly */ 3705b411b363SPhilipp Reisner wait_event(mdev->misc_wait, atomic_read(&mdev->ap_bio_cnt) == 0); 3706b411b363SPhilipp Reisner 3707b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 3708b411b363SPhilipp Reisner /* paranoia code */ 3709b411b363SPhilipp Reisner for (h = mdev->ee_hash; h < mdev->ee_hash + mdev->ee_hash_s; h++) 3710b411b363SPhilipp Reisner if (h->first) 3711b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED ee_hash[%u].first == %p, expected NULL\n", 3712b411b363SPhilipp Reisner (int)(h - mdev->ee_hash), h->first); 3713b411b363SPhilipp Reisner kfree(mdev->ee_hash); 3714b411b363SPhilipp Reisner mdev->ee_hash = NULL; 3715b411b363SPhilipp Reisner mdev->ee_hash_s = 0; 3716b411b363SPhilipp Reisner 3717b411b363SPhilipp Reisner /* paranoia code */ 3718b411b363SPhilipp Reisner for (h = mdev->tl_hash; h < mdev->tl_hash + mdev->tl_hash_s; h++) 3719b411b363SPhilipp Reisner if (h->first) 3720b411b363SPhilipp Reisner dev_err(DEV, "ASSERT FAILED tl_hash[%u] == %p, expected NULL\n", 3721b411b363SPhilipp Reisner (int)(h - mdev->tl_hash), h->first); 3722b411b363SPhilipp Reisner kfree(mdev->tl_hash); 3723b411b363SPhilipp Reisner mdev->tl_hash = NULL; 3724b411b363SPhilipp Reisner mdev->tl_hash_s = 0; 3725b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 3726b411b363SPhilipp Reisner 3727b411b363SPhilipp Reisner crypto_free_hash(mdev->cram_hmac_tfm); 3728b411b363SPhilipp Reisner mdev->cram_hmac_tfm = NULL; 3729b411b363SPhilipp Reisner 3730b411b363SPhilipp Reisner kfree(mdev->net_conf); 3731b411b363SPhilipp Reisner mdev->net_conf = NULL; 3732b411b363SPhilipp Reisner drbd_request_state(mdev, NS(conn, C_STANDALONE)); 3733b411b363SPhilipp Reisner } 3734b411b363SPhilipp Reisner 3735b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 3736b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 3737b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 3738b411b363SPhilipp Reisner * 3739b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 3740b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 3741b411b363SPhilipp Reisner */ 3742b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 3743b411b363SPhilipp Reisner if (i) 3744b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 3745b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 3746b411b363SPhilipp Reisner if (i) 3747b411b363SPhilipp Reisner dev_info(DEV, "pp_in_use = %u, expected 0\n", i); 3748b411b363SPhilipp Reisner 3749b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 3750b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 3751b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 3752b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 3753b411b363SPhilipp Reisner 3754b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 3755b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 3756b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 3757b411b363SPhilipp Reisner } 3758b411b363SPhilipp Reisner 3759b411b363SPhilipp Reisner /* 3760b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 3761b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 3762b411b363SPhilipp Reisner * 3763b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 3764b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 3765b411b363SPhilipp Reisner * 3766b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 3767b411b363SPhilipp Reisner */ 3768b411b363SPhilipp Reisner static int drbd_send_handshake(struct drbd_conf *mdev) 3769b411b363SPhilipp Reisner { 3770b411b363SPhilipp Reisner /* ASSERT current == mdev->receiver ... */ 3771b411b363SPhilipp Reisner struct p_handshake *p = &mdev->data.sbuf.handshake; 3772b411b363SPhilipp Reisner int ok; 3773b411b363SPhilipp Reisner 3774b411b363SPhilipp Reisner if (mutex_lock_interruptible(&mdev->data.mutex)) { 3775b411b363SPhilipp Reisner dev_err(DEV, "interrupted during initial handshake\n"); 3776b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 3777b411b363SPhilipp Reisner } 3778b411b363SPhilipp Reisner 3779b411b363SPhilipp Reisner if (mdev->data.socket == NULL) { 3780b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 3781b411b363SPhilipp Reisner return 0; 3782b411b363SPhilipp Reisner } 3783b411b363SPhilipp Reisner 3784b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 3785b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 3786b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 3787b411b363SPhilipp Reisner ok = _drbd_send_cmd( mdev, mdev->data.socket, P_HAND_SHAKE, 3788b411b363SPhilipp Reisner (struct p_header *)p, sizeof(*p), 0 ); 3789b411b363SPhilipp Reisner mutex_unlock(&mdev->data.mutex); 3790b411b363SPhilipp Reisner return ok; 3791b411b363SPhilipp Reisner } 3792b411b363SPhilipp Reisner 3793b411b363SPhilipp Reisner /* 3794b411b363SPhilipp Reisner * return values: 3795b411b363SPhilipp Reisner * 1 yes, we have a valid connection 3796b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 3797b411b363SPhilipp Reisner * -1 peer talks different language, 3798b411b363SPhilipp Reisner * no point in trying again, please go standalone. 3799b411b363SPhilipp Reisner */ 3800b411b363SPhilipp Reisner static int drbd_do_handshake(struct drbd_conf *mdev) 3801b411b363SPhilipp Reisner { 3802b411b363SPhilipp Reisner /* ASSERT current == mdev->receiver ... */ 3803b411b363SPhilipp Reisner struct p_handshake *p = &mdev->data.rbuf.handshake; 3804b411b363SPhilipp Reisner const int expect = sizeof(struct p_handshake) 3805b411b363SPhilipp Reisner -sizeof(struct p_header); 3806b411b363SPhilipp Reisner int rv; 3807b411b363SPhilipp Reisner 3808b411b363SPhilipp Reisner rv = drbd_send_handshake(mdev); 3809b411b363SPhilipp Reisner if (!rv) 3810b411b363SPhilipp Reisner return 0; 3811b411b363SPhilipp Reisner 3812b411b363SPhilipp Reisner rv = drbd_recv_header(mdev, &p->head); 3813b411b363SPhilipp Reisner if (!rv) 3814b411b363SPhilipp Reisner return 0; 3815b411b363SPhilipp Reisner 3816b411b363SPhilipp Reisner if (p->head.command != P_HAND_SHAKE) { 3817b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake packet, received: %s (0x%04x)\n", 3818b411b363SPhilipp Reisner cmdname(p->head.command), p->head.command); 3819b411b363SPhilipp Reisner return -1; 3820b411b363SPhilipp Reisner } 3821b411b363SPhilipp Reisner 3822b411b363SPhilipp Reisner if (p->head.length != expect) { 3823b411b363SPhilipp Reisner dev_err(DEV, "expected HandShake length: %u, received: %u\n", 3824b411b363SPhilipp Reisner expect, p->head.length); 3825b411b363SPhilipp Reisner return -1; 3826b411b363SPhilipp Reisner } 3827b411b363SPhilipp Reisner 3828b411b363SPhilipp Reisner rv = drbd_recv(mdev, &p->head.payload, expect); 3829b411b363SPhilipp Reisner 3830b411b363SPhilipp Reisner if (rv != expect) { 3831b411b363SPhilipp Reisner dev_err(DEV, "short read receiving handshake packet: l=%u\n", rv); 3832b411b363SPhilipp Reisner return 0; 3833b411b363SPhilipp Reisner } 3834b411b363SPhilipp Reisner 3835b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 3836b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 3837b411b363SPhilipp Reisner if (p->protocol_max == 0) 3838b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 3839b411b363SPhilipp Reisner 3840b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 3841b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 3842b411b363SPhilipp Reisner goto incompat; 3843b411b363SPhilipp Reisner 3844b411b363SPhilipp Reisner mdev->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 3845b411b363SPhilipp Reisner 3846b411b363SPhilipp Reisner dev_info(DEV, "Handshake successful: " 3847b411b363SPhilipp Reisner "Agreed network protocol version %d\n", mdev->agreed_pro_version); 3848b411b363SPhilipp Reisner 3849b411b363SPhilipp Reisner return 1; 3850b411b363SPhilipp Reisner 3851b411b363SPhilipp Reisner incompat: 3852b411b363SPhilipp Reisner dev_err(DEV, "incompatible DRBD dialects: " 3853b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 3854b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 3855b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 3856b411b363SPhilipp Reisner return -1; 3857b411b363SPhilipp Reisner } 3858b411b363SPhilipp Reisner 3859b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 3860b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 3861b411b363SPhilipp Reisner { 3862b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 3863b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 3864b10d96cbSJohannes Thoma return -1; 3865b411b363SPhilipp Reisner } 3866b411b363SPhilipp Reisner #else 3867b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 3868b10d96cbSJohannes Thoma 3869b10d96cbSJohannes Thoma /* Return value: 3870b10d96cbSJohannes Thoma 1 - auth succeeded, 3871b10d96cbSJohannes Thoma 0 - failed, try again (network error), 3872b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 3873b10d96cbSJohannes Thoma */ 3874b10d96cbSJohannes Thoma 3875b411b363SPhilipp Reisner static int drbd_do_auth(struct drbd_conf *mdev) 3876b411b363SPhilipp Reisner { 3877b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 3878b411b363SPhilipp Reisner struct scatterlist sg; 3879b411b363SPhilipp Reisner char *response = NULL; 3880b411b363SPhilipp Reisner char *right_response = NULL; 3881b411b363SPhilipp Reisner char *peers_ch = NULL; 3882b411b363SPhilipp Reisner struct p_header p; 3883b411b363SPhilipp Reisner unsigned int key_len = strlen(mdev->net_conf->shared_secret); 3884b411b363SPhilipp Reisner unsigned int resp_size; 3885b411b363SPhilipp Reisner struct hash_desc desc; 3886b411b363SPhilipp Reisner int rv; 3887b411b363SPhilipp Reisner 3888b411b363SPhilipp Reisner desc.tfm = mdev->cram_hmac_tfm; 3889b411b363SPhilipp Reisner desc.flags = 0; 3890b411b363SPhilipp Reisner 3891b411b363SPhilipp Reisner rv = crypto_hash_setkey(mdev->cram_hmac_tfm, 3892b411b363SPhilipp Reisner (u8 *)mdev->net_conf->shared_secret, key_len); 3893b411b363SPhilipp Reisner if (rv) { 3894b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_setkey() failed with %d\n", rv); 3895b10d96cbSJohannes Thoma rv = -1; 3896b411b363SPhilipp Reisner goto fail; 3897b411b363SPhilipp Reisner } 3898b411b363SPhilipp Reisner 3899b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 3900b411b363SPhilipp Reisner 3901b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 3902b411b363SPhilipp Reisner if (!rv) 3903b411b363SPhilipp Reisner goto fail; 3904b411b363SPhilipp Reisner 3905b411b363SPhilipp Reisner rv = drbd_recv_header(mdev, &p); 3906b411b363SPhilipp Reisner if (!rv) 3907b411b363SPhilipp Reisner goto fail; 3908b411b363SPhilipp Reisner 3909b411b363SPhilipp Reisner if (p.command != P_AUTH_CHALLENGE) { 3910b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge packet, received: %s (0x%04x)\n", 3911b411b363SPhilipp Reisner cmdname(p.command), p.command); 3912b411b363SPhilipp Reisner rv = 0; 3913b411b363SPhilipp Reisner goto fail; 3914b411b363SPhilipp Reisner } 3915b411b363SPhilipp Reisner 3916b411b363SPhilipp Reisner if (p.length > CHALLENGE_LEN*2) { 3917b411b363SPhilipp Reisner dev_err(DEV, "expected AuthChallenge payload too big.\n"); 3918b10d96cbSJohannes Thoma rv = -1; 3919b411b363SPhilipp Reisner goto fail; 3920b411b363SPhilipp Reisner } 3921b411b363SPhilipp Reisner 3922b411b363SPhilipp Reisner peers_ch = kmalloc(p.length, GFP_NOIO); 3923b411b363SPhilipp Reisner if (peers_ch == NULL) { 3924b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of peers_ch failed\n"); 3925b10d96cbSJohannes Thoma rv = -1; 3926b411b363SPhilipp Reisner goto fail; 3927b411b363SPhilipp Reisner } 3928b411b363SPhilipp Reisner 3929b411b363SPhilipp Reisner rv = drbd_recv(mdev, peers_ch, p.length); 3930b411b363SPhilipp Reisner 3931b411b363SPhilipp Reisner if (rv != p.length) { 3932b411b363SPhilipp Reisner dev_err(DEV, "short read AuthChallenge: l=%u\n", rv); 3933b411b363SPhilipp Reisner rv = 0; 3934b411b363SPhilipp Reisner goto fail; 3935b411b363SPhilipp Reisner } 3936b411b363SPhilipp Reisner 3937b411b363SPhilipp Reisner resp_size = crypto_hash_digestsize(mdev->cram_hmac_tfm); 3938b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 3939b411b363SPhilipp Reisner if (response == NULL) { 3940b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of response failed\n"); 3941b10d96cbSJohannes Thoma rv = -1; 3942b411b363SPhilipp Reisner goto fail; 3943b411b363SPhilipp Reisner } 3944b411b363SPhilipp Reisner 3945b411b363SPhilipp Reisner sg_init_table(&sg, 1); 3946b411b363SPhilipp Reisner sg_set_buf(&sg, peers_ch, p.length); 3947b411b363SPhilipp Reisner 3948b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 3949b411b363SPhilipp Reisner if (rv) { 3950b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 3951b10d96cbSJohannes Thoma rv = -1; 3952b411b363SPhilipp Reisner goto fail; 3953b411b363SPhilipp Reisner } 3954b411b363SPhilipp Reisner 3955b411b363SPhilipp Reisner rv = drbd_send_cmd2(mdev, P_AUTH_RESPONSE, response, resp_size); 3956b411b363SPhilipp Reisner if (!rv) 3957b411b363SPhilipp Reisner goto fail; 3958b411b363SPhilipp Reisner 3959b411b363SPhilipp Reisner rv = drbd_recv_header(mdev, &p); 3960b411b363SPhilipp Reisner if (!rv) 3961b411b363SPhilipp Reisner goto fail; 3962b411b363SPhilipp Reisner 3963b411b363SPhilipp Reisner if (p.command != P_AUTH_RESPONSE) { 3964b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse packet, received: %s (0x%04x)\n", 3965b411b363SPhilipp Reisner cmdname(p.command), p.command); 3966b411b363SPhilipp Reisner rv = 0; 3967b411b363SPhilipp Reisner goto fail; 3968b411b363SPhilipp Reisner } 3969b411b363SPhilipp Reisner 3970b411b363SPhilipp Reisner if (p.length != resp_size) { 3971b411b363SPhilipp Reisner dev_err(DEV, "expected AuthResponse payload of wrong size\n"); 3972b411b363SPhilipp Reisner rv = 0; 3973b411b363SPhilipp Reisner goto fail; 3974b411b363SPhilipp Reisner } 3975b411b363SPhilipp Reisner 3976b411b363SPhilipp Reisner rv = drbd_recv(mdev, response , resp_size); 3977b411b363SPhilipp Reisner 3978b411b363SPhilipp Reisner if (rv != resp_size) { 3979b411b363SPhilipp Reisner dev_err(DEV, "short read receiving AuthResponse: l=%u\n", rv); 3980b411b363SPhilipp Reisner rv = 0; 3981b411b363SPhilipp Reisner goto fail; 3982b411b363SPhilipp Reisner } 3983b411b363SPhilipp Reisner 3984b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 39852d1ee87dSJulia Lawall if (right_response == NULL) { 3986b411b363SPhilipp Reisner dev_err(DEV, "kmalloc of right_response failed\n"); 3987b10d96cbSJohannes Thoma rv = -1; 3988b411b363SPhilipp Reisner goto fail; 3989b411b363SPhilipp Reisner } 3990b411b363SPhilipp Reisner 3991b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 3992b411b363SPhilipp Reisner 3993b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 3994b411b363SPhilipp Reisner if (rv) { 3995b411b363SPhilipp Reisner dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv); 3996b10d96cbSJohannes Thoma rv = -1; 3997b411b363SPhilipp Reisner goto fail; 3998b411b363SPhilipp Reisner } 3999b411b363SPhilipp Reisner 4000b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4001b411b363SPhilipp Reisner 4002b411b363SPhilipp Reisner if (rv) 4003b411b363SPhilipp Reisner dev_info(DEV, "Peer authenticated using %d bytes of '%s' HMAC\n", 4004b411b363SPhilipp Reisner resp_size, mdev->net_conf->cram_hmac_alg); 4005b10d96cbSJohannes Thoma else 4006b10d96cbSJohannes Thoma rv = -1; 4007b411b363SPhilipp Reisner 4008b411b363SPhilipp Reisner fail: 4009b411b363SPhilipp Reisner kfree(peers_ch); 4010b411b363SPhilipp Reisner kfree(response); 4011b411b363SPhilipp Reisner kfree(right_response); 4012b411b363SPhilipp Reisner 4013b411b363SPhilipp Reisner return rv; 4014b411b363SPhilipp Reisner } 4015b411b363SPhilipp Reisner #endif 4016b411b363SPhilipp Reisner 4017b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4018b411b363SPhilipp Reisner { 4019b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4020b411b363SPhilipp Reisner unsigned int minor = mdev_to_minor(mdev); 4021b411b363SPhilipp Reisner int h; 4022b411b363SPhilipp Reisner 4023b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_receiver", minor); 4024b411b363SPhilipp Reisner 4025b411b363SPhilipp Reisner dev_info(DEV, "receiver (re)started\n"); 4026b411b363SPhilipp Reisner 4027b411b363SPhilipp Reisner do { 4028b411b363SPhilipp Reisner h = drbd_connect(mdev); 4029b411b363SPhilipp Reisner if (h == 0) { 4030b411b363SPhilipp Reisner drbd_disconnect(mdev); 4031b411b363SPhilipp Reisner __set_current_state(TASK_INTERRUPTIBLE); 4032b411b363SPhilipp Reisner schedule_timeout(HZ); 4033b411b363SPhilipp Reisner } 4034b411b363SPhilipp Reisner if (h == -1) { 4035b411b363SPhilipp Reisner dev_warn(DEV, "Discarding network configuration.\n"); 4036b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4037b411b363SPhilipp Reisner } 4038b411b363SPhilipp Reisner } while (h == 0); 4039b411b363SPhilipp Reisner 4040b411b363SPhilipp Reisner if (h > 0) { 4041b411b363SPhilipp Reisner if (get_net_conf(mdev)) { 4042b411b363SPhilipp Reisner drbdd(mdev); 4043b411b363SPhilipp Reisner put_net_conf(mdev); 4044b411b363SPhilipp Reisner } 4045b411b363SPhilipp Reisner } 4046b411b363SPhilipp Reisner 4047b411b363SPhilipp Reisner drbd_disconnect(mdev); 4048b411b363SPhilipp Reisner 4049b411b363SPhilipp Reisner dev_info(DEV, "receiver terminated\n"); 4050b411b363SPhilipp Reisner return 0; 4051b411b363SPhilipp Reisner } 4052b411b363SPhilipp Reisner 4053b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4054b411b363SPhilipp Reisner 4055b411b363SPhilipp Reisner static int got_RqSReply(struct drbd_conf *mdev, struct p_header *h) 4056b411b363SPhilipp Reisner { 4057b411b363SPhilipp Reisner struct p_req_state_reply *p = (struct p_req_state_reply *)h; 4058b411b363SPhilipp Reisner 4059b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4060b411b363SPhilipp Reisner 4061b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4062b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4063b411b363SPhilipp Reisner } else { 4064b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4065b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4066b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4067b411b363SPhilipp Reisner } 4068b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4069b411b363SPhilipp Reisner 4070b411b363SPhilipp Reisner return TRUE; 4071b411b363SPhilipp Reisner } 4072b411b363SPhilipp Reisner 4073b411b363SPhilipp Reisner static int got_Ping(struct drbd_conf *mdev, struct p_header *h) 4074b411b363SPhilipp Reisner { 4075b411b363SPhilipp Reisner return drbd_send_ping_ack(mdev); 4076b411b363SPhilipp Reisner 4077b411b363SPhilipp Reisner } 4078b411b363SPhilipp Reisner 4079b411b363SPhilipp Reisner static int got_PingAck(struct drbd_conf *mdev, struct p_header *h) 4080b411b363SPhilipp Reisner { 4081b411b363SPhilipp Reisner /* restore idle timeout */ 4082b411b363SPhilipp Reisner mdev->meta.socket->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ; 4083309d1608SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags)) 4084309d1608SPhilipp Reisner wake_up(&mdev->misc_wait); 4085b411b363SPhilipp Reisner 4086b411b363SPhilipp Reisner return TRUE; 4087b411b363SPhilipp Reisner } 4088b411b363SPhilipp Reisner 4089b411b363SPhilipp Reisner static int got_IsInSync(struct drbd_conf *mdev, struct p_header *h) 4090b411b363SPhilipp Reisner { 4091b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4092b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4093b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4094b411b363SPhilipp Reisner 4095b411b363SPhilipp Reisner D_ASSERT(mdev->agreed_pro_version >= 89); 4096b411b363SPhilipp Reisner 4097b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4098b411b363SPhilipp Reisner 4099b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4100b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4101b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4102b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 4103b411b363SPhilipp Reisner dec_rs_pending(mdev); 4104b411b363SPhilipp Reisner 4105b411b363SPhilipp Reisner return TRUE; 4106b411b363SPhilipp Reisner } 4107b411b363SPhilipp Reisner 4108b411b363SPhilipp Reisner /* when we receive the ACK for a write request, 4109b411b363SPhilipp Reisner * verify that we actually know about it */ 4110b411b363SPhilipp Reisner static struct drbd_request *_ack_id_to_req(struct drbd_conf *mdev, 4111b411b363SPhilipp Reisner u64 id, sector_t sector) 4112b411b363SPhilipp Reisner { 4113b411b363SPhilipp Reisner struct hlist_head *slot = tl_hash_slot(mdev, sector); 4114b411b363SPhilipp Reisner struct hlist_node *n; 4115b411b363SPhilipp Reisner struct drbd_request *req; 4116b411b363SPhilipp Reisner 4117b411b363SPhilipp Reisner hlist_for_each_entry(req, n, slot, colision) { 4118b411b363SPhilipp Reisner if ((unsigned long)req == (unsigned long)id) { 4119b411b363SPhilipp Reisner if (req->sector != sector) { 4120b411b363SPhilipp Reisner dev_err(DEV, "_ack_id_to_req: found req %p but it has " 4121b411b363SPhilipp Reisner "wrong sector (%llus versus %llus)\n", req, 4122b411b363SPhilipp Reisner (unsigned long long)req->sector, 4123b411b363SPhilipp Reisner (unsigned long long)sector); 4124b411b363SPhilipp Reisner break; 4125b411b363SPhilipp Reisner } 4126b411b363SPhilipp Reisner return req; 4127b411b363SPhilipp Reisner } 4128b411b363SPhilipp Reisner } 4129b411b363SPhilipp Reisner dev_err(DEV, "_ack_id_to_req: failed to find req %p, sector %llus in list\n", 4130b411b363SPhilipp Reisner (void *)(unsigned long)id, (unsigned long long)sector); 4131b411b363SPhilipp Reisner return NULL; 4132b411b363SPhilipp Reisner } 4133b411b363SPhilipp Reisner 4134b411b363SPhilipp Reisner typedef struct drbd_request *(req_validator_fn) 4135b411b363SPhilipp Reisner (struct drbd_conf *mdev, u64 id, sector_t sector); 4136b411b363SPhilipp Reisner 4137b411b363SPhilipp Reisner static int validate_req_change_req_state(struct drbd_conf *mdev, 4138b411b363SPhilipp Reisner u64 id, sector_t sector, req_validator_fn validator, 4139b411b363SPhilipp Reisner const char *func, enum drbd_req_event what) 4140b411b363SPhilipp Reisner { 4141b411b363SPhilipp Reisner struct drbd_request *req; 4142b411b363SPhilipp Reisner struct bio_and_error m; 4143b411b363SPhilipp Reisner 4144b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 4145b411b363SPhilipp Reisner req = validator(mdev, id, sector); 4146b411b363SPhilipp Reisner if (unlikely(!req)) { 4147b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4148b411b363SPhilipp Reisner dev_err(DEV, "%s: got a corrupt block_id/sector pair\n", func); 4149b411b363SPhilipp Reisner return FALSE; 4150b411b363SPhilipp Reisner } 4151b411b363SPhilipp Reisner __req_mod(req, what, &m); 4152b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4153b411b363SPhilipp Reisner 4154b411b363SPhilipp Reisner if (m.bio) 4155b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 4156b411b363SPhilipp Reisner return TRUE; 4157b411b363SPhilipp Reisner } 4158b411b363SPhilipp Reisner 4159b411b363SPhilipp Reisner static int got_BlockAck(struct drbd_conf *mdev, struct p_header *h) 4160b411b363SPhilipp Reisner { 4161b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4162b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4163b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4164b411b363SPhilipp Reisner enum drbd_req_event what; 4165b411b363SPhilipp Reisner 4166b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4167b411b363SPhilipp Reisner 4168b411b363SPhilipp Reisner if (is_syncer_block_id(p->block_id)) { 4169b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4170b411b363SPhilipp Reisner dec_rs_pending(mdev); 4171b411b363SPhilipp Reisner return TRUE; 4172b411b363SPhilipp Reisner } 4173b411b363SPhilipp Reisner switch (be16_to_cpu(h->command)) { 4174b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 4175b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4176b411b363SPhilipp Reisner what = write_acked_by_peer_and_sis; 4177b411b363SPhilipp Reisner break; 4178b411b363SPhilipp Reisner case P_WRITE_ACK: 4179b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4180b411b363SPhilipp Reisner what = write_acked_by_peer; 4181b411b363SPhilipp Reisner break; 4182b411b363SPhilipp Reisner case P_RECV_ACK: 4183b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_B); 4184b411b363SPhilipp Reisner what = recv_acked_by_peer; 4185b411b363SPhilipp Reisner break; 4186b411b363SPhilipp Reisner case P_DISCARD_ACK: 4187b411b363SPhilipp Reisner D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C); 4188b411b363SPhilipp Reisner what = conflict_discarded_by_peer; 4189b411b363SPhilipp Reisner break; 4190b411b363SPhilipp Reisner default: 4191b411b363SPhilipp Reisner D_ASSERT(0); 4192b411b363SPhilipp Reisner return FALSE; 4193b411b363SPhilipp Reisner } 4194b411b363SPhilipp Reisner 4195b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4196b411b363SPhilipp Reisner _ack_id_to_req, __func__ , what); 4197b411b363SPhilipp Reisner } 4198b411b363SPhilipp Reisner 4199b411b363SPhilipp Reisner static int got_NegAck(struct drbd_conf *mdev, struct p_header *h) 4200b411b363SPhilipp Reisner { 4201b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4202b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4203b411b363SPhilipp Reisner 4204b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 4205b411b363SPhilipp Reisner dev_warn(DEV, "Got NegAck packet. Peer is in troubles?\n"); 4206b411b363SPhilipp Reisner 4207b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4208b411b363SPhilipp Reisner 4209b411b363SPhilipp Reisner if (is_syncer_block_id(p->block_id)) { 4210b411b363SPhilipp Reisner int size = be32_to_cpu(p->blksize); 4211b411b363SPhilipp Reisner dec_rs_pending(mdev); 4212b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4213b411b363SPhilipp Reisner return TRUE; 4214b411b363SPhilipp Reisner } 4215b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4216b411b363SPhilipp Reisner _ack_id_to_req, __func__ , neg_acked); 4217b411b363SPhilipp Reisner } 4218b411b363SPhilipp Reisner 4219b411b363SPhilipp Reisner static int got_NegDReply(struct drbd_conf *mdev, struct p_header *h) 4220b411b363SPhilipp Reisner { 4221b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4222b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4223b411b363SPhilipp Reisner 4224b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4225b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4226b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4227b411b363SPhilipp Reisner 4228b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4229b411b363SPhilipp Reisner _ar_id_to_req, __func__ , neg_acked); 4230b411b363SPhilipp Reisner } 4231b411b363SPhilipp Reisner 4232b411b363SPhilipp Reisner static int got_NegRSDReply(struct drbd_conf *mdev, struct p_header *h) 4233b411b363SPhilipp Reisner { 4234b411b363SPhilipp Reisner sector_t sector; 4235b411b363SPhilipp Reisner int size; 4236b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4237b411b363SPhilipp Reisner 4238b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4239b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4240b411b363SPhilipp Reisner 4241b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4242b411b363SPhilipp Reisner 4243b411b363SPhilipp Reisner dec_rs_pending(mdev); 4244b411b363SPhilipp Reisner 4245b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4246b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4247b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4248b411b363SPhilipp Reisner put_ldev(mdev); 4249b411b363SPhilipp Reisner } 4250b411b363SPhilipp Reisner 4251b411b363SPhilipp Reisner return TRUE; 4252b411b363SPhilipp Reisner } 4253b411b363SPhilipp Reisner 4254b411b363SPhilipp Reisner static int got_BarrierAck(struct drbd_conf *mdev, struct p_header *h) 4255b411b363SPhilipp Reisner { 4256b411b363SPhilipp Reisner struct p_barrier_ack *p = (struct p_barrier_ack *)h; 4257b411b363SPhilipp Reisner 4258b411b363SPhilipp Reisner tl_release(mdev, p->barrier, be32_to_cpu(p->set_size)); 4259b411b363SPhilipp Reisner 4260b411b363SPhilipp Reisner return TRUE; 4261b411b363SPhilipp Reisner } 4262b411b363SPhilipp Reisner 4263b411b363SPhilipp Reisner static int got_OVResult(struct drbd_conf *mdev, struct p_header *h) 4264b411b363SPhilipp Reisner { 4265b411b363SPhilipp Reisner struct p_block_ack *p = (struct p_block_ack *)h; 4266b411b363SPhilipp Reisner struct drbd_work *w; 4267b411b363SPhilipp Reisner sector_t sector; 4268b411b363SPhilipp Reisner int size; 4269b411b363SPhilipp Reisner 4270b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4271b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4272b411b363SPhilipp Reisner 4273b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4274b411b363SPhilipp Reisner 4275b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4276b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4277b411b363SPhilipp Reisner else 4278b411b363SPhilipp Reisner ov_oos_print(mdev); 4279b411b363SPhilipp Reisner 4280b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4281b411b363SPhilipp Reisner dec_rs_pending(mdev); 4282b411b363SPhilipp Reisner 4283b411b363SPhilipp Reisner if (--mdev->ov_left == 0) { 4284b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4285b411b363SPhilipp Reisner if (w) { 4286b411b363SPhilipp Reisner w->cb = w_ov_finished; 4287b411b363SPhilipp Reisner drbd_queue_work_front(&mdev->data.work, w); 4288b411b363SPhilipp Reisner } else { 4289b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4290b411b363SPhilipp Reisner ov_oos_print(mdev); 4291b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4292b411b363SPhilipp Reisner } 4293b411b363SPhilipp Reisner } 4294b411b363SPhilipp Reisner return TRUE; 4295b411b363SPhilipp Reisner } 4296b411b363SPhilipp Reisner 4297b411b363SPhilipp Reisner struct asender_cmd { 4298b411b363SPhilipp Reisner size_t pkt_size; 4299b411b363SPhilipp Reisner int (*process)(struct drbd_conf *mdev, struct p_header *h); 4300b411b363SPhilipp Reisner }; 4301b411b363SPhilipp Reisner 4302b411b363SPhilipp Reisner static struct asender_cmd *get_asender_cmd(int cmd) 4303b411b363SPhilipp Reisner { 4304b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 4305b411b363SPhilipp Reisner /* anything missing from this table is in 4306b411b363SPhilipp Reisner * the drbd_cmd_handler (drbd_default_handler) table, 4307b411b363SPhilipp Reisner * see the beginning of drbdd() */ 4308b411b363SPhilipp Reisner [P_PING] = { sizeof(struct p_header), got_Ping }, 4309b411b363SPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), got_PingAck }, 4310b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4311b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4312b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4313b411b363SPhilipp Reisner [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4314b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 4315b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 4316b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4317b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 4318b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 4319b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 4320b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 4321b411b363SPhilipp Reisner [P_MAX_CMD] = { 0, NULL }, 4322b411b363SPhilipp Reisner }; 4323b411b363SPhilipp Reisner if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL) 4324b411b363SPhilipp Reisner return NULL; 4325b411b363SPhilipp Reisner return &asender_tbl[cmd]; 4326b411b363SPhilipp Reisner } 4327b411b363SPhilipp Reisner 4328b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4329b411b363SPhilipp Reisner { 4330b411b363SPhilipp Reisner struct drbd_conf *mdev = thi->mdev; 4331b411b363SPhilipp Reisner struct p_header *h = &mdev->meta.rbuf.header; 4332b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 4333b411b363SPhilipp Reisner 4334b411b363SPhilipp Reisner int rv, len; 4335b411b363SPhilipp Reisner void *buf = h; 4336b411b363SPhilipp Reisner int received = 0; 4337b411b363SPhilipp Reisner int expect = sizeof(struct p_header); 4338b411b363SPhilipp Reisner int empty; 4339b411b363SPhilipp Reisner 4340b411b363SPhilipp Reisner sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev)); 4341b411b363SPhilipp Reisner 4342b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4343b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4344b411b363SPhilipp Reisner 4345b411b363SPhilipp Reisner while (get_t_state(thi) == Running) { 4346b411b363SPhilipp Reisner drbd_thread_current_set_cpu(mdev); 4347b411b363SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &mdev->flags)) { 4348b411b363SPhilipp Reisner ERR_IF(!drbd_send_ping(mdev)) goto reconnect; 4349b411b363SPhilipp Reisner mdev->meta.socket->sk->sk_rcvtimeo = 4350b411b363SPhilipp Reisner mdev->net_conf->ping_timeo*HZ/10; 4351b411b363SPhilipp Reisner } 4352b411b363SPhilipp Reisner 4353b411b363SPhilipp Reisner /* conditionally cork; 4354b411b363SPhilipp Reisner * it may hurt latency if we cork without much to send */ 4355b411b363SPhilipp Reisner if (!mdev->net_conf->no_cork && 4356b411b363SPhilipp Reisner 3 < atomic_read(&mdev->unacked_cnt)) 4357b411b363SPhilipp Reisner drbd_tcp_cork(mdev->meta.socket); 4358b411b363SPhilipp Reisner while (1) { 4359b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4360b411b363SPhilipp Reisner flush_signals(current); 4361b411b363SPhilipp Reisner if (!drbd_process_done_ee(mdev)) { 4362b411b363SPhilipp Reisner dev_err(DEV, "process_done_ee() = NOT_OK\n"); 4363b411b363SPhilipp Reisner goto reconnect; 4364b411b363SPhilipp Reisner } 4365b411b363SPhilipp Reisner /* to avoid race with newly queued ACKs */ 4366b411b363SPhilipp Reisner set_bit(SIGNAL_ASENDER, &mdev->flags); 4367b411b363SPhilipp Reisner spin_lock_irq(&mdev->req_lock); 4368b411b363SPhilipp Reisner empty = list_empty(&mdev->done_ee); 4369b411b363SPhilipp Reisner spin_unlock_irq(&mdev->req_lock); 4370b411b363SPhilipp Reisner /* new ack may have been queued right here, 4371b411b363SPhilipp Reisner * but then there is also a signal pending, 4372b411b363SPhilipp Reisner * and we start over... */ 4373b411b363SPhilipp Reisner if (empty) 4374b411b363SPhilipp Reisner break; 4375b411b363SPhilipp Reisner } 4376b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 4377b411b363SPhilipp Reisner if (!mdev->net_conf->no_cork) 4378b411b363SPhilipp Reisner drbd_tcp_uncork(mdev->meta.socket); 4379b411b363SPhilipp Reisner 4380b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4381b411b363SPhilipp Reisner if (signal_pending(current)) 4382b411b363SPhilipp Reisner continue; 4383b411b363SPhilipp Reisner 4384b411b363SPhilipp Reisner rv = drbd_recv_short(mdev, mdev->meta.socket, 4385b411b363SPhilipp Reisner buf, expect-received, 0); 4386b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4387b411b363SPhilipp Reisner 4388b411b363SPhilipp Reisner flush_signals(current); 4389b411b363SPhilipp Reisner 4390b411b363SPhilipp Reisner /* Note: 4391b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4392b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4393b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4394b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4395b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4396b411b363SPhilipp Reisner * rv == expected: full header or command 4397b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4398b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4399b411b363SPhilipp Reisner */ 4400b411b363SPhilipp Reisner if (likely(rv > 0)) { 4401b411b363SPhilipp Reisner received += rv; 4402b411b363SPhilipp Reisner buf += rv; 4403b411b363SPhilipp Reisner } else if (rv == 0) { 4404b411b363SPhilipp Reisner dev_err(DEV, "meta connection shut down by peer.\n"); 4405b411b363SPhilipp Reisner goto reconnect; 4406b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4407b411b363SPhilipp Reisner if (mdev->meta.socket->sk->sk_rcvtimeo == 4408b411b363SPhilipp Reisner mdev->net_conf->ping_timeo*HZ/10) { 4409b411b363SPhilipp Reisner dev_err(DEV, "PingAck did not arrive in time.\n"); 4410b411b363SPhilipp Reisner goto reconnect; 4411b411b363SPhilipp Reisner } 4412b411b363SPhilipp Reisner set_bit(SEND_PING, &mdev->flags); 4413b411b363SPhilipp Reisner continue; 4414b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4415b411b363SPhilipp Reisner continue; 4416b411b363SPhilipp Reisner } else { 4417b411b363SPhilipp Reisner dev_err(DEV, "sock_recvmsg returned %d\n", rv); 4418b411b363SPhilipp Reisner goto reconnect; 4419b411b363SPhilipp Reisner } 4420b411b363SPhilipp Reisner 4421b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4422b411b363SPhilipp Reisner if (unlikely(h->magic != BE_DRBD_MAGIC)) { 4423b411b363SPhilipp Reisner dev_err(DEV, "magic?? on meta m: 0x%lx c: %d l: %d\n", 4424b411b363SPhilipp Reisner (long)be32_to_cpu(h->magic), 4425b411b363SPhilipp Reisner h->command, h->length); 4426b411b363SPhilipp Reisner goto reconnect; 4427b411b363SPhilipp Reisner } 4428b411b363SPhilipp Reisner cmd = get_asender_cmd(be16_to_cpu(h->command)); 4429b411b363SPhilipp Reisner len = be16_to_cpu(h->length); 4430b411b363SPhilipp Reisner if (unlikely(cmd == NULL)) { 4431b411b363SPhilipp Reisner dev_err(DEV, "unknown command?? on meta m: 0x%lx c: %d l: %d\n", 4432b411b363SPhilipp Reisner (long)be32_to_cpu(h->magic), 4433b411b363SPhilipp Reisner h->command, h->length); 4434b411b363SPhilipp Reisner goto disconnect; 4435b411b363SPhilipp Reisner } 4436b411b363SPhilipp Reisner expect = cmd->pkt_size; 44376a0afdf5SJens Axboe ERR_IF(len != expect-sizeof(struct p_header)) 4438b411b363SPhilipp Reisner goto reconnect; 4439b411b363SPhilipp Reisner } 4440b411b363SPhilipp Reisner if (received == expect) { 4441b411b363SPhilipp Reisner D_ASSERT(cmd != NULL); 4442b411b363SPhilipp Reisner if (!cmd->process(mdev, h)) 4443b411b363SPhilipp Reisner goto reconnect; 4444b411b363SPhilipp Reisner 4445b411b363SPhilipp Reisner buf = h; 4446b411b363SPhilipp Reisner received = 0; 4447b411b363SPhilipp Reisner expect = sizeof(struct p_header); 4448b411b363SPhilipp Reisner cmd = NULL; 4449b411b363SPhilipp Reisner } 4450b411b363SPhilipp Reisner } 4451b411b363SPhilipp Reisner 4452b411b363SPhilipp Reisner if (0) { 4453b411b363SPhilipp Reisner reconnect: 4454b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE)); 4455b411b363SPhilipp Reisner } 4456b411b363SPhilipp Reisner if (0) { 4457b411b363SPhilipp Reisner disconnect: 4458b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 4459b411b363SPhilipp Reisner } 4460b411b363SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &mdev->flags); 4461b411b363SPhilipp Reisner 4462b411b363SPhilipp Reisner D_ASSERT(mdev->state.conn < C_CONNECTED); 4463b411b363SPhilipp Reisner dev_info(DEV, "asender terminated\n"); 4464b411b363SPhilipp Reisner 4465b411b363SPhilipp Reisner return 0; 4466b411b363SPhilipp Reisner } 4467