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; 5377351055SPhilipp Reisner int size; 5477351055SPhilipp Reisner int vnr; 5577351055SPhilipp Reisner }; 5677351055SPhilipp Reisner 57b411b363SPhilipp Reisner enum finish_epoch { 58b411b363SPhilipp Reisner FE_STILL_LIVE, 59b411b363SPhilipp Reisner FE_DESTROYED, 60b411b363SPhilipp Reisner FE_RECYCLED, 61b411b363SPhilipp Reisner }; 62b411b363SPhilipp Reisner 6365d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn); 6413e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 65360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data); 66b411b363SPhilipp Reisner 67b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 6800d56944SPhilipp Reisner static int e_end_block(struct drbd_work *, int); 69b411b363SPhilipp Reisner 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 72b411b363SPhilipp Reisner 7345bb912bSLars Ellenberg /* 7445bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7545bb912bSLars Ellenberg * page->private being our "next" pointer. 7645bb912bSLars Ellenberg */ 7745bb912bSLars Ellenberg 7845bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 7945bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8045bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8145bb912bSLars Ellenberg */ 8245bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8345bb912bSLars Ellenberg { 8445bb912bSLars Ellenberg struct page *page; 8545bb912bSLars Ellenberg struct page *tmp; 8645bb912bSLars Ellenberg 8745bb912bSLars Ellenberg BUG_ON(!n); 8845bb912bSLars Ellenberg BUG_ON(!head); 8945bb912bSLars Ellenberg 9045bb912bSLars Ellenberg page = *head; 9123ce4227SPhilipp Reisner 9223ce4227SPhilipp Reisner if (!page) 9323ce4227SPhilipp Reisner return NULL; 9423ce4227SPhilipp Reisner 9545bb912bSLars Ellenberg while (page) { 9645bb912bSLars Ellenberg tmp = page_chain_next(page); 9745bb912bSLars Ellenberg if (--n == 0) 9845bb912bSLars Ellenberg break; /* found sufficient pages */ 9945bb912bSLars Ellenberg if (tmp == NULL) 10045bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10145bb912bSLars Ellenberg return NULL; 10245bb912bSLars Ellenberg page = tmp; 10345bb912bSLars Ellenberg } 10445bb912bSLars Ellenberg 10545bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10645bb912bSLars Ellenberg set_page_private(page, 0); 10745bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10845bb912bSLars Ellenberg page = *head; 10945bb912bSLars Ellenberg *head = tmp; 11045bb912bSLars Ellenberg return page; 11145bb912bSLars Ellenberg } 11245bb912bSLars Ellenberg 11345bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11445bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11545bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11645bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11745bb912bSLars Ellenberg { 11845bb912bSLars Ellenberg struct page *tmp; 11945bb912bSLars Ellenberg int i = 1; 12045bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12145bb912bSLars Ellenberg ++i, page = tmp; 12245bb912bSLars Ellenberg if (len) 12345bb912bSLars Ellenberg *len = i; 12445bb912bSLars Ellenberg return page; 12545bb912bSLars Ellenberg } 12645bb912bSLars Ellenberg 12745bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12845bb912bSLars Ellenberg { 12945bb912bSLars Ellenberg struct page *tmp; 13045bb912bSLars Ellenberg int i = 0; 13145bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13245bb912bSLars Ellenberg put_page(page); 13345bb912bSLars Ellenberg ++i; 13445bb912bSLars Ellenberg } 13545bb912bSLars Ellenberg return i; 13645bb912bSLars Ellenberg } 13745bb912bSLars Ellenberg 13845bb912bSLars Ellenberg static void page_chain_add(struct page **head, 13945bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14045bb912bSLars Ellenberg { 14145bb912bSLars Ellenberg #if 1 14245bb912bSLars Ellenberg struct page *tmp; 14345bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14445bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14545bb912bSLars Ellenberg #endif 14645bb912bSLars Ellenberg 14745bb912bSLars Ellenberg /* add chain to head */ 14845bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 14945bb912bSLars Ellenberg *head = chain_first; 15045bb912bSLars Ellenberg } 15145bb912bSLars Ellenberg 15245bb912bSLars Ellenberg static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number) 153b411b363SPhilipp Reisner { 154b411b363SPhilipp Reisner struct page *page = NULL; 15545bb912bSLars Ellenberg struct page *tmp = NULL; 15645bb912bSLars Ellenberg int i = 0; 157b411b363SPhilipp Reisner 158b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 159b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16045bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 161b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16245bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16345bb912bSLars Ellenberg if (page) 16445bb912bSLars Ellenberg drbd_pp_vacant -= number; 165b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16645bb912bSLars Ellenberg if (page) 16745bb912bSLars Ellenberg return page; 168b411b363SPhilipp Reisner } 16945bb912bSLars Ellenberg 170b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 171b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 172b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17345bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17445bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17545bb912bSLars Ellenberg if (!tmp) 17645bb912bSLars Ellenberg break; 17745bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 17845bb912bSLars Ellenberg page = tmp; 17945bb912bSLars Ellenberg } 18045bb912bSLars Ellenberg 18145bb912bSLars Ellenberg if (i == number) 182b411b363SPhilipp Reisner return page; 18345bb912bSLars Ellenberg 18445bb912bSLars Ellenberg /* Not enough pages immediately available this time. 18545bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc will retry this 18645bb912bSLars Ellenberg * function "soon". */ 18745bb912bSLars Ellenberg if (page) { 18845bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 18945bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19045bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19145bb912bSLars Ellenberg drbd_pp_vacant += i; 19245bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19345bb912bSLars Ellenberg } 19445bb912bSLars Ellenberg return NULL; 195b411b363SPhilipp Reisner } 196b411b363SPhilipp Reisner 197b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 198b411b363SPhilipp Reisner { 199db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 200b411b363SPhilipp Reisner struct list_head *le, *tle; 201b411b363SPhilipp Reisner 202b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 203b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 204b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 205b411b363SPhilipp Reisner stop to examine the list... */ 206b411b363SPhilipp Reisner 207b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 208db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 209db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) 210b411b363SPhilipp Reisner break; 211b411b363SPhilipp Reisner list_move(le, to_be_freed); 212b411b363SPhilipp Reisner } 213b411b363SPhilipp Reisner } 214b411b363SPhilipp Reisner 215b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 216b411b363SPhilipp Reisner { 217b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 218db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 219b411b363SPhilipp Reisner 22087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 221b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 22287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 223b411b363SPhilipp Reisner 224db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 225db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 226b411b363SPhilipp Reisner } 227b411b363SPhilipp Reisner 228b411b363SPhilipp Reisner /** 22945bb912bSLars Ellenberg * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled) 230b411b363SPhilipp Reisner * @mdev: DRBD device. 23145bb912bSLars Ellenberg * @number: number of pages requested 23245bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 233b411b363SPhilipp Reisner * 23445bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23545bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23645bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 23745bb912bSLars Ellenberg * 23845bb912bSLars Ellenberg * Returns a page chain linked via page->private. 239b411b363SPhilipp Reisner */ 24045bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 241b411b363SPhilipp Reisner { 242b411b363SPhilipp Reisner struct page *page = NULL; 243b411b363SPhilipp Reisner DEFINE_WAIT(wait); 244b411b363SPhilipp Reisner 24545bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 24645bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 24789e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) 24845bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 249b411b363SPhilipp Reisner 25045bb912bSLars Ellenberg while (page == NULL) { 251b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 252b411b363SPhilipp Reisner 253b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 254b411b363SPhilipp Reisner 25589e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) { 25645bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 257b411b363SPhilipp Reisner if (page) 258b411b363SPhilipp Reisner break; 259b411b363SPhilipp Reisner } 260b411b363SPhilipp Reisner 261b411b363SPhilipp Reisner if (!retry) 262b411b363SPhilipp Reisner break; 263b411b363SPhilipp Reisner 264b411b363SPhilipp Reisner if (signal_pending(current)) { 265b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 266b411b363SPhilipp Reisner break; 267b411b363SPhilipp Reisner } 268b411b363SPhilipp Reisner 269b411b363SPhilipp Reisner schedule(); 270b411b363SPhilipp Reisner } 271b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 272b411b363SPhilipp Reisner 27345bb912bSLars Ellenberg if (page) 27445bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 275b411b363SPhilipp Reisner return page; 276b411b363SPhilipp Reisner } 277b411b363SPhilipp Reisner 278b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 27987eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 28045bb912bSLars Ellenberg * Either links the page chain back to the global pool, 28145bb912bSLars Ellenberg * or returns all pages to the system. */ 282435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 283b411b363SPhilipp Reisner { 284435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 285b411b363SPhilipp Reisner int i; 286435f0740SLars Ellenberg 2871816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE)*minor_count) 28845bb912bSLars Ellenberg i = page_chain_free(page); 28945bb912bSLars Ellenberg else { 29045bb912bSLars Ellenberg struct page *tmp; 29145bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 292b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 29345bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 29445bb912bSLars Ellenberg drbd_pp_vacant += i; 295b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 296b411b363SPhilipp Reisner } 297435f0740SLars Ellenberg i = atomic_sub_return(i, a); 29845bb912bSLars Ellenberg if (i < 0) 299435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 300435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 301b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 302b411b363SPhilipp Reisner } 303b411b363SPhilipp Reisner 304b411b363SPhilipp Reisner /* 305b411b363SPhilipp Reisner You need to hold the req_lock: 306b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 307b411b363SPhilipp Reisner 308b411b363SPhilipp Reisner You must not have the req_lock: 309b411b363SPhilipp Reisner drbd_free_ee() 310b411b363SPhilipp Reisner drbd_alloc_ee() 311b411b363SPhilipp Reisner drbd_init_ee() 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 * 320f6ffca9fSAndreas Gruenbacher drbd_alloc_ee(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)) 333b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 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 365db830c46SAndreas Gruenbacher void drbd_free_some_ee(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) { 388db830c46SAndreas Gruenbacher drbd_free_some_ee(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; 407b411b363SPhilipp Reisner int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS); 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) 415db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 416b411b363SPhilipp Reisner 417b411b363SPhilipp Reisner /* possible callbacks here: 418b411b363SPhilipp Reisner * e_end_block, and e_end_resync_block, e_send_discard_ack. 419b411b363SPhilipp Reisner * all ignore the last argument. 420b411b363SPhilipp Reisner */ 421db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 422b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 42300d56944SPhilipp Reisner ok = peer_req->w.cb(&peer_req->w, !ok) && ok; 424db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 425b411b363SPhilipp Reisner } 426b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 427b411b363SPhilipp Reisner 428b411b363SPhilipp Reisner return ok; 429b411b363SPhilipp Reisner } 430b411b363SPhilipp Reisner 431b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 432b411b363SPhilipp Reisner { 433b411b363SPhilipp Reisner DEFINE_WAIT(wait); 434b411b363SPhilipp Reisner 435b411b363SPhilipp Reisner /* avoids spin_lock/unlock 436b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 437b411b363SPhilipp Reisner while (!list_empty(head)) { 438b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 43987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4407eaceaccSJens Axboe io_schedule(); 441b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 44287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 443b411b363SPhilipp Reisner } 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner 446b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 447b411b363SPhilipp Reisner { 44887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 449b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 45087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 451b411b363SPhilipp Reisner } 452b411b363SPhilipp Reisner 453b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 454b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4557653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 456b411b363SPhilipp Reisner { 457b411b363SPhilipp Reisner struct sock *sk = sock->sk; 458b411b363SPhilipp Reisner int err = 0; 459b411b363SPhilipp Reisner 460b411b363SPhilipp Reisner *what = "listen"; 461b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 462b411b363SPhilipp Reisner if (err < 0) 463b411b363SPhilipp Reisner goto out; 464b411b363SPhilipp Reisner 465b411b363SPhilipp Reisner *what = "sock_create_lite"; 466b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 467b411b363SPhilipp Reisner newsock); 468b411b363SPhilipp Reisner if (err < 0) 469b411b363SPhilipp Reisner goto out; 470b411b363SPhilipp Reisner 471b411b363SPhilipp Reisner *what = "accept"; 472b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 473b411b363SPhilipp Reisner if (err < 0) { 474b411b363SPhilipp Reisner sock_release(*newsock); 475b411b363SPhilipp Reisner *newsock = NULL; 476b411b363SPhilipp Reisner goto out; 477b411b363SPhilipp Reisner } 478b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 479b411b363SPhilipp Reisner 480b411b363SPhilipp Reisner out: 481b411b363SPhilipp Reisner return err; 482b411b363SPhilipp Reisner } 483b411b363SPhilipp Reisner 484dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 485b411b363SPhilipp Reisner { 486b411b363SPhilipp Reisner mm_segment_t oldfs; 487b411b363SPhilipp Reisner struct kvec iov = { 488b411b363SPhilipp Reisner .iov_base = buf, 489b411b363SPhilipp Reisner .iov_len = size, 490b411b363SPhilipp Reisner }; 491b411b363SPhilipp Reisner struct msghdr msg = { 492b411b363SPhilipp Reisner .msg_iovlen = 1, 493b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 494b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 495b411b363SPhilipp Reisner }; 496b411b363SPhilipp Reisner int rv; 497b411b363SPhilipp Reisner 498b411b363SPhilipp Reisner oldfs = get_fs(); 499b411b363SPhilipp Reisner set_fs(KERNEL_DS); 500b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 501b411b363SPhilipp Reisner set_fs(oldfs); 502b411b363SPhilipp Reisner 503b411b363SPhilipp Reisner return rv; 504b411b363SPhilipp Reisner } 505b411b363SPhilipp Reisner 506de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 507b411b363SPhilipp Reisner { 508b411b363SPhilipp Reisner mm_segment_t oldfs; 509b411b363SPhilipp Reisner struct kvec iov = { 510b411b363SPhilipp Reisner .iov_base = buf, 511b411b363SPhilipp Reisner .iov_len = size, 512b411b363SPhilipp Reisner }; 513b411b363SPhilipp Reisner struct msghdr msg = { 514b411b363SPhilipp Reisner .msg_iovlen = 1, 515b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 516b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 517b411b363SPhilipp Reisner }; 518b411b363SPhilipp Reisner int rv; 519b411b363SPhilipp Reisner 520b411b363SPhilipp Reisner oldfs = get_fs(); 521b411b363SPhilipp Reisner set_fs(KERNEL_DS); 522b411b363SPhilipp Reisner 523b411b363SPhilipp Reisner for (;;) { 524de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 525b411b363SPhilipp Reisner if (rv == size) 526b411b363SPhilipp Reisner break; 527b411b363SPhilipp Reisner 528b411b363SPhilipp Reisner /* Note: 529b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 530b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 531b411b363SPhilipp Reisner */ 532b411b363SPhilipp Reisner 533b411b363SPhilipp Reisner if (rv < 0) { 534b411b363SPhilipp Reisner if (rv == -ECONNRESET) 535de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 536b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 537de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 538b411b363SPhilipp Reisner break; 539b411b363SPhilipp Reisner } else if (rv == 0) { 540de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 541b411b363SPhilipp Reisner break; 542b411b363SPhilipp Reisner } else { 543b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 544b411b363SPhilipp Reisner * after we read a partial message 545b411b363SPhilipp Reisner */ 546b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 547b411b363SPhilipp Reisner break; 548b411b363SPhilipp Reisner } 549b411b363SPhilipp Reisner }; 550b411b363SPhilipp Reisner 551b411b363SPhilipp Reisner set_fs(oldfs); 552b411b363SPhilipp Reisner 553b411b363SPhilipp Reisner if (rv != size) 554bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 555b411b363SPhilipp Reisner 556b411b363SPhilipp Reisner return rv; 557b411b363SPhilipp Reisner } 558b411b363SPhilipp Reisner 5595dbf1673SLars Ellenberg /* quoting tcp(7): 5605dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5615dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5625dbf1673SLars Ellenberg * This is our wrapper to do so. 5635dbf1673SLars Ellenberg */ 5645dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5655dbf1673SLars Ellenberg unsigned int rcv) 5665dbf1673SLars Ellenberg { 5675dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5685dbf1673SLars Ellenberg if (snd) { 5695dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5705dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5715dbf1673SLars Ellenberg } 5725dbf1673SLars Ellenberg if (rcv) { 5735dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5745dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5755dbf1673SLars Ellenberg } 5765dbf1673SLars Ellenberg } 5775dbf1673SLars Ellenberg 578eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 579b411b363SPhilipp Reisner { 580b411b363SPhilipp Reisner const char *what; 581b411b363SPhilipp Reisner struct socket *sock; 582b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 583b411b363SPhilipp Reisner int err; 584b411b363SPhilipp Reisner int disconnect_on_error = 1; 585b411b363SPhilipp Reisner 586eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 587b411b363SPhilipp Reisner return NULL; 588b411b363SPhilipp Reisner 589b411b363SPhilipp Reisner what = "sock_create_kern"; 590eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 591b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 592b411b363SPhilipp Reisner if (err < 0) { 593b411b363SPhilipp Reisner sock = NULL; 594b411b363SPhilipp Reisner goto out; 595b411b363SPhilipp Reisner } 596b411b363SPhilipp Reisner 597b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 598eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 599eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 600eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 601b411b363SPhilipp Reisner 602b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 603b411b363SPhilipp Reisner * for the outgoing connections. 604b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 605b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 606b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 607b411b363SPhilipp Reisner * a free one dynamically. 608b411b363SPhilipp Reisner */ 609eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 610eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 611eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 612b411b363SPhilipp Reisner src_in6.sin6_port = 0; 613b411b363SPhilipp Reisner else 614b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 615b411b363SPhilipp Reisner 616b411b363SPhilipp Reisner what = "bind before connect"; 617b411b363SPhilipp Reisner err = sock->ops->bind(sock, 618b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 619eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 620b411b363SPhilipp Reisner if (err < 0) 621b411b363SPhilipp Reisner goto out; 622b411b363SPhilipp Reisner 623b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 624b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 625b411b363SPhilipp Reisner disconnect_on_error = 0; 626b411b363SPhilipp Reisner what = "connect"; 627b411b363SPhilipp Reisner err = sock->ops->connect(sock, 628eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 629eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 630b411b363SPhilipp Reisner 631b411b363SPhilipp Reisner out: 632b411b363SPhilipp Reisner if (err < 0) { 633b411b363SPhilipp Reisner if (sock) { 634b411b363SPhilipp Reisner sock_release(sock); 635b411b363SPhilipp Reisner sock = NULL; 636b411b363SPhilipp Reisner } 637b411b363SPhilipp Reisner switch (-err) { 638b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 639b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 640b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 641b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 642b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 643b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 644b411b363SPhilipp Reisner disconnect_on_error = 0; 645b411b363SPhilipp Reisner break; 646b411b363SPhilipp Reisner default: 647eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 648b411b363SPhilipp Reisner } 649b411b363SPhilipp Reisner if (disconnect_on_error) 650bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 651b411b363SPhilipp Reisner } 652eac3e990SPhilipp Reisner put_net_conf(tconn); 653b411b363SPhilipp Reisner return sock; 654b411b363SPhilipp Reisner } 655b411b363SPhilipp Reisner 6567653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 657b411b363SPhilipp Reisner { 658b411b363SPhilipp Reisner int timeo, err; 659b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 660b411b363SPhilipp Reisner const char *what; 661b411b363SPhilipp Reisner 6627653620dSPhilipp Reisner if (!get_net_conf(tconn)) 663b411b363SPhilipp Reisner return NULL; 664b411b363SPhilipp Reisner 665b411b363SPhilipp Reisner what = "sock_create_kern"; 6667653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 667b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 668b411b363SPhilipp Reisner if (err) { 669b411b363SPhilipp Reisner s_listen = NULL; 670b411b363SPhilipp Reisner goto out; 671b411b363SPhilipp Reisner } 672b411b363SPhilipp Reisner 6737653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 674b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 675b411b363SPhilipp Reisner 676b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 677b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 678b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 6797653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 6807653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 681b411b363SPhilipp Reisner 682b411b363SPhilipp Reisner what = "bind before listen"; 683b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 6847653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 6857653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 686b411b363SPhilipp Reisner if (err < 0) 687b411b363SPhilipp Reisner goto out; 688b411b363SPhilipp Reisner 6897653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 690b411b363SPhilipp Reisner 691b411b363SPhilipp Reisner out: 692b411b363SPhilipp Reisner if (s_listen) 693b411b363SPhilipp Reisner sock_release(s_listen); 694b411b363SPhilipp Reisner if (err < 0) { 695b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 6967653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 697bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 698b411b363SPhilipp Reisner } 699b411b363SPhilipp Reisner } 7007653620dSPhilipp Reisner put_net_conf(tconn); 701b411b363SPhilipp Reisner 702b411b363SPhilipp Reisner return s_estab; 703b411b363SPhilipp Reisner } 704b411b363SPhilipp Reisner 705d38e787eSPhilipp Reisner static int drbd_send_fp(struct drbd_tconn *tconn, struct socket *sock, enum drbd_packet cmd) 706b411b363SPhilipp Reisner { 707d38e787eSPhilipp Reisner struct p_header *h = &tconn->data.sbuf.header; 708b411b363SPhilipp Reisner 709d38e787eSPhilipp Reisner return _conn_send_cmd(tconn, 0, sock, cmd, h, sizeof(*h), 0); 710b411b363SPhilipp Reisner } 711b411b363SPhilipp Reisner 712a25b63f1SPhilipp Reisner static enum drbd_packet drbd_recv_fp(struct drbd_tconn *tconn, struct socket *sock) 713b411b363SPhilipp Reisner { 714a25b63f1SPhilipp Reisner struct p_header80 *h = &tconn->data.rbuf.header.h80; 715b411b363SPhilipp Reisner int rr; 716b411b363SPhilipp Reisner 717dbd9eea0SPhilipp Reisner rr = drbd_recv_short(sock, h, sizeof(*h), 0); 718b411b363SPhilipp Reisner 719ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 720b411b363SPhilipp Reisner return be16_to_cpu(h->command); 721b411b363SPhilipp Reisner 722b411b363SPhilipp Reisner return 0xffff; 723b411b363SPhilipp Reisner } 724b411b363SPhilipp Reisner 725b411b363SPhilipp Reisner /** 726b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 727b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 728b411b363SPhilipp Reisner */ 729dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 730b411b363SPhilipp Reisner { 731b411b363SPhilipp Reisner int rr; 732b411b363SPhilipp Reisner char tb[4]; 733b411b363SPhilipp Reisner 734b411b363SPhilipp Reisner if (!*sock) 73581e84650SAndreas Gruenbacher return false; 736b411b363SPhilipp Reisner 737dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 738b411b363SPhilipp Reisner 739b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 74081e84650SAndreas Gruenbacher return true; 741b411b363SPhilipp Reisner } else { 742b411b363SPhilipp Reisner sock_release(*sock); 743b411b363SPhilipp Reisner *sock = NULL; 74481e84650SAndreas Gruenbacher return false; 745b411b363SPhilipp Reisner } 746b411b363SPhilipp Reisner } 747b411b363SPhilipp Reisner 748907599e0SPhilipp Reisner static int drbd_connected(int vnr, void *p, void *data) 749907599e0SPhilipp Reisner { 750907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 751907599e0SPhilipp Reisner int ok = 1; 752907599e0SPhilipp Reisner 753907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 754907599e0SPhilipp Reisner mdev->peer_seq = 0; 755907599e0SPhilipp Reisner 7568410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 7578410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 7588410da8fSPhilipp Reisner &mdev->own_state_mutex; 7598410da8fSPhilipp Reisner 760907599e0SPhilipp Reisner ok &= drbd_send_sync_param(mdev, &mdev->sync_conf); 761907599e0SPhilipp Reisner ok &= drbd_send_sizes(mdev, 0, 0); 762907599e0SPhilipp Reisner ok &= drbd_send_uuids(mdev); 763907599e0SPhilipp Reisner ok &= drbd_send_state(mdev); 764907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 765907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 766907599e0SPhilipp Reisner 7678410da8fSPhilipp Reisner 768907599e0SPhilipp Reisner return !ok; 769907599e0SPhilipp Reisner } 770907599e0SPhilipp Reisner 771b411b363SPhilipp Reisner /* 772b411b363SPhilipp Reisner * return values: 773b411b363SPhilipp Reisner * 1 yes, we have a valid connection 774b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 775b411b363SPhilipp Reisner * -1 peer talks different language, 776b411b363SPhilipp Reisner * no point in trying again, please go standalone. 777b411b363SPhilipp Reisner * -2 We do not have a network config... 778b411b363SPhilipp Reisner */ 779907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 780b411b363SPhilipp Reisner { 781b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 782b411b363SPhilipp Reisner int try, h, ok; 783b411b363SPhilipp Reisner 784bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 785b411b363SPhilipp Reisner return -2; 786b411b363SPhilipp Reisner 787907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 788907599e0SPhilipp Reisner tconn->agreed_pro_version = 99; 789fd340c12SPhilipp Reisner /* agreed_pro_version must be smaller than 100 so we send the old 790fd340c12SPhilipp Reisner header (h80) in the first packet and in the handshake packet. */ 791b411b363SPhilipp Reisner 792b411b363SPhilipp Reisner sock = NULL; 793b411b363SPhilipp Reisner msock = NULL; 794b411b363SPhilipp Reisner 795b411b363SPhilipp Reisner do { 796b411b363SPhilipp Reisner for (try = 0;;) { 797b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 798907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 799b411b363SPhilipp Reisner if (s || ++try >= 3) 800b411b363SPhilipp Reisner break; 801b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 80220ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 803b411b363SPhilipp Reisner } 804b411b363SPhilipp Reisner 805b411b363SPhilipp Reisner if (s) { 806b411b363SPhilipp Reisner if (!sock) { 807907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_S); 808b411b363SPhilipp Reisner sock = s; 809b411b363SPhilipp Reisner s = NULL; 810b411b363SPhilipp Reisner } else if (!msock) { 811907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_M); 812b411b363SPhilipp Reisner msock = s; 813b411b363SPhilipp Reisner s = NULL; 814b411b363SPhilipp Reisner } else { 815907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 816b411b363SPhilipp Reisner goto out_release_sockets; 817b411b363SPhilipp Reisner } 818b411b363SPhilipp Reisner } 819b411b363SPhilipp Reisner 820b411b363SPhilipp Reisner if (sock && msock) { 821907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 822dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 823dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 824b411b363SPhilipp Reisner if (ok) 825b411b363SPhilipp Reisner break; 826b411b363SPhilipp Reisner } 827b411b363SPhilipp Reisner 828b411b363SPhilipp Reisner retry: 829907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 830b411b363SPhilipp Reisner if (s) { 831907599e0SPhilipp Reisner try = drbd_recv_fp(tconn, s); 832dbd9eea0SPhilipp Reisner drbd_socket_okay(&sock); 833dbd9eea0SPhilipp Reisner drbd_socket_okay(&msock); 834b411b363SPhilipp Reisner switch (try) { 835b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 836b411b363SPhilipp Reisner if (sock) { 837907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 838b411b363SPhilipp Reisner sock_release(sock); 839b411b363SPhilipp Reisner } 840b411b363SPhilipp Reisner sock = s; 841b411b363SPhilipp Reisner break; 842b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 843b411b363SPhilipp Reisner if (msock) { 844907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 845b411b363SPhilipp Reisner sock_release(msock); 846b411b363SPhilipp Reisner } 847b411b363SPhilipp Reisner msock = s; 848907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 849b411b363SPhilipp Reisner break; 850b411b363SPhilipp Reisner default: 851907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 852b411b363SPhilipp Reisner sock_release(s); 853b411b363SPhilipp Reisner if (random32() & 1) 854b411b363SPhilipp Reisner goto retry; 855b411b363SPhilipp Reisner } 856b411b363SPhilipp Reisner } 857b411b363SPhilipp Reisner 858bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 859b411b363SPhilipp Reisner goto out_release_sockets; 860b411b363SPhilipp Reisner if (signal_pending(current)) { 861b411b363SPhilipp Reisner flush_signals(current); 862b411b363SPhilipp Reisner smp_rmb(); 863907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 864b411b363SPhilipp Reisner goto out_release_sockets; 865b411b363SPhilipp Reisner } 866b411b363SPhilipp Reisner 867b411b363SPhilipp Reisner if (sock && msock) { 868dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 869dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 870b411b363SPhilipp Reisner if (ok) 871b411b363SPhilipp Reisner break; 872b411b363SPhilipp Reisner } 873b411b363SPhilipp Reisner } while (1); 874b411b363SPhilipp Reisner 875b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 876b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 877b411b363SPhilipp Reisner 878b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 879b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 880b411b363SPhilipp Reisner 881b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 882b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 883b411b363SPhilipp Reisner 884b411b363SPhilipp Reisner /* NOT YET ... 885907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 886b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 887b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 888b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 889b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 890907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 891b411b363SPhilipp Reisner 892907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 893907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 894b411b363SPhilipp Reisner 895b411b363SPhilipp Reisner /* we don't want delays. 89625985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 897b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 898b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 899b411b363SPhilipp Reisner 900907599e0SPhilipp Reisner tconn->data.socket = sock; 901907599e0SPhilipp Reisner tconn->meta.socket = msock; 902907599e0SPhilipp Reisner tconn->last_received = jiffies; 903b411b363SPhilipp Reisner 904907599e0SPhilipp Reisner h = drbd_do_handshake(tconn); 905b411b363SPhilipp Reisner if (h <= 0) 906b411b363SPhilipp Reisner return h; 907b411b363SPhilipp Reisner 908907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 909b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 910907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 911b10d96cbSJohannes Thoma case -1: 912907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 913b411b363SPhilipp Reisner return -1; 914b10d96cbSJohannes Thoma case 0: 915907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 916b10d96cbSJohannes Thoma return 0; 917b411b363SPhilipp Reisner } 918b411b363SPhilipp Reisner } 919b411b363SPhilipp Reisner 920bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 921b411b363SPhilipp Reisner return 0; 922b411b363SPhilipp Reisner 923907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 924b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 925b411b363SPhilipp Reisner 926907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 927b411b363SPhilipp Reisner 928907599e0SPhilipp Reisner if (drbd_send_protocol(tconn) == -1) 9297e2455c1SPhilipp Reisner return -1; 930b411b363SPhilipp Reisner 931907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 932b411b363SPhilipp Reisner 933b411b363SPhilipp Reisner out_release_sockets: 934b411b363SPhilipp Reisner if (sock) 935b411b363SPhilipp Reisner sock_release(sock); 936b411b363SPhilipp Reisner if (msock) 937b411b363SPhilipp Reisner sock_release(msock); 938b411b363SPhilipp Reisner return -1; 939b411b363SPhilipp Reisner } 940b411b363SPhilipp Reisner 941ce243853SPhilipp Reisner static bool decode_header(struct drbd_tconn *tconn, struct p_header *h, struct packet_info *pi) 942b411b363SPhilipp Reisner { 943fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 94477351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h80.command); 94577351055SPhilipp Reisner pi->size = be16_to_cpu(h->h80.length); 946eefc2f7dSPhilipp Reisner pi->vnr = 0; 947ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 94877351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h95.command); 94977351055SPhilipp Reisner pi->size = be32_to_cpu(h->h95.length) & 0x00ffffff; 95077351055SPhilipp Reisner pi->vnr = 0; 95102918be2SPhilipp Reisner } else { 952ce243853SPhilipp Reisner conn_err(tconn, "magic?? on data m: 0x%08x c: %d l: %d\n", 953004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 954004352faSLars Ellenberg be16_to_cpu(h->h80.command), 955004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 95681e84650SAndreas Gruenbacher return false; 957b411b363SPhilipp Reisner } 958257d0af6SPhilipp Reisner return true; 959257d0af6SPhilipp Reisner } 960257d0af6SPhilipp Reisner 9619ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 962257d0af6SPhilipp Reisner { 9639ba7aa00SPhilipp Reisner struct p_header *h = &tconn->data.rbuf.header; 964257d0af6SPhilipp Reisner int r; 965257d0af6SPhilipp Reisner 9669ba7aa00SPhilipp Reisner r = drbd_recv(tconn, h, sizeof(*h)); 967257d0af6SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 968257d0af6SPhilipp Reisner if (!signal_pending(current)) 9699ba7aa00SPhilipp Reisner conn_warn(tconn, "short read expecting header on sock: r=%d\n", r); 970257d0af6SPhilipp Reisner return false; 971257d0af6SPhilipp Reisner } 972257d0af6SPhilipp Reisner 9739ba7aa00SPhilipp Reisner r = decode_header(tconn, h, pi); 9749ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 975b411b363SPhilipp Reisner 976257d0af6SPhilipp Reisner return r; 977b411b363SPhilipp Reisner } 978b411b363SPhilipp Reisner 9792451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 980b411b363SPhilipp Reisner { 981b411b363SPhilipp Reisner int rv; 982b411b363SPhilipp Reisner 983b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 984fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 985dd3932edSChristoph Hellwig NULL); 986b411b363SPhilipp Reisner if (rv) { 987b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 988b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 989b411b363SPhilipp Reisner * don't try again for ANY return value != 0 990b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 991b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 992b411b363SPhilipp Reisner } 993b411b363SPhilipp Reisner put_ldev(mdev); 994b411b363SPhilipp Reisner } 995b411b363SPhilipp Reisner } 996b411b363SPhilipp Reisner 997b411b363SPhilipp Reisner /** 998b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 999b411b363SPhilipp Reisner * @mdev: DRBD device. 1000b411b363SPhilipp Reisner * @epoch: Epoch object. 1001b411b363SPhilipp Reisner * @ev: Epoch event. 1002b411b363SPhilipp Reisner */ 1003b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1004b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1005b411b363SPhilipp Reisner enum epoch_event ev) 1006b411b363SPhilipp Reisner { 10072451fc3bSPhilipp Reisner int epoch_size; 1008b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1009b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1010b411b363SPhilipp Reisner 1011b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1012b411b363SPhilipp Reisner do { 1013b411b363SPhilipp Reisner next_epoch = NULL; 1014b411b363SPhilipp Reisner 1015b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1016b411b363SPhilipp Reisner 1017b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1018b411b363SPhilipp Reisner case EV_PUT: 1019b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1020b411b363SPhilipp Reisner break; 1021b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1022b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1023b411b363SPhilipp Reisner break; 1024b411b363SPhilipp Reisner case EV_BECAME_LAST: 1025b411b363SPhilipp Reisner /* nothing to do*/ 1026b411b363SPhilipp Reisner break; 1027b411b363SPhilipp Reisner } 1028b411b363SPhilipp Reisner 1029b411b363SPhilipp Reisner if (epoch_size != 0 && 1030b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10312451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1032b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1033b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1034b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1035b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1036b411b363SPhilipp Reisner } 1037b411b363SPhilipp Reisner dec_unacked(mdev); 1038b411b363SPhilipp Reisner 1039b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1040b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1041b411b363SPhilipp Reisner list_del(&epoch->list); 1042b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1043b411b363SPhilipp Reisner mdev->epochs--; 1044b411b363SPhilipp Reisner kfree(epoch); 1045b411b363SPhilipp Reisner 1046b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1047b411b363SPhilipp Reisner rv = FE_DESTROYED; 1048b411b363SPhilipp Reisner } else { 1049b411b363SPhilipp Reisner epoch->flags = 0; 1050b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1051698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1052b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1053b411b363SPhilipp Reisner rv = FE_RECYCLED; 10542451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1055b411b363SPhilipp Reisner } 1056b411b363SPhilipp Reisner } 1057b411b363SPhilipp Reisner 1058b411b363SPhilipp Reisner if (!next_epoch) 1059b411b363SPhilipp Reisner break; 1060b411b363SPhilipp Reisner 1061b411b363SPhilipp Reisner epoch = next_epoch; 1062b411b363SPhilipp Reisner } while (1); 1063b411b363SPhilipp Reisner 1064b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1065b411b363SPhilipp Reisner 1066b411b363SPhilipp Reisner return rv; 1067b411b363SPhilipp Reisner } 1068b411b363SPhilipp Reisner 1069b411b363SPhilipp Reisner /** 1070b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1071b411b363SPhilipp Reisner * @mdev: DRBD device. 1072b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1073b411b363SPhilipp Reisner */ 1074b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1075b411b363SPhilipp Reisner { 1076b411b363SPhilipp Reisner enum write_ordering_e pwo; 1077b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1078b411b363SPhilipp Reisner [WO_none] = "none", 1079b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1080b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1081b411b363SPhilipp Reisner }; 1082b411b363SPhilipp Reisner 1083b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1084b411b363SPhilipp Reisner wo = min(pwo, wo); 1085b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1086b411b363SPhilipp Reisner wo = WO_drain_io; 1087b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1088b411b363SPhilipp Reisner wo = WO_none; 1089b411b363SPhilipp Reisner mdev->write_ordering = wo; 10902451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1091b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1092b411b363SPhilipp Reisner } 1093b411b363SPhilipp Reisner 1094b411b363SPhilipp Reisner /** 1095fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 109645bb912bSLars Ellenberg * @mdev: DRBD device. 1097db830c46SAndreas Gruenbacher * @peer_req: peer request 109845bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 109910f6d992SLars Ellenberg * 110010f6d992SLars Ellenberg * May spread the pages to multiple bios, 110110f6d992SLars Ellenberg * depending on bio_add_page restrictions. 110210f6d992SLars Ellenberg * 110310f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 110410f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 110510f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 110610f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 110710f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 110810f6d992SLars Ellenberg * on certain Xen deployments. 110945bb912bSLars Ellenberg */ 111045bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1111fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1112fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 111345bb912bSLars Ellenberg const unsigned rw, const int fault_type) 111445bb912bSLars Ellenberg { 111545bb912bSLars Ellenberg struct bio *bios = NULL; 111645bb912bSLars Ellenberg struct bio *bio; 1117db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1118db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1119db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 112045bb912bSLars Ellenberg unsigned n_bios = 0; 112145bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 112210f6d992SLars Ellenberg int err = -ENOMEM; 112345bb912bSLars Ellenberg 112445bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 112545bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 112645bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 112745bb912bSLars Ellenberg * request in more than one bio. */ 112845bb912bSLars Ellenberg next_bio: 112945bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 113045bb912bSLars Ellenberg if (!bio) { 113145bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 113245bb912bSLars Ellenberg goto fail; 113345bb912bSLars Ellenberg } 1134db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 113545bb912bSLars Ellenberg bio->bi_sector = sector; 113645bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 113745bb912bSLars Ellenberg bio->bi_rw = rw; 1138db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1139fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 114045bb912bSLars Ellenberg 114145bb912bSLars Ellenberg bio->bi_next = bios; 114245bb912bSLars Ellenberg bios = bio; 114345bb912bSLars Ellenberg ++n_bios; 114445bb912bSLars Ellenberg 114545bb912bSLars Ellenberg page_chain_for_each(page) { 114645bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 114745bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 114810f6d992SLars Ellenberg /* A single page must always be possible! 114910f6d992SLars Ellenberg * But in case it fails anyways, 115010f6d992SLars Ellenberg * we deal with it, and complain (below). */ 115110f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 115210f6d992SLars Ellenberg dev_err(DEV, 115310f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 115410f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 115510f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 115610f6d992SLars Ellenberg err = -ENOSPC; 115710f6d992SLars Ellenberg goto fail; 115810f6d992SLars Ellenberg } 115945bb912bSLars Ellenberg goto next_bio; 116045bb912bSLars Ellenberg } 116145bb912bSLars Ellenberg ds -= len; 116245bb912bSLars Ellenberg sector += len >> 9; 116345bb912bSLars Ellenberg --nr_pages; 116445bb912bSLars Ellenberg } 116545bb912bSLars Ellenberg D_ASSERT(page == NULL); 116645bb912bSLars Ellenberg D_ASSERT(ds == 0); 116745bb912bSLars Ellenberg 1168db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 116945bb912bSLars Ellenberg do { 117045bb912bSLars Ellenberg bio = bios; 117145bb912bSLars Ellenberg bios = bios->bi_next; 117245bb912bSLars Ellenberg bio->bi_next = NULL; 117345bb912bSLars Ellenberg 117445bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 117545bb912bSLars Ellenberg } while (bios); 117645bb912bSLars Ellenberg return 0; 117745bb912bSLars Ellenberg 117845bb912bSLars Ellenberg fail: 117945bb912bSLars Ellenberg while (bios) { 118045bb912bSLars Ellenberg bio = bios; 118145bb912bSLars Ellenberg bios = bios->bi_next; 118245bb912bSLars Ellenberg bio_put(bio); 118345bb912bSLars Ellenberg } 118410f6d992SLars Ellenberg return err; 118545bb912bSLars Ellenberg } 118645bb912bSLars Ellenberg 118753840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1188db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 118953840641SAndreas Gruenbacher { 1190db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 119153840641SAndreas Gruenbacher 119253840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 119353840641SAndreas Gruenbacher drbd_clear_interval(i); 119453840641SAndreas Gruenbacher 11956c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 119653840641SAndreas Gruenbacher if (i->waiting) 119753840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 119853840641SAndreas Gruenbacher } 119953840641SAndreas Gruenbacher 1200d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1201d8763023SAndreas Gruenbacher unsigned int data_size) 1202b411b363SPhilipp Reisner { 12032451fc3bSPhilipp Reisner int rv; 1204e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.rbuf.barrier; 1205b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1206b411b363SPhilipp Reisner 1207b411b363SPhilipp Reisner inc_unacked(mdev); 1208b411b363SPhilipp Reisner 1209b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1210b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1211b411b363SPhilipp Reisner 1212b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1213b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1214b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1215b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1216b411b363SPhilipp Reisner * completed. */ 1217b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1218b411b363SPhilipp Reisner case WO_none: 1219b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 122081e84650SAndreas Gruenbacher return true; 1221b411b363SPhilipp Reisner 1222b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1223b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1224b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12252451fc3bSPhilipp Reisner if (epoch) 12262451fc3bSPhilipp Reisner break; 12272451fc3bSPhilipp Reisner else 1228b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12292451fc3bSPhilipp Reisner /* Fall through */ 12302451fc3bSPhilipp Reisner 12312451fc3bSPhilipp Reisner case WO_bdev_flush: 12322451fc3bSPhilipp Reisner case WO_drain_io: 1233b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12342451fc3bSPhilipp Reisner drbd_flush(mdev); 12352451fc3bSPhilipp Reisner 12362451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12372451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12382451fc3bSPhilipp Reisner if (epoch) 12392451fc3bSPhilipp Reisner break; 1240b411b363SPhilipp Reisner } 1241b411b363SPhilipp Reisner 12422451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12432451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12442451fc3bSPhilipp Reisner 12452451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12462451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1247b411b363SPhilipp Reisner 124881e84650SAndreas Gruenbacher return true; 12492451fc3bSPhilipp Reisner default: 12502451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 125181e84650SAndreas Gruenbacher return false; 1252b411b363SPhilipp Reisner } 1253b411b363SPhilipp Reisner 1254b411b363SPhilipp Reisner epoch->flags = 0; 1255b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1256b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1257b411b363SPhilipp Reisner 1258b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1259b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1260b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1261b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1262b411b363SPhilipp Reisner mdev->epochs++; 1263b411b363SPhilipp Reisner } else { 1264b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1265b411b363SPhilipp Reisner kfree(epoch); 1266b411b363SPhilipp Reisner } 1267b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1268b411b363SPhilipp Reisner 126981e84650SAndreas Gruenbacher return true; 1270b411b363SPhilipp Reisner } 1271b411b363SPhilipp Reisner 1272b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1273b411b363SPhilipp Reisner * and from receive_Data */ 1274f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1275f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1276f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1277b411b363SPhilipp Reisner { 12786666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1279db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1280b411b363SPhilipp Reisner struct page *page; 128145bb912bSLars Ellenberg int dgs, ds, rr; 1282a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1283a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 12846b4388acSPhilipp Reisner unsigned long *data; 1285b411b363SPhilipp Reisner 1286a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1287a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1288b411b363SPhilipp Reisner 1289b411b363SPhilipp Reisner if (dgs) { 1290de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1291b411b363SPhilipp Reisner if (rr != dgs) { 12920ddc5549SLars Ellenberg if (!signal_pending(current)) 12930ddc5549SLars Ellenberg dev_warn(DEV, 12940ddc5549SLars Ellenberg "short read receiving data digest: read %d expected %d\n", 1295b411b363SPhilipp Reisner rr, dgs); 1296b411b363SPhilipp Reisner return NULL; 1297b411b363SPhilipp Reisner } 1298b411b363SPhilipp Reisner } 1299b411b363SPhilipp Reisner 1300b411b363SPhilipp Reisner data_size -= dgs; 1301b411b363SPhilipp Reisner 1302841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1303841ce241SAndreas Gruenbacher return NULL; 1304841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1305841ce241SAndreas Gruenbacher return NULL; 1306841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1307841ce241SAndreas Gruenbacher return NULL; 1308b411b363SPhilipp Reisner 13096666032aSLars Ellenberg /* even though we trust out peer, 13106666032aSLars Ellenberg * we sometimes have to double check. */ 13116666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1312fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1313fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13146666032aSLars Ellenberg (unsigned long long)capacity, 13156666032aSLars Ellenberg (unsigned long long)sector, data_size); 13166666032aSLars Ellenberg return NULL; 13176666032aSLars Ellenberg } 13186666032aSLars Ellenberg 1319b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1320b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1321b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1322db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1323db830c46SAndreas Gruenbacher if (!peer_req) 1324b411b363SPhilipp Reisner return NULL; 132545bb912bSLars Ellenberg 1326b411b363SPhilipp Reisner ds = data_size; 1327db830c46SAndreas Gruenbacher page = peer_req->pages; 132845bb912bSLars Ellenberg page_chain_for_each(page) { 132945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13306b4388acSPhilipp Reisner data = kmap(page); 1331de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, len); 13320cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13336b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13346b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13356b4388acSPhilipp Reisner } 1336b411b363SPhilipp Reisner kunmap(page); 133745bb912bSLars Ellenberg if (rr != len) { 1338db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 13390ddc5549SLars Ellenberg if (!signal_pending(current)) 1340b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 134145bb912bSLars Ellenberg rr, len); 1342b411b363SPhilipp Reisner return NULL; 1343b411b363SPhilipp Reisner } 1344b411b363SPhilipp Reisner ds -= rr; 1345b411b363SPhilipp Reisner } 1346b411b363SPhilipp Reisner 1347b411b363SPhilipp Reisner if (dgs) { 1348db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1349b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1350470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1351470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1352b411b363SPhilipp Reisner drbd_bcast_ee(mdev, "digest failed", 1353db830c46SAndreas Gruenbacher dgs, dig_in, dig_vv, peer_req); 1354db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1355b411b363SPhilipp Reisner return NULL; 1356b411b363SPhilipp Reisner } 1357b411b363SPhilipp Reisner } 1358b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1359db830c46SAndreas Gruenbacher return peer_req; 1360b411b363SPhilipp Reisner } 1361b411b363SPhilipp Reisner 1362b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1363b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1364b411b363SPhilipp Reisner */ 1365b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1366b411b363SPhilipp Reisner { 1367b411b363SPhilipp Reisner struct page *page; 1368b411b363SPhilipp Reisner int rr, rv = 1; 1369b411b363SPhilipp Reisner void *data; 1370b411b363SPhilipp Reisner 1371c3470cdeSLars Ellenberg if (!data_size) 137281e84650SAndreas Gruenbacher return true; 1373c3470cdeSLars Ellenberg 137445bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1375b411b363SPhilipp Reisner 1376b411b363SPhilipp Reisner data = kmap(page); 1377b411b363SPhilipp Reisner while (data_size) { 1378de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, min_t(int, data_size, PAGE_SIZE)); 1379b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1380b411b363SPhilipp Reisner rv = 0; 13810ddc5549SLars Ellenberg if (!signal_pending(current)) 13820ddc5549SLars Ellenberg dev_warn(DEV, 13830ddc5549SLars Ellenberg "short read receiving data: read %d expected %d\n", 1384b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1385b411b363SPhilipp Reisner break; 1386b411b363SPhilipp Reisner } 1387b411b363SPhilipp Reisner data_size -= rr; 1388b411b363SPhilipp Reisner } 1389b411b363SPhilipp Reisner kunmap(page); 1390435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1391b411b363SPhilipp Reisner return rv; 1392b411b363SPhilipp Reisner } 1393b411b363SPhilipp Reisner 1394b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1395b411b363SPhilipp Reisner sector_t sector, int data_size) 1396b411b363SPhilipp Reisner { 1397b411b363SPhilipp Reisner struct bio_vec *bvec; 1398b411b363SPhilipp Reisner struct bio *bio; 1399b411b363SPhilipp Reisner int dgs, rr, i, expect; 1400a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1401a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1402b411b363SPhilipp Reisner 1403a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1404a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1405b411b363SPhilipp Reisner 1406b411b363SPhilipp Reisner if (dgs) { 1407de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1408b411b363SPhilipp Reisner if (rr != dgs) { 14090ddc5549SLars Ellenberg if (!signal_pending(current)) 14100ddc5549SLars Ellenberg dev_warn(DEV, 14110ddc5549SLars Ellenberg "short read receiving data reply digest: read %d expected %d\n", 1412b411b363SPhilipp Reisner rr, dgs); 1413b411b363SPhilipp Reisner return 0; 1414b411b363SPhilipp Reisner } 1415b411b363SPhilipp Reisner } 1416b411b363SPhilipp Reisner 1417b411b363SPhilipp Reisner data_size -= dgs; 1418b411b363SPhilipp Reisner 1419b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1420b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1421b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1422b411b363SPhilipp Reisner 1423b411b363SPhilipp Reisner bio = req->master_bio; 1424b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1425b411b363SPhilipp Reisner 1426b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1427b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1428de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, 1429b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1430b411b363SPhilipp Reisner expect); 1431b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1432b411b363SPhilipp Reisner if (rr != expect) { 14330ddc5549SLars Ellenberg if (!signal_pending(current)) 1434b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1435b411b363SPhilipp Reisner "read %d expected %d\n", 1436b411b363SPhilipp Reisner rr, expect); 1437b411b363SPhilipp Reisner return 0; 1438b411b363SPhilipp Reisner } 1439b411b363SPhilipp Reisner data_size -= rr; 1440b411b363SPhilipp Reisner } 1441b411b363SPhilipp Reisner 1442b411b363SPhilipp Reisner if (dgs) { 1443a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1444b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1445b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1446b411b363SPhilipp Reisner return 0; 1447b411b363SPhilipp Reisner } 1448b411b363SPhilipp Reisner } 1449b411b363SPhilipp Reisner 1450b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1451b411b363SPhilipp Reisner return 1; 1452b411b363SPhilipp Reisner } 1453b411b363SPhilipp Reisner 1454b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1455b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 145600d56944SPhilipp Reisner static int e_end_resync_block(struct drbd_work *w, int unused) 1457b411b363SPhilipp Reisner { 14588050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 14598050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 146000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1461db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1462b411b363SPhilipp Reisner int ok; 1463b411b363SPhilipp Reisner 1464db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1465b411b363SPhilipp Reisner 1466db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1467db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1468db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1469b411b363SPhilipp Reisner } else { 1470b411b363SPhilipp Reisner /* Record failure to sync */ 1471db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1472b411b363SPhilipp Reisner 1473db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1474b411b363SPhilipp Reisner } 1475b411b363SPhilipp Reisner dec_unacked(mdev); 1476b411b363SPhilipp Reisner 1477b411b363SPhilipp Reisner return ok; 1478b411b363SPhilipp Reisner } 1479b411b363SPhilipp Reisner 1480b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1481b411b363SPhilipp Reisner { 1482db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1483b411b363SPhilipp Reisner 1484db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1485db830c46SAndreas Gruenbacher if (!peer_req) 148645bb912bSLars Ellenberg goto fail; 1487b411b363SPhilipp Reisner 1488b411b363SPhilipp Reisner dec_rs_pending(mdev); 1489b411b363SPhilipp Reisner 1490b411b363SPhilipp Reisner inc_unacked(mdev); 1491b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1492b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1493b411b363SPhilipp Reisner 1494db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 149545bb912bSLars Ellenberg 149687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1497db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 149887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1499b411b363SPhilipp Reisner 15000f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1501fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 150281e84650SAndreas Gruenbacher return true; 150345bb912bSLars Ellenberg 150410f6d992SLars Ellenberg /* don't care for the reason here */ 150510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 150687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1507db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 150887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 150922cc37a9SLars Ellenberg 1510db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 151145bb912bSLars Ellenberg fail: 151245bb912bSLars Ellenberg put_ldev(mdev); 151381e84650SAndreas Gruenbacher return false; 1514b411b363SPhilipp Reisner } 1515b411b363SPhilipp Reisner 1516668eebc6SAndreas Gruenbacher static struct drbd_request * 1517bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1518bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1519668eebc6SAndreas Gruenbacher { 1520668eebc6SAndreas Gruenbacher struct drbd_request *req; 1521668eebc6SAndreas Gruenbacher 1522bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1523bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15245e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1525668eebc6SAndreas Gruenbacher return req; 1526c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1527c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1528c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1529c3afd8f5SAndreas Gruenbacher } 1530668eebc6SAndreas Gruenbacher return NULL; 1531668eebc6SAndreas Gruenbacher } 1532668eebc6SAndreas Gruenbacher 1533d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1534d8763023SAndreas Gruenbacher unsigned int data_size) 1535b411b363SPhilipp Reisner { 1536b411b363SPhilipp Reisner struct drbd_request *req; 1537b411b363SPhilipp Reisner sector_t sector; 1538b411b363SPhilipp Reisner int ok; 1539e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1540b411b363SPhilipp Reisner 1541b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1542b411b363SPhilipp Reisner 154387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1544bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 154587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1546c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 154781e84650SAndreas Gruenbacher return false; 1548b411b363SPhilipp Reisner 154924c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1550b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1551b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1552b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1553b411b363SPhilipp Reisner 1554b411b363SPhilipp Reisner if (ok) 15558554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1556b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1557b411b363SPhilipp Reisner * I don't think we may complete this just yet 1558b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1559b411b363SPhilipp Reisner 1560b411b363SPhilipp Reisner return ok; 1561b411b363SPhilipp Reisner } 1562b411b363SPhilipp Reisner 1563d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1564d8763023SAndreas Gruenbacher unsigned int data_size) 1565b411b363SPhilipp Reisner { 1566b411b363SPhilipp Reisner sector_t sector; 1567b411b363SPhilipp Reisner int ok; 1568e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1569b411b363SPhilipp Reisner 1570b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1571b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1572b411b363SPhilipp Reisner 1573b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1574b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1575b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1576fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1577b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1578b411b363SPhilipp Reisner } else { 1579b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1580b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1581b411b363SPhilipp Reisner 1582b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1583b411b363SPhilipp Reisner 15842b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1585b411b363SPhilipp Reisner } 1586b411b363SPhilipp Reisner 1587778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1588778f271dSPhilipp Reisner 1589b411b363SPhilipp Reisner return ok; 1590b411b363SPhilipp Reisner } 1591b411b363SPhilipp Reisner 1592b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1593b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1594b411b363SPhilipp Reisner */ 159500d56944SPhilipp Reisner static int e_end_block(struct drbd_work *w, int cancel) 1596b411b363SPhilipp Reisner { 15978050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 15988050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 159900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1600db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1601b411b363SPhilipp Reisner int ok = 1, pcmd; 1602b411b363SPhilipp Reisner 160389e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1604db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1605b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1606b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1607db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1608b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1609db830c46SAndreas Gruenbacher ok &= drbd_send_ack(mdev, pcmd, peer_req); 1610b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1611db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1612b411b363SPhilipp Reisner } else { 1613db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1614b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1615b411b363SPhilipp Reisner * maybe assert this? */ 1616b411b363SPhilipp Reisner } 1617b411b363SPhilipp Reisner dec_unacked(mdev); 1618b411b363SPhilipp Reisner } 1619b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1620b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 162189e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 162287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1623db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1624db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 162587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1626bb3bfe96SAndreas Gruenbacher } else 1627db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1628b411b363SPhilipp Reisner 1629db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1630b411b363SPhilipp Reisner 1631b411b363SPhilipp Reisner return ok; 1632b411b363SPhilipp Reisner } 1633b411b363SPhilipp Reisner 163400d56944SPhilipp Reisner static int e_send_discard_ack(struct drbd_work *w, int unused) 1635b411b363SPhilipp Reisner { 16368050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16378050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 163800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1639206d3589SAndreas Gruenbacher int ok; 1640b411b363SPhilipp Reisner 164189e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1642db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_DISCARD_ACK, peer_req); 1643b411b363SPhilipp Reisner dec_unacked(mdev); 1644b411b363SPhilipp Reisner 1645b411b363SPhilipp Reisner return ok; 1646b411b363SPhilipp Reisner } 1647b411b363SPhilipp Reisner 16483e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 16493e394da1SAndreas Gruenbacher { 16503e394da1SAndreas Gruenbacher /* 16513e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 16523e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 16533e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 16543e394da1SAndreas Gruenbacher */ 16553e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 16563e394da1SAndreas Gruenbacher } 16573e394da1SAndreas Gruenbacher 16583e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 16593e394da1SAndreas Gruenbacher { 16603e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 16613e394da1SAndreas Gruenbacher } 16623e394da1SAndreas Gruenbacher 166343ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 16643e394da1SAndreas Gruenbacher { 166543ae077dSAndreas Gruenbacher unsigned int old_peer_seq; 16663e394da1SAndreas Gruenbacher 16673e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 166843ae077dSAndreas Gruenbacher old_peer_seq = mdev->peer_seq; 166943ae077dSAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 16703e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 167143ae077dSAndreas Gruenbacher if (old_peer_seq != peer_seq) 16723e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 16733e394da1SAndreas Gruenbacher } 16743e394da1SAndreas Gruenbacher 1675b411b363SPhilipp Reisner /* Called from receive_Data. 1676b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1677b411b363SPhilipp Reisner * 1678b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1679b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1680b411b363SPhilipp Reisner * been sent. 1681b411b363SPhilipp Reisner * 1682b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1683b411b363SPhilipp Reisner * 1684b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1685b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1686b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1687b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1688b411b363SPhilipp Reisner * 1689b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1690b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1691b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1692b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1693b411b363SPhilipp Reisner * 1694b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1695b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1696b411b363SPhilipp Reisner static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq) 1697b411b363SPhilipp Reisner { 1698b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1699b411b363SPhilipp Reisner unsigned int p_seq; 1700b411b363SPhilipp Reisner long timeout; 1701b411b363SPhilipp Reisner int ret = 0; 1702b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1703b411b363SPhilipp Reisner for (;;) { 1704b411b363SPhilipp Reisner prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 17053e394da1SAndreas Gruenbacher if (!seq_greater(packet_seq, mdev->peer_seq + 1)) 1706b411b363SPhilipp Reisner break; 1707b411b363SPhilipp Reisner if (signal_pending(current)) { 1708b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1709b411b363SPhilipp Reisner break; 1710b411b363SPhilipp Reisner } 1711b411b363SPhilipp Reisner p_seq = mdev->peer_seq; 1712b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 171371b1c1ebSAndreas Gruenbacher timeout = mdev->tconn->net_conf->ping_timeo*HZ/10; 171471b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1715b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1716b411b363SPhilipp Reisner if (timeout == 0 && p_seq == mdev->peer_seq) { 1717b411b363SPhilipp Reisner ret = -ETIMEDOUT; 171871b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1719b411b363SPhilipp Reisner break; 1720b411b363SPhilipp Reisner } 1721b411b363SPhilipp Reisner } 1722b411b363SPhilipp Reisner finish_wait(&mdev->seq_wait, &wait); 1723b411b363SPhilipp Reisner if (mdev->peer_seq+1 == packet_seq) 1724b411b363SPhilipp Reisner mdev->peer_seq++; 1725b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1726b411b363SPhilipp Reisner return ret; 1727b411b363SPhilipp Reisner } 1728b411b363SPhilipp Reisner 1729688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1730688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1731688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1732688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 173376d2e7ecSPhilipp Reisner { 173476d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 173576d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1736688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 173776d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 173876d2e7ecSPhilipp Reisner } 173976d2e7ecSPhilipp Reisner 1740b411b363SPhilipp Reisner /* mirrored write */ 1741d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1742d8763023SAndreas Gruenbacher unsigned int data_size) 1743b411b363SPhilipp Reisner { 1744b411b363SPhilipp Reisner sector_t sector; 1745db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1746e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1747b411b363SPhilipp Reisner int rw = WRITE; 1748b411b363SPhilipp Reisner u32 dp_flags; 1749b411b363SPhilipp Reisner 1750b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 1751b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1752b411b363SPhilipp Reisner if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num)) 1753b411b363SPhilipp Reisner mdev->peer_seq++; 1754b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 1755b411b363SPhilipp Reisner 17562b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1757b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1758b411b363SPhilipp Reisner return drbd_drain_block(mdev, data_size); 1759b411b363SPhilipp Reisner } 1760b411b363SPhilipp Reisner 1761fcefa62eSAndreas Gruenbacher /* 1762fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 1763fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 1764fcefa62eSAndreas Gruenbacher * end of this function. 1765fcefa62eSAndreas Gruenbacher */ 1766b411b363SPhilipp Reisner 1767b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1768db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, data_size); 1769db830c46SAndreas Gruenbacher if (!peer_req) { 1770b411b363SPhilipp Reisner put_ldev(mdev); 177181e84650SAndreas Gruenbacher return false; 1772b411b363SPhilipp Reisner } 1773b411b363SPhilipp Reisner 1774db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 1775b411b363SPhilipp Reisner 1776688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 1777688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 1778688593c5SLars Ellenberg 1779688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 1780db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 1781688593c5SLars Ellenberg 1782b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1783db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 1784db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 1785db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 1786b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1787b411b363SPhilipp Reisner 1788b411b363SPhilipp Reisner /* I'm the receiver, I do hold a net_cnt reference. */ 178989e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->two_primaries) { 179087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1791b411b363SPhilipp Reisner } else { 1792b411b363SPhilipp Reisner /* don't get the req_lock yet, 1793b411b363SPhilipp Reisner * we may sleep in drbd_wait_peer_seq */ 1794db830c46SAndreas Gruenbacher const int size = peer_req->i.size; 179525703f83SPhilipp Reisner const int discard = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 1796b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1797b411b363SPhilipp Reisner int first; 1798b411b363SPhilipp Reisner 179989e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 1800b411b363SPhilipp Reisner 1801b411b363SPhilipp Reisner /* conflict detection and handling: 1802b411b363SPhilipp Reisner * 1. wait on the sequence number, 1803b411b363SPhilipp Reisner * in case this data packet overtook ACK packets. 18045e472264SAndreas Gruenbacher * 2. check for conflicting write requests. 1805b411b363SPhilipp Reisner * 1806b411b363SPhilipp Reisner * Note: for two_primaries, we are protocol C, 1807b411b363SPhilipp Reisner * so there cannot be any request that is DONE 1808b411b363SPhilipp Reisner * but still on the transfer log. 1809b411b363SPhilipp Reisner * 1810b411b363SPhilipp Reisner * if no conflicting request is found: 1811b411b363SPhilipp Reisner * submit. 1812b411b363SPhilipp Reisner * 1813b411b363SPhilipp Reisner * if any conflicting request is found 1814b411b363SPhilipp Reisner * that has not yet been acked, 1815b411b363SPhilipp Reisner * AND I have the "discard concurrent writes" flag: 1816b411b363SPhilipp Reisner * queue (via done_ee) the P_DISCARD_ACK; OUT. 1817b411b363SPhilipp Reisner * 1818b411b363SPhilipp Reisner * if any conflicting request is found: 1819b411b363SPhilipp Reisner * block the receiver, waiting on misc_wait 1820b411b363SPhilipp Reisner * until no more conflicting requests are there, 1821b411b363SPhilipp Reisner * or we get interrupted (disconnect). 1822b411b363SPhilipp Reisner * 1823b411b363SPhilipp Reisner * we do not just write after local io completion of those 1824b411b363SPhilipp Reisner * requests, but only after req is done completely, i.e. 1825b411b363SPhilipp Reisner * we wait for the P_DISCARD_ACK to arrive! 1826b411b363SPhilipp Reisner * 1827b411b363SPhilipp Reisner * then proceed normally, i.e. submit. 1828b411b363SPhilipp Reisner */ 1829b411b363SPhilipp Reisner if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num))) 1830b411b363SPhilipp Reisner goto out_interrupted; 1831b411b363SPhilipp Reisner 183287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1833b411b363SPhilipp Reisner 1834206d3589SAndreas Gruenbacher /* 1835206d3589SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will 1836206d3589SAndreas Gruenbacher * prevent new conflicting local requests from being added. 1837206d3589SAndreas Gruenbacher */ 1838206d3589SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 1839206d3589SAndreas Gruenbacher 1840b411b363SPhilipp Reisner first = 1; 1841b411b363SPhilipp Reisner for (;;) { 1842de696716SAndreas Gruenbacher struct drbd_interval *i; 1843b411b363SPhilipp Reisner int have_unacked = 0; 1844b411b363SPhilipp Reisner int have_conflict = 0; 1845b411b363SPhilipp Reisner prepare_to_wait(&mdev->misc_wait, &wait, 1846b411b363SPhilipp Reisner TASK_INTERRUPTIBLE); 1847de696716SAndreas Gruenbacher 1848206d3589SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 1849206d3589SAndreas Gruenbacher struct drbd_request *req2; 1850206d3589SAndreas Gruenbacher 1851206d3589SAndreas Gruenbacher if (i == &peer_req->i || !i->local) 1852206d3589SAndreas Gruenbacher continue; 1853206d3589SAndreas Gruenbacher 1854b411b363SPhilipp Reisner /* only ALERT on first iteration, 1855b411b363SPhilipp Reisner * we may be woken up early... */ 1856b411b363SPhilipp Reisner if (first) 1857206d3589SAndreas Gruenbacher dev_alert(DEV, "%s[%u] Concurrent local write detected!" 1858b411b363SPhilipp Reisner " new: %llus +%u; pending: %llus +%u\n", 1859b411b363SPhilipp Reisner current->comm, current->pid, 1860b411b363SPhilipp Reisner (unsigned long long)sector, size, 18615e472264SAndreas Gruenbacher (unsigned long long)i->sector, i->size); 18625e472264SAndreas Gruenbacher 18635e472264SAndreas Gruenbacher req2 = container_of(i, struct drbd_request, i); 1864de696716SAndreas Gruenbacher if (req2->rq_state & RQ_NET_PENDING) 1865b411b363SPhilipp Reisner ++have_unacked; 1866b411b363SPhilipp Reisner ++have_conflict; 1867206d3589SAndreas Gruenbacher break; 1868b411b363SPhilipp Reisner } 1869b411b363SPhilipp Reisner if (!have_conflict) 1870b411b363SPhilipp Reisner break; 1871b411b363SPhilipp Reisner 1872b411b363SPhilipp Reisner /* Discard Ack only for the _first_ iteration */ 1873b411b363SPhilipp Reisner if (first && discard && have_unacked) { 1874b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n", 1875b411b363SPhilipp Reisner (unsigned long long)sector); 1876206d3589SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 1877b411b363SPhilipp Reisner inc_unacked(mdev); 1878db830c46SAndreas Gruenbacher peer_req->w.cb = e_send_discard_ack; 1879db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 1880b411b363SPhilipp Reisner 188187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1882b411b363SPhilipp Reisner 1883b411b363SPhilipp Reisner /* we could probably send that P_DISCARD_ACK ourselves, 1884b411b363SPhilipp Reisner * but I don't like the receiver using the msock */ 1885b411b363SPhilipp Reisner 1886b411b363SPhilipp Reisner put_ldev(mdev); 18870625ac19SPhilipp Reisner wake_asender(mdev->tconn); 1888b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 188981e84650SAndreas Gruenbacher return true; 1890b411b363SPhilipp Reisner } 1891b411b363SPhilipp Reisner 1892b411b363SPhilipp Reisner if (signal_pending(current)) { 1893206d3589SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 189487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1895b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1896b411b363SPhilipp Reisner goto out_interrupted; 1897b411b363SPhilipp Reisner } 1898b411b363SPhilipp Reisner 1899a500c2efSAndreas Gruenbacher /* Indicate to wake up mdev->misc_wait upon completion. */ 190053840641SAndreas Gruenbacher i->waiting = true; 1901a500c2efSAndreas Gruenbacher 190287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1903b411b363SPhilipp Reisner if (first) { 1904b411b363SPhilipp Reisner first = 0; 1905b411b363SPhilipp Reisner dev_alert(DEV, "Concurrent write! [W AFTERWARDS] " 1906b411b363SPhilipp Reisner "sec=%llus\n", (unsigned long long)sector); 1907b411b363SPhilipp Reisner } else if (discard) { 1908b411b363SPhilipp Reisner /* we had none on the first iteration. 1909b411b363SPhilipp Reisner * there must be none now. */ 1910b411b363SPhilipp Reisner D_ASSERT(have_unacked == 0); 1911b411b363SPhilipp Reisner } 1912206d3589SAndreas Gruenbacher /* FIXME: Introduce a timeout here after which we disconnect. */ 1913b411b363SPhilipp Reisner schedule(); 191487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1915b411b363SPhilipp Reisner } 1916b411b363SPhilipp Reisner finish_wait(&mdev->misc_wait, &wait); 1917b411b363SPhilipp Reisner } 1918b411b363SPhilipp Reisner 1919db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 192087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1921b411b363SPhilipp Reisner 192289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 1923b411b363SPhilipp Reisner case DRBD_PROT_C: 1924b411b363SPhilipp Reisner inc_unacked(mdev); 1925b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 1926b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1927b411b363SPhilipp Reisner break; 1928b411b363SPhilipp Reisner case DRBD_PROT_B: 1929b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 1930b411b363SPhilipp Reisner * sends on the msock, but anyways */ 1931db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 1932b411b363SPhilipp Reisner break; 1933b411b363SPhilipp Reisner case DRBD_PROT_A: 1934b411b363SPhilipp Reisner /* nothing to do */ 1935b411b363SPhilipp Reisner break; 1936b411b363SPhilipp Reisner } 1937b411b363SPhilipp Reisner 19386719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 1939b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 1940db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 1941db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 1942db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 1943db830c46SAndreas Gruenbacher drbd_al_begin_io(mdev, peer_req->i.sector); 1944b411b363SPhilipp Reisner } 1945b411b363SPhilipp Reisner 1946fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR) == 0) 194781e84650SAndreas Gruenbacher return true; 1948b411b363SPhilipp Reisner 194910f6d992SLars Ellenberg /* don't care for the reason here */ 195010f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 195187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1952db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 1953db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 195487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1955db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 1956db830c46SAndreas Gruenbacher drbd_al_complete_io(mdev, peer_req->i.sector); 195722cc37a9SLars Ellenberg 1958b411b363SPhilipp Reisner out_interrupted: 1959db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 1960b411b363SPhilipp Reisner put_ldev(mdev); 1961db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 196281e84650SAndreas Gruenbacher return false; 1963b411b363SPhilipp Reisner } 1964b411b363SPhilipp Reisner 19650f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 19660f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 19670f0601f4SLars Ellenberg * 19680f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 19690f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 19700f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 19710f0601f4SLars Ellenberg * activity, it obviously is "busy". 19720f0601f4SLars Ellenberg * 19730f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 19740f0601f4SLars Ellenberg * to have a short time average so we can react faster. 19750f0601f4SLars Ellenberg */ 1976e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 19770f0601f4SLars Ellenberg { 19780f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 19790f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 1980e3555d85SPhilipp Reisner struct lc_element *tmp; 19810f0601f4SLars Ellenberg int curr_events; 19820f0601f4SLars Ellenberg int throttle = 0; 19830f0601f4SLars Ellenberg 19840f0601f4SLars Ellenberg /* feature disabled? */ 19850f0601f4SLars Ellenberg if (mdev->sync_conf.c_min_rate == 0) 19860f0601f4SLars Ellenberg return 0; 19870f0601f4SLars Ellenberg 1988e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 1989e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 1990e3555d85SPhilipp Reisner if (tmp) { 1991e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 1992e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 1993e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1994e3555d85SPhilipp Reisner return 0; 1995e3555d85SPhilipp Reisner } 1996e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 1997e3555d85SPhilipp Reisner } 1998e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 1999e3555d85SPhilipp Reisner 20000f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 20010f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 20020f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2003e3555d85SPhilipp Reisner 20040f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 20050f0601f4SLars Ellenberg unsigned long rs_left; 20060f0601f4SLars Ellenberg int i; 20070f0601f4SLars Ellenberg 20080f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 20090f0601f4SLars Ellenberg 20100f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 20110f0601f4SLars Ellenberg * approx. */ 20122649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 20132649f080SLars Ellenberg 20142649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 20152649f080SLars Ellenberg rs_left = mdev->ov_left; 20162649f080SLars Ellenberg else 20170f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 20180f0601f4SLars Ellenberg 20190f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 20200f0601f4SLars Ellenberg if (!dt) 20210f0601f4SLars Ellenberg dt++; 20220f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 20230f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 20240f0601f4SLars Ellenberg 20250f0601f4SLars Ellenberg if (dbdt > mdev->sync_conf.c_min_rate) 20260f0601f4SLars Ellenberg throttle = 1; 20270f0601f4SLars Ellenberg } 20280f0601f4SLars Ellenberg return throttle; 20290f0601f4SLars Ellenberg } 20300f0601f4SLars Ellenberg 20310f0601f4SLars Ellenberg 2032d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2033d8763023SAndreas Gruenbacher unsigned int digest_size) 2034b411b363SPhilipp Reisner { 2035b411b363SPhilipp Reisner sector_t sector; 2036b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2037db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2038b411b363SPhilipp Reisner struct digest_info *di = NULL; 2039b18b37beSPhilipp Reisner int size, verb; 2040b411b363SPhilipp Reisner unsigned int fault_type; 2041e42325a5SPhilipp Reisner struct p_block_req *p = &mdev->tconn->data.rbuf.block_req; 2042b411b363SPhilipp Reisner 2043b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2044b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2045b411b363SPhilipp Reisner 2046c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2047b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2048b411b363SPhilipp Reisner (unsigned long long)sector, size); 204981e84650SAndreas Gruenbacher return false; 2050b411b363SPhilipp Reisner } 2051b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2052b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2053b411b363SPhilipp Reisner (unsigned long long)sector, size); 205481e84650SAndreas Gruenbacher return false; 2055b411b363SPhilipp Reisner } 2056b411b363SPhilipp Reisner 2057b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2058b18b37beSPhilipp Reisner verb = 1; 2059b18b37beSPhilipp Reisner switch (cmd) { 2060b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2061b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2062b18b37beSPhilipp Reisner break; 2063b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2064b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2065b18b37beSPhilipp Reisner case P_OV_REQUEST: 2066b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2067b18b37beSPhilipp Reisner break; 2068b18b37beSPhilipp Reisner case P_OV_REPLY: 2069b18b37beSPhilipp Reisner verb = 0; 2070b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2071b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2072b18b37beSPhilipp Reisner break; 2073b18b37beSPhilipp Reisner default: 2074b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2075b18b37beSPhilipp Reisner cmdname(cmd)); 2076b18b37beSPhilipp Reisner } 2077b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2078b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2079b411b363SPhilipp Reisner "no local data.\n"); 2080b18b37beSPhilipp Reisner 2081a821cc4aSLars Ellenberg /* drain possibly payload */ 2082a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 2083b411b363SPhilipp Reisner } 2084b411b363SPhilipp Reisner 2085b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2086b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2087b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2088db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2089db830c46SAndreas Gruenbacher if (!peer_req) { 2090b411b363SPhilipp Reisner put_ldev(mdev); 209181e84650SAndreas Gruenbacher return false; 2092b411b363SPhilipp Reisner } 2093b411b363SPhilipp Reisner 209402918be2SPhilipp Reisner switch (cmd) { 2095b411b363SPhilipp Reisner case P_DATA_REQUEST: 2096db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2097b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 209880a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 209980a40e43SLars Ellenberg goto submit; 210080a40e43SLars Ellenberg 2101b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2102db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2103b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 21045f9915bbSLars Ellenberg /* used in the sector offset progress display */ 21055f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2106b411b363SPhilipp Reisner break; 2107b411b363SPhilipp Reisner 2108b411b363SPhilipp Reisner case P_OV_REPLY: 2109b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2110b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2111b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2112b411b363SPhilipp Reisner if (!di) 2113b411b363SPhilipp Reisner goto out_free_e; 2114b411b363SPhilipp Reisner 2115b411b363SPhilipp Reisner di->digest_size = digest_size; 2116b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2117b411b363SPhilipp Reisner 2118db830c46SAndreas Gruenbacher peer_req->digest = di; 2119db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2120c36c3cedSLars Ellenberg 2121de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, di->digest, digest_size) != digest_size) 2122b411b363SPhilipp Reisner goto out_free_e; 2123b411b363SPhilipp Reisner 212402918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 212531890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2126db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 21275f9915bbSLars Ellenberg /* used in the sector offset progress display */ 21285f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 212902918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 21302649f080SLars Ellenberg /* track progress, we may need to throttle */ 21312649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2132db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2133b411b363SPhilipp Reisner dec_rs_pending(mdev); 21340f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 21350f0601f4SLars Ellenberg * but accounting still needs to be done. */ 21360f0601f4SLars Ellenberg goto submit_for_resync; 2137b411b363SPhilipp Reisner } 2138b411b363SPhilipp Reisner break; 2139b411b363SPhilipp Reisner 2140b411b363SPhilipp Reisner case P_OV_REQUEST: 2141b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 214231890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2143de228bbaSLars Ellenberg unsigned long now = jiffies; 2144de228bbaSLars Ellenberg int i; 2145b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2146b411b363SPhilipp Reisner mdev->ov_position = sector; 214730b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 214830b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2149de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2150de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2151de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2152de228bbaSLars Ellenberg } 2153b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2154b411b363SPhilipp Reisner (unsigned long long)sector); 2155b411b363SPhilipp Reisner } 2156db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2157b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2158b411b363SPhilipp Reisner break; 2159b411b363SPhilipp Reisner 2160b411b363SPhilipp Reisner default: 2161b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 216202918be2SPhilipp Reisner cmdname(cmd)); 2163b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 216480a40e43SLars Ellenberg goto out_free_e; 2165b411b363SPhilipp Reisner } 2166b411b363SPhilipp Reisner 21670f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 21680f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 21690f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 21700f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 21710f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 21720f0601f4SLars Ellenberg * 21730f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 21740f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 21750f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 21760f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 21770f0601f4SLars Ellenberg * a while, anyways. 21780f0601f4SLars Ellenberg */ 2179b411b363SPhilipp Reisner 21800f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 21810f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 21820f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 21830f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 21840f0601f4SLars Ellenberg * 21850f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 21860f0601f4SLars Ellenberg * we would also throttle its application reads. 21870f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 21880f0601f4SLars Ellenberg */ 2189e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2190e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2191e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 219280a40e43SLars Ellenberg goto out_free_e; 2193b411b363SPhilipp Reisner 21940f0601f4SLars Ellenberg submit_for_resync: 21950f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 21960f0601f4SLars Ellenberg 219780a40e43SLars Ellenberg submit: 2198b411b363SPhilipp Reisner inc_unacked(mdev); 219987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2200db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 220187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2202b411b363SPhilipp Reisner 2203fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 220481e84650SAndreas Gruenbacher return true; 2205b411b363SPhilipp Reisner 220610f6d992SLars Ellenberg /* don't care for the reason here */ 220710f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 220887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2209db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 221087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 221122cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 221222cc37a9SLars Ellenberg 2213b411b363SPhilipp Reisner out_free_e: 2214b411b363SPhilipp Reisner put_ldev(mdev); 2215db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 221681e84650SAndreas Gruenbacher return false; 2217b411b363SPhilipp Reisner } 2218b411b363SPhilipp Reisner 2219b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2220b411b363SPhilipp Reisner { 2221b411b363SPhilipp Reisner int self, peer, rv = -100; 2222b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2223b411b363SPhilipp Reisner 2224b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2225b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2226b411b363SPhilipp Reisner 2227b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2228b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2229b411b363SPhilipp Reisner 223089e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2231b411b363SPhilipp Reisner case ASB_CONSENSUS: 2232b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2233b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2234b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2235b411b363SPhilipp Reisner break; 2236b411b363SPhilipp Reisner case ASB_DISCONNECT: 2237b411b363SPhilipp Reisner break; 2238b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2239b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2240b411b363SPhilipp Reisner rv = -1; 2241b411b363SPhilipp Reisner break; 2242b411b363SPhilipp Reisner } 2243b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2244b411b363SPhilipp Reisner rv = 1; 2245b411b363SPhilipp Reisner break; 2246b411b363SPhilipp Reisner } 2247b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2248b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2249b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2250b411b363SPhilipp Reisner rv = 1; 2251b411b363SPhilipp Reisner break; 2252b411b363SPhilipp Reisner } 2253b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2254b411b363SPhilipp Reisner rv = -1; 2255b411b363SPhilipp Reisner break; 2256b411b363SPhilipp Reisner } 2257b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2258ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2259b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2260b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2261b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 226225703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2263b411b363SPhilipp Reisner ? -1 : 1; 2264b411b363SPhilipp Reisner break; 2265b411b363SPhilipp Reisner } else { 2266b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2267b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2268b411b363SPhilipp Reisner } 226989e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2270b411b363SPhilipp Reisner break; 2271b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2272b411b363SPhilipp Reisner if (ch_self < ch_peer) 2273b411b363SPhilipp Reisner rv = -1; 2274b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2275b411b363SPhilipp Reisner rv = 1; 2276b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2277b411b363SPhilipp Reisner /* Well, then use something else. */ 227825703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2279b411b363SPhilipp Reisner ? -1 : 1; 2280b411b363SPhilipp Reisner break; 2281b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2282b411b363SPhilipp Reisner rv = -1; 2283b411b363SPhilipp Reisner break; 2284b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2285b411b363SPhilipp Reisner rv = 1; 2286b411b363SPhilipp Reisner } 2287b411b363SPhilipp Reisner 2288b411b363SPhilipp Reisner return rv; 2289b411b363SPhilipp Reisner } 2290b411b363SPhilipp Reisner 2291b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2292b411b363SPhilipp Reisner { 22936184ea21SAndreas Gruenbacher int hg, rv = -100; 2294b411b363SPhilipp Reisner 229589e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2296b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2297b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2298b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2299b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2300b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2301b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2302b411b363SPhilipp Reisner break; 2303b411b363SPhilipp Reisner case ASB_DISCONNECT: 2304b411b363SPhilipp Reisner break; 2305b411b363SPhilipp Reisner case ASB_CONSENSUS: 2306b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2307b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2308b411b363SPhilipp Reisner rv = hg; 2309b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2310b411b363SPhilipp Reisner rv = hg; 2311b411b363SPhilipp Reisner break; 2312b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2313b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2314b411b363SPhilipp Reisner break; 2315b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2316b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2317b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2318b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2319b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2320bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2321bb437946SAndreas Gruenbacher 2322bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2323b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2324b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2325b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2326bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2327bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2328b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2329b411b363SPhilipp Reisner } else { 2330b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2331b411b363SPhilipp Reisner rv = hg; 2332b411b363SPhilipp Reisner } 2333b411b363SPhilipp Reisner } else 2334b411b363SPhilipp Reisner rv = hg; 2335b411b363SPhilipp Reisner } 2336b411b363SPhilipp Reisner 2337b411b363SPhilipp Reisner return rv; 2338b411b363SPhilipp Reisner } 2339b411b363SPhilipp Reisner 2340b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2341b411b363SPhilipp Reisner { 23426184ea21SAndreas Gruenbacher int hg, rv = -100; 2343b411b363SPhilipp Reisner 234489e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2345b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2346b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2347b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2348b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2349b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2350b411b363SPhilipp Reisner case ASB_CONSENSUS: 2351b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2352b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2353b411b363SPhilipp Reisner break; 2354b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2355b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2356b411b363SPhilipp Reisner break; 2357b411b363SPhilipp Reisner case ASB_DISCONNECT: 2358b411b363SPhilipp Reisner break; 2359b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2360b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2361b411b363SPhilipp Reisner if (hg == -1) { 2362bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2363bb437946SAndreas Gruenbacher 2364b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2365b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2366b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2367bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2368bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2369b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2370b411b363SPhilipp Reisner } else { 2371b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2372b411b363SPhilipp Reisner rv = hg; 2373b411b363SPhilipp Reisner } 2374b411b363SPhilipp Reisner } else 2375b411b363SPhilipp Reisner rv = hg; 2376b411b363SPhilipp Reisner } 2377b411b363SPhilipp Reisner 2378b411b363SPhilipp Reisner return rv; 2379b411b363SPhilipp Reisner } 2380b411b363SPhilipp Reisner 2381b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2382b411b363SPhilipp Reisner u64 bits, u64 flags) 2383b411b363SPhilipp Reisner { 2384b411b363SPhilipp Reisner if (!uuid) { 2385b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2386b411b363SPhilipp Reisner return; 2387b411b363SPhilipp Reisner } 2388b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2389b411b363SPhilipp Reisner text, 2390b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2391b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2392b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2393b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2394b411b363SPhilipp Reisner (unsigned long long)bits, 2395b411b363SPhilipp Reisner (unsigned long long)flags); 2396b411b363SPhilipp Reisner } 2397b411b363SPhilipp Reisner 2398b411b363SPhilipp Reisner /* 2399b411b363SPhilipp Reisner 100 after split brain try auto recover 2400b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2401b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2402b411b363SPhilipp Reisner 0 no Sync 2403b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2404b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2405b411b363SPhilipp Reisner -100 after split brain, disconnect 2406b411b363SPhilipp Reisner -1000 unrelated data 24074a23f264SPhilipp Reisner -1091 requires proto 91 24084a23f264SPhilipp Reisner -1096 requires proto 96 2409b411b363SPhilipp Reisner */ 2410b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2411b411b363SPhilipp Reisner { 2412b411b363SPhilipp Reisner u64 self, peer; 2413b411b363SPhilipp Reisner int i, j; 2414b411b363SPhilipp Reisner 2415b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2416b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2417b411b363SPhilipp Reisner 2418b411b363SPhilipp Reisner *rule_nr = 10; 2419b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2420b411b363SPhilipp Reisner return 0; 2421b411b363SPhilipp Reisner 2422b411b363SPhilipp Reisner *rule_nr = 20; 2423b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2424b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2425b411b363SPhilipp Reisner return -2; 2426b411b363SPhilipp Reisner 2427b411b363SPhilipp Reisner *rule_nr = 30; 2428b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2429b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2430b411b363SPhilipp Reisner return 2; 2431b411b363SPhilipp Reisner 2432b411b363SPhilipp Reisner if (self == peer) { 2433b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2434b411b363SPhilipp Reisner 2435b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2436b411b363SPhilipp Reisner 243731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24384a23f264SPhilipp Reisner return -1091; 2439b411b363SPhilipp Reisner 2440b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2441b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2442b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2443b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2444b411b363SPhilipp Reisner 2445b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2446b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2447b411b363SPhilipp Reisner *rule_nr = 34; 2448b411b363SPhilipp Reisner } else { 2449b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2450b411b363SPhilipp Reisner *rule_nr = 36; 2451b411b363SPhilipp Reisner } 2452b411b363SPhilipp Reisner 2453b411b363SPhilipp Reisner return 1; 2454b411b363SPhilipp Reisner } 2455b411b363SPhilipp Reisner 2456b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2457b411b363SPhilipp Reisner 245831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 24594a23f264SPhilipp Reisner return -1091; 2460b411b363SPhilipp Reisner 2461b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2462b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2463b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2464b411b363SPhilipp Reisner 2465b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2466b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2467b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2468b411b363SPhilipp Reisner 2469b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2470b411b363SPhilipp Reisner *rule_nr = 35; 2471b411b363SPhilipp Reisner } else { 2472b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2473b411b363SPhilipp Reisner *rule_nr = 37; 2474b411b363SPhilipp Reisner } 2475b411b363SPhilipp Reisner 2476b411b363SPhilipp Reisner return -1; 2477b411b363SPhilipp Reisner } 2478b411b363SPhilipp Reisner 2479b411b363SPhilipp Reisner /* Common power [off|failure] */ 2480b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2481b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2482b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2483b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2484b411b363SPhilipp Reisner *rule_nr = 40; 2485b411b363SPhilipp Reisner 2486b411b363SPhilipp Reisner switch (rct) { 2487b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2488b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2489b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2490b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 249125703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2492b411b363SPhilipp Reisner return dc ? -1 : 1; 2493b411b363SPhilipp Reisner } 2494b411b363SPhilipp Reisner } 2495b411b363SPhilipp Reisner 2496b411b363SPhilipp Reisner *rule_nr = 50; 2497b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2498b411b363SPhilipp Reisner if (self == peer) 2499b411b363SPhilipp Reisner return -1; 2500b411b363SPhilipp Reisner 2501b411b363SPhilipp Reisner *rule_nr = 51; 2502b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2503b411b363SPhilipp Reisner if (self == peer) { 250431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 25054a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 25064a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 25074a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2508b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2509b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2510b411b363SPhilipp Reisner 251131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25124a23f264SPhilipp Reisner return -1091; 2513b411b363SPhilipp Reisner 2514b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2515b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 25164a23f264SPhilipp Reisner 25174a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 25184a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 25194a23f264SPhilipp Reisner 2520b411b363SPhilipp Reisner return -1; 2521b411b363SPhilipp Reisner } 2522b411b363SPhilipp Reisner } 2523b411b363SPhilipp Reisner 2524b411b363SPhilipp Reisner *rule_nr = 60; 2525b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2526b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2527b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2528b411b363SPhilipp Reisner if (self == peer) 2529b411b363SPhilipp Reisner return -2; 2530b411b363SPhilipp Reisner } 2531b411b363SPhilipp Reisner 2532b411b363SPhilipp Reisner *rule_nr = 70; 2533b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2534b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2535b411b363SPhilipp Reisner if (self == peer) 2536b411b363SPhilipp Reisner return 1; 2537b411b363SPhilipp Reisner 2538b411b363SPhilipp Reisner *rule_nr = 71; 2539b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2540b411b363SPhilipp Reisner if (self == peer) { 254131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 25424a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 25434a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 25444a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2545b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2546b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2547b411b363SPhilipp Reisner 254831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25494a23f264SPhilipp Reisner return -1091; 2550b411b363SPhilipp Reisner 2551b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2552b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2553b411b363SPhilipp Reisner 25544a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2555b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2556b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2557b411b363SPhilipp Reisner 2558b411b363SPhilipp Reisner return 1; 2559b411b363SPhilipp Reisner } 2560b411b363SPhilipp Reisner } 2561b411b363SPhilipp Reisner 2562b411b363SPhilipp Reisner 2563b411b363SPhilipp Reisner *rule_nr = 80; 2564d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2565b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2566b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2567b411b363SPhilipp Reisner if (self == peer) 2568b411b363SPhilipp Reisner return 2; 2569b411b363SPhilipp Reisner } 2570b411b363SPhilipp Reisner 2571b411b363SPhilipp Reisner *rule_nr = 90; 2572b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2573b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2574b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2575b411b363SPhilipp Reisner return 100; 2576b411b363SPhilipp Reisner 2577b411b363SPhilipp Reisner *rule_nr = 100; 2578b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2579b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2580b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2581b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2582b411b363SPhilipp Reisner if (self == peer) 2583b411b363SPhilipp Reisner return -100; 2584b411b363SPhilipp Reisner } 2585b411b363SPhilipp Reisner } 2586b411b363SPhilipp Reisner 2587b411b363SPhilipp Reisner return -1000; 2588b411b363SPhilipp Reisner } 2589b411b363SPhilipp Reisner 2590b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2591b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2592b411b363SPhilipp Reisner */ 2593b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2594b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2595b411b363SPhilipp Reisner { 2596b411b363SPhilipp Reisner int hg, rule_nr; 2597b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2598b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2599b411b363SPhilipp Reisner 2600b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2601b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2602b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2603b411b363SPhilipp Reisner 2604b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2605b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2606b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2607b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2608b411b363SPhilipp Reisner 2609b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2610b411b363SPhilipp Reisner 2611b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2612b411b363SPhilipp Reisner 2613b411b363SPhilipp Reisner if (hg == -1000) { 2614b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2615b411b363SPhilipp Reisner return C_MASK; 2616b411b363SPhilipp Reisner } 26174a23f264SPhilipp Reisner if (hg < -1000) { 26184a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2619b411b363SPhilipp Reisner return C_MASK; 2620b411b363SPhilipp Reisner } 2621b411b363SPhilipp Reisner 2622b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2623b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2624b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2625b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2626b411b363SPhilipp Reisner if (f) 2627b411b363SPhilipp Reisner hg = hg*2; 2628b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2629b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2630b411b363SPhilipp Reisner } 2631b411b363SPhilipp Reisner 26323a11a487SAdam Gandelman if (abs(hg) == 100) 26333a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 26343a11a487SAdam Gandelman 263589e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2636b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2637b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2638b411b363SPhilipp Reisner int forced = (hg == -100); 2639b411b363SPhilipp Reisner 2640b411b363SPhilipp Reisner switch (pcount) { 2641b411b363SPhilipp Reisner case 0: 2642b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2643b411b363SPhilipp Reisner break; 2644b411b363SPhilipp Reisner case 1: 2645b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2646b411b363SPhilipp Reisner break; 2647b411b363SPhilipp Reisner case 2: 2648b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2649b411b363SPhilipp Reisner break; 2650b411b363SPhilipp Reisner } 2651b411b363SPhilipp Reisner if (abs(hg) < 100) { 2652b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2653b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2654b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2655b411b363SPhilipp Reisner if (forced) { 2656b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2657b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2658b411b363SPhilipp Reisner hg = hg*2; 2659b411b363SPhilipp Reisner } 2660b411b363SPhilipp Reisner } 2661b411b363SPhilipp Reisner } 2662b411b363SPhilipp Reisner 2663b411b363SPhilipp Reisner if (hg == -100) { 266489e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2665b411b363SPhilipp Reisner hg = -1; 266689e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2667b411b363SPhilipp Reisner hg = 1; 2668b411b363SPhilipp Reisner 2669b411b363SPhilipp Reisner if (abs(hg) < 100) 2670b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2671b411b363SPhilipp Reisner "Sync from %s node\n", 2672b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2673b411b363SPhilipp Reisner } 2674b411b363SPhilipp Reisner 2675b411b363SPhilipp Reisner if (hg == -100) { 2676580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2677580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2678580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2679580b9767SLars Ellenberg * to that disk, in a way... */ 26803a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2681b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2682b411b363SPhilipp Reisner return C_MASK; 2683b411b363SPhilipp Reisner } 2684b411b363SPhilipp Reisner 2685b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2686b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2687b411b363SPhilipp Reisner return C_MASK; 2688b411b363SPhilipp Reisner } 2689b411b363SPhilipp Reisner 2690b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2691b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 269289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2693b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2694b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2695b411b363SPhilipp Reisner /* fall through */ 2696b411b363SPhilipp Reisner case ASB_DISCONNECT: 2697b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2698b411b363SPhilipp Reisner return C_MASK; 2699b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2700b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2701b411b363SPhilipp Reisner "assumption\n"); 2702b411b363SPhilipp Reisner } 2703b411b363SPhilipp Reisner } 2704b411b363SPhilipp Reisner 270589e58e75SPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) { 2706cf14c2e9SPhilipp Reisner if (hg == 0) 2707cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2708cf14c2e9SPhilipp Reisner else 2709cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2710cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2711cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2712cf14c2e9SPhilipp Reisner return C_MASK; 2713cf14c2e9SPhilipp Reisner } 2714cf14c2e9SPhilipp Reisner 2715b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2716b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 271720ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 271820ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2719b411b363SPhilipp Reisner return C_MASK; 2720b411b363SPhilipp Reisner } 2721b411b363SPhilipp Reisner 2722b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2723b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2724b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2725b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2726b411b363SPhilipp Reisner } else { 2727b411b363SPhilipp Reisner rv = C_CONNECTED; 2728b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2729b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2730b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2731b411b363SPhilipp Reisner } 2732b411b363SPhilipp Reisner } 2733b411b363SPhilipp Reisner 2734b411b363SPhilipp Reisner return rv; 2735b411b363SPhilipp Reisner } 2736b411b363SPhilipp Reisner 2737b411b363SPhilipp Reisner /* returns 1 if invalid */ 2738b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2739b411b363SPhilipp Reisner { 2740b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2741b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2742b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2743b411b363SPhilipp Reisner return 0; 2744b411b363SPhilipp Reisner 2745b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2746b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2747b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2748b411b363SPhilipp Reisner return 1; 2749b411b363SPhilipp Reisner 2750b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2751b411b363SPhilipp Reisner if (peer == self) 2752b411b363SPhilipp Reisner return 0; 2753b411b363SPhilipp Reisner 2754b411b363SPhilipp Reisner /* everything es is invalid. */ 2755b411b363SPhilipp Reisner return 1; 2756b411b363SPhilipp Reisner } 2757b411b363SPhilipp Reisner 2758d8763023SAndreas Gruenbacher static int receive_protocol(struct drbd_conf *mdev, enum drbd_packet cmd, 2759d8763023SAndreas Gruenbacher unsigned int data_size) 2760b411b363SPhilipp Reisner { 2761e42325a5SPhilipp Reisner struct p_protocol *p = &mdev->tconn->data.rbuf.protocol; 2762b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2763cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2764b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2765b411b363SPhilipp Reisner 2766b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2767b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2768b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2769b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2770b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2771cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2772cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2773cf14c2e9SPhilipp Reisner 2774cf14c2e9SPhilipp Reisner clear_bit(CONN_DRY_RUN, &mdev->flags); 2775cf14c2e9SPhilipp Reisner 2776cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 2777cf14c2e9SPhilipp Reisner set_bit(CONN_DRY_RUN, &mdev->flags); 2778b411b363SPhilipp Reisner 277989e58e75SPhilipp Reisner if (p_proto != mdev->tconn->net_conf->wire_protocol) { 2780b411b363SPhilipp Reisner dev_err(DEV, "incompatible communication protocols\n"); 2781b411b363SPhilipp Reisner goto disconnect; 2782b411b363SPhilipp Reisner } 2783b411b363SPhilipp Reisner 278489e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, mdev->tconn->net_conf->after_sb_0p)) { 2785b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-0pri settings\n"); 2786b411b363SPhilipp Reisner goto disconnect; 2787b411b363SPhilipp Reisner } 2788b411b363SPhilipp Reisner 278989e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, mdev->tconn->net_conf->after_sb_1p)) { 2790b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-1pri settings\n"); 2791b411b363SPhilipp Reisner goto disconnect; 2792b411b363SPhilipp Reisner } 2793b411b363SPhilipp Reisner 279489e58e75SPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, mdev->tconn->net_conf->after_sb_2p)) { 2795b411b363SPhilipp Reisner dev_err(DEV, "incompatible after-sb-2pri settings\n"); 2796b411b363SPhilipp Reisner goto disconnect; 2797b411b363SPhilipp Reisner } 2798b411b363SPhilipp Reisner 279989e58e75SPhilipp Reisner if (p_want_lose && mdev->tconn->net_conf->want_lose) { 2800b411b363SPhilipp Reisner dev_err(DEV, "both sides have the 'want_lose' flag set\n"); 2801b411b363SPhilipp Reisner goto disconnect; 2802b411b363SPhilipp Reisner } 2803b411b363SPhilipp Reisner 280489e58e75SPhilipp Reisner if (p_two_primaries != mdev->tconn->net_conf->two_primaries) { 2805b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the two-primaries options\n"); 2806b411b363SPhilipp Reisner goto disconnect; 2807b411b363SPhilipp Reisner } 2808b411b363SPhilipp Reisner 280931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version >= 87) { 281089e58e75SPhilipp Reisner unsigned char *my_alg = mdev->tconn->net_conf->integrity_alg; 2811b411b363SPhilipp Reisner 2812de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p_integrity_alg, data_size) != data_size) 281381e84650SAndreas Gruenbacher return false; 2814b411b363SPhilipp Reisner 2815b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2816b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 2817b411b363SPhilipp Reisner dev_err(DEV, "incompatible setting of the data-integrity-alg\n"); 2818b411b363SPhilipp Reisner goto disconnect; 2819b411b363SPhilipp Reisner } 2820b411b363SPhilipp Reisner dev_info(DEV, "data-integrity-alg: %s\n", 2821b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2822b411b363SPhilipp Reisner } 2823b411b363SPhilipp Reisner 282481e84650SAndreas Gruenbacher return true; 2825b411b363SPhilipp Reisner 2826b411b363SPhilipp Reisner disconnect: 2827b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 282881e84650SAndreas Gruenbacher return false; 2829b411b363SPhilipp Reisner } 2830b411b363SPhilipp Reisner 2831b411b363SPhilipp Reisner /* helper function 2832b411b363SPhilipp Reisner * input: alg name, feature name 2833b411b363SPhilipp Reisner * return: NULL (alg name was "") 2834b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2835b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2836b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2837b411b363SPhilipp Reisner const char *alg, const char *name) 2838b411b363SPhilipp Reisner { 2839b411b363SPhilipp Reisner struct crypto_hash *tfm; 2840b411b363SPhilipp Reisner 2841b411b363SPhilipp Reisner if (!alg[0]) 2842b411b363SPhilipp Reisner return NULL; 2843b411b363SPhilipp Reisner 2844b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2845b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2846b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2847b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2848b411b363SPhilipp Reisner return tfm; 2849b411b363SPhilipp Reisner } 2850b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2851b411b363SPhilipp Reisner crypto_free_hash(tfm); 2852b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2853b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2854b411b363SPhilipp Reisner } 2855b411b363SPhilipp Reisner return tfm; 2856b411b363SPhilipp Reisner } 2857b411b363SPhilipp Reisner 2858d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2859d8763023SAndreas Gruenbacher unsigned int packet_size) 2860b411b363SPhilipp Reisner { 286181e84650SAndreas Gruenbacher int ok = true; 2862e42325a5SPhilipp Reisner struct p_rs_param_95 *p = &mdev->tconn->data.rbuf.rs_param_95; 2863b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2864b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2865b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 286631890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2867778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2868778f271dSPhilipp Reisner int fifo_size = 0; 2869b411b363SPhilipp Reisner 2870b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2871b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2872b411b363SPhilipp Reisner + SHARED_SECRET_MAX 28738e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 28748e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2875b411b363SPhilipp Reisner 287602918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2877b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 287802918be2SPhilipp Reisner packet_size, exp_max_sz); 287981e84650SAndreas Gruenbacher return false; 2880b411b363SPhilipp Reisner } 2881b411b363SPhilipp Reisner 2882b411b363SPhilipp Reisner if (apv <= 88) { 2883257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 288402918be2SPhilipp Reisner data_size = packet_size - header_size; 28858e26f9ccSPhilipp Reisner } else if (apv <= 94) { 2886257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 288702918be2SPhilipp Reisner data_size = packet_size - header_size; 2888b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 28898e26f9ccSPhilipp Reisner } else { 2890257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 289102918be2SPhilipp Reisner data_size = packet_size - header_size; 2892b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2893b411b363SPhilipp Reisner } 2894b411b363SPhilipp Reisner 2895b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2896b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2897b411b363SPhilipp Reisner 2898de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, &p->head.payload, header_size) != header_size) 289981e84650SAndreas Gruenbacher return false; 2900b411b363SPhilipp Reisner 2901b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 2902b411b363SPhilipp Reisner 2903b411b363SPhilipp Reisner if (apv >= 88) { 2904b411b363SPhilipp Reisner if (apv == 88) { 2905b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 2906b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 2907b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 2908b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 290981e84650SAndreas Gruenbacher return false; 2910b411b363SPhilipp Reisner } 2911b411b363SPhilipp Reisner 2912de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->verify_alg, data_size) != data_size) 291381e84650SAndreas Gruenbacher return false; 2914b411b363SPhilipp Reisner 2915b411b363SPhilipp Reisner /* we expect NUL terminated string */ 2916b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2917b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 2918b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 2919b411b363SPhilipp Reisner 2920b411b363SPhilipp Reisner } else /* apv >= 89 */ { 2921b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 2922b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 2923b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 2924b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 2925b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 2926b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 2927b411b363SPhilipp Reisner } 2928b411b363SPhilipp Reisner 2929b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 2930b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2931b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 2932b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 2933b411b363SPhilipp Reisner goto disconnect; 2934b411b363SPhilipp Reisner } 2935b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 2936b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 2937b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 2938b411b363SPhilipp Reisner verify_tfm = NULL; 2939b411b363SPhilipp Reisner goto disconnect; 2940b411b363SPhilipp Reisner } 2941b411b363SPhilipp Reisner } 2942b411b363SPhilipp Reisner 2943b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 2944b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 2945b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 2946b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 2947b411b363SPhilipp Reisner goto disconnect; 2948b411b363SPhilipp Reisner } 2949b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 2950b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 2951b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 2952b411b363SPhilipp Reisner csums_tfm = NULL; 2953b411b363SPhilipp Reisner goto disconnect; 2954b411b363SPhilipp Reisner } 2955b411b363SPhilipp Reisner } 2956b411b363SPhilipp Reisner 29578e26f9ccSPhilipp Reisner if (apv > 94) { 29588e26f9ccSPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 29598e26f9ccSPhilipp Reisner mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 29608e26f9ccSPhilipp Reisner mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target); 29618e26f9ccSPhilipp Reisner mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target); 29628e26f9ccSPhilipp Reisner mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate); 2963778f271dSPhilipp Reisner 2964778f271dSPhilipp Reisner fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 2965778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 2966778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 2967778f271dSPhilipp Reisner if (!rs_plan_s) { 2968778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 2969778f271dSPhilipp Reisner goto disconnect; 2970778f271dSPhilipp Reisner } 2971778f271dSPhilipp Reisner } 29728e26f9ccSPhilipp Reisner } 2973b411b363SPhilipp Reisner 2974b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 2975b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 2976b411b363SPhilipp Reisner if (verify_tfm) { 2977b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 2978b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 2979b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 2980b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 2981b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 2982b411b363SPhilipp Reisner } 2983b411b363SPhilipp Reisner if (csums_tfm) { 2984b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 2985b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 2986b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 2987b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 2988b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 2989b411b363SPhilipp Reisner } 2990778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 2991778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 2992778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 2993778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 2994778f271dSPhilipp Reisner mdev->rs_planed = 0; 2995778f271dSPhilipp Reisner } 2996b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 2997b411b363SPhilipp Reisner } 2998b411b363SPhilipp Reisner 2999b411b363SPhilipp Reisner return ok; 3000b411b363SPhilipp Reisner disconnect: 3001b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3002b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3003b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3004b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3005b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 3006b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 300781e84650SAndreas Gruenbacher return false; 3008b411b363SPhilipp Reisner } 3009b411b363SPhilipp Reisner 3010b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3011b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3012b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3013b411b363SPhilipp Reisner { 3014b411b363SPhilipp Reisner sector_t d; 3015b411b363SPhilipp Reisner if (a == 0 || b == 0) 3016b411b363SPhilipp Reisner return; 3017b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3018b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3019b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3020b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3021b411b363SPhilipp Reisner } 3022b411b363SPhilipp Reisner 3023d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 3024d8763023SAndreas Gruenbacher unsigned int data_size) 3025b411b363SPhilipp Reisner { 3026e42325a5SPhilipp Reisner struct p_sizes *p = &mdev->tconn->data.rbuf.sizes; 3027b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3028b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3029b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3030e89b591cSPhilipp Reisner enum dds_flags ddsf; 3031b411b363SPhilipp Reisner 3032b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3033b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3034b411b363SPhilipp Reisner 3035b411b363SPhilipp Reisner if (p_size == 0 && mdev->state.disk == D_DISKLESS) { 3036b411b363SPhilipp Reisner dev_err(DEV, "some backing storage is needed\n"); 3037b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 303881e84650SAndreas Gruenbacher return false; 3039b411b363SPhilipp Reisner } 3040b411b363SPhilipp Reisner 3041b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3042b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3043b411b363SPhilipp Reisner mdev->p_size = p_size; 3044b411b363SPhilipp Reisner 3045b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3046b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3047b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3048b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3049b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3050b411b363SPhilipp Reisner 3051b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3052b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3053b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3054b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3055b411b363SPhilipp Reisner p_usize); 3056b411b363SPhilipp Reisner 3057b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3058b411b363SPhilipp Reisner 3059b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3060b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3061b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3062b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3063b411b363SPhilipp Reisner } 3064b411b363SPhilipp Reisner 3065b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3066b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3067a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3068b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3069b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3070b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3071b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 3072b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 3073b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3074b411b363SPhilipp Reisner put_ldev(mdev); 307581e84650SAndreas Gruenbacher return false; 3076b411b363SPhilipp Reisner } 3077b411b363SPhilipp Reisner put_ldev(mdev); 3078b411b363SPhilipp Reisner } 3079b411b363SPhilipp Reisner 3080e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3081b411b363SPhilipp Reisner if (get_ldev(mdev)) { 308224c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3083b411b363SPhilipp Reisner put_ldev(mdev); 3084b411b363SPhilipp Reisner if (dd == dev_size_error) 308581e84650SAndreas Gruenbacher return false; 3086b411b363SPhilipp Reisner drbd_md_sync(mdev); 3087b411b363SPhilipp Reisner } else { 3088b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3089b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3090b411b363SPhilipp Reisner } 3091b411b363SPhilipp Reisner 309299432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 309399432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 309499432fccSPhilipp Reisner 3095b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3096b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3097b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3098b411b363SPhilipp Reisner ldsc = 1; 3099b411b363SPhilipp Reisner } 3100b411b363SPhilipp Reisner 3101b411b363SPhilipp Reisner put_ldev(mdev); 3102b411b363SPhilipp Reisner } 3103b411b363SPhilipp Reisner 3104b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3105b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3106b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3107b411b363SPhilipp Reisner /* we have different sizes, probably peer 3108b411b363SPhilipp Reisner * needs to know my new size... */ 3109e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3110b411b363SPhilipp Reisner } 3111b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3112b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3113b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3114e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3115e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3116e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3117b411b363SPhilipp Reisner else 3118e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3119e89b591cSPhilipp Reisner } else 3120b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3121b411b363SPhilipp Reisner } 3122b411b363SPhilipp Reisner } 3123b411b363SPhilipp Reisner 312481e84650SAndreas Gruenbacher return true; 3125b411b363SPhilipp Reisner } 3126b411b363SPhilipp Reisner 3127d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3128d8763023SAndreas Gruenbacher unsigned int data_size) 3129b411b363SPhilipp Reisner { 3130e42325a5SPhilipp Reisner struct p_uuids *p = &mdev->tconn->data.rbuf.uuids; 3131b411b363SPhilipp Reisner u64 *p_uuid; 313262b0da3aSLars Ellenberg int i, updated_uuids = 0; 3133b411b363SPhilipp Reisner 3134b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3135b411b363SPhilipp Reisner 3136b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3137b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3138b411b363SPhilipp Reisner 3139b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3140b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3141b411b363SPhilipp Reisner 3142b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3143b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3144b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3145b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3146b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3147b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 3148b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 314981e84650SAndreas Gruenbacher return false; 3150b411b363SPhilipp Reisner } 3151b411b363SPhilipp Reisner 3152b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3153b411b363SPhilipp Reisner int skip_initial_sync = 3154b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 315531890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3156b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3157b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3158b411b363SPhilipp Reisner if (skip_initial_sync) { 3159b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3160b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 316120ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 316220ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3163b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3164b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3165b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3166b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3167b411b363SPhilipp Reisner drbd_md_sync(mdev); 316862b0da3aSLars Ellenberg updated_uuids = 1; 3169b411b363SPhilipp Reisner } 3170b411b363SPhilipp Reisner put_ldev(mdev); 317118a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 317218a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 317318a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 317418a50fa2SPhilipp Reisner for me. */ 317562b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3176b411b363SPhilipp Reisner } 3177b411b363SPhilipp Reisner 3178b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3179b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3180b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3181b411b363SPhilipp Reisner new disk state... */ 31828410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 31838410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3184b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 318562b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 318662b0da3aSLars Ellenberg 318762b0da3aSLars Ellenberg if (updated_uuids) 318862b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3189b411b363SPhilipp Reisner 319081e84650SAndreas Gruenbacher return true; 3191b411b363SPhilipp Reisner } 3192b411b363SPhilipp Reisner 3193b411b363SPhilipp Reisner /** 3194b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3195b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3196b411b363SPhilipp Reisner */ 3197b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3198b411b363SPhilipp Reisner { 3199b411b363SPhilipp Reisner union drbd_state ms; 3200b411b363SPhilipp Reisner 3201b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3202b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3203b411b363SPhilipp Reisner 3204b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3205b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3206b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3207b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3208b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3209b411b363SPhilipp Reisner }; 3210b411b363SPhilipp Reisner 3211b411b363SPhilipp Reisner ms.i = ps.i; 3212b411b363SPhilipp Reisner 3213b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3214b411b363SPhilipp Reisner ms.peer = ps.role; 3215b411b363SPhilipp Reisner ms.role = ps.peer; 3216b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3217b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3218b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3219b411b363SPhilipp Reisner 3220b411b363SPhilipp Reisner return ms; 3221b411b363SPhilipp Reisner } 3222b411b363SPhilipp Reisner 3223d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3224d8763023SAndreas Gruenbacher unsigned int data_size) 3225b411b363SPhilipp Reisner { 3226e42325a5SPhilipp Reisner struct p_req_state *p = &mdev->tconn->data.rbuf.req_state; 3227b411b363SPhilipp Reisner union drbd_state mask, val; 3228bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3229b411b363SPhilipp Reisner 3230b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3231b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3232b411b363SPhilipp Reisner 323325703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 32348410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3235b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 323681e84650SAndreas Gruenbacher return true; 3237b411b363SPhilipp Reisner } 3238b411b363SPhilipp Reisner 3239b411b363SPhilipp Reisner mask = convert_state(mask); 3240b411b363SPhilipp Reisner val = convert_state(val); 3241b411b363SPhilipp Reisner 3242047cd4a6SPhilipp Reisner if (cmd == P_CONN_ST_CHG_REQ) { 3243047cd4a6SPhilipp Reisner rv = conn_request_state(mdev->tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY); 3244047cd4a6SPhilipp Reisner conn_send_sr_reply(mdev->tconn, rv); 3245047cd4a6SPhilipp Reisner } else { 3246b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3247b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3248047cd4a6SPhilipp Reisner } 3249047cd4a6SPhilipp Reisner 3250b411b363SPhilipp Reisner drbd_md_sync(mdev); 3251b411b363SPhilipp Reisner 325281e84650SAndreas Gruenbacher return true; 3253b411b363SPhilipp Reisner } 3254b411b363SPhilipp Reisner 3255d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3256d8763023SAndreas Gruenbacher unsigned int data_size) 3257b411b363SPhilipp Reisner { 3258e42325a5SPhilipp Reisner struct p_state *p = &mdev->tconn->data.rbuf.state; 32594ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3260b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 326165d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3262b411b363SPhilipp Reisner int rv; 3263b411b363SPhilipp Reisner 3264b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3265b411b363SPhilipp Reisner 3266b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3267b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3268b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3269b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3270b411b363SPhilipp Reisner } 3271b411b363SPhilipp Reisner 327287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3273b411b363SPhilipp Reisner retry: 32744ac4aadaSLars Ellenberg os = ns = mdev->state; 327587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3276b411b363SPhilipp Reisner 3277e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3278e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3279e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3280e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3281e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3282e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3283e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3284e9ef7bb6SLars Ellenberg * syncing states. 3285e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3286e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3287e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3288e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3289e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3290e9ef7bb6SLars Ellenberg 3291e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3292e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3293e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3294e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3295e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3296e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3297e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 329881e84650SAndreas Gruenbacher return true; 3299e9ef7bb6SLars Ellenberg } 3300e9ef7bb6SLars Ellenberg } 3301e9ef7bb6SLars Ellenberg 3302e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3303e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3304e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3305e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3306e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3307e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3308e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3309e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3310e9ef7bb6SLars Ellenberg 33114ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 33124ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3313b411b363SPhilipp Reisner 331467531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 331567531718SPhilipp Reisner ns.conn = C_BEHIND; 331667531718SPhilipp Reisner 3317b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3318b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3319b411b363SPhilipp Reisner int cr; /* consider resync */ 3320b411b363SPhilipp Reisner 3321b411b363SPhilipp Reisner /* if we established a new connection */ 33224ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3323b411b363SPhilipp Reisner /* if we had an established connection 3324b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 33254ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3326b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 33274ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3328b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3329b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3330b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3331b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3332b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 33334ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3334b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3335b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3336b411b363SPhilipp Reisner 3337b411b363SPhilipp Reisner if (cr) 33384ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3339b411b363SPhilipp Reisner 3340b411b363SPhilipp Reisner put_ldev(mdev); 33414ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 33424ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3343b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 334482f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3345b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3346b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3347b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3348580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3349b411b363SPhilipp Reisner } else { 3350cf14c2e9SPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags)) 335181e84650SAndreas Gruenbacher return false; 33524ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 3353b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 335481e84650SAndreas Gruenbacher return false; 3355b411b363SPhilipp Reisner } 3356b411b363SPhilipp Reisner } 3357b411b363SPhilipp Reisner } 3358b411b363SPhilipp Reisner 335987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 33604ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3361b411b363SPhilipp Reisner goto retry; 3362b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3363b411b363SPhilipp Reisner ns.peer = peer_state.role; 3364b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3365b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 33664ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3367b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 33684ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 33694ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3370481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 33718554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3372481c6f50SPhilipp Reisner for temporal network outages! */ 337387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3374481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 3375481c6f50SPhilipp Reisner tl_clear(mdev); 3376481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3377481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 3378481c6f50SPhilipp Reisner drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0)); 337981e84650SAndreas Gruenbacher return false; 3380481c6f50SPhilipp Reisner } 338165d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3382b411b363SPhilipp Reisner ns = mdev->state; 338387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3384b411b363SPhilipp Reisner 3385b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 3386b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_DISCONNECTING)); 338781e84650SAndreas Gruenbacher return false; 3388b411b363SPhilipp Reisner } 3389b411b363SPhilipp Reisner 33904ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 33914ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3392b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3393b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3394b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3395b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3396b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3397b411b363SPhilipp Reisner drbd_send_state(mdev); 3398b411b363SPhilipp Reisner } 3399b411b363SPhilipp Reisner } 3400b411b363SPhilipp Reisner 340189e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3402b411b363SPhilipp Reisner 3403b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3404b411b363SPhilipp Reisner 340581e84650SAndreas Gruenbacher return true; 3406b411b363SPhilipp Reisner } 3407b411b363SPhilipp Reisner 3408d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3409d8763023SAndreas Gruenbacher unsigned int data_size) 3410b411b363SPhilipp Reisner { 3411e42325a5SPhilipp Reisner struct p_rs_uuid *p = &mdev->tconn->data.rbuf.rs_uuid; 3412b411b363SPhilipp Reisner 3413b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3414b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3415c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3416b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3417b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3418b411b363SPhilipp Reisner 3419b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3420b411b363SPhilipp Reisner 3421b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3422b411b363SPhilipp Reisner _not_ be rotated into the history */ 3423b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3424b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3425b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3426b411b363SPhilipp Reisner 342762b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3428b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3429b411b363SPhilipp Reisner 3430b411b363SPhilipp Reisner put_ldev(mdev); 3431b411b363SPhilipp Reisner } else 3432b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3433b411b363SPhilipp Reisner 343481e84650SAndreas Gruenbacher return true; 3435b411b363SPhilipp Reisner } 3436b411b363SPhilipp Reisner 34372c46407dSAndreas Gruenbacher /** 34382c46407dSAndreas Gruenbacher * receive_bitmap_plain 34392c46407dSAndreas Gruenbacher * 34402c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34412c46407dSAndreas Gruenbacher * code upon failure. 34422c46407dSAndreas Gruenbacher */ 34432c46407dSAndreas Gruenbacher static int 344402918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3445b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3446b411b363SPhilipp Reisner { 3447b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3448b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 34492c46407dSAndreas Gruenbacher int err; 3450b411b363SPhilipp Reisner 345102918be2SPhilipp Reisner if (want != data_size) { 345202918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 34532c46407dSAndreas Gruenbacher return -EIO; 3454b411b363SPhilipp Reisner } 3455b411b363SPhilipp Reisner if (want == 0) 34562c46407dSAndreas Gruenbacher return 0; 3457de0ff338SPhilipp Reisner err = drbd_recv(mdev->tconn, buffer, want); 34582c46407dSAndreas Gruenbacher if (err != want) { 34592c46407dSAndreas Gruenbacher if (err >= 0) 34602c46407dSAndreas Gruenbacher err = -EIO; 34612c46407dSAndreas Gruenbacher return err; 34622c46407dSAndreas Gruenbacher } 3463b411b363SPhilipp Reisner 3464b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3465b411b363SPhilipp Reisner 3466b411b363SPhilipp Reisner c->word_offset += num_words; 3467b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3468b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3469b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3470b411b363SPhilipp Reisner 34712c46407dSAndreas Gruenbacher return 1; 3472b411b363SPhilipp Reisner } 3473b411b363SPhilipp Reisner 34742c46407dSAndreas Gruenbacher /** 34752c46407dSAndreas Gruenbacher * recv_bm_rle_bits 34762c46407dSAndreas Gruenbacher * 34772c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 34782c46407dSAndreas Gruenbacher * code upon failure. 34792c46407dSAndreas Gruenbacher */ 34802c46407dSAndreas Gruenbacher static int 3481b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3482b411b363SPhilipp Reisner struct p_compressed_bm *p, 3483c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3484c6d25cfeSPhilipp Reisner unsigned int len) 3485b411b363SPhilipp Reisner { 3486b411b363SPhilipp Reisner struct bitstream bs; 3487b411b363SPhilipp Reisner u64 look_ahead; 3488b411b363SPhilipp Reisner u64 rl; 3489b411b363SPhilipp Reisner u64 tmp; 3490b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3491b411b363SPhilipp Reisner unsigned long e; 3492b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3493b411b363SPhilipp Reisner int have; 3494b411b363SPhilipp Reisner int bits; 3495b411b363SPhilipp Reisner 3496b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3497b411b363SPhilipp Reisner 3498b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3499b411b363SPhilipp Reisner if (bits < 0) 35002c46407dSAndreas Gruenbacher return -EIO; 3501b411b363SPhilipp Reisner 3502b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3503b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3504b411b363SPhilipp Reisner if (bits <= 0) 35052c46407dSAndreas Gruenbacher return -EIO; 3506b411b363SPhilipp Reisner 3507b411b363SPhilipp Reisner if (toggle) { 3508b411b363SPhilipp Reisner e = s + rl -1; 3509b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3510b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 35112c46407dSAndreas Gruenbacher return -EIO; 3512b411b363SPhilipp Reisner } 3513b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3514b411b363SPhilipp Reisner } 3515b411b363SPhilipp Reisner 3516b411b363SPhilipp Reisner if (have < bits) { 3517b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3518b411b363SPhilipp Reisner have, bits, look_ahead, 3519b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3520b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 35212c46407dSAndreas Gruenbacher return -EIO; 3522b411b363SPhilipp Reisner } 3523b411b363SPhilipp Reisner look_ahead >>= bits; 3524b411b363SPhilipp Reisner have -= bits; 3525b411b363SPhilipp Reisner 3526b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3527b411b363SPhilipp Reisner if (bits < 0) 35282c46407dSAndreas Gruenbacher return -EIO; 3529b411b363SPhilipp Reisner look_ahead |= tmp << have; 3530b411b363SPhilipp Reisner have += bits; 3531b411b363SPhilipp Reisner } 3532b411b363SPhilipp Reisner 3533b411b363SPhilipp Reisner c->bit_offset = s; 3534b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3535b411b363SPhilipp Reisner 35362c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3537b411b363SPhilipp Reisner } 3538b411b363SPhilipp Reisner 35392c46407dSAndreas Gruenbacher /** 35402c46407dSAndreas Gruenbacher * decode_bitmap_c 35412c46407dSAndreas Gruenbacher * 35422c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35432c46407dSAndreas Gruenbacher * code upon failure. 35442c46407dSAndreas Gruenbacher */ 35452c46407dSAndreas Gruenbacher static int 3546b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3547b411b363SPhilipp Reisner struct p_compressed_bm *p, 3548c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3549c6d25cfeSPhilipp Reisner unsigned int len) 3550b411b363SPhilipp Reisner { 3551b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3552c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3553b411b363SPhilipp Reisner 3554b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3555b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3556b411b363SPhilipp Reisner * during all our tests. */ 3557b411b363SPhilipp Reisner 3558b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 3559b411b363SPhilipp Reisner drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR)); 35602c46407dSAndreas Gruenbacher return -EIO; 3561b411b363SPhilipp Reisner } 3562b411b363SPhilipp Reisner 3563b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3564b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3565b411b363SPhilipp Reisner { 3566b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3567c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3568b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3569b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3570b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3571b411b363SPhilipp Reisner unsigned r; 3572b411b363SPhilipp Reisner 3573b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3574b411b363SPhilipp Reisner if (total == 0) 3575b411b363SPhilipp Reisner return; 3576b411b363SPhilipp Reisner 3577b411b363SPhilipp Reisner /* don't report if not compressed */ 3578b411b363SPhilipp Reisner if (total >= plain) 3579b411b363SPhilipp Reisner return; 3580b411b363SPhilipp Reisner 3581b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3582b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3583b411b363SPhilipp Reisner : (1000 * total / plain); 3584b411b363SPhilipp Reisner 3585b411b363SPhilipp Reisner if (r > 1000) 3586b411b363SPhilipp Reisner r = 1000; 3587b411b363SPhilipp Reisner 3588b411b363SPhilipp Reisner r = 1000 - r; 3589b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3590b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3591b411b363SPhilipp Reisner direction, 3592b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3593b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3594b411b363SPhilipp Reisner total, r/10, r % 10); 3595b411b363SPhilipp Reisner } 3596b411b363SPhilipp Reisner 3597b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3598b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3599b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3600b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3601b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3602b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3603b411b363SPhilipp Reisner 3604b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3605d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3606d8763023SAndreas Gruenbacher unsigned int data_size) 3607b411b363SPhilipp Reisner { 3608b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3609b411b363SPhilipp Reisner void *buffer; 36102c46407dSAndreas Gruenbacher int err; 361181e84650SAndreas Gruenbacher int ok = false; 3612257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 361377351055SPhilipp Reisner struct packet_info pi; 3614b411b363SPhilipp Reisner 361520ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 361620ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 361720ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3618b411b363SPhilipp Reisner 3619b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3620b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3621b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3622b411b363SPhilipp Reisner if (!buffer) { 3623b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3624b411b363SPhilipp Reisner goto out; 3625b411b363SPhilipp Reisner } 3626b411b363SPhilipp Reisner 3627b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3628b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3629b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3630b411b363SPhilipp Reisner }; 3631b411b363SPhilipp Reisner 36322c46407dSAndreas Gruenbacher for(;;) { 363302918be2SPhilipp Reisner if (cmd == P_BITMAP) { 36342c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 363502918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3636b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3637b411b363SPhilipp Reisner * and the feature is enabled! */ 3638b411b363SPhilipp Reisner struct p_compressed_bm *p; 3639b411b363SPhilipp Reisner 364002918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3641b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3642b411b363SPhilipp Reisner goto out; 3643b411b363SPhilipp Reisner } 3644b411b363SPhilipp Reisner /* use the page buff */ 3645b411b363SPhilipp Reisner p = buffer; 3646b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 3647de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->head.payload, data_size) != data_size) 3648b411b363SPhilipp Reisner goto out; 3649004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3650004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 365178fcbdaeSAndreas Gruenbacher goto out; 3652b411b363SPhilipp Reisner } 3653c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3654b411b363SPhilipp Reisner } else { 365502918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3656b411b363SPhilipp Reisner goto out; 3657b411b363SPhilipp Reisner } 3658b411b363SPhilipp Reisner 365902918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3660257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3661b411b363SPhilipp Reisner 36622c46407dSAndreas Gruenbacher if (err <= 0) { 36632c46407dSAndreas Gruenbacher if (err < 0) 36642c46407dSAndreas Gruenbacher goto out; 3665b411b363SPhilipp Reisner break; 36662c46407dSAndreas Gruenbacher } 36679ba7aa00SPhilipp Reisner if (!drbd_recv_header(mdev->tconn, &pi)) 3668b411b363SPhilipp Reisner goto out; 366977351055SPhilipp Reisner cmd = pi.cmd; 367077351055SPhilipp Reisner data_size = pi.size; 36712c46407dSAndreas Gruenbacher } 3672b411b363SPhilipp Reisner 3673b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3674b411b363SPhilipp Reisner 3675b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3676de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3677de1f8e4aSAndreas Gruenbacher 3678b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3679b411b363SPhilipp Reisner if (!ok) 3680b411b363SPhilipp Reisner goto out; 3681b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3682de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3683de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3684b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3685b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3686b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3687b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3688b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3689b411b363SPhilipp Reisner } 3690b411b363SPhilipp Reisner 369181e84650SAndreas Gruenbacher ok = true; 3692b411b363SPhilipp Reisner out: 369320ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 3694b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3695b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3696b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3697b411b363SPhilipp Reisner return ok; 3698b411b363SPhilipp Reisner } 3699b411b363SPhilipp Reisner 3700d8763023SAndreas Gruenbacher static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 3701d8763023SAndreas Gruenbacher unsigned int data_size) 3702b411b363SPhilipp Reisner { 3703b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3704b411b363SPhilipp Reisner static char sink[128]; 3705b411b363SPhilipp Reisner int size, want, r; 3706b411b363SPhilipp Reisner 3707b411b363SPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 370802918be2SPhilipp Reisner cmd, data_size); 3709b411b363SPhilipp Reisner 371002918be2SPhilipp Reisner size = data_size; 3711b411b363SPhilipp Reisner while (size > 0) { 3712b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 3713de0ff338SPhilipp Reisner r = drbd_recv(mdev->tconn, sink, want); 3714841ce241SAndreas Gruenbacher if (!expect(r > 0)) 3715841ce241SAndreas Gruenbacher break; 3716b411b363SPhilipp Reisner size -= r; 3717b411b363SPhilipp Reisner } 3718b411b363SPhilipp Reisner return size == 0; 3719b411b363SPhilipp Reisner } 3720b411b363SPhilipp Reisner 3721d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3722d8763023SAndreas Gruenbacher unsigned int data_size) 3723b411b363SPhilipp Reisner { 3724b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3725b411b363SPhilipp Reisner * with the data requests being unplugged */ 3726e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3727b411b363SPhilipp Reisner 372881e84650SAndreas Gruenbacher return true; 3729b411b363SPhilipp Reisner } 3730b411b363SPhilipp Reisner 3731d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3732d8763023SAndreas Gruenbacher unsigned int data_size) 373373a01a18SPhilipp Reisner { 3734e42325a5SPhilipp Reisner struct p_block_desc *p = &mdev->tconn->data.rbuf.block_desc; 373573a01a18SPhilipp Reisner 3736f735e363SLars Ellenberg switch (mdev->state.conn) { 3737f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3738f735e363SLars Ellenberg case C_WF_BITMAP_T: 3739f735e363SLars Ellenberg case C_BEHIND: 3740f735e363SLars Ellenberg break; 3741f735e363SLars Ellenberg default: 3742f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3743f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3744f735e363SLars Ellenberg } 3745f735e363SLars Ellenberg 374673a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 374773a01a18SPhilipp Reisner 374881e84650SAndreas Gruenbacher return true; 374973a01a18SPhilipp Reisner } 375073a01a18SPhilipp Reisner 3751d8763023SAndreas Gruenbacher typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packet cmd, 3752d8763023SAndreas Gruenbacher unsigned int to_receive); 3753b411b363SPhilipp Reisner 375402918be2SPhilipp Reisner struct data_cmd { 375502918be2SPhilipp Reisner int expect_payload; 375602918be2SPhilipp Reisner size_t pkt_size; 375702918be2SPhilipp Reisner drbd_cmd_handler_f function; 3758b411b363SPhilipp Reisner }; 3759b411b363SPhilipp Reisner 376002918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 376102918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 376202918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 376302918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 376402918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 3765257d0af6SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3766257d0af6SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), receive_bitmap } , 3767257d0af6SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), receive_UnplugRemote }, 376802918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 376902918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 3770257d0af6SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), receive_SyncParam }, 3771257d0af6SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), receive_SyncParam }, 377202918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 377302918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 377402918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 377502918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 377602918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 377702918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 377802918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 377902918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 378002918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 378102918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 378273a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 3783047cd4a6SPhilipp Reisner [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 378402918be2SPhilipp Reisner /* anything missing from this table is in 378502918be2SPhilipp Reisner * the asender_tbl, see get_asender_cmd */ 378602918be2SPhilipp Reisner [P_MAX_CMD] = { 0, 0, NULL }, 378702918be2SPhilipp Reisner }; 378802918be2SPhilipp Reisner 378902918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 3790e42325a5SPhilipp Reisner mdev->tconn->data.rbuf.header.head.payload. 379102918be2SPhilipp Reisner 3792e42325a5SPhilipp Reisner Usually in mdev->tconn->data.rbuf.header.head the callback can find the usual 379302918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 379402918be2SPhilipp Reisner */ 3795b411b363SPhilipp Reisner 3796eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 3797b411b363SPhilipp Reisner { 3798eefc2f7dSPhilipp Reisner struct p_header *header = &tconn->data.rbuf.header; 379977351055SPhilipp Reisner struct packet_info pi; 380002918be2SPhilipp Reisner size_t shs; /* sub header size */ 380102918be2SPhilipp Reisner int rv; 3802b411b363SPhilipp Reisner 3803eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 3804eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 3805eefc2f7dSPhilipp Reisner if (!drbd_recv_header(tconn, &pi)) 380602918be2SPhilipp Reisner goto err_out; 380702918be2SPhilipp Reisner 380877351055SPhilipp Reisner if (unlikely(pi.cmd >= P_MAX_CMD || !drbd_cmd_handler[pi.cmd].function)) { 3809eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 381002918be2SPhilipp Reisner goto err_out; 38110b33a916SLars Ellenberg } 3812b411b363SPhilipp Reisner 381377351055SPhilipp Reisner shs = drbd_cmd_handler[pi.cmd].pkt_size - sizeof(struct p_header); 381477351055SPhilipp Reisner if (pi.size - shs > 0 && !drbd_cmd_handler[pi.cmd].expect_payload) { 3815eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 3816c13f7e1aSLars Ellenberg goto err_out; 3817c13f7e1aSLars Ellenberg } 3818c13f7e1aSLars Ellenberg 3819c13f7e1aSLars Ellenberg if (shs) { 3820eefc2f7dSPhilipp Reisner rv = drbd_recv(tconn, &header->payload, shs); 382102918be2SPhilipp Reisner if (unlikely(rv != shs)) { 38220ddc5549SLars Ellenberg if (!signal_pending(current)) 3823eefc2f7dSPhilipp Reisner conn_warn(tconn, "short read while reading sub header: rv=%d\n", rv); 382402918be2SPhilipp Reisner goto err_out; 3825b411b363SPhilipp Reisner } 382602918be2SPhilipp Reisner } 382702918be2SPhilipp Reisner 3828eefc2f7dSPhilipp Reisner rv = drbd_cmd_handler[pi.cmd].function(vnr_to_mdev(tconn, pi.vnr), pi.cmd, pi.size - shs); 382902918be2SPhilipp Reisner 383002918be2SPhilipp Reisner if (unlikely(!rv)) { 3831eefc2f7dSPhilipp Reisner conn_err(tconn, "error receiving %s, l: %d!\n", 383277351055SPhilipp Reisner cmdname(pi.cmd), pi.size); 383302918be2SPhilipp Reisner goto err_out; 3834b411b363SPhilipp Reisner } 3835b411b363SPhilipp Reisner } 383602918be2SPhilipp Reisner 383702918be2SPhilipp Reisner if (0) { 383802918be2SPhilipp Reisner err_out: 3839bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 3840b411b363SPhilipp Reisner } 3841b411b363SPhilipp Reisner } 3842b411b363SPhilipp Reisner 3843a21e9298SPhilipp Reisner void drbd_flush_workqueue(struct drbd_conf *mdev) 3844b411b363SPhilipp Reisner { 3845b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3846b411b363SPhilipp Reisner 3847b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 3848a21e9298SPhilipp Reisner barr.w.mdev = mdev; 3849b411b363SPhilipp Reisner init_completion(&barr.done); 3850a21e9298SPhilipp Reisner drbd_queue_work(&mdev->tconn->data.work, &barr.w); 3851b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3852b411b363SPhilipp Reisner } 3853b411b363SPhilipp Reisner 3854360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 3855b411b363SPhilipp Reisner { 3856bbeb641cSPhilipp Reisner enum drbd_conns oc; 3857b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3858b411b363SPhilipp Reisner 3859bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 3860b411b363SPhilipp Reisner return; 3861b411b363SPhilipp Reisner 3862b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3863360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 3864360cc740SPhilipp Reisner drbd_free_sock(tconn); 3865360cc740SPhilipp Reisner 3866360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 3867360cc740SPhilipp Reisner 3868360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 3869360cc740SPhilipp Reisner 3870360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 3871bbeb641cSPhilipp Reisner oc = tconn->cstate; 3872bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 3873bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 3874bbeb641cSPhilipp Reisner 3875360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 3876360cc740SPhilipp Reisner 3877bbeb641cSPhilipp Reisner if (oc == C_DISCONNECTING) { 3878360cc740SPhilipp Reisner wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0); 3879360cc740SPhilipp Reisner 3880360cc740SPhilipp Reisner crypto_free_hash(tconn->cram_hmac_tfm); 3881360cc740SPhilipp Reisner tconn->cram_hmac_tfm = NULL; 3882360cc740SPhilipp Reisner 3883360cc740SPhilipp Reisner kfree(tconn->net_conf); 3884360cc740SPhilipp Reisner tconn->net_conf = NULL; 3885bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE); 3886360cc740SPhilipp Reisner } 3887360cc740SPhilipp Reisner } 3888360cc740SPhilipp Reisner 3889360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 3890360cc740SPhilipp Reisner { 3891360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 3892360cc740SPhilipp Reisner enum drbd_fencing_p fp; 3893360cc740SPhilipp Reisner unsigned int i; 3894b411b363SPhilipp Reisner 389585719573SPhilipp Reisner /* wait for current activity to cease. */ 389687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3897b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 3898b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 3899b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 390087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3901b411b363SPhilipp Reisner 3902b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 3903b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 3904b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 3905b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 3906b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 3907b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 3908b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 3909b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 3910b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 3911b411b363SPhilipp Reisner * on the fly. */ 3912b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 3913b411b363SPhilipp Reisner mdev->rs_total = 0; 3914b411b363SPhilipp Reisner mdev->rs_failed = 0; 3915b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 3916b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 3917b411b363SPhilipp Reisner 39187fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 39197fde2be9SPhilipp Reisner 3920b411b363SPhilipp Reisner /* make sure syncer is stopped and w_resume_next_sg queued */ 3921b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 3922b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 3923b411b363SPhilipp Reisner 3924b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 3925b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 3926b411b363SPhilipp Reisner * to be "canceled" */ 3927a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 3928b411b363SPhilipp Reisner 3929b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 3930b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 3931b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 3932b411b363SPhilipp Reisner 3933b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3934b411b363SPhilipp Reisner mdev->p_uuid = NULL; 3935b411b363SPhilipp Reisner 3936fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 3937b411b363SPhilipp Reisner tl_clear(mdev); 3938b411b363SPhilipp Reisner 3939b411b363SPhilipp Reisner drbd_md_sync(mdev); 3940b411b363SPhilipp Reisner 3941b411b363SPhilipp Reisner fp = FP_DONT_CARE; 3942b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3943b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 3944b411b363SPhilipp Reisner put_ldev(mdev); 3945b411b363SPhilipp Reisner } 3946b411b363SPhilipp Reisner 394787f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 394887f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 3949b411b363SPhilipp Reisner 395020ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 395120ceb2b2SLars Ellenberg * if any. */ 395220ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 395320ceb2b2SLars Ellenberg 3954b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 3955b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 3956b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 3957b411b363SPhilipp Reisner * 3958b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 3959b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 3960b411b363SPhilipp Reisner */ 3961b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 3962b411b363SPhilipp Reisner if (i) 3963b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 3964435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 3965435f0740SLars Ellenberg if (i) 3966435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 3967b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 3968b411b363SPhilipp Reisner if (i) 396945bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 3970b411b363SPhilipp Reisner 3971b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 3972b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 3973b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 3974b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 3975b411b363SPhilipp Reisner 3976b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 3977b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 3978b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 3979360cc740SPhilipp Reisner 3980360cc740SPhilipp Reisner return 0; 3981b411b363SPhilipp Reisner } 3982b411b363SPhilipp Reisner 3983b411b363SPhilipp Reisner /* 3984b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 3985b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 3986b411b363SPhilipp Reisner * 3987b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 3988b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 3989b411b363SPhilipp Reisner * 3990b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 3991b411b363SPhilipp Reisner */ 39928a22ccccSPhilipp Reisner static int drbd_send_handshake(struct drbd_tconn *tconn) 3993b411b363SPhilipp Reisner { 3994e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 39958a22ccccSPhilipp Reisner struct p_handshake *p = &tconn->data.sbuf.handshake; 3996b411b363SPhilipp Reisner int ok; 3997b411b363SPhilipp Reisner 39988a22ccccSPhilipp Reisner if (mutex_lock_interruptible(&tconn->data.mutex)) { 39998a22ccccSPhilipp Reisner conn_err(tconn, "interrupted during initial handshake\n"); 4000b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 4001b411b363SPhilipp Reisner } 4002b411b363SPhilipp Reisner 40038a22ccccSPhilipp Reisner if (tconn->data.socket == NULL) { 40048a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4005b411b363SPhilipp Reisner return 0; 4006b411b363SPhilipp Reisner } 4007b411b363SPhilipp Reisner 4008b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4009b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4010b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 40118a22ccccSPhilipp Reisner ok = _conn_send_cmd(tconn, 0, tconn->data.socket, P_HAND_SHAKE, 4012c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 40138a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4014b411b363SPhilipp Reisner return ok; 4015b411b363SPhilipp Reisner } 4016b411b363SPhilipp Reisner 4017b411b363SPhilipp Reisner /* 4018b411b363SPhilipp Reisner * return values: 4019b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4020b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4021b411b363SPhilipp Reisner * -1 peer talks different language, 4022b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4023b411b363SPhilipp Reisner */ 402465d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn) 4025b411b363SPhilipp Reisner { 402665d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 402765d11ed6SPhilipp Reisner struct p_handshake *p = &tconn->data.rbuf.handshake; 402802918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 402977351055SPhilipp Reisner struct packet_info pi; 4030b411b363SPhilipp Reisner int rv; 4031b411b363SPhilipp Reisner 403265d11ed6SPhilipp Reisner rv = drbd_send_handshake(tconn); 4033b411b363SPhilipp Reisner if (!rv) 4034b411b363SPhilipp Reisner return 0; 4035b411b363SPhilipp Reisner 403665d11ed6SPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4037b411b363SPhilipp Reisner if (!rv) 4038b411b363SPhilipp Reisner return 0; 4039b411b363SPhilipp Reisner 404077351055SPhilipp Reisner if (pi.cmd != P_HAND_SHAKE) { 404165d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake packet, received: %s (0x%04x)\n", 404277351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4043b411b363SPhilipp Reisner return -1; 4044b411b363SPhilipp Reisner } 4045b411b363SPhilipp Reisner 404677351055SPhilipp Reisner if (pi.size != expect) { 404765d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake length: %u, received: %u\n", 404877351055SPhilipp Reisner expect, pi.size); 4049b411b363SPhilipp Reisner return -1; 4050b411b363SPhilipp Reisner } 4051b411b363SPhilipp Reisner 405265d11ed6SPhilipp Reisner rv = drbd_recv(tconn, &p->head.payload, expect); 4053b411b363SPhilipp Reisner 4054b411b363SPhilipp Reisner if (rv != expect) { 40550ddc5549SLars Ellenberg if (!signal_pending(current)) 405665d11ed6SPhilipp Reisner conn_warn(tconn, "short read receiving handshake packet: l=%u\n", rv); 4057b411b363SPhilipp Reisner return 0; 4058b411b363SPhilipp Reisner } 4059b411b363SPhilipp Reisner 4060b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4061b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4062b411b363SPhilipp Reisner if (p->protocol_max == 0) 4063b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4064b411b363SPhilipp Reisner 4065b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4066b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4067b411b363SPhilipp Reisner goto incompat; 4068b411b363SPhilipp Reisner 406965d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4070b411b363SPhilipp Reisner 407165d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 407265d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4073b411b363SPhilipp Reisner 4074b411b363SPhilipp Reisner return 1; 4075b411b363SPhilipp Reisner 4076b411b363SPhilipp Reisner incompat: 407765d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4078b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4079b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4080b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4081b411b363SPhilipp Reisner return -1; 4082b411b363SPhilipp Reisner } 4083b411b363SPhilipp Reisner 4084b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 408513e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4086b411b363SPhilipp Reisner { 4087b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4088b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4089b10d96cbSJohannes Thoma return -1; 4090b411b363SPhilipp Reisner } 4091b411b363SPhilipp Reisner #else 4092b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4093b10d96cbSJohannes Thoma 4094b10d96cbSJohannes Thoma /* Return value: 4095b10d96cbSJohannes Thoma 1 - auth succeeded, 4096b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4097b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4098b10d96cbSJohannes Thoma */ 4099b10d96cbSJohannes Thoma 410013e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4101b411b363SPhilipp Reisner { 4102b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4103b411b363SPhilipp Reisner struct scatterlist sg; 4104b411b363SPhilipp Reisner char *response = NULL; 4105b411b363SPhilipp Reisner char *right_response = NULL; 4106b411b363SPhilipp Reisner char *peers_ch = NULL; 410713e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4108b411b363SPhilipp Reisner unsigned int resp_size; 4109b411b363SPhilipp Reisner struct hash_desc desc; 411077351055SPhilipp Reisner struct packet_info pi; 4111b411b363SPhilipp Reisner int rv; 4112b411b363SPhilipp Reisner 411313e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4114b411b363SPhilipp Reisner desc.flags = 0; 4115b411b363SPhilipp Reisner 411613e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 411713e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4118b411b363SPhilipp Reisner if (rv) { 411913e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4120b10d96cbSJohannes Thoma rv = -1; 4121b411b363SPhilipp Reisner goto fail; 4122b411b363SPhilipp Reisner } 4123b411b363SPhilipp Reisner 4124b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4125b411b363SPhilipp Reisner 412613e6037dSPhilipp Reisner rv = conn_send_cmd2(tconn, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4127b411b363SPhilipp Reisner if (!rv) 4128b411b363SPhilipp Reisner goto fail; 4129b411b363SPhilipp Reisner 413013e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4131b411b363SPhilipp Reisner if (!rv) 4132b411b363SPhilipp Reisner goto fail; 4133b411b363SPhilipp Reisner 413477351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 413513e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 413677351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4137b411b363SPhilipp Reisner rv = 0; 4138b411b363SPhilipp Reisner goto fail; 4139b411b363SPhilipp Reisner } 4140b411b363SPhilipp Reisner 414177351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 414213e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4143b10d96cbSJohannes Thoma rv = -1; 4144b411b363SPhilipp Reisner goto fail; 4145b411b363SPhilipp Reisner } 4146b411b363SPhilipp Reisner 414777351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4148b411b363SPhilipp Reisner if (peers_ch == NULL) { 414913e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4150b10d96cbSJohannes Thoma rv = -1; 4151b411b363SPhilipp Reisner goto fail; 4152b411b363SPhilipp Reisner } 4153b411b363SPhilipp Reisner 415413e6037dSPhilipp Reisner rv = drbd_recv(tconn, peers_ch, pi.size); 4155b411b363SPhilipp Reisner 415677351055SPhilipp Reisner if (rv != pi.size) { 41570ddc5549SLars Ellenberg if (!signal_pending(current)) 415813e6037dSPhilipp Reisner conn_warn(tconn, "short read AuthChallenge: l=%u\n", rv); 4159b411b363SPhilipp Reisner rv = 0; 4160b411b363SPhilipp Reisner goto fail; 4161b411b363SPhilipp Reisner } 4162b411b363SPhilipp Reisner 416313e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4164b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4165b411b363SPhilipp Reisner if (response == NULL) { 416613e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4167b10d96cbSJohannes Thoma rv = -1; 4168b411b363SPhilipp Reisner goto fail; 4169b411b363SPhilipp Reisner } 4170b411b363SPhilipp Reisner 4171b411b363SPhilipp Reisner sg_init_table(&sg, 1); 417277351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4173b411b363SPhilipp Reisner 4174b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4175b411b363SPhilipp Reisner if (rv) { 417613e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4177b10d96cbSJohannes Thoma rv = -1; 4178b411b363SPhilipp Reisner goto fail; 4179b411b363SPhilipp Reisner } 4180b411b363SPhilipp Reisner 418113e6037dSPhilipp Reisner rv = conn_send_cmd2(tconn, P_AUTH_RESPONSE, response, resp_size); 4182b411b363SPhilipp Reisner if (!rv) 4183b411b363SPhilipp Reisner goto fail; 4184b411b363SPhilipp Reisner 418513e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4186b411b363SPhilipp Reisner if (!rv) 4187b411b363SPhilipp Reisner goto fail; 4188b411b363SPhilipp Reisner 418977351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 419013e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 419177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4192b411b363SPhilipp Reisner rv = 0; 4193b411b363SPhilipp Reisner goto fail; 4194b411b363SPhilipp Reisner } 4195b411b363SPhilipp Reisner 419677351055SPhilipp Reisner if (pi.size != resp_size) { 419713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4198b411b363SPhilipp Reisner rv = 0; 4199b411b363SPhilipp Reisner goto fail; 4200b411b363SPhilipp Reisner } 4201b411b363SPhilipp Reisner 420213e6037dSPhilipp Reisner rv = drbd_recv(tconn, response , resp_size); 4203b411b363SPhilipp Reisner 4204b411b363SPhilipp Reisner if (rv != resp_size) { 42050ddc5549SLars Ellenberg if (!signal_pending(current)) 420613e6037dSPhilipp Reisner conn_warn(tconn, "short read receiving AuthResponse: l=%u\n", rv); 4207b411b363SPhilipp Reisner rv = 0; 4208b411b363SPhilipp Reisner goto fail; 4209b411b363SPhilipp Reisner } 4210b411b363SPhilipp Reisner 4211b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 42122d1ee87dSJulia Lawall if (right_response == NULL) { 421313e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4214b10d96cbSJohannes Thoma rv = -1; 4215b411b363SPhilipp Reisner goto fail; 4216b411b363SPhilipp Reisner } 4217b411b363SPhilipp Reisner 4218b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4219b411b363SPhilipp Reisner 4220b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4221b411b363SPhilipp Reisner if (rv) { 422213e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4223b10d96cbSJohannes Thoma rv = -1; 4224b411b363SPhilipp Reisner goto fail; 4225b411b363SPhilipp Reisner } 4226b411b363SPhilipp Reisner 4227b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4228b411b363SPhilipp Reisner 4229b411b363SPhilipp Reisner if (rv) 423013e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 423113e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4232b10d96cbSJohannes Thoma else 4233b10d96cbSJohannes Thoma rv = -1; 4234b411b363SPhilipp Reisner 4235b411b363SPhilipp Reisner fail: 4236b411b363SPhilipp Reisner kfree(peers_ch); 4237b411b363SPhilipp Reisner kfree(response); 4238b411b363SPhilipp Reisner kfree(right_response); 4239b411b363SPhilipp Reisner 4240b411b363SPhilipp Reisner return rv; 4241b411b363SPhilipp Reisner } 4242b411b363SPhilipp Reisner #endif 4243b411b363SPhilipp Reisner 4244b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4245b411b363SPhilipp Reisner { 4246392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4247b411b363SPhilipp Reisner int h; 4248b411b363SPhilipp Reisner 42494d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4250b411b363SPhilipp Reisner 4251b411b363SPhilipp Reisner do { 42524d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4253b411b363SPhilipp Reisner if (h == 0) { 42544d641dd7SPhilipp Reisner drbd_disconnect(tconn); 425520ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4256b411b363SPhilipp Reisner } 4257b411b363SPhilipp Reisner if (h == -1) { 42584d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4259bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4260b411b363SPhilipp Reisner } 4261b411b363SPhilipp Reisner } while (h == 0); 4262b411b363SPhilipp Reisner 4263b411b363SPhilipp Reisner if (h > 0) { 42644d641dd7SPhilipp Reisner if (get_net_conf(tconn)) { 42654d641dd7SPhilipp Reisner drbdd(tconn); 42664d641dd7SPhilipp Reisner put_net_conf(tconn); 4267b411b363SPhilipp Reisner } 4268b411b363SPhilipp Reisner } 4269b411b363SPhilipp Reisner 42704d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4271b411b363SPhilipp Reisner 42724d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4273b411b363SPhilipp Reisner return 0; 4274b411b363SPhilipp Reisner } 4275b411b363SPhilipp Reisner 4276b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4277b411b363SPhilipp Reisner 4278d8763023SAndreas Gruenbacher static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4279b411b363SPhilipp Reisner { 4280257d0af6SPhilipp Reisner struct p_req_state_reply *p = &mdev->tconn->meta.rbuf.req_state_reply; 4281fc3b10a4SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 4282b411b363SPhilipp Reisner 4283b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4284b411b363SPhilipp Reisner 4285fc3b10a4SPhilipp Reisner if (cmd == P_STATE_CHG_REPLY) { 4286b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4287b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4288b411b363SPhilipp Reisner } else { 4289b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4290b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4291b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4292b411b363SPhilipp Reisner } 4293b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4294fc3b10a4SPhilipp Reisner } else /* conn == P_CONN_ST_CHG_REPLY */ { 4295fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4296fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4297fc3b10a4SPhilipp Reisner } else { 4298fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4299fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4300fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4301fc3b10a4SPhilipp Reisner } 4302fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4303fc3b10a4SPhilipp Reisner } 430481e84650SAndreas Gruenbacher return true; 4305b411b363SPhilipp Reisner } 4306b411b363SPhilipp Reisner 4307d8763023SAndreas Gruenbacher static int got_Ping(struct drbd_conf *mdev, enum drbd_packet cmd) 4308b411b363SPhilipp Reisner { 43092a67d8b9SPhilipp Reisner return drbd_send_ping_ack(mdev->tconn); 4310b411b363SPhilipp Reisner 4311b411b363SPhilipp Reisner } 4312b411b363SPhilipp Reisner 4313d8763023SAndreas Gruenbacher static int got_PingAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4314b411b363SPhilipp Reisner { 43152a67d8b9SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 4316b411b363SPhilipp Reisner /* restore idle timeout */ 43172a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 43182a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 43192a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4320b411b363SPhilipp Reisner 432181e84650SAndreas Gruenbacher return true; 4322b411b363SPhilipp Reisner } 4323b411b363SPhilipp Reisner 4324d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4325b411b363SPhilipp Reisner { 4326257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4327b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4328b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4329b411b363SPhilipp Reisner 433031890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4331b411b363SPhilipp Reisner 4332b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4333b411b363SPhilipp Reisner 43341d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4335b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4336b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4337b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4338b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 43391d53f09eSLars Ellenberg put_ldev(mdev); 43401d53f09eSLars Ellenberg } 4341b411b363SPhilipp Reisner dec_rs_pending(mdev); 4342778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4343b411b363SPhilipp Reisner 434481e84650SAndreas Gruenbacher return true; 4345b411b363SPhilipp Reisner } 4346b411b363SPhilipp Reisner 4347bc9c5c41SAndreas Gruenbacher static int 4348bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4349bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4350bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4351b411b363SPhilipp Reisner { 4352b411b363SPhilipp Reisner struct drbd_request *req; 4353b411b363SPhilipp Reisner struct bio_and_error m; 4354b411b363SPhilipp Reisner 435587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4356bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4357b411b363SPhilipp Reisner if (unlikely(!req)) { 435887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 435981e84650SAndreas Gruenbacher return false; 4360b411b363SPhilipp Reisner } 4361b411b363SPhilipp Reisner __req_mod(req, what, &m); 436287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4363b411b363SPhilipp Reisner 4364b411b363SPhilipp Reisner if (m.bio) 4365b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 436681e84650SAndreas Gruenbacher return true; 4367b411b363SPhilipp Reisner } 4368b411b363SPhilipp Reisner 4369d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4370b411b363SPhilipp Reisner { 4371257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4372b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4373b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4374b411b363SPhilipp Reisner enum drbd_req_event what; 4375b411b363SPhilipp Reisner 4376b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4377b411b363SPhilipp Reisner 4378579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4379b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4380b411b363SPhilipp Reisner dec_rs_pending(mdev); 438181e84650SAndreas Gruenbacher return true; 4382b411b363SPhilipp Reisner } 4383257d0af6SPhilipp Reisner switch (cmd) { 4384b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 438589e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43868554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4387b411b363SPhilipp Reisner break; 4388b411b363SPhilipp Reisner case P_WRITE_ACK: 438989e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43908554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4391b411b363SPhilipp Reisner break; 4392b411b363SPhilipp Reisner case P_RECV_ACK: 439389e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 43948554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4395b411b363SPhilipp Reisner break; 4396b411b363SPhilipp Reisner case P_DISCARD_ACK: 439789e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 43988554df1cSAndreas Gruenbacher what = CONFLICT_DISCARDED_BY_PEER; 4399b411b363SPhilipp Reisner break; 4400b411b363SPhilipp Reisner default: 4401b411b363SPhilipp Reisner D_ASSERT(0); 440281e84650SAndreas Gruenbacher return false; 4403b411b363SPhilipp Reisner } 4404b411b363SPhilipp Reisner 4405b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4406bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4407bc9c5c41SAndreas Gruenbacher what, false); 4408b411b363SPhilipp Reisner } 4409b411b363SPhilipp Reisner 4410d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4411b411b363SPhilipp Reisner { 4412257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4413b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 44142deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 441589e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 441689e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4417c3afd8f5SAndreas Gruenbacher bool found; 4418b411b363SPhilipp Reisner 4419b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4420b411b363SPhilipp Reisner 4421579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4422b411b363SPhilipp Reisner dec_rs_pending(mdev); 4423b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 442481e84650SAndreas Gruenbacher return true; 4425b411b363SPhilipp Reisner } 44262deb8336SPhilipp Reisner 4427c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4428bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 44298554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4430c3afd8f5SAndreas Gruenbacher if (!found) { 44312deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 44322deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4433c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 44342deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 44352deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4436c3afd8f5SAndreas Gruenbacher if (!missing_ok) 44372deb8336SPhilipp Reisner return false; 4438c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 44392deb8336SPhilipp Reisner } 44402deb8336SPhilipp Reisner return true; 4441b411b363SPhilipp Reisner } 4442b411b363SPhilipp Reisner 4443d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4444b411b363SPhilipp Reisner { 4445257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4446b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4447b411b363SPhilipp Reisner 4448b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4449b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4450b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4451b411b363SPhilipp Reisner 4452b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4453bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 44548554df1cSAndreas Gruenbacher NEG_ACKED, false); 4455b411b363SPhilipp Reisner } 4456b411b363SPhilipp Reisner 4457d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4458b411b363SPhilipp Reisner { 4459b411b363SPhilipp Reisner sector_t sector; 4460b411b363SPhilipp Reisner int size; 4461257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4462b411b363SPhilipp Reisner 4463b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4464b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4465b411b363SPhilipp Reisner 4466b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4467b411b363SPhilipp Reisner 4468b411b363SPhilipp Reisner dec_rs_pending(mdev); 4469b411b363SPhilipp Reisner 4470b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4471b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4472257d0af6SPhilipp Reisner switch (cmd) { 4473d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4474b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4475d612d309SPhilipp Reisner case P_RS_CANCEL: 4476d612d309SPhilipp Reisner break; 4477d612d309SPhilipp Reisner default: 4478d612d309SPhilipp Reisner D_ASSERT(0); 4479d612d309SPhilipp Reisner put_ldev(mdev); 4480d612d309SPhilipp Reisner return false; 4481d612d309SPhilipp Reisner } 4482b411b363SPhilipp Reisner put_ldev(mdev); 4483b411b363SPhilipp Reisner } 4484b411b363SPhilipp Reisner 448581e84650SAndreas Gruenbacher return true; 4486b411b363SPhilipp Reisner } 4487b411b363SPhilipp Reisner 4488d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4489b411b363SPhilipp Reisner { 4490257d0af6SPhilipp Reisner struct p_barrier_ack *p = &mdev->tconn->meta.rbuf.barrier_ack; 4491b411b363SPhilipp Reisner 4492b411b363SPhilipp Reisner tl_release(mdev, p->barrier, be32_to_cpu(p->set_size)); 4493b411b363SPhilipp Reisner 4494c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4495c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4496370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4497370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4498370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4499c4752ef1SPhilipp Reisner } 4500c4752ef1SPhilipp Reisner 450181e84650SAndreas Gruenbacher return true; 4502b411b363SPhilipp Reisner } 4503b411b363SPhilipp Reisner 4504d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4505b411b363SPhilipp Reisner { 4506257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4507b411b363SPhilipp Reisner struct drbd_work *w; 4508b411b363SPhilipp Reisner sector_t sector; 4509b411b363SPhilipp Reisner int size; 4510b411b363SPhilipp Reisner 4511b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4512b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4513b411b363SPhilipp Reisner 4514b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4515b411b363SPhilipp Reisner 4516b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4517b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4518b411b363SPhilipp Reisner else 4519b411b363SPhilipp Reisner ov_oos_print(mdev); 4520b411b363SPhilipp Reisner 45211d53f09eSLars Ellenberg if (!get_ldev(mdev)) 452281e84650SAndreas Gruenbacher return true; 45231d53f09eSLars Ellenberg 4524b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4525b411b363SPhilipp Reisner dec_rs_pending(mdev); 4526b411b363SPhilipp Reisner 4527ea5442afSLars Ellenberg --mdev->ov_left; 4528ea5442afSLars Ellenberg 4529ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4530ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4531ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4532ea5442afSLars Ellenberg 4533ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4534b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4535b411b363SPhilipp Reisner if (w) { 4536b411b363SPhilipp Reisner w->cb = w_ov_finished; 4537a21e9298SPhilipp Reisner w->mdev = mdev; 4538e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4539b411b363SPhilipp Reisner } else { 4540b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4541b411b363SPhilipp Reisner ov_oos_print(mdev); 4542b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4543b411b363SPhilipp Reisner } 4544b411b363SPhilipp Reisner } 45451d53f09eSLars Ellenberg put_ldev(mdev); 454681e84650SAndreas Gruenbacher return true; 4547b411b363SPhilipp Reisner } 4548b411b363SPhilipp Reisner 4549d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 45500ced55a3SPhilipp Reisner { 455181e84650SAndreas Gruenbacher return true; 45520ced55a3SPhilipp Reisner } 45530ced55a3SPhilipp Reisner 4554b411b363SPhilipp Reisner struct asender_cmd { 4555b411b363SPhilipp Reisner size_t pkt_size; 4556d8763023SAndreas Gruenbacher int (*process)(struct drbd_conf *mdev, enum drbd_packet cmd); 4557b411b363SPhilipp Reisner }; 4558b411b363SPhilipp Reisner 4559b411b363SPhilipp Reisner static struct asender_cmd *get_asender_cmd(int cmd) 4560b411b363SPhilipp Reisner { 4561b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 4562b411b363SPhilipp Reisner /* anything missing from this table is in 4563b411b363SPhilipp Reisner * the drbd_cmd_handler (drbd_default_handler) table, 4564b411b363SPhilipp Reisner * see the beginning of drbdd() */ 4565257d0af6SPhilipp Reisner [P_PING] = { sizeof(struct p_header), got_Ping }, 4566257d0af6SPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), got_PingAck }, 4567b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4568b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4569b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4570b411b363SPhilipp Reisner [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 4571b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 4572b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 4573b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4574b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 4575b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 4576b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 4577b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 457802918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 4579d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply}, 4580fc3b10a4SPhilipp Reisner [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_RqSReply }, 4581b411b363SPhilipp Reisner [P_MAX_CMD] = { 0, NULL }, 4582b411b363SPhilipp Reisner }; 4583b411b363SPhilipp Reisner if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL) 4584b411b363SPhilipp Reisner return NULL; 4585b411b363SPhilipp Reisner return &asender_tbl[cmd]; 4586b411b363SPhilipp Reisner } 4587b411b363SPhilipp Reisner 458832862ec7SPhilipp Reisner static int _drbd_process_done_ee(int vnr, void *p, void *data) 458932862ec7SPhilipp Reisner { 459032862ec7SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 459132862ec7SPhilipp Reisner return !drbd_process_done_ee(mdev); 459232862ec7SPhilipp Reisner } 459332862ec7SPhilipp Reisner 459432862ec7SPhilipp Reisner static int _check_ee_empty(int vnr, void *p, void *data) 459532862ec7SPhilipp Reisner { 459632862ec7SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 459732862ec7SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 459832862ec7SPhilipp Reisner int not_empty; 459932862ec7SPhilipp Reisner 460032862ec7SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 460132862ec7SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 460232862ec7SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 460332862ec7SPhilipp Reisner 460432862ec7SPhilipp Reisner return not_empty; 460532862ec7SPhilipp Reisner } 460632862ec7SPhilipp Reisner 460732862ec7SPhilipp Reisner static int tconn_process_done_ee(struct drbd_tconn *tconn) 460832862ec7SPhilipp Reisner { 460932862ec7SPhilipp Reisner int not_empty, err; 461032862ec7SPhilipp Reisner 461132862ec7SPhilipp Reisner do { 461232862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 461332862ec7SPhilipp Reisner flush_signals(current); 461432862ec7SPhilipp Reisner err = idr_for_each(&tconn->volumes, _drbd_process_done_ee, NULL); 461532862ec7SPhilipp Reisner if (err) 461632862ec7SPhilipp Reisner return err; 461732862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 461832862ec7SPhilipp Reisner not_empty = idr_for_each(&tconn->volumes, _check_ee_empty, NULL); 461932862ec7SPhilipp Reisner } while (not_empty); 462032862ec7SPhilipp Reisner 462132862ec7SPhilipp Reisner return 0; 462232862ec7SPhilipp Reisner } 462332862ec7SPhilipp Reisner 4624b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4625b411b363SPhilipp Reisner { 4626392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 462732862ec7SPhilipp Reisner struct p_header *h = &tconn->meta.rbuf.header; 4628b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 462977351055SPhilipp Reisner struct packet_info pi; 4630257d0af6SPhilipp Reisner int rv; 4631b411b363SPhilipp Reisner void *buf = h; 4632b411b363SPhilipp Reisner int received = 0; 4633257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4634f36af18cSLars Ellenberg int ping_timeout_active = 0; 4635b411b363SPhilipp Reisner 4636b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4637b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4638b411b363SPhilipp Reisner 4639e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 464080822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 464132862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 46422a67d8b9SPhilipp Reisner if (!drbd_send_ping(tconn)) { 464332862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 4644841ce241SAndreas Gruenbacher goto reconnect; 4645841ce241SAndreas Gruenbacher } 464632862ec7SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = 464732862ec7SPhilipp Reisner tconn->net_conf->ping_timeo*HZ/10; 4648f36af18cSLars Ellenberg ping_timeout_active = 1; 4649b411b363SPhilipp Reisner } 4650b411b363SPhilipp Reisner 465132862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 465232862ec7SPhilipp Reisner much to send */ 465332862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 465432862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 465532862ec7SPhilipp Reisner if (tconn_process_done_ee(tconn)) 4656b411b363SPhilipp Reisner goto reconnect; 4657b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 465832862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 465932862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 4660b411b363SPhilipp Reisner 4661b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4662b411b363SPhilipp Reisner if (signal_pending(current)) 4663b411b363SPhilipp Reisner continue; 4664b411b363SPhilipp Reisner 466532862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 466632862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4667b411b363SPhilipp Reisner 4668b411b363SPhilipp Reisner flush_signals(current); 4669b411b363SPhilipp Reisner 4670b411b363SPhilipp Reisner /* Note: 4671b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4672b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4673b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4674b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4675b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4676b411b363SPhilipp Reisner * rv == expected: full header or command 4677b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4678b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4679b411b363SPhilipp Reisner */ 4680b411b363SPhilipp Reisner if (likely(rv > 0)) { 4681b411b363SPhilipp Reisner received += rv; 4682b411b363SPhilipp Reisner buf += rv; 4683b411b363SPhilipp Reisner } else if (rv == 0) { 468432862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 4685b411b363SPhilipp Reisner goto reconnect; 4686b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4687cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4688cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 468932862ec7SPhilipp Reisner if (time_after(tconn->last_received, 469032862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 4691cb6518cbSLars Ellenberg continue; 4692f36af18cSLars Ellenberg if (ping_timeout_active) { 469332862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 4694b411b363SPhilipp Reisner goto reconnect; 4695b411b363SPhilipp Reisner } 469632862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 4697b411b363SPhilipp Reisner continue; 4698b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4699b411b363SPhilipp Reisner continue; 4700b411b363SPhilipp Reisner } else { 470132862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 4702b411b363SPhilipp Reisner goto reconnect; 4703b411b363SPhilipp Reisner } 4704b411b363SPhilipp Reisner 4705b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 470632862ec7SPhilipp Reisner if (!decode_header(tconn, h, &pi)) 4707b411b363SPhilipp Reisner goto reconnect; 470877351055SPhilipp Reisner cmd = get_asender_cmd(pi.cmd); 4709b411b363SPhilipp Reisner if (unlikely(cmd == NULL)) { 471032862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 471177351055SPhilipp Reisner pi.cmd, pi.size); 4712b411b363SPhilipp Reisner goto disconnect; 4713b411b363SPhilipp Reisner } 4714b411b363SPhilipp Reisner expect = cmd->pkt_size; 471577351055SPhilipp Reisner if (pi.size != expect - sizeof(struct p_header)) { 471632862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 471777351055SPhilipp Reisner pi.cmd, pi.size); 4718b411b363SPhilipp Reisner goto reconnect; 4719b411b363SPhilipp Reisner } 4720257d0af6SPhilipp Reisner } 4721b411b363SPhilipp Reisner if (received == expect) { 472232862ec7SPhilipp Reisner tconn->last_received = jiffies; 472332862ec7SPhilipp Reisner if (!cmd->process(vnr_to_mdev(tconn, pi.vnr), pi.cmd)) 4724b411b363SPhilipp Reisner goto reconnect; 4725b411b363SPhilipp Reisner 4726f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4727f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 4728f36af18cSLars Ellenberg if (cmd == get_asender_cmd(P_PING_ACK)) 4729f36af18cSLars Ellenberg ping_timeout_active = 0; 4730f36af18cSLars Ellenberg 4731b411b363SPhilipp Reisner buf = h; 4732b411b363SPhilipp Reisner received = 0; 4733257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4734b411b363SPhilipp Reisner cmd = NULL; 4735b411b363SPhilipp Reisner } 4736b411b363SPhilipp Reisner } 4737b411b363SPhilipp Reisner 4738b411b363SPhilipp Reisner if (0) { 4739b411b363SPhilipp Reisner reconnect: 4740bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4741b411b363SPhilipp Reisner } 4742b411b363SPhilipp Reisner if (0) { 4743b411b363SPhilipp Reisner disconnect: 4744bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4745b411b363SPhilipp Reisner } 474632862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4747b411b363SPhilipp Reisner 474832862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 4749b411b363SPhilipp Reisner 4750b411b363SPhilipp Reisner return 0; 4751b411b363SPhilipp Reisner } 4752