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/pkt_sched.h> 40b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 41b411b363SPhilipp Reisner #include <linux/unistd.h> 42b411b363SPhilipp Reisner #include <linux/vmalloc.h> 43b411b363SPhilipp Reisner #include <linux/random.h> 44b411b363SPhilipp Reisner #include <linux/string.h> 45b411b363SPhilipp Reisner #include <linux/scatterlist.h> 46b411b363SPhilipp Reisner #include "drbd_int.h" 47b411b363SPhilipp Reisner #include "drbd_req.h" 48b411b363SPhilipp Reisner 49b411b363SPhilipp Reisner #include "drbd_vli.h" 50b411b363SPhilipp Reisner 5177351055SPhilipp Reisner struct packet_info { 5277351055SPhilipp Reisner enum drbd_packet cmd; 53e2857216SAndreas Gruenbacher unsigned int size; 54e2857216SAndreas Gruenbacher unsigned int vnr; 55e658983aSAndreas Gruenbacher void *data; 5677351055SPhilipp Reisner }; 5777351055SPhilipp Reisner 58b411b363SPhilipp Reisner enum finish_epoch { 59b411b363SPhilipp Reisner FE_STILL_LIVE, 60b411b363SPhilipp Reisner FE_DESTROYED, 61b411b363SPhilipp Reisner FE_RECYCLED, 62b411b363SPhilipp Reisner }; 63b411b363SPhilipp Reisner 646038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn); 6513e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 66360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data); 67b411b363SPhilipp Reisner 68b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 6999920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 73b411b363SPhilipp Reisner 7445bb912bSLars Ellenberg /* 7545bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7645bb912bSLars Ellenberg * page->private being our "next" pointer. 7745bb912bSLars Ellenberg */ 7845bb912bSLars Ellenberg 7945bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8045bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8145bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8245bb912bSLars Ellenberg */ 8345bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8445bb912bSLars Ellenberg { 8545bb912bSLars Ellenberg struct page *page; 8645bb912bSLars Ellenberg struct page *tmp; 8745bb912bSLars Ellenberg 8845bb912bSLars Ellenberg BUG_ON(!n); 8945bb912bSLars Ellenberg BUG_ON(!head); 9045bb912bSLars Ellenberg 9145bb912bSLars Ellenberg page = *head; 9223ce4227SPhilipp Reisner 9323ce4227SPhilipp Reisner if (!page) 9423ce4227SPhilipp Reisner return NULL; 9523ce4227SPhilipp Reisner 9645bb912bSLars Ellenberg while (page) { 9745bb912bSLars Ellenberg tmp = page_chain_next(page); 9845bb912bSLars Ellenberg if (--n == 0) 9945bb912bSLars Ellenberg break; /* found sufficient pages */ 10045bb912bSLars Ellenberg if (tmp == NULL) 10145bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10245bb912bSLars Ellenberg return NULL; 10345bb912bSLars Ellenberg page = tmp; 10445bb912bSLars Ellenberg } 10545bb912bSLars Ellenberg 10645bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10745bb912bSLars Ellenberg set_page_private(page, 0); 10845bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10945bb912bSLars Ellenberg page = *head; 11045bb912bSLars Ellenberg *head = tmp; 11145bb912bSLars Ellenberg return page; 11245bb912bSLars Ellenberg } 11345bb912bSLars Ellenberg 11445bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11545bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11645bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11745bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11845bb912bSLars Ellenberg { 11945bb912bSLars Ellenberg struct page *tmp; 12045bb912bSLars Ellenberg int i = 1; 12145bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12245bb912bSLars Ellenberg ++i, page = tmp; 12345bb912bSLars Ellenberg if (len) 12445bb912bSLars Ellenberg *len = i; 12545bb912bSLars Ellenberg return page; 12645bb912bSLars Ellenberg } 12745bb912bSLars Ellenberg 12845bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12945bb912bSLars Ellenberg { 13045bb912bSLars Ellenberg struct page *tmp; 13145bb912bSLars Ellenberg int i = 0; 13245bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13345bb912bSLars Ellenberg put_page(page); 13445bb912bSLars Ellenberg ++i; 13545bb912bSLars Ellenberg } 13645bb912bSLars Ellenberg return i; 13745bb912bSLars Ellenberg } 13845bb912bSLars Ellenberg 13945bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14045bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14145bb912bSLars Ellenberg { 14245bb912bSLars Ellenberg #if 1 14345bb912bSLars Ellenberg struct page *tmp; 14445bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14545bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14645bb912bSLars Ellenberg #endif 14745bb912bSLars Ellenberg 14845bb912bSLars Ellenberg /* add chain to head */ 14945bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15045bb912bSLars Ellenberg *head = chain_first; 15145bb912bSLars Ellenberg } 15245bb912bSLars Ellenberg 15345bb912bSLars Ellenberg static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number) 154b411b363SPhilipp Reisner { 155b411b363SPhilipp Reisner struct page *page = NULL; 15645bb912bSLars Ellenberg struct page *tmp = NULL; 15745bb912bSLars Ellenberg int i = 0; 158b411b363SPhilipp Reisner 159b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 160b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16145bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 162b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16345bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16445bb912bSLars Ellenberg if (page) 16545bb912bSLars Ellenberg drbd_pp_vacant -= number; 166b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16745bb912bSLars Ellenberg if (page) 16845bb912bSLars Ellenberg return page; 169b411b363SPhilipp Reisner } 17045bb912bSLars Ellenberg 171b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 172b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 173b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17445bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17545bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17645bb912bSLars Ellenberg if (!tmp) 17745bb912bSLars Ellenberg break; 17845bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 17945bb912bSLars Ellenberg page = tmp; 18045bb912bSLars Ellenberg } 18145bb912bSLars Ellenberg 18245bb912bSLars Ellenberg if (i == number) 183b411b363SPhilipp Reisner return page; 18445bb912bSLars Ellenberg 18545bb912bSLars Ellenberg /* Not enough pages immediately available this time. 18645bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc will retry this 18745bb912bSLars Ellenberg * function "soon". */ 18845bb912bSLars Ellenberg if (page) { 18945bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19045bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19145bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19245bb912bSLars Ellenberg drbd_pp_vacant += i; 19345bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19445bb912bSLars Ellenberg } 19545bb912bSLars Ellenberg return NULL; 196b411b363SPhilipp Reisner } 197b411b363SPhilipp Reisner 198b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 199b411b363SPhilipp Reisner { 200db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 201b411b363SPhilipp Reisner struct list_head *le, *tle; 202b411b363SPhilipp Reisner 203b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 204b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 205b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 206b411b363SPhilipp Reisner stop to examine the list... */ 207b411b363SPhilipp Reisner 208b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 209db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 210db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) 211b411b363SPhilipp Reisner break; 212b411b363SPhilipp Reisner list_move(le, to_be_freed); 213b411b363SPhilipp Reisner } 214b411b363SPhilipp Reisner } 215b411b363SPhilipp Reisner 216b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 217b411b363SPhilipp Reisner { 218b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 219db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 220b411b363SPhilipp Reisner 22187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 222b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 22387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 224b411b363SPhilipp Reisner 225db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 2263967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 227b411b363SPhilipp Reisner } 228b411b363SPhilipp Reisner 229b411b363SPhilipp Reisner /** 23045bb912bSLars Ellenberg * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled) 231b411b363SPhilipp Reisner * @mdev: DRBD device. 23245bb912bSLars Ellenberg * @number: number of pages requested 23345bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 234b411b363SPhilipp Reisner * 23545bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23645bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23745bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 23845bb912bSLars Ellenberg * 23945bb912bSLars Ellenberg * Returns a page chain linked via page->private. 240b411b363SPhilipp Reisner */ 24145bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 242b411b363SPhilipp Reisner { 243b411b363SPhilipp Reisner struct page *page = NULL; 244b411b363SPhilipp Reisner DEFINE_WAIT(wait); 245b411b363SPhilipp Reisner 24645bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 24745bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 24889e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) 24945bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 250b411b363SPhilipp Reisner 25145bb912bSLars Ellenberg while (page == NULL) { 252b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 253b411b363SPhilipp Reisner 254b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 255b411b363SPhilipp Reisner 25689e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) { 25745bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 258b411b363SPhilipp Reisner if (page) 259b411b363SPhilipp Reisner break; 260b411b363SPhilipp Reisner } 261b411b363SPhilipp Reisner 262b411b363SPhilipp Reisner if (!retry) 263b411b363SPhilipp Reisner break; 264b411b363SPhilipp Reisner 265b411b363SPhilipp Reisner if (signal_pending(current)) { 266b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 267b411b363SPhilipp Reisner break; 268b411b363SPhilipp Reisner } 269b411b363SPhilipp Reisner 270b411b363SPhilipp Reisner schedule(); 271b411b363SPhilipp Reisner } 272b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 273b411b363SPhilipp Reisner 27445bb912bSLars Ellenberg if (page) 27545bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 276b411b363SPhilipp Reisner return page; 277b411b363SPhilipp Reisner } 278b411b363SPhilipp Reisner 279b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 28087eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 28145bb912bSLars Ellenberg * Either links the page chain back to the global pool, 28245bb912bSLars Ellenberg * or returns all pages to the system. */ 283435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 284b411b363SPhilipp Reisner { 285435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 286b411b363SPhilipp Reisner int i; 287435f0740SLars Ellenberg 2881816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 28945bb912bSLars Ellenberg i = page_chain_free(page); 29045bb912bSLars Ellenberg else { 29145bb912bSLars Ellenberg struct page *tmp; 29245bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 293b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 29445bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 29545bb912bSLars Ellenberg drbd_pp_vacant += i; 296b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 297b411b363SPhilipp Reisner } 298435f0740SLars Ellenberg i = atomic_sub_return(i, a); 29945bb912bSLars Ellenberg if (i < 0) 300435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 301435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 302b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 303b411b363SPhilipp Reisner } 304b411b363SPhilipp Reisner 305b411b363SPhilipp Reisner /* 306b411b363SPhilipp Reisner You need to hold the req_lock: 307b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 308b411b363SPhilipp Reisner 309b411b363SPhilipp Reisner You must not have the req_lock: 3103967deb1SAndreas Gruenbacher drbd_free_peer_req() 3110db55363SAndreas Gruenbacher drbd_alloc_peer_req() 312b411b363SPhilipp Reisner drbd_release_ee() 313b411b363SPhilipp Reisner drbd_ee_fix_bhs() 314b411b363SPhilipp Reisner drbd_process_done_ee() 315b411b363SPhilipp Reisner drbd_clear_done_ee() 316b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 317b411b363SPhilipp Reisner */ 318b411b363SPhilipp Reisner 319f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 3200db55363SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector, 321f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 322b411b363SPhilipp Reisner { 323db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 324b411b363SPhilipp Reisner struct page *page; 32545bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 326b411b363SPhilipp Reisner 3270cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 328b411b363SPhilipp Reisner return NULL; 329b411b363SPhilipp Reisner 330db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 331db830c46SAndreas Gruenbacher if (!peer_req) { 332b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 3330db55363SAndreas Gruenbacher dev_err(DEV, "%s: allocation failed\n", __func__); 334b411b363SPhilipp Reisner return NULL; 335b411b363SPhilipp Reisner } 336b411b363SPhilipp Reisner 33745bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 33845bb912bSLars Ellenberg if (!page) 33945bb912bSLars Ellenberg goto fail; 340b411b363SPhilipp Reisner 341db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 342db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 343db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 344db830c46SAndreas Gruenbacher peer_req->i.local = false; 345db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 34653840641SAndreas Gruenbacher 347db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 348a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 349db830c46SAndreas Gruenbacher peer_req->pages = page; 350db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 351db830c46SAndreas Gruenbacher peer_req->flags = 0; 3529a8e7753SAndreas Gruenbacher /* 3539a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3549a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3559a8e7753SAndreas Gruenbacher */ 356db830c46SAndreas Gruenbacher peer_req->block_id = id; 357b411b363SPhilipp Reisner 358db830c46SAndreas Gruenbacher return peer_req; 359b411b363SPhilipp Reisner 36045bb912bSLars Ellenberg fail: 361db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 362b411b363SPhilipp Reisner return NULL; 363b411b363SPhilipp Reisner } 364b411b363SPhilipp Reisner 3653967deb1SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 366f6ffca9fSAndreas Gruenbacher int is_net) 367b411b363SPhilipp Reisner { 368db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 369db830c46SAndreas Gruenbacher kfree(peer_req->digest); 370db830c46SAndreas Gruenbacher drbd_pp_free(mdev, peer_req->pages, is_net); 371db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 372db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 373db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 374b411b363SPhilipp Reisner } 375b411b363SPhilipp Reisner 376b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 377b411b363SPhilipp Reisner { 378b411b363SPhilipp Reisner LIST_HEAD(work_list); 379db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 380b411b363SPhilipp Reisner int count = 0; 381435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 382b411b363SPhilipp Reisner 38387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 384b411b363SPhilipp Reisner list_splice_init(list, &work_list); 38587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 386b411b363SPhilipp Reisner 387db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 3883967deb1SAndreas Gruenbacher __drbd_free_peer_req(mdev, peer_req, is_net); 389b411b363SPhilipp Reisner count++; 390b411b363SPhilipp Reisner } 391b411b363SPhilipp Reisner return count; 392b411b363SPhilipp Reisner } 393b411b363SPhilipp Reisner 394b411b363SPhilipp Reisner 39532862ec7SPhilipp Reisner /* See also comments in _req_mod(,BARRIER_ACKED) 396b411b363SPhilipp Reisner * and receive_Barrier. 397b411b363SPhilipp Reisner * 398b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 399b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 400b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 401b411b363SPhilipp Reisner */ 402b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 403b411b363SPhilipp Reisner { 404b411b363SPhilipp Reisner LIST_HEAD(work_list); 405b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 406db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 407e2b3032bSAndreas Gruenbacher int err = 0; 408b411b363SPhilipp Reisner 40987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 410b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 411b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 41287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 413b411b363SPhilipp Reisner 414db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 4153967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 416b411b363SPhilipp Reisner 417b411b363SPhilipp Reisner /* possible callbacks here: 4187be8da07SAndreas Gruenbacher * e_end_block, and e_end_resync_block, e_send_discard_write. 419b411b363SPhilipp Reisner * all ignore the last argument. 420b411b363SPhilipp Reisner */ 421db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 422e2b3032bSAndreas Gruenbacher int err2; 423e2b3032bSAndreas Gruenbacher 424b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 425e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 426e2b3032bSAndreas Gruenbacher if (!err) 427e2b3032bSAndreas Gruenbacher err = err2; 4283967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 429b411b363SPhilipp Reisner } 430b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 431b411b363SPhilipp Reisner 432e2b3032bSAndreas Gruenbacher return err; 433b411b363SPhilipp Reisner } 434b411b363SPhilipp Reisner 435b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 436b411b363SPhilipp Reisner { 437b411b363SPhilipp Reisner DEFINE_WAIT(wait); 438b411b363SPhilipp Reisner 439b411b363SPhilipp Reisner /* avoids spin_lock/unlock 440b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 441b411b363SPhilipp Reisner while (!list_empty(head)) { 442b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 44387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4447eaceaccSJens Axboe io_schedule(); 445b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 44687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 447b411b363SPhilipp Reisner } 448b411b363SPhilipp Reisner } 449b411b363SPhilipp Reisner 450b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 451b411b363SPhilipp Reisner { 45287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 453b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 45487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 455b411b363SPhilipp Reisner } 456b411b363SPhilipp Reisner 457b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 458b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4597653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 460b411b363SPhilipp Reisner { 461b411b363SPhilipp Reisner struct sock *sk = sock->sk; 462b411b363SPhilipp Reisner int err = 0; 463b411b363SPhilipp Reisner 464b411b363SPhilipp Reisner *what = "listen"; 465b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 466b411b363SPhilipp Reisner if (err < 0) 467b411b363SPhilipp Reisner goto out; 468b411b363SPhilipp Reisner 469b411b363SPhilipp Reisner *what = "sock_create_lite"; 470b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 471b411b363SPhilipp Reisner newsock); 472b411b363SPhilipp Reisner if (err < 0) 473b411b363SPhilipp Reisner goto out; 474b411b363SPhilipp Reisner 475b411b363SPhilipp Reisner *what = "accept"; 476b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 477b411b363SPhilipp Reisner if (err < 0) { 478b411b363SPhilipp Reisner sock_release(*newsock); 479b411b363SPhilipp Reisner *newsock = NULL; 480b411b363SPhilipp Reisner goto out; 481b411b363SPhilipp Reisner } 482b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 483b411b363SPhilipp Reisner 484b411b363SPhilipp Reisner out: 485b411b363SPhilipp Reisner return err; 486b411b363SPhilipp Reisner } 487b411b363SPhilipp Reisner 488dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 489b411b363SPhilipp Reisner { 490b411b363SPhilipp Reisner mm_segment_t oldfs; 491b411b363SPhilipp Reisner struct kvec iov = { 492b411b363SPhilipp Reisner .iov_base = buf, 493b411b363SPhilipp Reisner .iov_len = size, 494b411b363SPhilipp Reisner }; 495b411b363SPhilipp Reisner struct msghdr msg = { 496b411b363SPhilipp Reisner .msg_iovlen = 1, 497b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 498b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 499b411b363SPhilipp Reisner }; 500b411b363SPhilipp Reisner int rv; 501b411b363SPhilipp Reisner 502b411b363SPhilipp Reisner oldfs = get_fs(); 503b411b363SPhilipp Reisner set_fs(KERNEL_DS); 504b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 505b411b363SPhilipp Reisner set_fs(oldfs); 506b411b363SPhilipp Reisner 507b411b363SPhilipp Reisner return rv; 508b411b363SPhilipp Reisner } 509b411b363SPhilipp Reisner 510de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 511b411b363SPhilipp Reisner { 512b411b363SPhilipp Reisner mm_segment_t oldfs; 513b411b363SPhilipp Reisner struct kvec iov = { 514b411b363SPhilipp Reisner .iov_base = buf, 515b411b363SPhilipp Reisner .iov_len = size, 516b411b363SPhilipp Reisner }; 517b411b363SPhilipp Reisner struct msghdr msg = { 518b411b363SPhilipp Reisner .msg_iovlen = 1, 519b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 520b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 521b411b363SPhilipp Reisner }; 522b411b363SPhilipp Reisner int rv; 523b411b363SPhilipp Reisner 524b411b363SPhilipp Reisner oldfs = get_fs(); 525b411b363SPhilipp Reisner set_fs(KERNEL_DS); 526b411b363SPhilipp Reisner 527b411b363SPhilipp Reisner for (;;) { 528de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 529b411b363SPhilipp Reisner if (rv == size) 530b411b363SPhilipp Reisner break; 531b411b363SPhilipp Reisner 532b411b363SPhilipp Reisner /* Note: 533b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 534b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 535b411b363SPhilipp Reisner */ 536b411b363SPhilipp Reisner 537b411b363SPhilipp Reisner if (rv < 0) { 538b411b363SPhilipp Reisner if (rv == -ECONNRESET) 539de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 540b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 541de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 542b411b363SPhilipp Reisner break; 543b411b363SPhilipp Reisner } else if (rv == 0) { 544de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 545b411b363SPhilipp Reisner break; 546b411b363SPhilipp Reisner } else { 547b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 548b411b363SPhilipp Reisner * after we read a partial message 549b411b363SPhilipp Reisner */ 550b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 551b411b363SPhilipp Reisner break; 552b411b363SPhilipp Reisner } 553b411b363SPhilipp Reisner }; 554b411b363SPhilipp Reisner 555b411b363SPhilipp Reisner set_fs(oldfs); 556b411b363SPhilipp Reisner 557b411b363SPhilipp Reisner if (rv != size) 558bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 559b411b363SPhilipp Reisner 560b411b363SPhilipp Reisner return rv; 561b411b363SPhilipp Reisner } 562b411b363SPhilipp Reisner 563c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 564c6967746SAndreas Gruenbacher { 565c6967746SAndreas Gruenbacher int err; 566c6967746SAndreas Gruenbacher 567c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 568c6967746SAndreas Gruenbacher if (err != size) { 569c6967746SAndreas Gruenbacher if (err >= 0) 570c6967746SAndreas Gruenbacher err = -EIO; 571c6967746SAndreas Gruenbacher } else 572c6967746SAndreas Gruenbacher err = 0; 573c6967746SAndreas Gruenbacher return err; 574c6967746SAndreas Gruenbacher } 575c6967746SAndreas Gruenbacher 576a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 577a5c31904SAndreas Gruenbacher { 578a5c31904SAndreas Gruenbacher int err; 579a5c31904SAndreas Gruenbacher 580a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 581a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 582a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 583a5c31904SAndreas Gruenbacher return err; 584a5c31904SAndreas Gruenbacher } 585a5c31904SAndreas Gruenbacher 5865dbf1673SLars Ellenberg /* quoting tcp(7): 5875dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5885dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5895dbf1673SLars Ellenberg * This is our wrapper to do so. 5905dbf1673SLars Ellenberg */ 5915dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5925dbf1673SLars Ellenberg unsigned int rcv) 5935dbf1673SLars Ellenberg { 5945dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5955dbf1673SLars Ellenberg if (snd) { 5965dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5975dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5985dbf1673SLars Ellenberg } 5995dbf1673SLars Ellenberg if (rcv) { 6005dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 6015dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 6025dbf1673SLars Ellenberg } 6035dbf1673SLars Ellenberg } 6045dbf1673SLars Ellenberg 605eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 606b411b363SPhilipp Reisner { 607b411b363SPhilipp Reisner const char *what; 608b411b363SPhilipp Reisner struct socket *sock; 609b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 610b411b363SPhilipp Reisner int err; 611b411b363SPhilipp Reisner int disconnect_on_error = 1; 612b411b363SPhilipp Reisner 613eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 614b411b363SPhilipp Reisner return NULL; 615b411b363SPhilipp Reisner 616b411b363SPhilipp Reisner what = "sock_create_kern"; 617eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 618b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 619b411b363SPhilipp Reisner if (err < 0) { 620b411b363SPhilipp Reisner sock = NULL; 621b411b363SPhilipp Reisner goto out; 622b411b363SPhilipp Reisner } 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 625eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 626eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 627eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 628b411b363SPhilipp Reisner 629b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 630b411b363SPhilipp Reisner * for the outgoing connections. 631b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 632b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 633b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 634b411b363SPhilipp Reisner * a free one dynamically. 635b411b363SPhilipp Reisner */ 636eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 637eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 638eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 639b411b363SPhilipp Reisner src_in6.sin6_port = 0; 640b411b363SPhilipp Reisner else 641b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 642b411b363SPhilipp Reisner 643b411b363SPhilipp Reisner what = "bind before connect"; 644b411b363SPhilipp Reisner err = sock->ops->bind(sock, 645b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 646eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 647b411b363SPhilipp Reisner if (err < 0) 648b411b363SPhilipp Reisner goto out; 649b411b363SPhilipp Reisner 650b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 651b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 652b411b363SPhilipp Reisner disconnect_on_error = 0; 653b411b363SPhilipp Reisner what = "connect"; 654b411b363SPhilipp Reisner err = sock->ops->connect(sock, 655eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 656eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 657b411b363SPhilipp Reisner 658b411b363SPhilipp Reisner out: 659b411b363SPhilipp Reisner if (err < 0) { 660b411b363SPhilipp Reisner if (sock) { 661b411b363SPhilipp Reisner sock_release(sock); 662b411b363SPhilipp Reisner sock = NULL; 663b411b363SPhilipp Reisner } 664b411b363SPhilipp Reisner switch (-err) { 665b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 666b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 667b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 668b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 669b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 670b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 671b411b363SPhilipp Reisner disconnect_on_error = 0; 672b411b363SPhilipp Reisner break; 673b411b363SPhilipp Reisner default: 674eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 675b411b363SPhilipp Reisner } 676b411b363SPhilipp Reisner if (disconnect_on_error) 677bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 678b411b363SPhilipp Reisner } 679eac3e990SPhilipp Reisner put_net_conf(tconn); 680b411b363SPhilipp Reisner return sock; 681b411b363SPhilipp Reisner } 682b411b363SPhilipp Reisner 6837653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 684b411b363SPhilipp Reisner { 685b411b363SPhilipp Reisner int timeo, err; 686b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 687b411b363SPhilipp Reisner const char *what; 688b411b363SPhilipp Reisner 6897653620dSPhilipp Reisner if (!get_net_conf(tconn)) 690b411b363SPhilipp Reisner return NULL; 691b411b363SPhilipp Reisner 692b411b363SPhilipp Reisner what = "sock_create_kern"; 6937653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 694b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 695b411b363SPhilipp Reisner if (err) { 696b411b363SPhilipp Reisner s_listen = NULL; 697b411b363SPhilipp Reisner goto out; 698b411b363SPhilipp Reisner } 699b411b363SPhilipp Reisner 7007653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 701b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 702b411b363SPhilipp Reisner 703b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 704b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 705b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 7067653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 7077653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 708b411b363SPhilipp Reisner 709b411b363SPhilipp Reisner what = "bind before listen"; 710b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 7117653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 7127653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 713b411b363SPhilipp Reisner if (err < 0) 714b411b363SPhilipp Reisner goto out; 715b411b363SPhilipp Reisner 7167653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 717b411b363SPhilipp Reisner 718b411b363SPhilipp Reisner out: 719b411b363SPhilipp Reisner if (s_listen) 720b411b363SPhilipp Reisner sock_release(s_listen); 721b411b363SPhilipp Reisner if (err < 0) { 722b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7237653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 724bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 725b411b363SPhilipp Reisner } 726b411b363SPhilipp Reisner } 7277653620dSPhilipp Reisner put_net_conf(tconn); 728b411b363SPhilipp Reisner 729b411b363SPhilipp Reisner return s_estab; 730b411b363SPhilipp Reisner } 731b411b363SPhilipp Reisner 732e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 733b411b363SPhilipp Reisner 7349f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7359f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7369f5bdc33SAndreas Gruenbacher { 7379f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7389f5bdc33SAndreas Gruenbacher return -EIO; 739e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 740b411b363SPhilipp Reisner } 741b411b363SPhilipp Reisner 7429f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 743b411b363SPhilipp Reisner { 7449f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7459f5bdc33SAndreas Gruenbacher struct packet_info pi; 7469f5bdc33SAndreas Gruenbacher int err; 747b411b363SPhilipp Reisner 7489f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7499f5bdc33SAndreas Gruenbacher if (err != header_size) { 7509f5bdc33SAndreas Gruenbacher if (err >= 0) 7519f5bdc33SAndreas Gruenbacher err = -EIO; 7529f5bdc33SAndreas Gruenbacher return err; 7539f5bdc33SAndreas Gruenbacher } 7549f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 7559f5bdc33SAndreas Gruenbacher if (err) 7569f5bdc33SAndreas Gruenbacher return err; 7579f5bdc33SAndreas Gruenbacher return pi.cmd; 758b411b363SPhilipp Reisner } 759b411b363SPhilipp Reisner 760b411b363SPhilipp Reisner /** 761b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 762b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 763b411b363SPhilipp Reisner */ 764dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 765b411b363SPhilipp Reisner { 766b411b363SPhilipp Reisner int rr; 767b411b363SPhilipp Reisner char tb[4]; 768b411b363SPhilipp Reisner 769b411b363SPhilipp Reisner if (!*sock) 77081e84650SAndreas Gruenbacher return false; 771b411b363SPhilipp Reisner 772dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 773b411b363SPhilipp Reisner 774b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 77581e84650SAndreas Gruenbacher return true; 776b411b363SPhilipp Reisner } else { 777b411b363SPhilipp Reisner sock_release(*sock); 778b411b363SPhilipp Reisner *sock = NULL; 77981e84650SAndreas Gruenbacher return false; 780b411b363SPhilipp Reisner } 781b411b363SPhilipp Reisner } 7822325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 7832325eb66SPhilipp Reisner in a connection */ 7842325eb66SPhilipp Reisner int drbd_connected(int vnr, void *p, void *data) 785907599e0SPhilipp Reisner { 786907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 7870829f5edSAndreas Gruenbacher int err; 788907599e0SPhilipp Reisner 789907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 790907599e0SPhilipp Reisner mdev->peer_seq = 0; 791907599e0SPhilipp Reisner 7928410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 7938410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 7948410da8fSPhilipp Reisner &mdev->own_state_mutex; 7958410da8fSPhilipp Reisner 7960829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 7970829f5edSAndreas Gruenbacher if (!err) 7980829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 7990829f5edSAndreas Gruenbacher if (!err) 8000829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8010829f5edSAndreas Gruenbacher if (!err) 8020829f5edSAndreas Gruenbacher err = drbd_send_state(mdev); 803907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 804907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8058b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8060829f5edSAndreas Gruenbacher return err; 807907599e0SPhilipp Reisner } 808907599e0SPhilipp Reisner 809b411b363SPhilipp Reisner /* 810b411b363SPhilipp Reisner * return values: 811b411b363SPhilipp Reisner * 1 yes, we have a valid connection 812b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 813b411b363SPhilipp Reisner * -1 peer talks different language, 814b411b363SPhilipp Reisner * no point in trying again, please go standalone. 815b411b363SPhilipp Reisner * -2 We do not have a network config... 816b411b363SPhilipp Reisner */ 817907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 818b411b363SPhilipp Reisner { 8192bf89621SAndreas Gruenbacher struct socket *sock, *msock; 820b411b363SPhilipp Reisner int try, h, ok; 821b411b363SPhilipp Reisner 822bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 823b411b363SPhilipp Reisner return -2; 824b411b363SPhilipp Reisner 825907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 8260916e0e3SAndreas Gruenbacher 8270916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8280916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 829b411b363SPhilipp Reisner 830b411b363SPhilipp Reisner do { 8312bf89621SAndreas Gruenbacher struct socket *s; 8322bf89621SAndreas Gruenbacher 833b411b363SPhilipp Reisner for (try = 0;;) { 834b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 835907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 836b411b363SPhilipp Reisner if (s || ++try >= 3) 837b411b363SPhilipp Reisner break; 838b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 83920ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 840b411b363SPhilipp Reisner } 841b411b363SPhilipp Reisner 842b411b363SPhilipp Reisner if (s) { 8432bf89621SAndreas Gruenbacher if (!tconn->data.socket) { 8442bf89621SAndreas Gruenbacher tconn->data.socket = s; 8459f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->data, P_INITIAL_DATA); 8462bf89621SAndreas Gruenbacher } else if (!tconn->meta.socket) { 8472bf89621SAndreas Gruenbacher tconn->meta.socket = s; 8489f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->meta, P_INITIAL_META); 849b411b363SPhilipp Reisner } else { 850907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 851b411b363SPhilipp Reisner goto out_release_sockets; 852b411b363SPhilipp Reisner } 853b411b363SPhilipp Reisner } 854b411b363SPhilipp Reisner 8552bf89621SAndreas Gruenbacher if (tconn->data.socket && tconn->meta.socket) { 856907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 8572bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 8582bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 859b411b363SPhilipp Reisner if (ok) 860b411b363SPhilipp Reisner break; 861b411b363SPhilipp Reisner } 862b411b363SPhilipp Reisner 863b411b363SPhilipp Reisner retry: 864907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 865b411b363SPhilipp Reisner if (s) { 8669f5bdc33SAndreas Gruenbacher try = receive_first_packet(tconn, s); 8672bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->data.socket); 8682bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->meta.socket); 869b411b363SPhilipp Reisner switch (try) { 870e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 8712bf89621SAndreas Gruenbacher if (tconn->data.socket) { 872907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 8732bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 874b411b363SPhilipp Reisner } 8752bf89621SAndreas Gruenbacher tconn->data.socket = s; 876b411b363SPhilipp Reisner break; 877e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 8782bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 879907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 8802bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 881b411b363SPhilipp Reisner } 8822bf89621SAndreas Gruenbacher tconn->meta.socket = s; 883907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 884b411b363SPhilipp Reisner break; 885b411b363SPhilipp Reisner default: 886907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 887b411b363SPhilipp Reisner sock_release(s); 888b411b363SPhilipp Reisner if (random32() & 1) 889b411b363SPhilipp Reisner goto retry; 890b411b363SPhilipp Reisner } 891b411b363SPhilipp Reisner } 892b411b363SPhilipp Reisner 893bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 894b411b363SPhilipp Reisner goto out_release_sockets; 895b411b363SPhilipp Reisner if (signal_pending(current)) { 896b411b363SPhilipp Reisner flush_signals(current); 897b411b363SPhilipp Reisner smp_rmb(); 898907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 899b411b363SPhilipp Reisner goto out_release_sockets; 900b411b363SPhilipp Reisner } 901b411b363SPhilipp Reisner 9022bf89621SAndreas Gruenbacher if (tconn->data.socket && &tconn->meta.socket) { 9032bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 9042bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 905b411b363SPhilipp Reisner if (ok) 906b411b363SPhilipp Reisner break; 907b411b363SPhilipp Reisner } 908b411b363SPhilipp Reisner } while (1); 909b411b363SPhilipp Reisner 9102bf89621SAndreas Gruenbacher sock = tconn->data.socket; 9112bf89621SAndreas Gruenbacher msock = tconn->meta.socket; 9122bf89621SAndreas Gruenbacher 913b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 914b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 915b411b363SPhilipp Reisner 916b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 917b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 918b411b363SPhilipp Reisner 919b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 920b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 921b411b363SPhilipp Reisner 922b411b363SPhilipp Reisner /* NOT YET ... 923907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 924b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9256038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 926b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 927b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 928907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 929b411b363SPhilipp Reisner 930907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 931907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 932b411b363SPhilipp Reisner 933b411b363SPhilipp Reisner /* we don't want delays. 93425985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 935b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 936b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 937b411b363SPhilipp Reisner 938907599e0SPhilipp Reisner tconn->last_received = jiffies; 939b411b363SPhilipp Reisner 9406038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 941b411b363SPhilipp Reisner if (h <= 0) 942b411b363SPhilipp Reisner return h; 943b411b363SPhilipp Reisner 944907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 945b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 946907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 947b10d96cbSJohannes Thoma case -1: 948907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 949b411b363SPhilipp Reisner return -1; 950b10d96cbSJohannes Thoma case 0: 951907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 952b10d96cbSJohannes Thoma return 0; 953b411b363SPhilipp Reisner } 954b411b363SPhilipp Reisner } 955b411b363SPhilipp Reisner 956bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 957b411b363SPhilipp Reisner return 0; 958b411b363SPhilipp Reisner 959907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 960b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 961b411b363SPhilipp Reisner 962907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 963b411b363SPhilipp Reisner 964387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 9657e2455c1SPhilipp Reisner return -1; 966b411b363SPhilipp Reisner 967907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 968b411b363SPhilipp Reisner 969b411b363SPhilipp Reisner out_release_sockets: 9702bf89621SAndreas Gruenbacher if (tconn->data.socket) { 9712bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 9722bf89621SAndreas Gruenbacher tconn->data.socket = NULL; 9732bf89621SAndreas Gruenbacher } 9742bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 9752bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 9762bf89621SAndreas Gruenbacher tconn->meta.socket = NULL; 9772bf89621SAndreas Gruenbacher } 978b411b363SPhilipp Reisner return -1; 979b411b363SPhilipp Reisner } 980b411b363SPhilipp Reisner 981e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 982b411b363SPhilipp Reisner { 983e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 984e658983aSAndreas Gruenbacher 9850c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 9860c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 9870c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 9880c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 9890c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 9900c8e36d9SAndreas Gruenbacher return -EINVAL; 9910c8e36d9SAndreas Gruenbacher } 9920c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 9930c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 9940c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 9950c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 996e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 997e658983aSAndreas Gruenbacher struct p_header95 *h = header; 998e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 999b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1000eefc2f7dSPhilipp Reisner pi->vnr = 0; 1001e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1002e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1003e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1004e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1005e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 100677351055SPhilipp Reisner pi->vnr = 0; 100702918be2SPhilipp Reisner } else { 1008e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1009e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1010e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 10118172f3e9SAndreas Gruenbacher return -EINVAL; 1012b411b363SPhilipp Reisner } 1013e658983aSAndreas Gruenbacher pi->data = header + header_size; 10148172f3e9SAndreas Gruenbacher return 0; 1015257d0af6SPhilipp Reisner } 1016257d0af6SPhilipp Reisner 10179ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1018257d0af6SPhilipp Reisner { 1019e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 102069bc7bc3SAndreas Gruenbacher int err; 1021257d0af6SPhilipp Reisner 1022e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1023a5c31904SAndreas Gruenbacher if (err) 102469bc7bc3SAndreas Gruenbacher return err; 1025257d0af6SPhilipp Reisner 1026e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 10279ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1028b411b363SPhilipp Reisner 102969bc7bc3SAndreas Gruenbacher return err; 1030b411b363SPhilipp Reisner } 1031b411b363SPhilipp Reisner 10322451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 1033b411b363SPhilipp Reisner { 1034b411b363SPhilipp Reisner int rv; 1035b411b363SPhilipp Reisner 1036b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 1037fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 1038dd3932edSChristoph Hellwig NULL); 1039b411b363SPhilipp Reisner if (rv) { 1040b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 1041b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1042b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1043b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1044b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 1045b411b363SPhilipp Reisner } 1046b411b363SPhilipp Reisner put_ldev(mdev); 1047b411b363SPhilipp Reisner } 1048b411b363SPhilipp Reisner } 1049b411b363SPhilipp Reisner 1050b411b363SPhilipp Reisner /** 1051b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1052b411b363SPhilipp Reisner * @mdev: DRBD device. 1053b411b363SPhilipp Reisner * @epoch: Epoch object. 1054b411b363SPhilipp Reisner * @ev: Epoch event. 1055b411b363SPhilipp Reisner */ 1056b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1057b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1058b411b363SPhilipp Reisner enum epoch_event ev) 1059b411b363SPhilipp Reisner { 10602451fc3bSPhilipp Reisner int epoch_size; 1061b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1062b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1063b411b363SPhilipp Reisner 1064b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1065b411b363SPhilipp Reisner do { 1066b411b363SPhilipp Reisner next_epoch = NULL; 1067b411b363SPhilipp Reisner 1068b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1069b411b363SPhilipp Reisner 1070b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1071b411b363SPhilipp Reisner case EV_PUT: 1072b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1073b411b363SPhilipp Reisner break; 1074b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1075b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1076b411b363SPhilipp Reisner break; 1077b411b363SPhilipp Reisner case EV_BECAME_LAST: 1078b411b363SPhilipp Reisner /* nothing to do*/ 1079b411b363SPhilipp Reisner break; 1080b411b363SPhilipp Reisner } 1081b411b363SPhilipp Reisner 1082b411b363SPhilipp Reisner if (epoch_size != 0 && 1083b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10842451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1085b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1086b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1087b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1088b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1089b411b363SPhilipp Reisner } 1090b411b363SPhilipp Reisner dec_unacked(mdev); 1091b411b363SPhilipp Reisner 1092b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1093b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1094b411b363SPhilipp Reisner list_del(&epoch->list); 1095b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1096b411b363SPhilipp Reisner mdev->epochs--; 1097b411b363SPhilipp Reisner kfree(epoch); 1098b411b363SPhilipp Reisner 1099b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1100b411b363SPhilipp Reisner rv = FE_DESTROYED; 1101b411b363SPhilipp Reisner } else { 1102b411b363SPhilipp Reisner epoch->flags = 0; 1103b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1104698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1105b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1106b411b363SPhilipp Reisner rv = FE_RECYCLED; 11072451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1108b411b363SPhilipp Reisner } 1109b411b363SPhilipp Reisner } 1110b411b363SPhilipp Reisner 1111b411b363SPhilipp Reisner if (!next_epoch) 1112b411b363SPhilipp Reisner break; 1113b411b363SPhilipp Reisner 1114b411b363SPhilipp Reisner epoch = next_epoch; 1115b411b363SPhilipp Reisner } while (1); 1116b411b363SPhilipp Reisner 1117b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1118b411b363SPhilipp Reisner 1119b411b363SPhilipp Reisner return rv; 1120b411b363SPhilipp Reisner } 1121b411b363SPhilipp Reisner 1122b411b363SPhilipp Reisner /** 1123b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1124b411b363SPhilipp Reisner * @mdev: DRBD device. 1125b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1126b411b363SPhilipp Reisner */ 1127b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1128b411b363SPhilipp Reisner { 1129b411b363SPhilipp Reisner enum write_ordering_e pwo; 1130b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1131b411b363SPhilipp Reisner [WO_none] = "none", 1132b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1133b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1134b411b363SPhilipp Reisner }; 1135b411b363SPhilipp Reisner 1136b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1137b411b363SPhilipp Reisner wo = min(pwo, wo); 1138b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1139b411b363SPhilipp Reisner wo = WO_drain_io; 1140b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1141b411b363SPhilipp Reisner wo = WO_none; 1142b411b363SPhilipp Reisner mdev->write_ordering = wo; 11432451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1144b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1145b411b363SPhilipp Reisner } 1146b411b363SPhilipp Reisner 1147b411b363SPhilipp Reisner /** 1148fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 114945bb912bSLars Ellenberg * @mdev: DRBD device. 1150db830c46SAndreas Gruenbacher * @peer_req: peer request 115145bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 115210f6d992SLars Ellenberg * 115310f6d992SLars Ellenberg * May spread the pages to multiple bios, 115410f6d992SLars Ellenberg * depending on bio_add_page restrictions. 115510f6d992SLars Ellenberg * 115610f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 115710f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 115810f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 115910f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 116010f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 116110f6d992SLars Ellenberg * on certain Xen deployments. 116245bb912bSLars Ellenberg */ 116345bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1164fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1165fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 116645bb912bSLars Ellenberg const unsigned rw, const int fault_type) 116745bb912bSLars Ellenberg { 116845bb912bSLars Ellenberg struct bio *bios = NULL; 116945bb912bSLars Ellenberg struct bio *bio; 1170db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1171db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1172db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 117345bb912bSLars Ellenberg unsigned n_bios = 0; 117445bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 117510f6d992SLars Ellenberg int err = -ENOMEM; 117645bb912bSLars Ellenberg 117745bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 117845bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 117945bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1180da4a75d2SLars Ellenberg * request in more than one bio. 1181da4a75d2SLars Ellenberg * 1182da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1183da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1184da4a75d2SLars Ellenberg */ 118545bb912bSLars Ellenberg next_bio: 118645bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 118745bb912bSLars Ellenberg if (!bio) { 118845bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 118945bb912bSLars Ellenberg goto fail; 119045bb912bSLars Ellenberg } 1191db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 119245bb912bSLars Ellenberg bio->bi_sector = sector; 119345bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 119445bb912bSLars Ellenberg bio->bi_rw = rw; 1195db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1196fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 119745bb912bSLars Ellenberg 119845bb912bSLars Ellenberg bio->bi_next = bios; 119945bb912bSLars Ellenberg bios = bio; 120045bb912bSLars Ellenberg ++n_bios; 120145bb912bSLars Ellenberg 120245bb912bSLars Ellenberg page_chain_for_each(page) { 120345bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 120445bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 120510f6d992SLars Ellenberg /* A single page must always be possible! 120610f6d992SLars Ellenberg * But in case it fails anyways, 120710f6d992SLars Ellenberg * we deal with it, and complain (below). */ 120810f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 120910f6d992SLars Ellenberg dev_err(DEV, 121010f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 121110f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 121210f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 121310f6d992SLars Ellenberg err = -ENOSPC; 121410f6d992SLars Ellenberg goto fail; 121510f6d992SLars Ellenberg } 121645bb912bSLars Ellenberg goto next_bio; 121745bb912bSLars Ellenberg } 121845bb912bSLars Ellenberg ds -= len; 121945bb912bSLars Ellenberg sector += len >> 9; 122045bb912bSLars Ellenberg --nr_pages; 122145bb912bSLars Ellenberg } 122245bb912bSLars Ellenberg D_ASSERT(page == NULL); 122345bb912bSLars Ellenberg D_ASSERT(ds == 0); 122445bb912bSLars Ellenberg 1225db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 122645bb912bSLars Ellenberg do { 122745bb912bSLars Ellenberg bio = bios; 122845bb912bSLars Ellenberg bios = bios->bi_next; 122945bb912bSLars Ellenberg bio->bi_next = NULL; 123045bb912bSLars Ellenberg 123145bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 123245bb912bSLars Ellenberg } while (bios); 123345bb912bSLars Ellenberg return 0; 123445bb912bSLars Ellenberg 123545bb912bSLars Ellenberg fail: 123645bb912bSLars Ellenberg while (bios) { 123745bb912bSLars Ellenberg bio = bios; 123845bb912bSLars Ellenberg bios = bios->bi_next; 123945bb912bSLars Ellenberg bio_put(bio); 124045bb912bSLars Ellenberg } 124110f6d992SLars Ellenberg return err; 124245bb912bSLars Ellenberg } 124345bb912bSLars Ellenberg 124453840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1245db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 124653840641SAndreas Gruenbacher { 1247db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 124853840641SAndreas Gruenbacher 124953840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 125053840641SAndreas Gruenbacher drbd_clear_interval(i); 125153840641SAndreas Gruenbacher 12526c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 125353840641SAndreas Gruenbacher if (i->waiting) 125453840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 125553840641SAndreas Gruenbacher } 125653840641SAndreas Gruenbacher 12574a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1258b411b363SPhilipp Reisner { 12594a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 12602451fc3bSPhilipp Reisner int rv; 1261e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1262b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1263b411b363SPhilipp Reisner 12644a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 12654a76b161SAndreas Gruenbacher if (!mdev) 12664a76b161SAndreas Gruenbacher return -EIO; 12674a76b161SAndreas Gruenbacher 1268b411b363SPhilipp Reisner inc_unacked(mdev); 1269b411b363SPhilipp Reisner 1270b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1271b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1272b411b363SPhilipp Reisner 1273b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1274b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1275b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1276b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1277b411b363SPhilipp Reisner * completed. */ 1278b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1279b411b363SPhilipp Reisner case WO_none: 1280b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 128182bc0194SAndreas Gruenbacher return 0; 1282b411b363SPhilipp Reisner 1283b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1284b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1285b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12862451fc3bSPhilipp Reisner if (epoch) 12872451fc3bSPhilipp Reisner break; 12882451fc3bSPhilipp Reisner else 1289b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12902451fc3bSPhilipp Reisner /* Fall through */ 12912451fc3bSPhilipp Reisner 12922451fc3bSPhilipp Reisner case WO_bdev_flush: 12932451fc3bSPhilipp Reisner case WO_drain_io: 1294b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12952451fc3bSPhilipp Reisner drbd_flush(mdev); 12962451fc3bSPhilipp Reisner 12972451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12982451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12992451fc3bSPhilipp Reisner if (epoch) 13002451fc3bSPhilipp Reisner break; 1301b411b363SPhilipp Reisner } 1302b411b363SPhilipp Reisner 13032451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 13042451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 13052451fc3bSPhilipp Reisner 13062451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 13072451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1308b411b363SPhilipp Reisner 130982bc0194SAndreas Gruenbacher return 0; 13102451fc3bSPhilipp Reisner default: 13112451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 131282bc0194SAndreas Gruenbacher return -EIO; 1313b411b363SPhilipp Reisner } 1314b411b363SPhilipp Reisner 1315b411b363SPhilipp Reisner epoch->flags = 0; 1316b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1317b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1318b411b363SPhilipp Reisner 1319b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1320b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1321b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1322b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1323b411b363SPhilipp Reisner mdev->epochs++; 1324b411b363SPhilipp Reisner } else { 1325b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1326b411b363SPhilipp Reisner kfree(epoch); 1327b411b363SPhilipp Reisner } 1328b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1329b411b363SPhilipp Reisner 133082bc0194SAndreas Gruenbacher return 0; 1331b411b363SPhilipp Reisner } 1332b411b363SPhilipp Reisner 1333b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1334b411b363SPhilipp Reisner * and from receive_Data */ 1335f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1336f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1337f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1338b411b363SPhilipp Reisner { 13396666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1340db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1341b411b363SPhilipp Reisner struct page *page; 1342a5c31904SAndreas Gruenbacher int dgs, ds, err; 1343a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1344a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 13456b4388acSPhilipp Reisner unsigned long *data; 1346b411b363SPhilipp Reisner 1347a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1348a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1349b411b363SPhilipp Reisner 1350b411b363SPhilipp Reisner if (dgs) { 13519f5bdc33SAndreas Gruenbacher /* 13529f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 13539f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 13549f5bdc33SAndreas Gruenbacher */ 1355a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1356a5c31904SAndreas Gruenbacher if (err) 1357b411b363SPhilipp Reisner return NULL; 1358b411b363SPhilipp Reisner } 1359b411b363SPhilipp Reisner 1360b411b363SPhilipp Reisner data_size -= dgs; 1361b411b363SPhilipp Reisner 1362841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1363841ce241SAndreas Gruenbacher return NULL; 1364841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1365841ce241SAndreas Gruenbacher return NULL; 1366841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1367841ce241SAndreas Gruenbacher return NULL; 1368b411b363SPhilipp Reisner 13696666032aSLars Ellenberg /* even though we trust out peer, 13706666032aSLars Ellenberg * we sometimes have to double check. */ 13716666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1372fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1373fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13746666032aSLars Ellenberg (unsigned long long)capacity, 13756666032aSLars Ellenberg (unsigned long long)sector, data_size); 13766666032aSLars Ellenberg return NULL; 13776666032aSLars Ellenberg } 13786666032aSLars Ellenberg 1379b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1380b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1381b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 13820db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1383db830c46SAndreas Gruenbacher if (!peer_req) 1384b411b363SPhilipp Reisner return NULL; 138545bb912bSLars Ellenberg 1386b411b363SPhilipp Reisner ds = data_size; 1387db830c46SAndreas Gruenbacher page = peer_req->pages; 138845bb912bSLars Ellenberg page_chain_for_each(page) { 138945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13906b4388acSPhilipp Reisner data = kmap(page); 1391a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 13920cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13936b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13946b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13956b4388acSPhilipp Reisner } 1396b411b363SPhilipp Reisner kunmap(page); 1397a5c31904SAndreas Gruenbacher if (err) { 13983967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1399b411b363SPhilipp Reisner return NULL; 1400b411b363SPhilipp Reisner } 1401a5c31904SAndreas Gruenbacher ds -= len; 1402b411b363SPhilipp Reisner } 1403b411b363SPhilipp Reisner 1404b411b363SPhilipp Reisner if (dgs) { 1405db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1406b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1407470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1408470be44aSLars Ellenberg (unsigned long long)sector, data_size); 14093967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1410b411b363SPhilipp Reisner return NULL; 1411b411b363SPhilipp Reisner } 1412b411b363SPhilipp Reisner } 1413b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1414db830c46SAndreas Gruenbacher return peer_req; 1415b411b363SPhilipp Reisner } 1416b411b363SPhilipp Reisner 1417b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1418b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1419b411b363SPhilipp Reisner */ 1420b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1421b411b363SPhilipp Reisner { 1422b411b363SPhilipp Reisner struct page *page; 1423a5c31904SAndreas Gruenbacher int err = 0; 1424b411b363SPhilipp Reisner void *data; 1425b411b363SPhilipp Reisner 1426c3470cdeSLars Ellenberg if (!data_size) 1427fc5be839SAndreas Gruenbacher return 0; 1428c3470cdeSLars Ellenberg 142945bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1430b411b363SPhilipp Reisner 1431b411b363SPhilipp Reisner data = kmap(page); 1432b411b363SPhilipp Reisner while (data_size) { 1433fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1434fc5be839SAndreas Gruenbacher 1435a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1436a5c31904SAndreas Gruenbacher if (err) 1437b411b363SPhilipp Reisner break; 1438a5c31904SAndreas Gruenbacher data_size -= len; 1439b411b363SPhilipp Reisner } 1440b411b363SPhilipp Reisner kunmap(page); 1441435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1442fc5be839SAndreas Gruenbacher return err; 1443b411b363SPhilipp Reisner } 1444b411b363SPhilipp Reisner 1445b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1446b411b363SPhilipp Reisner sector_t sector, int data_size) 1447b411b363SPhilipp Reisner { 1448b411b363SPhilipp Reisner struct bio_vec *bvec; 1449b411b363SPhilipp Reisner struct bio *bio; 1450a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1451a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1452a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1453b411b363SPhilipp Reisner 1454a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1455a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1456b411b363SPhilipp Reisner 1457b411b363SPhilipp Reisner if (dgs) { 1458a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1459a5c31904SAndreas Gruenbacher if (err) 1460a5c31904SAndreas Gruenbacher return err; 1461b411b363SPhilipp Reisner } 1462b411b363SPhilipp Reisner 1463b411b363SPhilipp Reisner data_size -= dgs; 1464b411b363SPhilipp Reisner 1465b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1466b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1467b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1468b411b363SPhilipp Reisner 1469b411b363SPhilipp Reisner bio = req->master_bio; 1470b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1471b411b363SPhilipp Reisner 1472b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1473a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1474b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1475a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1476b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1477a5c31904SAndreas Gruenbacher if (err) 1478a5c31904SAndreas Gruenbacher return err; 1479a5c31904SAndreas Gruenbacher data_size -= expect; 1480b411b363SPhilipp Reisner } 1481b411b363SPhilipp Reisner 1482b411b363SPhilipp Reisner if (dgs) { 1483a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1484b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1485b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 148628284cefSAndreas Gruenbacher return -EINVAL; 1487b411b363SPhilipp Reisner } 1488b411b363SPhilipp Reisner } 1489b411b363SPhilipp Reisner 1490b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 149128284cefSAndreas Gruenbacher return 0; 1492b411b363SPhilipp Reisner } 1493b411b363SPhilipp Reisner 1494b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1495b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 149699920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1497b411b363SPhilipp Reisner { 14988050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 14998050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 150000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1501db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 150299920dc5SAndreas Gruenbacher int err; 1503b411b363SPhilipp Reisner 1504db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1505b411b363SPhilipp Reisner 1506db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1507db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 150899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1509b411b363SPhilipp Reisner } else { 1510b411b363SPhilipp Reisner /* Record failure to sync */ 1511db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1512b411b363SPhilipp Reisner 151399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1514b411b363SPhilipp Reisner } 1515b411b363SPhilipp Reisner dec_unacked(mdev); 1516b411b363SPhilipp Reisner 151799920dc5SAndreas Gruenbacher return err; 1518b411b363SPhilipp Reisner } 1519b411b363SPhilipp Reisner 1520b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1521b411b363SPhilipp Reisner { 1522db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1523b411b363SPhilipp Reisner 1524db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1525db830c46SAndreas Gruenbacher if (!peer_req) 152645bb912bSLars Ellenberg goto fail; 1527b411b363SPhilipp Reisner 1528b411b363SPhilipp Reisner dec_rs_pending(mdev); 1529b411b363SPhilipp Reisner 1530b411b363SPhilipp Reisner inc_unacked(mdev); 1531b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1532b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1533b411b363SPhilipp Reisner 1534db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 153545bb912bSLars Ellenberg 153687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1537db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 153887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1539b411b363SPhilipp Reisner 15400f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1541fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1542e1c1b0fcSAndreas Gruenbacher return 0; 154345bb912bSLars Ellenberg 154410f6d992SLars Ellenberg /* don't care for the reason here */ 154510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 154687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1547db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 154887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 154922cc37a9SLars Ellenberg 15503967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 155145bb912bSLars Ellenberg fail: 155245bb912bSLars Ellenberg put_ldev(mdev); 1553e1c1b0fcSAndreas Gruenbacher return -EIO; 1554b411b363SPhilipp Reisner } 1555b411b363SPhilipp Reisner 1556668eebc6SAndreas Gruenbacher static struct drbd_request * 1557bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1558bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1559668eebc6SAndreas Gruenbacher { 1560668eebc6SAndreas Gruenbacher struct drbd_request *req; 1561668eebc6SAndreas Gruenbacher 1562bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1563bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15645e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1565668eebc6SAndreas Gruenbacher return req; 1566c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1567c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1568c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1569c3afd8f5SAndreas Gruenbacher } 1570668eebc6SAndreas Gruenbacher return NULL; 1571668eebc6SAndreas Gruenbacher } 1572668eebc6SAndreas Gruenbacher 15734a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1574b411b363SPhilipp Reisner { 15754a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1576b411b363SPhilipp Reisner struct drbd_request *req; 1577b411b363SPhilipp Reisner sector_t sector; 157882bc0194SAndreas Gruenbacher int err; 1579e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 15804a76b161SAndreas Gruenbacher 15814a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 15824a76b161SAndreas Gruenbacher if (!mdev) 15834a76b161SAndreas Gruenbacher return -EIO; 1584b411b363SPhilipp Reisner 1585b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1586b411b363SPhilipp Reisner 158787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1588bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 158987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1590c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 159182bc0194SAndreas Gruenbacher return -EIO; 1592b411b363SPhilipp Reisner 159324c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1594b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1595b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1596e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 159782bc0194SAndreas Gruenbacher if (!err) 15988554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1599b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1600b411b363SPhilipp Reisner * I don't think we may complete this just yet 1601b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1602b411b363SPhilipp Reisner 160382bc0194SAndreas Gruenbacher return err; 1604b411b363SPhilipp Reisner } 1605b411b363SPhilipp Reisner 16064a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1607b411b363SPhilipp Reisner { 16084a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1609b411b363SPhilipp Reisner sector_t sector; 161082bc0194SAndreas Gruenbacher int err; 1611e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16124a76b161SAndreas Gruenbacher 16134a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16144a76b161SAndreas Gruenbacher if (!mdev) 16154a76b161SAndreas Gruenbacher return -EIO; 1616b411b363SPhilipp Reisner 1617b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1618b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1619b411b363SPhilipp Reisner 1620b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1621b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1622b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1623fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1624e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1625b411b363SPhilipp Reisner } else { 1626b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1627b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1628b411b363SPhilipp Reisner 1629e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1630b411b363SPhilipp Reisner 1631e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1632b411b363SPhilipp Reisner } 1633b411b363SPhilipp Reisner 1634e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1635778f271dSPhilipp Reisner 163682bc0194SAndreas Gruenbacher return err; 1637b411b363SPhilipp Reisner } 1638b411b363SPhilipp Reisner 163999920dc5SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 16407be8da07SAndreas Gruenbacher { 16417be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 16427be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16437be8da07SAndreas Gruenbacher struct bio *bio; 16447be8da07SAndreas Gruenbacher unsigned long start_time; 16457be8da07SAndreas Gruenbacher unsigned long flags; 16467be8da07SAndreas Gruenbacher 16477be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16487be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16497be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 165099920dc5SAndreas Gruenbacher return -EIO; 16517be8da07SAndreas Gruenbacher } 16527be8da07SAndreas Gruenbacher bio = req->master_bio; 16537be8da07SAndreas Gruenbacher start_time = req->start_time; 16547be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 16557be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 16567be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16577be8da07SAndreas Gruenbacher 16587be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 16597be8da07SAndreas Gruenbacher /* retry */ ; 166099920dc5SAndreas Gruenbacher return 0; 16617be8da07SAndreas Gruenbacher } 16627be8da07SAndreas Gruenbacher 16637be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 16647be8da07SAndreas Gruenbacher sector_t sector, int size) 16657be8da07SAndreas Gruenbacher { 16667be8da07SAndreas Gruenbacher struct drbd_interval *i; 16677be8da07SAndreas Gruenbacher struct drbd_request *req; 16687be8da07SAndreas Gruenbacher 16697be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 16707be8da07SAndreas Gruenbacher if (!i->local) 16717be8da07SAndreas Gruenbacher continue; 16727be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 16737be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 16747be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 16757be8da07SAndreas Gruenbacher continue; 16767be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 16777be8da07SAndreas Gruenbacher req->w.mdev = mdev; 16787be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 16797be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 16807be8da07SAndreas Gruenbacher } 16817be8da07SAndreas Gruenbacher } 16827be8da07SAndreas Gruenbacher } 16837be8da07SAndreas Gruenbacher 1684b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1685b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1686b411b363SPhilipp Reisner */ 168799920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1688b411b363SPhilipp Reisner { 16898050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16908050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 169100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1692db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 169399920dc5SAndreas Gruenbacher int err = 0, pcmd; 1694b411b363SPhilipp Reisner 169589e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1696db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1697b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1698b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1699db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1700b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 170199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1702b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1703db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1704b411b363SPhilipp Reisner } else { 170599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1706b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1707b411b363SPhilipp Reisner * maybe assert this? */ 1708b411b363SPhilipp Reisner } 1709b411b363SPhilipp Reisner dec_unacked(mdev); 1710b411b363SPhilipp Reisner } 1711b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1712b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 171389e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 171487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1715db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1716db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 17177be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 17187be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 171987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1720bb3bfe96SAndreas Gruenbacher } else 1721db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1722b411b363SPhilipp Reisner 1723db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1724b411b363SPhilipp Reisner 172599920dc5SAndreas Gruenbacher return err; 1726b411b363SPhilipp Reisner } 1727b411b363SPhilipp Reisner 17287be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1729b411b363SPhilipp Reisner { 17307be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 17318050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17328050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 173399920dc5SAndreas Gruenbacher int err; 1734b411b363SPhilipp Reisner 173599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1736b411b363SPhilipp Reisner dec_unacked(mdev); 1737b411b363SPhilipp Reisner 173899920dc5SAndreas Gruenbacher return err; 1739b411b363SPhilipp Reisner } 1740b411b363SPhilipp Reisner 174199920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 17427be8da07SAndreas Gruenbacher { 17437be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17447be8da07SAndreas Gruenbacher } 17457be8da07SAndreas Gruenbacher 174699920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17477be8da07SAndreas Gruenbacher { 17487be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17497be8da07SAndreas Gruenbacher 17507be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 17517be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 17527be8da07SAndreas Gruenbacher } 17537be8da07SAndreas Gruenbacher 17543e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 17553e394da1SAndreas Gruenbacher { 17563e394da1SAndreas Gruenbacher /* 17573e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 17583e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 17593e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 17603e394da1SAndreas Gruenbacher */ 17613e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 17623e394da1SAndreas Gruenbacher } 17633e394da1SAndreas Gruenbacher 17643e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 17653e394da1SAndreas Gruenbacher { 17663e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 17673e394da1SAndreas Gruenbacher } 17683e394da1SAndreas Gruenbacher 17697be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 17707be8da07SAndreas Gruenbacher { 17717be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 17727be8da07SAndreas Gruenbacher 17737be8da07SAndreas Gruenbacher /* 17747be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 17757be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 17767be8da07SAndreas Gruenbacher * handle_write_conflicts(). 17777be8da07SAndreas Gruenbacher */ 17787be8da07SAndreas Gruenbacher return tconn->net_conf->two_primaries && 17797be8da07SAndreas Gruenbacher test_bit(DISCARD_CONCURRENT, &tconn->flags); 17807be8da07SAndreas Gruenbacher } 17817be8da07SAndreas Gruenbacher 178243ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 17833e394da1SAndreas Gruenbacher { 17843c13b680SLars Ellenberg unsigned int newest_peer_seq; 17853e394da1SAndreas Gruenbacher 17867be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 17873e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 17883c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 17893c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 17903e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 17913c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 17923c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 17933e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 17943e394da1SAndreas Gruenbacher } 17957be8da07SAndreas Gruenbacher } 17963e394da1SAndreas Gruenbacher 1797b411b363SPhilipp Reisner /* Called from receive_Data. 1798b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1799b411b363SPhilipp Reisner * 1800b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1801b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1802b411b363SPhilipp Reisner * been sent. 1803b411b363SPhilipp Reisner * 1804b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1805b411b363SPhilipp Reisner * 1806b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1807b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1808b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1809b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1810b411b363SPhilipp Reisner * 1811b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1812b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1813b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1814b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1815b411b363SPhilipp Reisner * 1816b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1817b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 18187be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1819b411b363SPhilipp Reisner { 1820b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1821b411b363SPhilipp Reisner long timeout; 18227be8da07SAndreas Gruenbacher int ret; 18237be8da07SAndreas Gruenbacher 18247be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 18257be8da07SAndreas Gruenbacher return 0; 18267be8da07SAndreas Gruenbacher 1827b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1828b411b363SPhilipp Reisner for (;;) { 18297be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 18307be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 18317be8da07SAndreas Gruenbacher ret = 0; 1832b411b363SPhilipp Reisner break; 18337be8da07SAndreas Gruenbacher } 1834b411b363SPhilipp Reisner if (signal_pending(current)) { 1835b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1836b411b363SPhilipp Reisner break; 1837b411b363SPhilipp Reisner } 18387be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1839b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 184071b1c1ebSAndreas Gruenbacher timeout = mdev->tconn->net_conf->ping_timeo*HZ/10; 184171b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1842b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 18437be8da07SAndreas Gruenbacher if (!timeout) { 1844b411b363SPhilipp Reisner ret = -ETIMEDOUT; 184571b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1846b411b363SPhilipp Reisner break; 1847b411b363SPhilipp Reisner } 1848b411b363SPhilipp Reisner } 1849b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 18507be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1851b411b363SPhilipp Reisner return ret; 1852b411b363SPhilipp Reisner } 1853b411b363SPhilipp Reisner 1854688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1855688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1856688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1857688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 185876d2e7ecSPhilipp Reisner { 185976d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 186076d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1861688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 186276d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 186376d2e7ecSPhilipp Reisner } 186476d2e7ecSPhilipp Reisner 18657be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 18667be8da07SAndreas Gruenbacher unsigned int size) 18677be8da07SAndreas Gruenbacher { 18687be8da07SAndreas Gruenbacher struct drbd_interval *i; 18697be8da07SAndreas Gruenbacher 18707be8da07SAndreas Gruenbacher repeat: 18717be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18727be8da07SAndreas Gruenbacher struct drbd_request *req; 18737be8da07SAndreas Gruenbacher struct bio_and_error m; 18747be8da07SAndreas Gruenbacher 18757be8da07SAndreas Gruenbacher if (!i->local) 18767be8da07SAndreas Gruenbacher continue; 18777be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18787be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 18797be8da07SAndreas Gruenbacher continue; 18807be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 18817be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 18827be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 18837be8da07SAndreas Gruenbacher if (m.bio) 18847be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 18857be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 18867be8da07SAndreas Gruenbacher goto repeat; 18877be8da07SAndreas Gruenbacher } 18887be8da07SAndreas Gruenbacher } 18897be8da07SAndreas Gruenbacher 18907be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 18917be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 18927be8da07SAndreas Gruenbacher { 18937be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 18947be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 18957be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 18967be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 18977be8da07SAndreas Gruenbacher struct drbd_interval *i; 18987be8da07SAndreas Gruenbacher bool equal; 18997be8da07SAndreas Gruenbacher int err; 19007be8da07SAndreas Gruenbacher 19017be8da07SAndreas Gruenbacher /* 19027be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 19037be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 19047be8da07SAndreas Gruenbacher */ 19057be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 19067be8da07SAndreas Gruenbacher 19077be8da07SAndreas Gruenbacher repeat: 19087be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19097be8da07SAndreas Gruenbacher if (i == &peer_req->i) 19107be8da07SAndreas Gruenbacher continue; 19117be8da07SAndreas Gruenbacher 19127be8da07SAndreas Gruenbacher if (!i->local) { 19137be8da07SAndreas Gruenbacher /* 19147be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 19157be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 19167be8da07SAndreas Gruenbacher * earlier peer request to complete. 19177be8da07SAndreas Gruenbacher */ 19187be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 19197be8da07SAndreas Gruenbacher if (err) 19207be8da07SAndreas Gruenbacher goto out; 19217be8da07SAndreas Gruenbacher goto repeat; 19227be8da07SAndreas Gruenbacher } 19237be8da07SAndreas Gruenbacher 19247be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 19257be8da07SAndreas Gruenbacher if (resolve_conflicts) { 19267be8da07SAndreas Gruenbacher /* 19277be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 19287be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 19297be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 19307be8da07SAndreas Gruenbacher * have completed. 19317be8da07SAndreas Gruenbacher */ 19327be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 19337be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 19347be8da07SAndreas Gruenbacher 19357be8da07SAndreas Gruenbacher if (!equal) 19367be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19377be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 19387be8da07SAndreas Gruenbacher "assuming %s came first\n", 19397be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19407be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 19417be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 19427be8da07SAndreas Gruenbacher 19437be8da07SAndreas Gruenbacher inc_unacked(mdev); 19447be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 19457be8da07SAndreas Gruenbacher e_send_retry_write; 19467be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 19477be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 19487be8da07SAndreas Gruenbacher 19497be8da07SAndreas Gruenbacher err = -ENOENT; 19507be8da07SAndreas Gruenbacher goto out; 19517be8da07SAndreas Gruenbacher } else { 19527be8da07SAndreas Gruenbacher struct drbd_request *req = 19537be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 19547be8da07SAndreas Gruenbacher 19557be8da07SAndreas Gruenbacher if (!equal) 19567be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19577be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 19587be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19597be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 19607be8da07SAndreas Gruenbacher 19617be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 19627be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 19637be8da07SAndreas Gruenbacher /* 19647be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 19657be8da07SAndreas Gruenbacher * decide if this request will be discarded or 19667be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 19677be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 19687be8da07SAndreas Gruenbacher * 19697be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 19707be8da07SAndreas Gruenbacher * request to finish locally before submitting 19717be8da07SAndreas Gruenbacher * the conflicting peer request. 19727be8da07SAndreas Gruenbacher */ 19737be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 19747be8da07SAndreas Gruenbacher if (err) { 19757be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 19767be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 19777be8da07SAndreas Gruenbacher CS_HARD); 19787be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 19797be8da07SAndreas Gruenbacher goto out; 19807be8da07SAndreas Gruenbacher } 19817be8da07SAndreas Gruenbacher goto repeat; 19827be8da07SAndreas Gruenbacher } 19837be8da07SAndreas Gruenbacher /* 19847be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 19857be8da07SAndreas Gruenbacher * the new peer request has completed. 19867be8da07SAndreas Gruenbacher */ 19877be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 19887be8da07SAndreas Gruenbacher } 19897be8da07SAndreas Gruenbacher } 19907be8da07SAndreas Gruenbacher err = 0; 19917be8da07SAndreas Gruenbacher 19927be8da07SAndreas Gruenbacher out: 19937be8da07SAndreas Gruenbacher if (err) 19947be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 19957be8da07SAndreas Gruenbacher return err; 19967be8da07SAndreas Gruenbacher } 19977be8da07SAndreas Gruenbacher 1998b411b363SPhilipp Reisner /* mirrored write */ 19994a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2000b411b363SPhilipp Reisner { 20014a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2002b411b363SPhilipp Reisner sector_t sector; 2003db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2004e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20057be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2006b411b363SPhilipp Reisner int rw = WRITE; 2007b411b363SPhilipp Reisner u32 dp_flags; 20087be8da07SAndreas Gruenbacher int err; 20097be8da07SAndreas Gruenbacher 20104a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 20114a76b161SAndreas Gruenbacher if (!mdev) 20124a76b161SAndreas Gruenbacher return -EIO; 20134a76b161SAndreas Gruenbacher 2014b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 201582bc0194SAndreas Gruenbacher int err2; 201682bc0194SAndreas Gruenbacher 20177be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2018e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 2019b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 2020e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 202182bc0194SAndreas Gruenbacher if (!err) 202282bc0194SAndreas Gruenbacher err = err2; 202382bc0194SAndreas Gruenbacher return err; 2024b411b363SPhilipp Reisner } 2025b411b363SPhilipp Reisner 2026fcefa62eSAndreas Gruenbacher /* 2027fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2028fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2029fcefa62eSAndreas Gruenbacher * end of this function. 2030fcefa62eSAndreas Gruenbacher */ 2031b411b363SPhilipp Reisner 2032b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2033e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2034db830c46SAndreas Gruenbacher if (!peer_req) { 2035b411b363SPhilipp Reisner put_ldev(mdev); 203682bc0194SAndreas Gruenbacher return -EIO; 2037b411b363SPhilipp Reisner } 2038b411b363SPhilipp Reisner 2039db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2040b411b363SPhilipp Reisner 2041688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2042688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2043688593c5SLars Ellenberg 2044688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2045db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2046688593c5SLars Ellenberg 2047b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2048db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2049db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2050db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2051b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2052b411b363SPhilipp Reisner 20537be8da07SAndreas Gruenbacher if (mdev->tconn->net_conf->two_primaries) { 20547be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 20557be8da07SAndreas Gruenbacher if (err) 2056b411b363SPhilipp Reisner goto out_interrupted; 205787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 20587be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 20597be8da07SAndreas Gruenbacher if (err) { 206087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 20617be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2062b411b363SPhilipp Reisner put_ldev(mdev); 206382bc0194SAndreas Gruenbacher return 0; 2064b411b363SPhilipp Reisner } 2065b411b363SPhilipp Reisner goto out_interrupted; 2066b411b363SPhilipp Reisner } 20677be8da07SAndreas Gruenbacher } else 206887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2069db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 207087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2071b411b363SPhilipp Reisner 207289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 2073b411b363SPhilipp Reisner case DRBD_PROT_C: 2074b411b363SPhilipp Reisner inc_unacked(mdev); 2075b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2076b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2077b411b363SPhilipp Reisner break; 2078b411b363SPhilipp Reisner case DRBD_PROT_B: 2079b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2080b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2081db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2082b411b363SPhilipp Reisner break; 2083b411b363SPhilipp Reisner case DRBD_PROT_A: 2084b411b363SPhilipp Reisner /* nothing to do */ 2085b411b363SPhilipp Reisner break; 2086b411b363SPhilipp Reisner } 2087b411b363SPhilipp Reisner 20886719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2089b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2090db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2091db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2092db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2093181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2094b411b363SPhilipp Reisner } 2095b411b363SPhilipp Reisner 209682bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 209782bc0194SAndreas Gruenbacher if (!err) 209882bc0194SAndreas Gruenbacher return 0; 2099b411b363SPhilipp Reisner 210010f6d992SLars Ellenberg /* don't care for the reason here */ 210110f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 210287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2103db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2104db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 210587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2106db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2107181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 210822cc37a9SLars Ellenberg 2109b411b363SPhilipp Reisner out_interrupted: 2110db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2111b411b363SPhilipp Reisner put_ldev(mdev); 21123967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 211382bc0194SAndreas Gruenbacher return err; 2114b411b363SPhilipp Reisner } 2115b411b363SPhilipp Reisner 21160f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 21170f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 21180f0601f4SLars Ellenberg * 21190f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 21200f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 21210f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 21220f0601f4SLars Ellenberg * activity, it obviously is "busy". 21230f0601f4SLars Ellenberg * 21240f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 21250f0601f4SLars Ellenberg * to have a short time average so we can react faster. 21260f0601f4SLars Ellenberg */ 2127e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 21280f0601f4SLars Ellenberg { 21290f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 21300f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2131e3555d85SPhilipp Reisner struct lc_element *tmp; 21320f0601f4SLars Ellenberg int curr_events; 21330f0601f4SLars Ellenberg int throttle = 0; 21340f0601f4SLars Ellenberg 21350f0601f4SLars Ellenberg /* feature disabled? */ 2136f399002eSLars Ellenberg if (mdev->ldev->dc.c_min_rate == 0) 21370f0601f4SLars Ellenberg return 0; 21380f0601f4SLars Ellenberg 2139e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2140e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2141e3555d85SPhilipp Reisner if (tmp) { 2142e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2143e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2144e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2145e3555d85SPhilipp Reisner return 0; 2146e3555d85SPhilipp Reisner } 2147e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2148e3555d85SPhilipp Reisner } 2149e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2150e3555d85SPhilipp Reisner 21510f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 21520f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 21530f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2154e3555d85SPhilipp Reisner 21550f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 21560f0601f4SLars Ellenberg unsigned long rs_left; 21570f0601f4SLars Ellenberg int i; 21580f0601f4SLars Ellenberg 21590f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 21600f0601f4SLars Ellenberg 21610f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 21620f0601f4SLars Ellenberg * approx. */ 21632649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 21642649f080SLars Ellenberg 21652649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 21662649f080SLars Ellenberg rs_left = mdev->ov_left; 21672649f080SLars Ellenberg else 21680f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 21690f0601f4SLars Ellenberg 21700f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 21710f0601f4SLars Ellenberg if (!dt) 21720f0601f4SLars Ellenberg dt++; 21730f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 21740f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 21750f0601f4SLars Ellenberg 2176f399002eSLars Ellenberg if (dbdt > mdev->ldev->dc.c_min_rate) 21770f0601f4SLars Ellenberg throttle = 1; 21780f0601f4SLars Ellenberg } 21790f0601f4SLars Ellenberg return throttle; 21800f0601f4SLars Ellenberg } 21810f0601f4SLars Ellenberg 21820f0601f4SLars Ellenberg 21834a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2184b411b363SPhilipp Reisner { 21854a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2186b411b363SPhilipp Reisner sector_t sector; 21874a76b161SAndreas Gruenbacher sector_t capacity; 2188db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2189b411b363SPhilipp Reisner struct digest_info *di = NULL; 2190b18b37beSPhilipp Reisner int size, verb; 2191b411b363SPhilipp Reisner unsigned int fault_type; 2192e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 21934a76b161SAndreas Gruenbacher 21944a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 21954a76b161SAndreas Gruenbacher if (!mdev) 21964a76b161SAndreas Gruenbacher return -EIO; 21974a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2198b411b363SPhilipp Reisner 2199b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2200b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2201b411b363SPhilipp Reisner 2202c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2203b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2204b411b363SPhilipp Reisner (unsigned long long)sector, size); 220582bc0194SAndreas Gruenbacher return -EINVAL; 2206b411b363SPhilipp Reisner } 2207b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2208b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2209b411b363SPhilipp Reisner (unsigned long long)sector, size); 221082bc0194SAndreas Gruenbacher return -EINVAL; 2211b411b363SPhilipp Reisner } 2212b411b363SPhilipp Reisner 2213b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2214b18b37beSPhilipp Reisner verb = 1; 2215e2857216SAndreas Gruenbacher switch (pi->cmd) { 2216b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2217b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2218b18b37beSPhilipp Reisner break; 2219b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2220b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2221b18b37beSPhilipp Reisner case P_OV_REQUEST: 2222b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2223b18b37beSPhilipp Reisner break; 2224b18b37beSPhilipp Reisner case P_OV_REPLY: 2225b18b37beSPhilipp Reisner verb = 0; 2226b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2227b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2228b18b37beSPhilipp Reisner break; 2229b18b37beSPhilipp Reisner default: 223049ba9b1bSAndreas Gruenbacher BUG(); 2231b18b37beSPhilipp Reisner } 2232b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2233b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2234b411b363SPhilipp Reisner "no local data.\n"); 2235b18b37beSPhilipp Reisner 2236a821cc4aSLars Ellenberg /* drain possibly payload */ 2237e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2238b411b363SPhilipp Reisner } 2239b411b363SPhilipp Reisner 2240b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2241b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2242b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 22430db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2244db830c46SAndreas Gruenbacher if (!peer_req) { 2245b411b363SPhilipp Reisner put_ldev(mdev); 224682bc0194SAndreas Gruenbacher return -ENOMEM; 2247b411b363SPhilipp Reisner } 2248b411b363SPhilipp Reisner 2249e2857216SAndreas Gruenbacher switch (pi->cmd) { 2250b411b363SPhilipp Reisner case P_DATA_REQUEST: 2251db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2252b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 225380a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 225480a40e43SLars Ellenberg goto submit; 225580a40e43SLars Ellenberg 2256b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2257db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2258b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 22595f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22605f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2261b411b363SPhilipp Reisner break; 2262b411b363SPhilipp Reisner 2263b411b363SPhilipp Reisner case P_OV_REPLY: 2264b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2265b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2266e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2267b411b363SPhilipp Reisner if (!di) 2268b411b363SPhilipp Reisner goto out_free_e; 2269b411b363SPhilipp Reisner 2270e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2271b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2272b411b363SPhilipp Reisner 2273db830c46SAndreas Gruenbacher peer_req->digest = di; 2274db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2275c36c3cedSLars Ellenberg 2276e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2277b411b363SPhilipp Reisner goto out_free_e; 2278b411b363SPhilipp Reisner 2279e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 228031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2281db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 22825f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22835f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2284e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 22852649f080SLars Ellenberg /* track progress, we may need to throttle */ 22862649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2287db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2288b411b363SPhilipp Reisner dec_rs_pending(mdev); 22890f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 22900f0601f4SLars Ellenberg * but accounting still needs to be done. */ 22910f0601f4SLars Ellenberg goto submit_for_resync; 2292b411b363SPhilipp Reisner } 2293b411b363SPhilipp Reisner break; 2294b411b363SPhilipp Reisner 2295b411b363SPhilipp Reisner case P_OV_REQUEST: 2296b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 229731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2298de228bbaSLars Ellenberg unsigned long now = jiffies; 2299de228bbaSLars Ellenberg int i; 2300b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2301b411b363SPhilipp Reisner mdev->ov_position = sector; 230230b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 230330b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2304de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2305de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2306de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2307de228bbaSLars Ellenberg } 2308b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2309b411b363SPhilipp Reisner (unsigned long long)sector); 2310b411b363SPhilipp Reisner } 2311db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2312b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2313b411b363SPhilipp Reisner break; 2314b411b363SPhilipp Reisner 2315b411b363SPhilipp Reisner default: 231649ba9b1bSAndreas Gruenbacher BUG(); 2317b411b363SPhilipp Reisner } 2318b411b363SPhilipp Reisner 23190f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 23200f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 23210f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 23220f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 23230f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 23240f0601f4SLars Ellenberg * 23250f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 23260f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 23270f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 23280f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 23290f0601f4SLars Ellenberg * a while, anyways. 23300f0601f4SLars Ellenberg */ 2331b411b363SPhilipp Reisner 23320f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 23330f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 23340f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 23350f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 23360f0601f4SLars Ellenberg * 23370f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 23380f0601f4SLars Ellenberg * we would also throttle its application reads. 23390f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 23400f0601f4SLars Ellenberg */ 2341e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2342e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2343e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 234480a40e43SLars Ellenberg goto out_free_e; 2345b411b363SPhilipp Reisner 23460f0601f4SLars Ellenberg submit_for_resync: 23470f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 23480f0601f4SLars Ellenberg 234980a40e43SLars Ellenberg submit: 2350b411b363SPhilipp Reisner inc_unacked(mdev); 235187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2352db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 235387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2354b411b363SPhilipp Reisner 2355fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 235682bc0194SAndreas Gruenbacher return 0; 2357b411b363SPhilipp Reisner 235810f6d992SLars Ellenberg /* don't care for the reason here */ 235910f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 236087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2361db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 236287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 236322cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 236422cc37a9SLars Ellenberg 2365b411b363SPhilipp Reisner out_free_e: 2366b411b363SPhilipp Reisner put_ldev(mdev); 23673967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 236882bc0194SAndreas Gruenbacher return -EIO; 2369b411b363SPhilipp Reisner } 2370b411b363SPhilipp Reisner 2371b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2372b411b363SPhilipp Reisner { 2373b411b363SPhilipp Reisner int self, peer, rv = -100; 2374b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2375b411b363SPhilipp Reisner 2376b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2377b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2378b411b363SPhilipp Reisner 2379b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2380b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2381b411b363SPhilipp Reisner 238289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2383b411b363SPhilipp Reisner case ASB_CONSENSUS: 2384b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2385b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2386b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2387b411b363SPhilipp Reisner break; 2388b411b363SPhilipp Reisner case ASB_DISCONNECT: 2389b411b363SPhilipp Reisner break; 2390b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2391b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2392b411b363SPhilipp Reisner rv = -1; 2393b411b363SPhilipp Reisner break; 2394b411b363SPhilipp Reisner } 2395b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2396b411b363SPhilipp Reisner rv = 1; 2397b411b363SPhilipp Reisner break; 2398b411b363SPhilipp Reisner } 2399b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2400b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2401b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2402b411b363SPhilipp Reisner rv = 1; 2403b411b363SPhilipp Reisner break; 2404b411b363SPhilipp Reisner } 2405b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2406b411b363SPhilipp Reisner rv = -1; 2407b411b363SPhilipp Reisner break; 2408b411b363SPhilipp Reisner } 2409b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2410ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2411b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2412b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2413b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 241425703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2415b411b363SPhilipp Reisner ? -1 : 1; 2416b411b363SPhilipp Reisner break; 2417b411b363SPhilipp Reisner } else { 2418b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2419b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2420b411b363SPhilipp Reisner } 242189e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2422b411b363SPhilipp Reisner break; 2423b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2424b411b363SPhilipp Reisner if (ch_self < ch_peer) 2425b411b363SPhilipp Reisner rv = -1; 2426b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2427b411b363SPhilipp Reisner rv = 1; 2428b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2429b411b363SPhilipp Reisner /* Well, then use something else. */ 243025703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2431b411b363SPhilipp Reisner ? -1 : 1; 2432b411b363SPhilipp Reisner break; 2433b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2434b411b363SPhilipp Reisner rv = -1; 2435b411b363SPhilipp Reisner break; 2436b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2437b411b363SPhilipp Reisner rv = 1; 2438b411b363SPhilipp Reisner } 2439b411b363SPhilipp Reisner 2440b411b363SPhilipp Reisner return rv; 2441b411b363SPhilipp Reisner } 2442b411b363SPhilipp Reisner 2443b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2444b411b363SPhilipp Reisner { 24456184ea21SAndreas Gruenbacher int hg, rv = -100; 2446b411b363SPhilipp Reisner 244789e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2448b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2449b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2450b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2451b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2452b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2453b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2454b411b363SPhilipp Reisner break; 2455b411b363SPhilipp Reisner case ASB_DISCONNECT: 2456b411b363SPhilipp Reisner break; 2457b411b363SPhilipp Reisner case ASB_CONSENSUS: 2458b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2459b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2460b411b363SPhilipp Reisner rv = hg; 2461b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2462b411b363SPhilipp Reisner rv = hg; 2463b411b363SPhilipp Reisner break; 2464b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2465b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2466b411b363SPhilipp Reisner break; 2467b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2468b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2469b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2470b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2471b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2472bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2473bb437946SAndreas Gruenbacher 2474bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2475b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2476b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2477b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2478bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2479bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2480b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2481b411b363SPhilipp Reisner } else { 2482b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2483b411b363SPhilipp Reisner rv = hg; 2484b411b363SPhilipp Reisner } 2485b411b363SPhilipp Reisner } else 2486b411b363SPhilipp Reisner rv = hg; 2487b411b363SPhilipp Reisner } 2488b411b363SPhilipp Reisner 2489b411b363SPhilipp Reisner return rv; 2490b411b363SPhilipp Reisner } 2491b411b363SPhilipp Reisner 2492b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2493b411b363SPhilipp Reisner { 24946184ea21SAndreas Gruenbacher int hg, rv = -100; 2495b411b363SPhilipp Reisner 249689e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2497b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2498b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2499b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2500b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2501b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2502b411b363SPhilipp Reisner case ASB_CONSENSUS: 2503b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2504b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2505b411b363SPhilipp Reisner break; 2506b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2507b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2508b411b363SPhilipp Reisner break; 2509b411b363SPhilipp Reisner case ASB_DISCONNECT: 2510b411b363SPhilipp Reisner break; 2511b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2512b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2513b411b363SPhilipp Reisner if (hg == -1) { 2514bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2515bb437946SAndreas Gruenbacher 2516b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2517b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2518b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2519bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2520bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2521b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2522b411b363SPhilipp Reisner } else { 2523b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2524b411b363SPhilipp Reisner rv = hg; 2525b411b363SPhilipp Reisner } 2526b411b363SPhilipp Reisner } else 2527b411b363SPhilipp Reisner rv = hg; 2528b411b363SPhilipp Reisner } 2529b411b363SPhilipp Reisner 2530b411b363SPhilipp Reisner return rv; 2531b411b363SPhilipp Reisner } 2532b411b363SPhilipp Reisner 2533b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2534b411b363SPhilipp Reisner u64 bits, u64 flags) 2535b411b363SPhilipp Reisner { 2536b411b363SPhilipp Reisner if (!uuid) { 2537b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2538b411b363SPhilipp Reisner return; 2539b411b363SPhilipp Reisner } 2540b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2541b411b363SPhilipp Reisner text, 2542b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2543b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2544b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2545b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2546b411b363SPhilipp Reisner (unsigned long long)bits, 2547b411b363SPhilipp Reisner (unsigned long long)flags); 2548b411b363SPhilipp Reisner } 2549b411b363SPhilipp Reisner 2550b411b363SPhilipp Reisner /* 2551b411b363SPhilipp Reisner 100 after split brain try auto recover 2552b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2553b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2554b411b363SPhilipp Reisner 0 no Sync 2555b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2556b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2557b411b363SPhilipp Reisner -100 after split brain, disconnect 2558b411b363SPhilipp Reisner -1000 unrelated data 25594a23f264SPhilipp Reisner -1091 requires proto 91 25604a23f264SPhilipp Reisner -1096 requires proto 96 2561b411b363SPhilipp Reisner */ 2562b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2563b411b363SPhilipp Reisner { 2564b411b363SPhilipp Reisner u64 self, peer; 2565b411b363SPhilipp Reisner int i, j; 2566b411b363SPhilipp Reisner 2567b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2568b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2569b411b363SPhilipp Reisner 2570b411b363SPhilipp Reisner *rule_nr = 10; 2571b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2572b411b363SPhilipp Reisner return 0; 2573b411b363SPhilipp Reisner 2574b411b363SPhilipp Reisner *rule_nr = 20; 2575b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2576b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2577b411b363SPhilipp Reisner return -2; 2578b411b363SPhilipp Reisner 2579b411b363SPhilipp Reisner *rule_nr = 30; 2580b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2581b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2582b411b363SPhilipp Reisner return 2; 2583b411b363SPhilipp Reisner 2584b411b363SPhilipp Reisner if (self == peer) { 2585b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2586b411b363SPhilipp Reisner 2587b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2588b411b363SPhilipp Reisner 258931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25904a23f264SPhilipp Reisner return -1091; 2591b411b363SPhilipp Reisner 2592b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2593b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2594b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2595b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2596b411b363SPhilipp Reisner 2597b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2598b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2599b411b363SPhilipp Reisner *rule_nr = 34; 2600b411b363SPhilipp Reisner } else { 2601b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2602b411b363SPhilipp Reisner *rule_nr = 36; 2603b411b363SPhilipp Reisner } 2604b411b363SPhilipp Reisner 2605b411b363SPhilipp Reisner return 1; 2606b411b363SPhilipp Reisner } 2607b411b363SPhilipp Reisner 2608b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2609b411b363SPhilipp Reisner 261031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26114a23f264SPhilipp Reisner return -1091; 2612b411b363SPhilipp Reisner 2613b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2614b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2615b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2616b411b363SPhilipp Reisner 2617b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2618b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2619b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2620b411b363SPhilipp Reisner 2621b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2622b411b363SPhilipp Reisner *rule_nr = 35; 2623b411b363SPhilipp Reisner } else { 2624b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2625b411b363SPhilipp Reisner *rule_nr = 37; 2626b411b363SPhilipp Reisner } 2627b411b363SPhilipp Reisner 2628b411b363SPhilipp Reisner return -1; 2629b411b363SPhilipp Reisner } 2630b411b363SPhilipp Reisner 2631b411b363SPhilipp Reisner /* Common power [off|failure] */ 2632b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2633b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2634b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2635b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2636b411b363SPhilipp Reisner *rule_nr = 40; 2637b411b363SPhilipp Reisner 2638b411b363SPhilipp Reisner switch (rct) { 2639b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2640b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2641b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2642b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 264325703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2644b411b363SPhilipp Reisner return dc ? -1 : 1; 2645b411b363SPhilipp Reisner } 2646b411b363SPhilipp Reisner } 2647b411b363SPhilipp Reisner 2648b411b363SPhilipp Reisner *rule_nr = 50; 2649b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2650b411b363SPhilipp Reisner if (self == peer) 2651b411b363SPhilipp Reisner return -1; 2652b411b363SPhilipp Reisner 2653b411b363SPhilipp Reisner *rule_nr = 51; 2654b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2655b411b363SPhilipp Reisner if (self == peer) { 265631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26574a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 26584a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 26594a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2660b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2661b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2662b411b363SPhilipp Reisner 266331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26644a23f264SPhilipp Reisner return -1091; 2665b411b363SPhilipp Reisner 2666b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2667b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 26684a23f264SPhilipp Reisner 26694a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 26704a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 26714a23f264SPhilipp Reisner 2672b411b363SPhilipp Reisner return -1; 2673b411b363SPhilipp Reisner } 2674b411b363SPhilipp Reisner } 2675b411b363SPhilipp Reisner 2676b411b363SPhilipp Reisner *rule_nr = 60; 2677b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2678b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2679b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2680b411b363SPhilipp Reisner if (self == peer) 2681b411b363SPhilipp Reisner return -2; 2682b411b363SPhilipp Reisner } 2683b411b363SPhilipp Reisner 2684b411b363SPhilipp Reisner *rule_nr = 70; 2685b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2686b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2687b411b363SPhilipp Reisner if (self == peer) 2688b411b363SPhilipp Reisner return 1; 2689b411b363SPhilipp Reisner 2690b411b363SPhilipp Reisner *rule_nr = 71; 2691b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2692b411b363SPhilipp Reisner if (self == peer) { 269331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26944a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 26954a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 26964a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2697b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2698b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2699b411b363SPhilipp Reisner 270031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27014a23f264SPhilipp Reisner return -1091; 2702b411b363SPhilipp Reisner 2703b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2704b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2705b411b363SPhilipp Reisner 27064a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2707b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2708b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2709b411b363SPhilipp Reisner 2710b411b363SPhilipp Reisner return 1; 2711b411b363SPhilipp Reisner } 2712b411b363SPhilipp Reisner } 2713b411b363SPhilipp Reisner 2714b411b363SPhilipp Reisner 2715b411b363SPhilipp Reisner *rule_nr = 80; 2716d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2717b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2718b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2719b411b363SPhilipp Reisner if (self == peer) 2720b411b363SPhilipp Reisner return 2; 2721b411b363SPhilipp Reisner } 2722b411b363SPhilipp Reisner 2723b411b363SPhilipp Reisner *rule_nr = 90; 2724b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2725b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2726b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2727b411b363SPhilipp Reisner return 100; 2728b411b363SPhilipp Reisner 2729b411b363SPhilipp Reisner *rule_nr = 100; 2730b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2731b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2732b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2733b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2734b411b363SPhilipp Reisner if (self == peer) 2735b411b363SPhilipp Reisner return -100; 2736b411b363SPhilipp Reisner } 2737b411b363SPhilipp Reisner } 2738b411b363SPhilipp Reisner 2739b411b363SPhilipp Reisner return -1000; 2740b411b363SPhilipp Reisner } 2741b411b363SPhilipp Reisner 2742b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2743b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2744b411b363SPhilipp Reisner */ 2745b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2746b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2747b411b363SPhilipp Reisner { 2748b411b363SPhilipp Reisner int hg, rule_nr; 2749b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2750b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2751b411b363SPhilipp Reisner 2752b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2753b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2754b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2755b411b363SPhilipp Reisner 2756b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2757b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2758b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2759b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2760b411b363SPhilipp Reisner 2761b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2762b411b363SPhilipp Reisner 2763b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2764b411b363SPhilipp Reisner 2765b411b363SPhilipp Reisner if (hg == -1000) { 2766b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2767b411b363SPhilipp Reisner return C_MASK; 2768b411b363SPhilipp Reisner } 27694a23f264SPhilipp Reisner if (hg < -1000) { 27704a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2771b411b363SPhilipp Reisner return C_MASK; 2772b411b363SPhilipp Reisner } 2773b411b363SPhilipp Reisner 2774b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2775b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2776b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2777b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2778b411b363SPhilipp Reisner if (f) 2779b411b363SPhilipp Reisner hg = hg*2; 2780b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2781b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2782b411b363SPhilipp Reisner } 2783b411b363SPhilipp Reisner 27843a11a487SAdam Gandelman if (abs(hg) == 100) 27853a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 27863a11a487SAdam Gandelman 278789e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2788b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2789b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2790b411b363SPhilipp Reisner int forced = (hg == -100); 2791b411b363SPhilipp Reisner 2792b411b363SPhilipp Reisner switch (pcount) { 2793b411b363SPhilipp Reisner case 0: 2794b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2795b411b363SPhilipp Reisner break; 2796b411b363SPhilipp Reisner case 1: 2797b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2798b411b363SPhilipp Reisner break; 2799b411b363SPhilipp Reisner case 2: 2800b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2801b411b363SPhilipp Reisner break; 2802b411b363SPhilipp Reisner } 2803b411b363SPhilipp Reisner if (abs(hg) < 100) { 2804b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2805b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2806b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2807b411b363SPhilipp Reisner if (forced) { 2808b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2809b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2810b411b363SPhilipp Reisner hg = hg*2; 2811b411b363SPhilipp Reisner } 2812b411b363SPhilipp Reisner } 2813b411b363SPhilipp Reisner } 2814b411b363SPhilipp Reisner 2815b411b363SPhilipp Reisner if (hg == -100) { 281689e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2817b411b363SPhilipp Reisner hg = -1; 281889e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2819b411b363SPhilipp Reisner hg = 1; 2820b411b363SPhilipp Reisner 2821b411b363SPhilipp Reisner if (abs(hg) < 100) 2822b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2823b411b363SPhilipp Reisner "Sync from %s node\n", 2824b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2825b411b363SPhilipp Reisner } 2826b411b363SPhilipp Reisner 2827b411b363SPhilipp Reisner if (hg == -100) { 2828580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2829580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2830580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2831580b9767SLars Ellenberg * to that disk, in a way... */ 28323a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2833b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2834b411b363SPhilipp Reisner return C_MASK; 2835b411b363SPhilipp Reisner } 2836b411b363SPhilipp Reisner 2837b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2838b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2839b411b363SPhilipp Reisner return C_MASK; 2840b411b363SPhilipp Reisner } 2841b411b363SPhilipp Reisner 2842b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2843b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 284489e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2845b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2846b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2847b411b363SPhilipp Reisner /* fall through */ 2848b411b363SPhilipp Reisner case ASB_DISCONNECT: 2849b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2850b411b363SPhilipp Reisner return C_MASK; 2851b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2852b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2853b411b363SPhilipp Reisner "assumption\n"); 2854b411b363SPhilipp Reisner } 2855b411b363SPhilipp Reisner } 2856b411b363SPhilipp Reisner 28578169e41bSPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2858cf14c2e9SPhilipp Reisner if (hg == 0) 2859cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2860cf14c2e9SPhilipp Reisner else 2861cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2862cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2863cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2864cf14c2e9SPhilipp Reisner return C_MASK; 2865cf14c2e9SPhilipp Reisner } 2866cf14c2e9SPhilipp Reisner 2867b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2868b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 286920ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 287020ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2871b411b363SPhilipp Reisner return C_MASK; 2872b411b363SPhilipp Reisner } 2873b411b363SPhilipp Reisner 2874b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2875b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2876b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2877b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2878b411b363SPhilipp Reisner } else { 2879b411b363SPhilipp Reisner rv = C_CONNECTED; 2880b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2881b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2882b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2883b411b363SPhilipp Reisner } 2884b411b363SPhilipp Reisner } 2885b411b363SPhilipp Reisner 2886b411b363SPhilipp Reisner return rv; 2887b411b363SPhilipp Reisner } 2888b411b363SPhilipp Reisner 2889b411b363SPhilipp Reisner /* returns 1 if invalid */ 2890b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2891b411b363SPhilipp Reisner { 2892b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2893b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2894b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2895b411b363SPhilipp Reisner return 0; 2896b411b363SPhilipp Reisner 2897b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2898b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2899b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2900b411b363SPhilipp Reisner return 1; 2901b411b363SPhilipp Reisner 2902b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2903b411b363SPhilipp Reisner if (peer == self) 2904b411b363SPhilipp Reisner return 0; 2905b411b363SPhilipp Reisner 2906b411b363SPhilipp Reisner /* everything es is invalid. */ 2907b411b363SPhilipp Reisner return 1; 2908b411b363SPhilipp Reisner } 2909b411b363SPhilipp Reisner 2910e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 2911b411b363SPhilipp Reisner { 2912e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 2913b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2914cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2915b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2916b411b363SPhilipp Reisner 2917b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2918b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2919b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2920b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2921b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2922cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2923cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2924cf14c2e9SPhilipp Reisner 29257204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 2926cf14c2e9SPhilipp Reisner 2927cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 29287204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 2929b411b363SPhilipp Reisner 29307204624cSPhilipp Reisner if (p_proto != tconn->net_conf->wire_protocol) { 29317204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 2932b411b363SPhilipp Reisner goto disconnect; 2933b411b363SPhilipp Reisner } 2934b411b363SPhilipp Reisner 29357204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, tconn->net_conf->after_sb_0p)) { 29367204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 2937b411b363SPhilipp Reisner goto disconnect; 2938b411b363SPhilipp Reisner } 2939b411b363SPhilipp Reisner 29407204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, tconn->net_conf->after_sb_1p)) { 29417204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 2942b411b363SPhilipp Reisner goto disconnect; 2943b411b363SPhilipp Reisner } 2944b411b363SPhilipp Reisner 29457204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, tconn->net_conf->after_sb_2p)) { 29467204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 2947b411b363SPhilipp Reisner goto disconnect; 2948b411b363SPhilipp Reisner } 2949b411b363SPhilipp Reisner 29507204624cSPhilipp Reisner if (p_want_lose && tconn->net_conf->want_lose) { 29517204624cSPhilipp Reisner conn_err(tconn, "both sides have the 'want_lose' flag set\n"); 2952b411b363SPhilipp Reisner goto disconnect; 2953b411b363SPhilipp Reisner } 2954b411b363SPhilipp Reisner 29557204624cSPhilipp Reisner if (p_two_primaries != tconn->net_conf->two_primaries) { 29567204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 2957b411b363SPhilipp Reisner goto disconnect; 2958b411b363SPhilipp Reisner } 2959b411b363SPhilipp Reisner 29607204624cSPhilipp Reisner if (tconn->agreed_pro_version >= 87) { 29617204624cSPhilipp Reisner unsigned char *my_alg = tconn->net_conf->integrity_alg; 296282bc0194SAndreas Gruenbacher int err; 2963b411b363SPhilipp Reisner 2964e2857216SAndreas Gruenbacher err = drbd_recv_all(tconn, p_integrity_alg, pi->size); 296582bc0194SAndreas Gruenbacher if (err) 296682bc0194SAndreas Gruenbacher return err; 2967b411b363SPhilipp Reisner 2968b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2969b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 29707204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the data-integrity-alg\n"); 2971b411b363SPhilipp Reisner goto disconnect; 2972b411b363SPhilipp Reisner } 29737204624cSPhilipp Reisner conn_info(tconn, "data-integrity-alg: %s\n", 2974b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2975b411b363SPhilipp Reisner } 2976b411b363SPhilipp Reisner 297782bc0194SAndreas Gruenbacher return 0; 2978b411b363SPhilipp Reisner 2979b411b363SPhilipp Reisner disconnect: 29807204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 298182bc0194SAndreas Gruenbacher return -EIO; 2982b411b363SPhilipp Reisner } 2983b411b363SPhilipp Reisner 2984b411b363SPhilipp Reisner /* helper function 2985b411b363SPhilipp Reisner * input: alg name, feature name 2986b411b363SPhilipp Reisner * return: NULL (alg name was "") 2987b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2988b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2989b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2990b411b363SPhilipp Reisner const char *alg, const char *name) 2991b411b363SPhilipp Reisner { 2992b411b363SPhilipp Reisner struct crypto_hash *tfm; 2993b411b363SPhilipp Reisner 2994b411b363SPhilipp Reisner if (!alg[0]) 2995b411b363SPhilipp Reisner return NULL; 2996b411b363SPhilipp Reisner 2997b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2998b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2999b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3000b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3001b411b363SPhilipp Reisner return tfm; 3002b411b363SPhilipp Reisner } 3003b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 3004b411b363SPhilipp Reisner crypto_free_hash(tfm); 3005b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 3006b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 3007b411b363SPhilipp Reisner } 3008b411b363SPhilipp Reisner return tfm; 3009b411b363SPhilipp Reisner } 3010b411b363SPhilipp Reisner 30114a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3012b411b363SPhilipp Reisner { 30134a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 30144a76b161SAndreas Gruenbacher int size = pi->size; 30154a76b161SAndreas Gruenbacher 30164a76b161SAndreas Gruenbacher while (size) { 30174a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 30184a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 30194a76b161SAndreas Gruenbacher if (s <= 0) { 30204a76b161SAndreas Gruenbacher if (s < 0) 30214a76b161SAndreas Gruenbacher return s; 30224a76b161SAndreas Gruenbacher break; 30234a76b161SAndreas Gruenbacher } 30244a76b161SAndreas Gruenbacher size -= s; 30254a76b161SAndreas Gruenbacher } 30264a76b161SAndreas Gruenbacher if (size) 30274a76b161SAndreas Gruenbacher return -EIO; 30284a76b161SAndreas Gruenbacher return 0; 30294a76b161SAndreas Gruenbacher } 30304a76b161SAndreas Gruenbacher 30314a76b161SAndreas Gruenbacher /* 30324a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 30334a76b161SAndreas Gruenbacher * 30344a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 30354a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 30364a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 30374a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 30384a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 30394a76b161SAndreas Gruenbacher * 30404a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 30414a76b161SAndreas Gruenbacher */ 30424a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 30434a76b161SAndreas Gruenbacher { 30444a76b161SAndreas Gruenbacher conn_warn(tconn, "Volume %u unknown; ignoring %s packet\n", 30454a76b161SAndreas Gruenbacher pi->vnr, cmdname(pi->cmd)); 30464a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 30474a76b161SAndreas Gruenbacher } 30484a76b161SAndreas Gruenbacher 30494a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 30504a76b161SAndreas Gruenbacher { 30514a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3052e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3053b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3054b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3055b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 30564a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3057778f271dSPhilipp Reisner int *rs_plan_s = NULL; 3058778f271dSPhilipp Reisner int fifo_size = 0; 305982bc0194SAndreas Gruenbacher int err; 3060b411b363SPhilipp Reisner 30614a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 30624a76b161SAndreas Gruenbacher if (!mdev) 30634a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 30644a76b161SAndreas Gruenbacher 3065b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3066b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3067b411b363SPhilipp Reisner + SHARED_SECRET_MAX 30688e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 30698e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3070b411b363SPhilipp Reisner 3071e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3072b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3073e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 307482bc0194SAndreas Gruenbacher return -EIO; 3075b411b363SPhilipp Reisner } 3076b411b363SPhilipp Reisner 3077b411b363SPhilipp Reisner if (apv <= 88) { 3078e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3079e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 30808e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3081e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3082e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3083b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 30848e26f9ccSPhilipp Reisner } else { 3085e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3086e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3087b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3088b411b363SPhilipp Reisner } 3089b411b363SPhilipp Reisner 3090b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3091e658983aSAndreas Gruenbacher p = pi->data; 3092b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3093b411b363SPhilipp Reisner 3094e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 309582bc0194SAndreas Gruenbacher if (err) 309682bc0194SAndreas Gruenbacher return err; 3097b411b363SPhilipp Reisner 3098f399002eSLars Ellenberg if (get_ldev(mdev)) { 3099f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3100f399002eSLars Ellenberg put_ldev(mdev); 3101f399002eSLars Ellenberg } 3102b411b363SPhilipp Reisner 3103b411b363SPhilipp Reisner if (apv >= 88) { 3104b411b363SPhilipp Reisner if (apv == 88) { 3105b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3106b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3107b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3108b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 310982bc0194SAndreas Gruenbacher return -EIO; 3110b411b363SPhilipp Reisner } 3111b411b363SPhilipp Reisner 311282bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 311382bc0194SAndreas Gruenbacher if (err) 311482bc0194SAndreas Gruenbacher return err; 3115b411b363SPhilipp Reisner 3116b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3117b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3118b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3119b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3120b411b363SPhilipp Reisner 3121b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3122b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3123b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3124b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3125b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3126b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3127b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3128b411b363SPhilipp Reisner } 3129b411b363SPhilipp Reisner 3130f399002eSLars Ellenberg if (strcmp(mdev->tconn->net_conf->verify_alg, p->verify_alg)) { 3131b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3132b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 3133f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg, p->verify_alg); 3134b411b363SPhilipp Reisner goto disconnect; 3135b411b363SPhilipp Reisner } 3136b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3137b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3138b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3139b411b363SPhilipp Reisner verify_tfm = NULL; 3140b411b363SPhilipp Reisner goto disconnect; 3141b411b363SPhilipp Reisner } 3142b411b363SPhilipp Reisner } 3143b411b363SPhilipp Reisner 3144f399002eSLars Ellenberg if (apv >= 89 && strcmp(mdev->tconn->net_conf->csums_alg, p->csums_alg)) { 3145b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3146b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 3147f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg, p->csums_alg); 3148b411b363SPhilipp Reisner goto disconnect; 3149b411b363SPhilipp Reisner } 3150b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3151b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3152b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3153b411b363SPhilipp Reisner csums_tfm = NULL; 3154b411b363SPhilipp Reisner goto disconnect; 3155b411b363SPhilipp Reisner } 3156b411b363SPhilipp Reisner } 3157b411b363SPhilipp Reisner 3158f399002eSLars Ellenberg if (apv > 94 && get_ldev(mdev)) { 3159f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3160f399002eSLars Ellenberg mdev->ldev->dc.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3161f399002eSLars Ellenberg mdev->ldev->dc.c_delay_target = be32_to_cpu(p->c_delay_target); 3162f399002eSLars Ellenberg mdev->ldev->dc.c_fill_target = be32_to_cpu(p->c_fill_target); 3163f399002eSLars Ellenberg mdev->ldev->dc.c_max_rate = be32_to_cpu(p->c_max_rate); 3164778f271dSPhilipp Reisner 3165f399002eSLars Ellenberg fifo_size = (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3166778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 3167778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 3168778f271dSPhilipp Reisner if (!rs_plan_s) { 3169778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3170f399002eSLars Ellenberg put_ldev(mdev); 3171778f271dSPhilipp Reisner goto disconnect; 3172778f271dSPhilipp Reisner } 3173778f271dSPhilipp Reisner } 3174f399002eSLars Ellenberg put_ldev(mdev); 31758e26f9ccSPhilipp Reisner } 3176b411b363SPhilipp Reisner 3177b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 3178b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 3179b411b363SPhilipp Reisner if (verify_tfm) { 3180f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->verify_alg, p->verify_alg); 3181f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3182f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3183f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3184b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3185b411b363SPhilipp Reisner } 3186b411b363SPhilipp Reisner if (csums_tfm) { 3187f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->csums_alg, p->csums_alg); 3188f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3189f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3190f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3191b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3192b411b363SPhilipp Reisner } 3193778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 3194778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 3195778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 3196778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 3197778f271dSPhilipp Reisner mdev->rs_planed = 0; 3198778f271dSPhilipp Reisner } 3199b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 3200b411b363SPhilipp Reisner } 320182bc0194SAndreas Gruenbacher return 0; 3202b411b363SPhilipp Reisner 3203b411b363SPhilipp Reisner disconnect: 3204b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3205b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3206b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3207b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3208b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 320938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 321082bc0194SAndreas Gruenbacher return -EIO; 3211b411b363SPhilipp Reisner } 3212b411b363SPhilipp Reisner 3213b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3214b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3215b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3216b411b363SPhilipp Reisner { 3217b411b363SPhilipp Reisner sector_t d; 3218b411b363SPhilipp Reisner if (a == 0 || b == 0) 3219b411b363SPhilipp Reisner return; 3220b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3221b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3222b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3223b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3224b411b363SPhilipp Reisner } 3225b411b363SPhilipp Reisner 32264a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3227b411b363SPhilipp Reisner { 32284a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3229e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3230b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3231b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3232b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3233e89b591cSPhilipp Reisner enum dds_flags ddsf; 3234b411b363SPhilipp Reisner 32354a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 32364a76b161SAndreas Gruenbacher if (!mdev) 32374a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 32384a76b161SAndreas Gruenbacher 3239b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3240b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3241b411b363SPhilipp Reisner 3242b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3243b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3244b411b363SPhilipp Reisner mdev->p_size = p_size; 3245b411b363SPhilipp Reisner 3246b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3247b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3248b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3249b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3250b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3251b411b363SPhilipp Reisner 3252b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3253b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3254b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3255b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3256b411b363SPhilipp Reisner p_usize); 3257b411b363SPhilipp Reisner 3258b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3259b411b363SPhilipp Reisner 3260b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3261b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3262b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3263b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3264b411b363SPhilipp Reisner } 3265b411b363SPhilipp Reisner 3266b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3267b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3268a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3269b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3270b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3271b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3272b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 327338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3274b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3275b411b363SPhilipp Reisner put_ldev(mdev); 327682bc0194SAndreas Gruenbacher return -EIO; 3277b411b363SPhilipp Reisner } 3278b411b363SPhilipp Reisner put_ldev(mdev); 3279b411b363SPhilipp Reisner } 3280b411b363SPhilipp Reisner 3281e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3282b411b363SPhilipp Reisner if (get_ldev(mdev)) { 328324c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3284b411b363SPhilipp Reisner put_ldev(mdev); 3285b411b363SPhilipp Reisner if (dd == dev_size_error) 328682bc0194SAndreas Gruenbacher return -EIO; 3287b411b363SPhilipp Reisner drbd_md_sync(mdev); 3288b411b363SPhilipp Reisner } else { 3289b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3290b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3291b411b363SPhilipp Reisner } 3292b411b363SPhilipp Reisner 329399432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 329499432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 329599432fccSPhilipp Reisner 3296b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3297b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3298b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3299b411b363SPhilipp Reisner ldsc = 1; 3300b411b363SPhilipp Reisner } 3301b411b363SPhilipp Reisner 3302b411b363SPhilipp Reisner put_ldev(mdev); 3303b411b363SPhilipp Reisner } 3304b411b363SPhilipp Reisner 3305b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3306b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3307b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3308b411b363SPhilipp Reisner /* we have different sizes, probably peer 3309b411b363SPhilipp Reisner * needs to know my new size... */ 3310e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3311b411b363SPhilipp Reisner } 3312b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3313b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3314b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3315e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3316e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3317e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3318b411b363SPhilipp Reisner else 3319e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3320e89b591cSPhilipp Reisner } else 3321b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3322b411b363SPhilipp Reisner } 3323b411b363SPhilipp Reisner } 3324b411b363SPhilipp Reisner 332582bc0194SAndreas Gruenbacher return 0; 3326b411b363SPhilipp Reisner } 3327b411b363SPhilipp Reisner 33284a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3329b411b363SPhilipp Reisner { 33304a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3331e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3332b411b363SPhilipp Reisner u64 *p_uuid; 333362b0da3aSLars Ellenberg int i, updated_uuids = 0; 3334b411b363SPhilipp Reisner 33354a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 33364a76b161SAndreas Gruenbacher if (!mdev) 33374a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 33384a76b161SAndreas Gruenbacher 3339b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3340b411b363SPhilipp Reisner 3341b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3342b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3343b411b363SPhilipp Reisner 3344b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3345b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3346b411b363SPhilipp Reisner 3347b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3348b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3349b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3350b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3351b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3352b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 335338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 335482bc0194SAndreas Gruenbacher return -EIO; 3355b411b363SPhilipp Reisner } 3356b411b363SPhilipp Reisner 3357b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3358b411b363SPhilipp Reisner int skip_initial_sync = 3359b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 336031890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3361b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3362b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3363b411b363SPhilipp Reisner if (skip_initial_sync) { 3364b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3365b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 336620ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 336720ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3368b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3369b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3370b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3371b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3372b411b363SPhilipp Reisner drbd_md_sync(mdev); 337362b0da3aSLars Ellenberg updated_uuids = 1; 3374b411b363SPhilipp Reisner } 3375b411b363SPhilipp Reisner put_ldev(mdev); 337618a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 337718a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 337818a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 337918a50fa2SPhilipp Reisner for me. */ 338062b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3381b411b363SPhilipp Reisner } 3382b411b363SPhilipp Reisner 3383b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3384b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3385b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3386b411b363SPhilipp Reisner new disk state... */ 33878410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 33888410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3389b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 339062b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 339162b0da3aSLars Ellenberg 339262b0da3aSLars Ellenberg if (updated_uuids) 339362b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3394b411b363SPhilipp Reisner 339582bc0194SAndreas Gruenbacher return 0; 3396b411b363SPhilipp Reisner } 3397b411b363SPhilipp Reisner 3398b411b363SPhilipp Reisner /** 3399b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3400b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3401b411b363SPhilipp Reisner */ 3402b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3403b411b363SPhilipp Reisner { 3404b411b363SPhilipp Reisner union drbd_state ms; 3405b411b363SPhilipp Reisner 3406b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3407b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3408b411b363SPhilipp Reisner 3409b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3410b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3411b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3412b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3413b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3414b411b363SPhilipp Reisner }; 3415b411b363SPhilipp Reisner 3416b411b363SPhilipp Reisner ms.i = ps.i; 3417b411b363SPhilipp Reisner 3418b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3419b411b363SPhilipp Reisner ms.peer = ps.role; 3420b411b363SPhilipp Reisner ms.role = ps.peer; 3421b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3422b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3423b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3424b411b363SPhilipp Reisner 3425b411b363SPhilipp Reisner return ms; 3426b411b363SPhilipp Reisner } 3427b411b363SPhilipp Reisner 34284a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3429b411b363SPhilipp Reisner { 34304a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3431e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3432b411b363SPhilipp Reisner union drbd_state mask, val; 3433bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3434b411b363SPhilipp Reisner 34354a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 34364a76b161SAndreas Gruenbacher if (!mdev) 34374a76b161SAndreas Gruenbacher return -EIO; 34384a76b161SAndreas Gruenbacher 3439b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3440b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3441b411b363SPhilipp Reisner 344225703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 34438410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3444b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 344582bc0194SAndreas Gruenbacher return 0; 3446b411b363SPhilipp Reisner } 3447b411b363SPhilipp Reisner 3448b411b363SPhilipp Reisner mask = convert_state(mask); 3449b411b363SPhilipp Reisner val = convert_state(val); 3450b411b363SPhilipp Reisner 3451b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3452b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3453047cd4a6SPhilipp Reisner 3454b411b363SPhilipp Reisner drbd_md_sync(mdev); 3455b411b363SPhilipp Reisner 345682bc0194SAndreas Gruenbacher return 0; 3457b411b363SPhilipp Reisner } 3458b411b363SPhilipp Reisner 3459e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3460dfafcc8aSPhilipp Reisner { 3461e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3462dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3463dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3464dfafcc8aSPhilipp Reisner 3465dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3466dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3467dfafcc8aSPhilipp Reisner 3468dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3469dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3470dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 347182bc0194SAndreas Gruenbacher return 0; 3472dfafcc8aSPhilipp Reisner } 3473dfafcc8aSPhilipp Reisner 3474dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3475dfafcc8aSPhilipp Reisner val = convert_state(val); 3476dfafcc8aSPhilipp Reisner 3477778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3478dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3479dfafcc8aSPhilipp Reisner 348082bc0194SAndreas Gruenbacher return 0; 3481dfafcc8aSPhilipp Reisner } 3482dfafcc8aSPhilipp Reisner 34834a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3484b411b363SPhilipp Reisner { 34854a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3486e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 34874ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3488b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 348965d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3490b411b363SPhilipp Reisner int rv; 3491b411b363SPhilipp Reisner 34924a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 34934a76b161SAndreas Gruenbacher if (!mdev) 34944a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 34954a76b161SAndreas Gruenbacher 3496b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3497b411b363SPhilipp Reisner 3498b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3499b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3500b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3501b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3502b411b363SPhilipp Reisner } 3503b411b363SPhilipp Reisner 350487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3505b411b363SPhilipp Reisner retry: 350678bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 350787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3508b411b363SPhilipp Reisner 3509e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3510e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3511e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3512e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3513e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3514e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3515e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3516e9ef7bb6SLars Ellenberg * syncing states. 3517e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3518e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3519e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3520e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3521e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3522e9ef7bb6SLars Ellenberg 3523e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3524e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3525e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3526e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3527e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3528e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3529e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 353082bc0194SAndreas Gruenbacher return 0; 3531e9ef7bb6SLars Ellenberg } 3532e9ef7bb6SLars Ellenberg } 3533e9ef7bb6SLars Ellenberg 3534e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3535e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3536e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3537e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3538e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3539e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3540e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3541e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3542e9ef7bb6SLars Ellenberg 35434ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 35444ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3545b411b363SPhilipp Reisner 354667531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 354767531718SPhilipp Reisner ns.conn = C_BEHIND; 354867531718SPhilipp Reisner 3549b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3550b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3551b411b363SPhilipp Reisner int cr; /* consider resync */ 3552b411b363SPhilipp Reisner 3553b411b363SPhilipp Reisner /* if we established a new connection */ 35544ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3555b411b363SPhilipp Reisner /* if we had an established connection 3556b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 35574ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3558b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 35594ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3560b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3561b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3562b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3563b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3564b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 35654ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3566b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3567b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3568b411b363SPhilipp Reisner 3569b411b363SPhilipp Reisner if (cr) 35704ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3571b411b363SPhilipp Reisner 3572b411b363SPhilipp Reisner put_ldev(mdev); 35734ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 35744ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3575b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 357682f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3577b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3578b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3579b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3580580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3581b411b363SPhilipp Reisner } else { 35828169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 358382bc0194SAndreas Gruenbacher return -EIO; 35844ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 358538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 358682bc0194SAndreas Gruenbacher return -EIO; 3587b411b363SPhilipp Reisner } 3588b411b363SPhilipp Reisner } 3589b411b363SPhilipp Reisner } 3590b411b363SPhilipp Reisner 359187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 359278bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3593b411b363SPhilipp Reisner goto retry; 3594b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3595b411b363SPhilipp Reisner ns.peer = peer_state.role; 3596b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3597b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 35984ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3599b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 36004ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 36012aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3602481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 36038554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3604481c6f50SPhilipp Reisner for temporal network outages! */ 360587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3606481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 36072f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3608481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3609481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 361038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 361182bc0194SAndreas Gruenbacher return -EIO; 3612481c6f50SPhilipp Reisner } 361365d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 361478bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 361587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3616b411b363SPhilipp Reisner 3617b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 361838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 361982bc0194SAndreas Gruenbacher return -EIO; 3620b411b363SPhilipp Reisner } 3621b411b363SPhilipp Reisner 36224ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 36234ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3624b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3625b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3626b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3627b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3628b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3629b411b363SPhilipp Reisner drbd_send_state(mdev); 3630b411b363SPhilipp Reisner } 3631b411b363SPhilipp Reisner } 3632b411b363SPhilipp Reisner 363389e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3634b411b363SPhilipp Reisner 3635b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3636b411b363SPhilipp Reisner 363782bc0194SAndreas Gruenbacher return 0; 3638b411b363SPhilipp Reisner } 3639b411b363SPhilipp Reisner 36404a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3641b411b363SPhilipp Reisner { 36424a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3643e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 36444a76b161SAndreas Gruenbacher 36454a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36464a76b161SAndreas Gruenbacher if (!mdev) 36474a76b161SAndreas Gruenbacher return -EIO; 3648b411b363SPhilipp Reisner 3649b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3650b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3651c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3652b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3653b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3654b411b363SPhilipp Reisner 3655b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3656b411b363SPhilipp Reisner 3657b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3658b411b363SPhilipp Reisner _not_ be rotated into the history */ 3659b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3660b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3661b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3662b411b363SPhilipp Reisner 366362b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3664b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3665b411b363SPhilipp Reisner 3666b411b363SPhilipp Reisner put_ldev(mdev); 3667b411b363SPhilipp Reisner } else 3668b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3669b411b363SPhilipp Reisner 367082bc0194SAndreas Gruenbacher return 0; 3671b411b363SPhilipp Reisner } 3672b411b363SPhilipp Reisner 36732c46407dSAndreas Gruenbacher /** 36742c46407dSAndreas Gruenbacher * receive_bitmap_plain 36752c46407dSAndreas Gruenbacher * 36762c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36772c46407dSAndreas Gruenbacher * code upon failure. 36782c46407dSAndreas Gruenbacher */ 36792c46407dSAndreas Gruenbacher static int 368050d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 3681e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 3682b411b363SPhilipp Reisner { 368350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 368450d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 3685e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 368650d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 3687e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 36882c46407dSAndreas Gruenbacher int err; 3689b411b363SPhilipp Reisner 369050d0b1adSAndreas Gruenbacher if (want != size) { 369150d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 36922c46407dSAndreas Gruenbacher return -EIO; 3693b411b363SPhilipp Reisner } 3694b411b363SPhilipp Reisner if (want == 0) 36952c46407dSAndreas Gruenbacher return 0; 3696e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 369782bc0194SAndreas Gruenbacher if (err) 36982c46407dSAndreas Gruenbacher return err; 3699b411b363SPhilipp Reisner 3700e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 3701b411b363SPhilipp Reisner 3702b411b363SPhilipp Reisner c->word_offset += num_words; 3703b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3704b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3705b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3706b411b363SPhilipp Reisner 37072c46407dSAndreas Gruenbacher return 1; 3708b411b363SPhilipp Reisner } 3709b411b363SPhilipp Reisner 3710a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 3711a02d1240SAndreas Gruenbacher { 3712a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 3713a02d1240SAndreas Gruenbacher } 3714a02d1240SAndreas Gruenbacher 3715a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 3716a02d1240SAndreas Gruenbacher { 3717a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 3718a02d1240SAndreas Gruenbacher } 3719a02d1240SAndreas Gruenbacher 3720a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 3721a02d1240SAndreas Gruenbacher { 3722a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 3723a02d1240SAndreas Gruenbacher } 3724a02d1240SAndreas Gruenbacher 37252c46407dSAndreas Gruenbacher /** 37262c46407dSAndreas Gruenbacher * recv_bm_rle_bits 37272c46407dSAndreas Gruenbacher * 37282c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 37292c46407dSAndreas Gruenbacher * code upon failure. 37302c46407dSAndreas Gruenbacher */ 37312c46407dSAndreas Gruenbacher static int 3732b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3733b411b363SPhilipp Reisner struct p_compressed_bm *p, 3734c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3735c6d25cfeSPhilipp Reisner unsigned int len) 3736b411b363SPhilipp Reisner { 3737b411b363SPhilipp Reisner struct bitstream bs; 3738b411b363SPhilipp Reisner u64 look_ahead; 3739b411b363SPhilipp Reisner u64 rl; 3740b411b363SPhilipp Reisner u64 tmp; 3741b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3742b411b363SPhilipp Reisner unsigned long e; 3743a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 3744b411b363SPhilipp Reisner int have; 3745b411b363SPhilipp Reisner int bits; 3746b411b363SPhilipp Reisner 3747a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 3748b411b363SPhilipp Reisner 3749b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3750b411b363SPhilipp Reisner if (bits < 0) 37512c46407dSAndreas Gruenbacher return -EIO; 3752b411b363SPhilipp Reisner 3753b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3754b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3755b411b363SPhilipp Reisner if (bits <= 0) 37562c46407dSAndreas Gruenbacher return -EIO; 3757b411b363SPhilipp Reisner 3758b411b363SPhilipp Reisner if (toggle) { 3759b411b363SPhilipp Reisner e = s + rl -1; 3760b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3761b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 37622c46407dSAndreas Gruenbacher return -EIO; 3763b411b363SPhilipp Reisner } 3764b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3765b411b363SPhilipp Reisner } 3766b411b363SPhilipp Reisner 3767b411b363SPhilipp Reisner if (have < bits) { 3768b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3769b411b363SPhilipp Reisner have, bits, look_ahead, 3770b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3771b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 37722c46407dSAndreas Gruenbacher return -EIO; 3773b411b363SPhilipp Reisner } 3774b411b363SPhilipp Reisner look_ahead >>= bits; 3775b411b363SPhilipp Reisner have -= bits; 3776b411b363SPhilipp Reisner 3777b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3778b411b363SPhilipp Reisner if (bits < 0) 37792c46407dSAndreas Gruenbacher return -EIO; 3780b411b363SPhilipp Reisner look_ahead |= tmp << have; 3781b411b363SPhilipp Reisner have += bits; 3782b411b363SPhilipp Reisner } 3783b411b363SPhilipp Reisner 3784b411b363SPhilipp Reisner c->bit_offset = s; 3785b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3786b411b363SPhilipp Reisner 37872c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3788b411b363SPhilipp Reisner } 3789b411b363SPhilipp Reisner 37902c46407dSAndreas Gruenbacher /** 37912c46407dSAndreas Gruenbacher * decode_bitmap_c 37922c46407dSAndreas Gruenbacher * 37932c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 37942c46407dSAndreas Gruenbacher * code upon failure. 37952c46407dSAndreas Gruenbacher */ 37962c46407dSAndreas Gruenbacher static int 3797b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3798b411b363SPhilipp Reisner struct p_compressed_bm *p, 3799c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3800c6d25cfeSPhilipp Reisner unsigned int len) 3801b411b363SPhilipp Reisner { 3802a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 3803e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 3804b411b363SPhilipp Reisner 3805b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3806b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3807b411b363SPhilipp Reisner * during all our tests. */ 3808b411b363SPhilipp Reisner 3809b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 381038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 38112c46407dSAndreas Gruenbacher return -EIO; 3812b411b363SPhilipp Reisner } 3813b411b363SPhilipp Reisner 3814b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3815b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3816b411b363SPhilipp Reisner { 3817b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 381850d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 381950d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 382050d0b1adSAndreas Gruenbacher unsigned int plain = 382150d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 382250d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 382350d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 382450d0b1adSAndreas Gruenbacher unsigned int r; 3825b411b363SPhilipp Reisner 3826b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3827b411b363SPhilipp Reisner if (total == 0) 3828b411b363SPhilipp Reisner return; 3829b411b363SPhilipp Reisner 3830b411b363SPhilipp Reisner /* don't report if not compressed */ 3831b411b363SPhilipp Reisner if (total >= plain) 3832b411b363SPhilipp Reisner return; 3833b411b363SPhilipp Reisner 3834b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3835b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3836b411b363SPhilipp Reisner : (1000 * total / plain); 3837b411b363SPhilipp Reisner 3838b411b363SPhilipp Reisner if (r > 1000) 3839b411b363SPhilipp Reisner r = 1000; 3840b411b363SPhilipp Reisner 3841b411b363SPhilipp Reisner r = 1000 - r; 3842b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3843b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3844b411b363SPhilipp Reisner direction, 3845b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3846b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3847b411b363SPhilipp Reisner total, r/10, r % 10); 3848b411b363SPhilipp Reisner } 3849b411b363SPhilipp Reisner 3850b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3851b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3852b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3853b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3854b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3855b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3856b411b363SPhilipp Reisner 3857b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 38584a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 3859b411b363SPhilipp Reisner { 38604a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3861b411b363SPhilipp Reisner struct bm_xfer_ctx c; 38622c46407dSAndreas Gruenbacher int err; 38634a76b161SAndreas Gruenbacher 38644a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38654a76b161SAndreas Gruenbacher if (!mdev) 38664a76b161SAndreas Gruenbacher return -EIO; 3867b411b363SPhilipp Reisner 386820ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 386920ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 387020ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3871b411b363SPhilipp Reisner 3872b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3873b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3874b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3875b411b363SPhilipp Reisner }; 3876b411b363SPhilipp Reisner 38772c46407dSAndreas Gruenbacher for(;;) { 3878e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 3879e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 3880e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 3881b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3882b411b363SPhilipp Reisner * and the feature is enabled! */ 3883e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 3884b411b363SPhilipp Reisner 388550d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 3886b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 388782bc0194SAndreas Gruenbacher err = -EIO; 3888b411b363SPhilipp Reisner goto out; 3889b411b363SPhilipp Reisner } 3890e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 3891e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 389282bc0194SAndreas Gruenbacher err = -EIO; 389378fcbdaeSAndreas Gruenbacher goto out; 3894b411b363SPhilipp Reisner } 3895e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 3896e658983aSAndreas Gruenbacher if (err) 3897e658983aSAndreas Gruenbacher goto out; 3898e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 3899b411b363SPhilipp Reisner } else { 3900e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 390182bc0194SAndreas Gruenbacher err = -EIO; 3902b411b363SPhilipp Reisner goto out; 3903b411b363SPhilipp Reisner } 3904b411b363SPhilipp Reisner 3905e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 390650d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 3907b411b363SPhilipp Reisner 39082c46407dSAndreas Gruenbacher if (err <= 0) { 39092c46407dSAndreas Gruenbacher if (err < 0) 39102c46407dSAndreas Gruenbacher goto out; 3911b411b363SPhilipp Reisner break; 39122c46407dSAndreas Gruenbacher } 3913e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 391482bc0194SAndreas Gruenbacher if (err) 3915b411b363SPhilipp Reisner goto out; 39162c46407dSAndreas Gruenbacher } 3917b411b363SPhilipp Reisner 3918b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3919b411b363SPhilipp Reisner 3920b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3921de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3922de1f8e4aSAndreas Gruenbacher 392382bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 392482bc0194SAndreas Gruenbacher if (err) 3925b411b363SPhilipp Reisner goto out; 3926b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3927de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3928de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3929b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3930b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3931b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3932b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3933b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3934b411b363SPhilipp Reisner } 393582bc0194SAndreas Gruenbacher err = 0; 3936b411b363SPhilipp Reisner 3937b411b363SPhilipp Reisner out: 393820ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 393982bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 3940b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 394182bc0194SAndreas Gruenbacher return err; 3942b411b363SPhilipp Reisner } 3943b411b363SPhilipp Reisner 39444a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 3945b411b363SPhilipp Reisner { 39464a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 3947e2857216SAndreas Gruenbacher pi->cmd, pi->size); 39482de876efSPhilipp Reisner 39494a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 39502de876efSPhilipp Reisner } 39512de876efSPhilipp Reisner 39524a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 3953b411b363SPhilipp Reisner { 3954b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3955b411b363SPhilipp Reisner * with the data requests being unplugged */ 39564a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 3957b411b363SPhilipp Reisner 395882bc0194SAndreas Gruenbacher return 0; 3959b411b363SPhilipp Reisner } 3960b411b363SPhilipp Reisner 39614a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 396273a01a18SPhilipp Reisner { 39634a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3964e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 39654a76b161SAndreas Gruenbacher 39664a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 39674a76b161SAndreas Gruenbacher if (!mdev) 39684a76b161SAndreas Gruenbacher return -EIO; 396973a01a18SPhilipp Reisner 3970f735e363SLars Ellenberg switch (mdev->state.conn) { 3971f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3972f735e363SLars Ellenberg case C_WF_BITMAP_T: 3973f735e363SLars Ellenberg case C_BEHIND: 3974f735e363SLars Ellenberg break; 3975f735e363SLars Ellenberg default: 3976f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3977f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3978f735e363SLars Ellenberg } 3979f735e363SLars Ellenberg 398073a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 398173a01a18SPhilipp Reisner 398282bc0194SAndreas Gruenbacher return 0; 398373a01a18SPhilipp Reisner } 398473a01a18SPhilipp Reisner 398502918be2SPhilipp Reisner struct data_cmd { 398602918be2SPhilipp Reisner int expect_payload; 398702918be2SPhilipp Reisner size_t pkt_size; 39884a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 3989b411b363SPhilipp Reisner }; 3990b411b363SPhilipp Reisner 399102918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 39924a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 39934a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 39944a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 39954a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 3996e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 3997e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 3998e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 39994a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 40004a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4001e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4002e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 40034a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 40044a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 40054a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 40064a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 40074a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 40084a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 40094a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 40104a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 40114a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 40124a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 40134a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 40144a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 401502918be2SPhilipp Reisner }; 401602918be2SPhilipp Reisner 4017eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4018b411b363SPhilipp Reisner { 401977351055SPhilipp Reisner struct packet_info pi; 402002918be2SPhilipp Reisner size_t shs; /* sub header size */ 402182bc0194SAndreas Gruenbacher int err; 4022b411b363SPhilipp Reisner 4023eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4024deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4025deebe195SAndreas Gruenbacher 4026eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 402769bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 402802918be2SPhilipp Reisner goto err_out; 402902918be2SPhilipp Reisner 4030deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 40314a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 4032eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 403302918be2SPhilipp Reisner goto err_out; 40340b33a916SLars Ellenberg } 4035b411b363SPhilipp Reisner 4036e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4037e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 4038eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 4039c13f7e1aSLars Ellenberg goto err_out; 4040c13f7e1aSLars Ellenberg } 4041c13f7e1aSLars Ellenberg 4042c13f7e1aSLars Ellenberg if (shs) { 4043e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4044a5c31904SAndreas Gruenbacher if (err) 404502918be2SPhilipp Reisner goto err_out; 4046e2857216SAndreas Gruenbacher pi.size -= shs; 4047b411b363SPhilipp Reisner } 404802918be2SPhilipp Reisner 40494a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 40504a76b161SAndreas Gruenbacher if (err) { 40519f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 40529f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 405302918be2SPhilipp Reisner goto err_out; 4054b411b363SPhilipp Reisner } 4055b411b363SPhilipp Reisner } 405682bc0194SAndreas Gruenbacher return; 405702918be2SPhilipp Reisner 405802918be2SPhilipp Reisner err_out: 4059bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4060b411b363SPhilipp Reisner } 4061b411b363SPhilipp Reisner 40620e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4063b411b363SPhilipp Reisner { 4064b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4065b411b363SPhilipp Reisner 4066b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 40670e29d163SPhilipp Reisner barr.w.tconn = tconn; 4068b411b363SPhilipp Reisner init_completion(&barr.done); 40690e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4070b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4071b411b363SPhilipp Reisner } 4072b411b363SPhilipp Reisner 4073360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 4074b411b363SPhilipp Reisner { 4075bbeb641cSPhilipp Reisner enum drbd_conns oc; 4076b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 4077b411b363SPhilipp Reisner 4078bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4079b411b363SPhilipp Reisner return; 4080b411b363SPhilipp Reisner 4081b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4082360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4083360cc740SPhilipp Reisner drbd_free_sock(tconn); 4084360cc740SPhilipp Reisner 4085360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 4086360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4087360cc740SPhilipp Reisner 4088cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4089cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4090cb703454SPhilipp Reisner 4091360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4092bbeb641cSPhilipp Reisner oc = tconn->cstate; 4093bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4094bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4095bbeb641cSPhilipp Reisner 4096360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4097360cc740SPhilipp Reisner 4098bbeb641cSPhilipp Reisner if (oc == C_DISCONNECTING) { 4099360cc740SPhilipp Reisner wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0); 4100360cc740SPhilipp Reisner 4101360cc740SPhilipp Reisner crypto_free_hash(tconn->cram_hmac_tfm); 4102360cc740SPhilipp Reisner tconn->cram_hmac_tfm = NULL; 4103360cc740SPhilipp Reisner 4104360cc740SPhilipp Reisner kfree(tconn->net_conf); 4105360cc740SPhilipp Reisner tconn->net_conf = NULL; 4106bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE); 4107360cc740SPhilipp Reisner } 4108360cc740SPhilipp Reisner } 4109360cc740SPhilipp Reisner 4110360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 4111360cc740SPhilipp Reisner { 4112360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 4113360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4114360cc740SPhilipp Reisner unsigned int i; 4115b411b363SPhilipp Reisner 411685719573SPhilipp Reisner /* wait for current activity to cease. */ 411787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4118b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4119b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4120b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 412187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4122b411b363SPhilipp Reisner 4123b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4124b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4125b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4126b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4127b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4128b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4129b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4130b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4131b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4132b411b363SPhilipp Reisner * on the fly. */ 4133b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4134b411b363SPhilipp Reisner mdev->rs_total = 0; 4135b411b363SPhilipp Reisner mdev->rs_failed = 0; 4136b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4137b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4138b411b363SPhilipp Reisner 41397fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 41407fde2be9SPhilipp Reisner 4141b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4142b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4143b411b363SPhilipp Reisner 4144b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4145b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4146b411b363SPhilipp Reisner * to be "canceled" */ 4147a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4148b411b363SPhilipp Reisner 4149b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 4150b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 4151b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 4152b411b363SPhilipp Reisner 4153b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4154b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4155b411b363SPhilipp Reisner 41562aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 41572f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4158b411b363SPhilipp Reisner 4159b411b363SPhilipp Reisner drbd_md_sync(mdev); 4160b411b363SPhilipp Reisner 4161b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4162b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4163b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 4164b411b363SPhilipp Reisner put_ldev(mdev); 4165b411b363SPhilipp Reisner } 4166b411b363SPhilipp Reisner 416720ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 416820ceb2b2SLars Ellenberg * if any. */ 416920ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 417020ceb2b2SLars Ellenberg 4171b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4172b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4173b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4174b411b363SPhilipp Reisner * 4175b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4176b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4177b411b363SPhilipp Reisner */ 4178b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 4179b411b363SPhilipp Reisner if (i) 4180b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4181435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4182435f0740SLars Ellenberg if (i) 4183435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4184b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4185b411b363SPhilipp Reisner if (i) 418645bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4187b411b363SPhilipp Reisner 4188b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4189b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4190b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4191b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4192b411b363SPhilipp Reisner 4193b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4194b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4195b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4196360cc740SPhilipp Reisner 4197360cc740SPhilipp Reisner return 0; 4198b411b363SPhilipp Reisner } 4199b411b363SPhilipp Reisner 4200b411b363SPhilipp Reisner /* 4201b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4202b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4203b411b363SPhilipp Reisner * 4204b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4205b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4206b411b363SPhilipp Reisner * 4207b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4208b411b363SPhilipp Reisner */ 42096038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4210b411b363SPhilipp Reisner { 42119f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 42129f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4213b411b363SPhilipp Reisner 42149f5bdc33SAndreas Gruenbacher sock = &tconn->data; 42159f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 42169f5bdc33SAndreas Gruenbacher if (!p) 4217e8d17b01SAndreas Gruenbacher return -EIO; 4218b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4219b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4220b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 42219f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4222b411b363SPhilipp Reisner } 4223b411b363SPhilipp Reisner 4224b411b363SPhilipp Reisner /* 4225b411b363SPhilipp Reisner * return values: 4226b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4227b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4228b411b363SPhilipp Reisner * -1 peer talks different language, 4229b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4230b411b363SPhilipp Reisner */ 42316038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4232b411b363SPhilipp Reisner { 423365d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4234e658983aSAndreas Gruenbacher struct p_connection_features *p; 4235e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 423677351055SPhilipp Reisner struct packet_info pi; 4237a5c31904SAndreas Gruenbacher int err; 4238b411b363SPhilipp Reisner 42396038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4240e8d17b01SAndreas Gruenbacher if (err) 4241b411b363SPhilipp Reisner return 0; 4242b411b363SPhilipp Reisner 424369bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 424469bc7bc3SAndreas Gruenbacher if (err) 4245b411b363SPhilipp Reisner return 0; 4246b411b363SPhilipp Reisner 42476038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 42486038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 424977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4250b411b363SPhilipp Reisner return -1; 4251b411b363SPhilipp Reisner } 4252b411b363SPhilipp Reisner 425377351055SPhilipp Reisner if (pi.size != expect) { 42546038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 425577351055SPhilipp Reisner expect, pi.size); 4256b411b363SPhilipp Reisner return -1; 4257b411b363SPhilipp Reisner } 4258b411b363SPhilipp Reisner 4259e658983aSAndreas Gruenbacher p = pi.data; 4260e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4261a5c31904SAndreas Gruenbacher if (err) 4262b411b363SPhilipp Reisner return 0; 4263b411b363SPhilipp Reisner 4264b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4265b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4266b411b363SPhilipp Reisner if (p->protocol_max == 0) 4267b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4268b411b363SPhilipp Reisner 4269b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4270b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4271b411b363SPhilipp Reisner goto incompat; 4272b411b363SPhilipp Reisner 427365d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4274b411b363SPhilipp Reisner 427565d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 427665d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4277b411b363SPhilipp Reisner 4278b411b363SPhilipp Reisner return 1; 4279b411b363SPhilipp Reisner 4280b411b363SPhilipp Reisner incompat: 428165d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4282b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4283b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4284b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4285b411b363SPhilipp Reisner return -1; 4286b411b363SPhilipp Reisner } 4287b411b363SPhilipp Reisner 4288b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 428913e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4290b411b363SPhilipp Reisner { 4291b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4292b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4293b10d96cbSJohannes Thoma return -1; 4294b411b363SPhilipp Reisner } 4295b411b363SPhilipp Reisner #else 4296b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4297b10d96cbSJohannes Thoma 4298b10d96cbSJohannes Thoma /* Return value: 4299b10d96cbSJohannes Thoma 1 - auth succeeded, 4300b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4301b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4302b10d96cbSJohannes Thoma */ 4303b10d96cbSJohannes Thoma 430413e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4305b411b363SPhilipp Reisner { 43069f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4307b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4308b411b363SPhilipp Reisner struct scatterlist sg; 4309b411b363SPhilipp Reisner char *response = NULL; 4310b411b363SPhilipp Reisner char *right_response = NULL; 4311b411b363SPhilipp Reisner char *peers_ch = NULL; 431213e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4313b411b363SPhilipp Reisner unsigned int resp_size; 4314b411b363SPhilipp Reisner struct hash_desc desc; 431577351055SPhilipp Reisner struct packet_info pi; 431669bc7bc3SAndreas Gruenbacher int err, rv; 4317b411b363SPhilipp Reisner 43189f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 43199f5bdc33SAndreas Gruenbacher 432013e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4321b411b363SPhilipp Reisner desc.flags = 0; 4322b411b363SPhilipp Reisner 432313e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 432413e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4325b411b363SPhilipp Reisner if (rv) { 432613e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4327b10d96cbSJohannes Thoma rv = -1; 4328b411b363SPhilipp Reisner goto fail; 4329b411b363SPhilipp Reisner } 4330b411b363SPhilipp Reisner 4331b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4332b411b363SPhilipp Reisner 43339f5bdc33SAndreas Gruenbacher sock = &tconn->data; 43349f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 43359f5bdc33SAndreas Gruenbacher rv = 0; 43369f5bdc33SAndreas Gruenbacher goto fail; 43379f5bdc33SAndreas Gruenbacher } 4338e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 43399f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4340b411b363SPhilipp Reisner if (!rv) 4341b411b363SPhilipp Reisner goto fail; 4342b411b363SPhilipp Reisner 434369bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 434469bc7bc3SAndreas Gruenbacher if (err) { 434569bc7bc3SAndreas Gruenbacher rv = 0; 4346b411b363SPhilipp Reisner goto fail; 434769bc7bc3SAndreas Gruenbacher } 4348b411b363SPhilipp Reisner 434977351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 435013e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 435177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4352b411b363SPhilipp Reisner rv = 0; 4353b411b363SPhilipp Reisner goto fail; 4354b411b363SPhilipp Reisner } 4355b411b363SPhilipp Reisner 435677351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 435713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4358b10d96cbSJohannes Thoma rv = -1; 4359b411b363SPhilipp Reisner goto fail; 4360b411b363SPhilipp Reisner } 4361b411b363SPhilipp Reisner 436277351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4363b411b363SPhilipp Reisner if (peers_ch == NULL) { 436413e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4365b10d96cbSJohannes Thoma rv = -1; 4366b411b363SPhilipp Reisner goto fail; 4367b411b363SPhilipp Reisner } 4368b411b363SPhilipp Reisner 4369a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4370a5c31904SAndreas Gruenbacher if (err) { 4371b411b363SPhilipp Reisner rv = 0; 4372b411b363SPhilipp Reisner goto fail; 4373b411b363SPhilipp Reisner } 4374b411b363SPhilipp Reisner 437513e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4376b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4377b411b363SPhilipp Reisner if (response == NULL) { 437813e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4379b10d96cbSJohannes Thoma rv = -1; 4380b411b363SPhilipp Reisner goto fail; 4381b411b363SPhilipp Reisner } 4382b411b363SPhilipp Reisner 4383b411b363SPhilipp Reisner sg_init_table(&sg, 1); 438477351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4385b411b363SPhilipp Reisner 4386b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4387b411b363SPhilipp Reisner if (rv) { 438813e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4389b10d96cbSJohannes Thoma rv = -1; 4390b411b363SPhilipp Reisner goto fail; 4391b411b363SPhilipp Reisner } 4392b411b363SPhilipp Reisner 43939f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 43949f5bdc33SAndreas Gruenbacher rv = 0; 43959f5bdc33SAndreas Gruenbacher goto fail; 43969f5bdc33SAndreas Gruenbacher } 4397e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 43989f5bdc33SAndreas Gruenbacher response, resp_size); 4399b411b363SPhilipp Reisner if (!rv) 4400b411b363SPhilipp Reisner goto fail; 4401b411b363SPhilipp Reisner 440269bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 440369bc7bc3SAndreas Gruenbacher if (err) { 440469bc7bc3SAndreas Gruenbacher rv = 0; 4405b411b363SPhilipp Reisner goto fail; 440669bc7bc3SAndreas Gruenbacher } 4407b411b363SPhilipp Reisner 440877351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 440913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 441077351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4411b411b363SPhilipp Reisner rv = 0; 4412b411b363SPhilipp Reisner goto fail; 4413b411b363SPhilipp Reisner } 4414b411b363SPhilipp Reisner 441577351055SPhilipp Reisner if (pi.size != resp_size) { 441613e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4417b411b363SPhilipp Reisner rv = 0; 4418b411b363SPhilipp Reisner goto fail; 4419b411b363SPhilipp Reisner } 4420b411b363SPhilipp Reisner 4421a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4422a5c31904SAndreas Gruenbacher if (err) { 4423b411b363SPhilipp Reisner rv = 0; 4424b411b363SPhilipp Reisner goto fail; 4425b411b363SPhilipp Reisner } 4426b411b363SPhilipp Reisner 4427b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 44282d1ee87dSJulia Lawall if (right_response == NULL) { 442913e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4430b10d96cbSJohannes Thoma rv = -1; 4431b411b363SPhilipp Reisner goto fail; 4432b411b363SPhilipp Reisner } 4433b411b363SPhilipp Reisner 4434b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4435b411b363SPhilipp Reisner 4436b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4437b411b363SPhilipp Reisner if (rv) { 443813e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4439b10d96cbSJohannes Thoma rv = -1; 4440b411b363SPhilipp Reisner goto fail; 4441b411b363SPhilipp Reisner } 4442b411b363SPhilipp Reisner 4443b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4444b411b363SPhilipp Reisner 4445b411b363SPhilipp Reisner if (rv) 444613e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 444713e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4448b10d96cbSJohannes Thoma else 4449b10d96cbSJohannes Thoma rv = -1; 4450b411b363SPhilipp Reisner 4451b411b363SPhilipp Reisner fail: 4452b411b363SPhilipp Reisner kfree(peers_ch); 4453b411b363SPhilipp Reisner kfree(response); 4454b411b363SPhilipp Reisner kfree(right_response); 4455b411b363SPhilipp Reisner 4456b411b363SPhilipp Reisner return rv; 4457b411b363SPhilipp Reisner } 4458b411b363SPhilipp Reisner #endif 4459b411b363SPhilipp Reisner 4460b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4461b411b363SPhilipp Reisner { 4462392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4463b411b363SPhilipp Reisner int h; 4464b411b363SPhilipp Reisner 44654d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4466b411b363SPhilipp Reisner 4467b411b363SPhilipp Reisner do { 44684d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4469b411b363SPhilipp Reisner if (h == 0) { 44704d641dd7SPhilipp Reisner drbd_disconnect(tconn); 447120ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4472b411b363SPhilipp Reisner } 4473b411b363SPhilipp Reisner if (h == -1) { 44744d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4475bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4476b411b363SPhilipp Reisner } 4477b411b363SPhilipp Reisner } while (h == 0); 4478b411b363SPhilipp Reisner 4479b411b363SPhilipp Reisner if (h > 0) { 44804d641dd7SPhilipp Reisner if (get_net_conf(tconn)) { 44814d641dd7SPhilipp Reisner drbdd(tconn); 44824d641dd7SPhilipp Reisner put_net_conf(tconn); 4483b411b363SPhilipp Reisner } 4484b411b363SPhilipp Reisner } 4485b411b363SPhilipp Reisner 44864d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4487b411b363SPhilipp Reisner 44884d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4489b411b363SPhilipp Reisner return 0; 4490b411b363SPhilipp Reisner } 4491b411b363SPhilipp Reisner 4492b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4493b411b363SPhilipp Reisner 4494e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4495b411b363SPhilipp Reisner { 4496e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4497b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4498b411b363SPhilipp Reisner 4499fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4500fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4501fc3b10a4SPhilipp Reisner } else { 4502fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4503fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4504fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4505fc3b10a4SPhilipp Reisner } 4506fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4507e4f78edeSPhilipp Reisner 45082735a594SAndreas Gruenbacher return 0; 4509fc3b10a4SPhilipp Reisner } 4510e4f78edeSPhilipp Reisner 45111952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4512e4f78edeSPhilipp Reisner { 45131952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4514e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4515e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4516e4f78edeSPhilipp Reisner 45171952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 45181952e916SAndreas Gruenbacher if (!mdev) 45192735a594SAndreas Gruenbacher return -EIO; 45201952e916SAndreas Gruenbacher 4521e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4522e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4523e4f78edeSPhilipp Reisner } else { 4524e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4525e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4526e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4527e4f78edeSPhilipp Reisner } 4528e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4529e4f78edeSPhilipp Reisner 45302735a594SAndreas Gruenbacher return 0; 4531b411b363SPhilipp Reisner } 4532b411b363SPhilipp Reisner 4533e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4534b411b363SPhilipp Reisner { 45352735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4536b411b363SPhilipp Reisner 4537b411b363SPhilipp Reisner } 4538b411b363SPhilipp Reisner 4539e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4540b411b363SPhilipp Reisner { 4541b411b363SPhilipp Reisner /* restore idle timeout */ 45422a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 45432a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 45442a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4545b411b363SPhilipp Reisner 45462735a594SAndreas Gruenbacher return 0; 4547b411b363SPhilipp Reisner } 4548b411b363SPhilipp Reisner 45491952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4550b411b363SPhilipp Reisner { 45511952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4552e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4553b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4554b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4555b411b363SPhilipp Reisner 45561952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 45571952e916SAndreas Gruenbacher if (!mdev) 45582735a594SAndreas Gruenbacher return -EIO; 45591952e916SAndreas Gruenbacher 456031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4561b411b363SPhilipp Reisner 4562b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4563b411b363SPhilipp Reisner 45641d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4565b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4566b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4567b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4568b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 45691d53f09eSLars Ellenberg put_ldev(mdev); 45701d53f09eSLars Ellenberg } 4571b411b363SPhilipp Reisner dec_rs_pending(mdev); 4572778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4573b411b363SPhilipp Reisner 45742735a594SAndreas Gruenbacher return 0; 4575b411b363SPhilipp Reisner } 4576b411b363SPhilipp Reisner 4577bc9c5c41SAndreas Gruenbacher static int 4578bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4579bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4580bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4581b411b363SPhilipp Reisner { 4582b411b363SPhilipp Reisner struct drbd_request *req; 4583b411b363SPhilipp Reisner struct bio_and_error m; 4584b411b363SPhilipp Reisner 458587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4586bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4587b411b363SPhilipp Reisner if (unlikely(!req)) { 458887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 458985997675SAndreas Gruenbacher return -EIO; 4590b411b363SPhilipp Reisner } 4591b411b363SPhilipp Reisner __req_mod(req, what, &m); 459287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4593b411b363SPhilipp Reisner 4594b411b363SPhilipp Reisner if (m.bio) 4595b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 459685997675SAndreas Gruenbacher return 0; 4597b411b363SPhilipp Reisner } 4598b411b363SPhilipp Reisner 45991952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4600b411b363SPhilipp Reisner { 46011952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4602e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4603b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4604b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4605b411b363SPhilipp Reisner enum drbd_req_event what; 4606b411b363SPhilipp Reisner 46071952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 46081952e916SAndreas Gruenbacher if (!mdev) 46092735a594SAndreas Gruenbacher return -EIO; 46101952e916SAndreas Gruenbacher 4611b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4612b411b363SPhilipp Reisner 4613579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4614b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4615b411b363SPhilipp Reisner dec_rs_pending(mdev); 46162735a594SAndreas Gruenbacher return 0; 4617b411b363SPhilipp Reisner } 4618e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4619b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 462089e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46218554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4622b411b363SPhilipp Reisner break; 4623b411b363SPhilipp Reisner case P_WRITE_ACK: 462489e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46258554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4626b411b363SPhilipp Reisner break; 4627b411b363SPhilipp Reisner case P_RECV_ACK: 462889e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 46298554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4630b411b363SPhilipp Reisner break; 46317be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 463289e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46337be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 46347be8da07SAndreas Gruenbacher break; 46357be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 46367be8da07SAndreas Gruenbacher D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46377be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4638b411b363SPhilipp Reisner break; 4639b411b363SPhilipp Reisner default: 46402735a594SAndreas Gruenbacher BUG(); 4641b411b363SPhilipp Reisner } 4642b411b363SPhilipp Reisner 46432735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4644bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4645bc9c5c41SAndreas Gruenbacher what, false); 4646b411b363SPhilipp Reisner } 4647b411b363SPhilipp Reisner 46481952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 4649b411b363SPhilipp Reisner { 46501952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4651e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4652b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 46532deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 46541952e916SAndreas Gruenbacher bool missing_ok = tconn->net_conf->wire_protocol == DRBD_PROT_A || 46551952e916SAndreas Gruenbacher tconn->net_conf->wire_protocol == DRBD_PROT_B; 465685997675SAndreas Gruenbacher int err; 4657b411b363SPhilipp Reisner 46581952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 46591952e916SAndreas Gruenbacher if (!mdev) 46602735a594SAndreas Gruenbacher return -EIO; 46611952e916SAndreas Gruenbacher 4662b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4663b411b363SPhilipp Reisner 4664579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4665b411b363SPhilipp Reisner dec_rs_pending(mdev); 4666b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 46672735a594SAndreas Gruenbacher return 0; 4668b411b363SPhilipp Reisner } 46692deb8336SPhilipp Reisner 467085997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 4671bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 46728554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 467385997675SAndreas Gruenbacher if (err) { 46742deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 46752deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4676c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 46772deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 46782deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4679c3afd8f5SAndreas Gruenbacher if (!missing_ok) 46802735a594SAndreas Gruenbacher return err; 4681c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 46822deb8336SPhilipp Reisner } 46832735a594SAndreas Gruenbacher return 0; 4684b411b363SPhilipp Reisner } 4685b411b363SPhilipp Reisner 46861952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4687b411b363SPhilipp Reisner { 46881952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4689e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4690b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4691b411b363SPhilipp Reisner 46921952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 46931952e916SAndreas Gruenbacher if (!mdev) 46942735a594SAndreas Gruenbacher return -EIO; 46951952e916SAndreas Gruenbacher 4696b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 46977be8da07SAndreas Gruenbacher 4698b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4699b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4700b411b363SPhilipp Reisner 47012735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4702bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 47038554df1cSAndreas Gruenbacher NEG_ACKED, false); 4704b411b363SPhilipp Reisner } 4705b411b363SPhilipp Reisner 47061952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4707b411b363SPhilipp Reisner { 47081952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4709b411b363SPhilipp Reisner sector_t sector; 4710b411b363SPhilipp Reisner int size; 4711e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 47121952e916SAndreas Gruenbacher 47131952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47141952e916SAndreas Gruenbacher if (!mdev) 47152735a594SAndreas Gruenbacher return -EIO; 4716b411b363SPhilipp Reisner 4717b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4718b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4719b411b363SPhilipp Reisner 4720b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4721b411b363SPhilipp Reisner 4722b411b363SPhilipp Reisner dec_rs_pending(mdev); 4723b411b363SPhilipp Reisner 4724b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4725b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4726e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4727d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4728b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4729d612d309SPhilipp Reisner case P_RS_CANCEL: 4730d612d309SPhilipp Reisner break; 4731d612d309SPhilipp Reisner default: 47322735a594SAndreas Gruenbacher BUG(); 4733d612d309SPhilipp Reisner } 4734b411b363SPhilipp Reisner put_ldev(mdev); 4735b411b363SPhilipp Reisner } 4736b411b363SPhilipp Reisner 47372735a594SAndreas Gruenbacher return 0; 4738b411b363SPhilipp Reisner } 4739b411b363SPhilipp Reisner 47401952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 4741b411b363SPhilipp Reisner { 47421952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4743e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 47441952e916SAndreas Gruenbacher 47451952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47461952e916SAndreas Gruenbacher if (!mdev) 47472735a594SAndreas Gruenbacher return -EIO; 4748b411b363SPhilipp Reisner 47492f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4750b411b363SPhilipp Reisner 4751c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4752c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4753370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4754370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4755370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4756c4752ef1SPhilipp Reisner } 4757c4752ef1SPhilipp Reisner 47582735a594SAndreas Gruenbacher return 0; 4759b411b363SPhilipp Reisner } 4760b411b363SPhilipp Reisner 47611952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 4762b411b363SPhilipp Reisner { 47631952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4764e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4765b411b363SPhilipp Reisner struct drbd_work *w; 4766b411b363SPhilipp Reisner sector_t sector; 4767b411b363SPhilipp Reisner int size; 4768b411b363SPhilipp Reisner 47691952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47701952e916SAndreas Gruenbacher if (!mdev) 47712735a594SAndreas Gruenbacher return -EIO; 47721952e916SAndreas Gruenbacher 4773b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4774b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4775b411b363SPhilipp Reisner 4776b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4777b411b363SPhilipp Reisner 4778b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 47798f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 4780b411b363SPhilipp Reisner else 47818f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4782b411b363SPhilipp Reisner 47831d53f09eSLars Ellenberg if (!get_ldev(mdev)) 47842735a594SAndreas Gruenbacher return 0; 47851d53f09eSLars Ellenberg 4786b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4787b411b363SPhilipp Reisner dec_rs_pending(mdev); 4788b411b363SPhilipp Reisner 4789ea5442afSLars Ellenberg --mdev->ov_left; 4790ea5442afSLars Ellenberg 4791ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4792ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4793ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4794ea5442afSLars Ellenberg 4795ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4796b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4797b411b363SPhilipp Reisner if (w) { 4798b411b363SPhilipp Reisner w->cb = w_ov_finished; 4799a21e9298SPhilipp Reisner w->mdev = mdev; 4800e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4801b411b363SPhilipp Reisner } else { 4802b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 48038f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4804b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4805b411b363SPhilipp Reisner } 4806b411b363SPhilipp Reisner } 48071d53f09eSLars Ellenberg put_ldev(mdev); 48082735a594SAndreas Gruenbacher return 0; 4809b411b363SPhilipp Reisner } 4810b411b363SPhilipp Reisner 48111952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 48120ced55a3SPhilipp Reisner { 48132735a594SAndreas Gruenbacher return 0; 48140ced55a3SPhilipp Reisner } 48150ced55a3SPhilipp Reisner 481632862ec7SPhilipp Reisner static int tconn_process_done_ee(struct drbd_tconn *tconn) 481732862ec7SPhilipp Reisner { 4818082a3439SPhilipp Reisner struct drbd_conf *mdev; 4819082a3439SPhilipp Reisner int i, not_empty = 0; 482032862ec7SPhilipp Reisner 482132862ec7SPhilipp Reisner do { 482232862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 482332862ec7SPhilipp Reisner flush_signals(current); 4824082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4825e2b3032bSAndreas Gruenbacher if (drbd_process_done_ee(mdev)) 4826082a3439SPhilipp Reisner return 1; /* error */ 4827082a3439SPhilipp Reisner } 482832862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 4829082a3439SPhilipp Reisner 4830082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4831082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4832082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 4833082a3439SPhilipp Reisner if (not_empty) 4834082a3439SPhilipp Reisner break; 4835082a3439SPhilipp Reisner } 4836082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 483732862ec7SPhilipp Reisner } while (not_empty); 483832862ec7SPhilipp Reisner 483932862ec7SPhilipp Reisner return 0; 484032862ec7SPhilipp Reisner } 484132862ec7SPhilipp Reisner 48427201b972SAndreas Gruenbacher struct asender_cmd { 48437201b972SAndreas Gruenbacher size_t pkt_size; 48441952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 48457201b972SAndreas Gruenbacher }; 48467201b972SAndreas Gruenbacher 48477201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 4848e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 4849e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 48501952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 48511952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 48521952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 48531952e916SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 48541952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 48551952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 48561952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 48571952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 48581952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 48591952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 48601952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 48611952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 48621952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 48631952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 48641952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 48657201b972SAndreas Gruenbacher }; 48667201b972SAndreas Gruenbacher 4867b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4868b411b363SPhilipp Reisner { 4869392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4870b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 487177351055SPhilipp Reisner struct packet_info pi; 4872257d0af6SPhilipp Reisner int rv; 4873e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 4874b411b363SPhilipp Reisner int received = 0; 487552b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 487652b061a4SAndreas Gruenbacher int expect = header_size; 4877f36af18cSLars Ellenberg int ping_timeout_active = 0; 4878b411b363SPhilipp Reisner 4879b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4880b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4881b411b363SPhilipp Reisner 4882e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 488380822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 488432862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 4885a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 488632862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 4887841ce241SAndreas Gruenbacher goto reconnect; 4888841ce241SAndreas Gruenbacher } 488932862ec7SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = 489032862ec7SPhilipp Reisner tconn->net_conf->ping_timeo*HZ/10; 4891f36af18cSLars Ellenberg ping_timeout_active = 1; 4892b411b363SPhilipp Reisner } 4893b411b363SPhilipp Reisner 489432862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 489532862ec7SPhilipp Reisner much to send */ 489632862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 489732862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 4898082a3439SPhilipp Reisner if (tconn_process_done_ee(tconn)) { 4899082a3439SPhilipp Reisner conn_err(tconn, "tconn_process_done_ee() failed\n"); 4900b411b363SPhilipp Reisner goto reconnect; 4901082a3439SPhilipp Reisner } 4902b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 490332862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 490432862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 4905b411b363SPhilipp Reisner 4906b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4907b411b363SPhilipp Reisner if (signal_pending(current)) 4908b411b363SPhilipp Reisner continue; 4909b411b363SPhilipp Reisner 491032862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 491132862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4912b411b363SPhilipp Reisner 4913b411b363SPhilipp Reisner flush_signals(current); 4914b411b363SPhilipp Reisner 4915b411b363SPhilipp Reisner /* Note: 4916b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4917b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4918b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4919b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4920b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4921b411b363SPhilipp Reisner * rv == expected: full header or command 4922b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4923b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4924b411b363SPhilipp Reisner */ 4925b411b363SPhilipp Reisner if (likely(rv > 0)) { 4926b411b363SPhilipp Reisner received += rv; 4927b411b363SPhilipp Reisner buf += rv; 4928b411b363SPhilipp Reisner } else if (rv == 0) { 492932862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 4930b411b363SPhilipp Reisner goto reconnect; 4931b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4932cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4933cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 493432862ec7SPhilipp Reisner if (time_after(tconn->last_received, 493532862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 4936cb6518cbSLars Ellenberg continue; 4937f36af18cSLars Ellenberg if (ping_timeout_active) { 493832862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 4939b411b363SPhilipp Reisner goto reconnect; 4940b411b363SPhilipp Reisner } 494132862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 4942b411b363SPhilipp Reisner continue; 4943b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4944b411b363SPhilipp Reisner continue; 4945b411b363SPhilipp Reisner } else { 494632862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 4947b411b363SPhilipp Reisner goto reconnect; 4948b411b363SPhilipp Reisner } 4949b411b363SPhilipp Reisner 4950b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4951e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 4952b411b363SPhilipp Reisner goto reconnect; 49537201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 49541952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 495532862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 495677351055SPhilipp Reisner pi.cmd, pi.size); 4957b411b363SPhilipp Reisner goto disconnect; 4958b411b363SPhilipp Reisner } 4959e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 496052b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 496132862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 496277351055SPhilipp Reisner pi.cmd, pi.size); 4963b411b363SPhilipp Reisner goto reconnect; 4964b411b363SPhilipp Reisner } 4965257d0af6SPhilipp Reisner } 4966b411b363SPhilipp Reisner if (received == expect) { 49672735a594SAndreas Gruenbacher bool err; 4968a4fbda8eSPhilipp Reisner 49692735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 49702735a594SAndreas Gruenbacher if (err) { 49711952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 4972b411b363SPhilipp Reisner goto reconnect; 49731952e916SAndreas Gruenbacher } 4974b411b363SPhilipp Reisner 4975a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 4976a4fbda8eSPhilipp Reisner 4977f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4978f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 49797201b972SAndreas Gruenbacher if (cmd == &asender_tbl[P_PING_ACK]) 4980f36af18cSLars Ellenberg ping_timeout_active = 0; 4981f36af18cSLars Ellenberg 4982e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 4983b411b363SPhilipp Reisner received = 0; 498452b061a4SAndreas Gruenbacher expect = header_size; 4985b411b363SPhilipp Reisner cmd = NULL; 4986b411b363SPhilipp Reisner } 4987b411b363SPhilipp Reisner } 4988b411b363SPhilipp Reisner 4989b411b363SPhilipp Reisner if (0) { 4990b411b363SPhilipp Reisner reconnect: 4991bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4992b411b363SPhilipp Reisner } 4993b411b363SPhilipp Reisner if (0) { 4994b411b363SPhilipp Reisner disconnect: 4995bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4996b411b363SPhilipp Reisner } 499732862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4998b411b363SPhilipp Reisner 499932862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5000b411b363SPhilipp Reisner 5001b411b363SPhilipp Reisner return 0; 5002b411b363SPhilipp Reisner } 5003