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" 47a3603a6eSAndreas Gruenbacher #include "drbd_protocol.h" 48b411b363SPhilipp Reisner #include "drbd_req.h" 49b411b363SPhilipp Reisner #include "drbd_vli.h" 50b411b363SPhilipp Reisner 5120c68fdeSLars Ellenberg #define PRO_FEATURES (FF_TRIM) 5220c68fdeSLars Ellenberg 5377351055SPhilipp Reisner struct packet_info { 5477351055SPhilipp Reisner enum drbd_packet cmd; 55e2857216SAndreas Gruenbacher unsigned int size; 56e2857216SAndreas Gruenbacher unsigned int vnr; 57e658983aSAndreas Gruenbacher void *data; 5877351055SPhilipp Reisner }; 5977351055SPhilipp Reisner 60b411b363SPhilipp Reisner enum finish_epoch { 61b411b363SPhilipp Reisner FE_STILL_LIVE, 62b411b363SPhilipp Reisner FE_DESTROYED, 63b411b363SPhilipp Reisner FE_RECYCLED, 64b411b363SPhilipp Reisner }; 65b411b363SPhilipp Reisner 66bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection); 67bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection); 6869a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *); 69a0fb3c47SLars Ellenberg static void conn_wait_active_ee_empty(struct drbd_connection *connection); 70bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *, struct drbd_epoch *, enum epoch_event); 7199920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 72b411b363SPhilipp Reisner 73b411b363SPhilipp Reisner 74b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 75b411b363SPhilipp Reisner 7645bb912bSLars Ellenberg /* 7745bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7845bb912bSLars Ellenberg * page->private being our "next" pointer. 7945bb912bSLars Ellenberg */ 8045bb912bSLars Ellenberg 8145bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8245bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8345bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8445bb912bSLars Ellenberg */ 8545bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8645bb912bSLars Ellenberg { 8745bb912bSLars Ellenberg struct page *page; 8845bb912bSLars Ellenberg struct page *tmp; 8945bb912bSLars Ellenberg 9045bb912bSLars Ellenberg BUG_ON(!n); 9145bb912bSLars Ellenberg BUG_ON(!head); 9245bb912bSLars Ellenberg 9345bb912bSLars Ellenberg page = *head; 9423ce4227SPhilipp Reisner 9523ce4227SPhilipp Reisner if (!page) 9623ce4227SPhilipp Reisner return NULL; 9723ce4227SPhilipp Reisner 9845bb912bSLars Ellenberg while (page) { 9945bb912bSLars Ellenberg tmp = page_chain_next(page); 10045bb912bSLars Ellenberg if (--n == 0) 10145bb912bSLars Ellenberg break; /* found sufficient pages */ 10245bb912bSLars Ellenberg if (tmp == NULL) 10345bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10445bb912bSLars Ellenberg return NULL; 10545bb912bSLars Ellenberg page = tmp; 10645bb912bSLars Ellenberg } 10745bb912bSLars Ellenberg 10845bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10945bb912bSLars Ellenberg set_page_private(page, 0); 11045bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11145bb912bSLars Ellenberg page = *head; 11245bb912bSLars Ellenberg *head = tmp; 11345bb912bSLars Ellenberg return page; 11445bb912bSLars Ellenberg } 11545bb912bSLars Ellenberg 11645bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11745bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11845bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11945bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 12045bb912bSLars Ellenberg { 12145bb912bSLars Ellenberg struct page *tmp; 12245bb912bSLars Ellenberg int i = 1; 12345bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12445bb912bSLars Ellenberg ++i, page = tmp; 12545bb912bSLars Ellenberg if (len) 12645bb912bSLars Ellenberg *len = i; 12745bb912bSLars Ellenberg return page; 12845bb912bSLars Ellenberg } 12945bb912bSLars Ellenberg 13045bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13145bb912bSLars Ellenberg { 13245bb912bSLars Ellenberg struct page *tmp; 13345bb912bSLars Ellenberg int i = 0; 13445bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13545bb912bSLars Ellenberg put_page(page); 13645bb912bSLars Ellenberg ++i; 13745bb912bSLars Ellenberg } 13845bb912bSLars Ellenberg return i; 13945bb912bSLars Ellenberg } 14045bb912bSLars Ellenberg 14145bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14245bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14345bb912bSLars Ellenberg { 14445bb912bSLars Ellenberg #if 1 14545bb912bSLars Ellenberg struct page *tmp; 14645bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14745bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14845bb912bSLars Ellenberg #endif 14945bb912bSLars Ellenberg 15045bb912bSLars Ellenberg /* add chain to head */ 15145bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15245bb912bSLars Ellenberg *head = chain_first; 15345bb912bSLars Ellenberg } 15445bb912bSLars Ellenberg 155b30ab791SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_device *device, 15618c2d522SAndreas Gruenbacher unsigned int number) 157b411b363SPhilipp Reisner { 158b411b363SPhilipp Reisner struct page *page = NULL; 15945bb912bSLars Ellenberg struct page *tmp = NULL; 16018c2d522SAndreas Gruenbacher unsigned int i = 0; 161b411b363SPhilipp Reisner 162b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 163b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16445bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 165b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16645bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16745bb912bSLars Ellenberg if (page) 16845bb912bSLars Ellenberg drbd_pp_vacant -= number; 169b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 17045bb912bSLars Ellenberg if (page) 17145bb912bSLars Ellenberg return page; 172b411b363SPhilipp Reisner } 17345bb912bSLars Ellenberg 174b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 175b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 176b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17745bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17845bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17945bb912bSLars Ellenberg if (!tmp) 18045bb912bSLars Ellenberg break; 18145bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18245bb912bSLars Ellenberg page = tmp; 18345bb912bSLars Ellenberg } 18445bb912bSLars Ellenberg 18545bb912bSLars Ellenberg if (i == number) 186b411b363SPhilipp Reisner return page; 18745bb912bSLars Ellenberg 18845bb912bSLars Ellenberg /* Not enough pages immediately available this time. 189c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 19045bb912bSLars Ellenberg * function "soon". */ 19145bb912bSLars Ellenberg if (page) { 19245bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19345bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19445bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19545bb912bSLars Ellenberg drbd_pp_vacant += i; 19645bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19745bb912bSLars Ellenberg } 19845bb912bSLars Ellenberg return NULL; 199b411b363SPhilipp Reisner } 200b411b363SPhilipp Reisner 201b30ab791SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_device *device, 202a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 203b411b363SPhilipp Reisner { 204a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req, *tmp; 205b411b363SPhilipp Reisner 206b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 207b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 208b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 209b411b363SPhilipp Reisner stop to examine the list... */ 210b411b363SPhilipp Reisner 211a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, tmp, &device->net_ee, w.list) { 212045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 213b411b363SPhilipp Reisner break; 214a8cd15baSAndreas Gruenbacher list_move(&peer_req->w.list, to_be_freed); 215b411b363SPhilipp Reisner } 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner 218b30ab791SAndreas Gruenbacher static void drbd_kick_lo_and_reclaim_net(struct drbd_device *device) 219b411b363SPhilipp Reisner { 220b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 221db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 222b411b363SPhilipp Reisner 2230500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 224b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 2250500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 226b411b363SPhilipp Reisner 227a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 228b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 229b411b363SPhilipp Reisner } 230b411b363SPhilipp Reisner 231b411b363SPhilipp Reisner /** 232c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 233b30ab791SAndreas Gruenbacher * @device: DRBD device. 23445bb912bSLars Ellenberg * @number: number of pages requested 23545bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 236b411b363SPhilipp Reisner * 23745bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 2380e49d7b0SLars Ellenberg * the kernel. 23945bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 24045bb912bSLars Ellenberg * 2410e49d7b0SLars Ellenberg * If this allocation would exceed the max_buffers setting, we throttle 2420e49d7b0SLars Ellenberg * allocation (schedule_timeout) to give the system some room to breathe. 2430e49d7b0SLars Ellenberg * 2440e49d7b0SLars Ellenberg * We do not use max-buffers as hard limit, because it could lead to 2450e49d7b0SLars Ellenberg * congestion and further to a distributed deadlock during online-verify or 2460e49d7b0SLars Ellenberg * (checksum based) resync, if the max-buffers, socket buffer sizes and 2470e49d7b0SLars Ellenberg * resync-rate settings are mis-configured. 2480e49d7b0SLars Ellenberg * 24945bb912bSLars Ellenberg * Returns a page chain linked via page->private. 250b411b363SPhilipp Reisner */ 25169a22773SAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_peer_device *peer_device, unsigned int number, 252c37c8ecfSAndreas Gruenbacher bool retry) 253b411b363SPhilipp Reisner { 25469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 255b411b363SPhilipp Reisner struct page *page = NULL; 25644ed167dSPhilipp Reisner struct net_conf *nc; 257b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2580e49d7b0SLars Ellenberg unsigned int mxb; 259b411b363SPhilipp Reisner 26044ed167dSPhilipp Reisner rcu_read_lock(); 26169a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 26244ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 26344ed167dSPhilipp Reisner rcu_read_unlock(); 26444ed167dSPhilipp Reisner 265b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) 266b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 267b411b363SPhilipp Reisner 26845bb912bSLars Ellenberg while (page == NULL) { 269b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 270b411b363SPhilipp Reisner 271b30ab791SAndreas Gruenbacher drbd_kick_lo_and_reclaim_net(device); 272b411b363SPhilipp Reisner 273b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) { 274b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 275b411b363SPhilipp Reisner if (page) 276b411b363SPhilipp Reisner break; 277b411b363SPhilipp Reisner } 278b411b363SPhilipp Reisner 279b411b363SPhilipp Reisner if (!retry) 280b411b363SPhilipp Reisner break; 281b411b363SPhilipp Reisner 282b411b363SPhilipp Reisner if (signal_pending(current)) { 283d0180171SAndreas Gruenbacher drbd_warn(device, "drbd_alloc_pages interrupted!\n"); 284b411b363SPhilipp Reisner break; 285b411b363SPhilipp Reisner } 286b411b363SPhilipp Reisner 2870e49d7b0SLars Ellenberg if (schedule_timeout(HZ/10) == 0) 2880e49d7b0SLars Ellenberg mxb = UINT_MAX; 289b411b363SPhilipp Reisner } 290b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 291b411b363SPhilipp Reisner 29245bb912bSLars Ellenberg if (page) 293b30ab791SAndreas Gruenbacher atomic_add(number, &device->pp_in_use); 294b411b363SPhilipp Reisner return page; 295b411b363SPhilipp Reisner } 296b411b363SPhilipp Reisner 297c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 2980500813fSAndreas Gruenbacher * Is also used from inside an other spin_lock_irq(&resource->req_lock); 29945bb912bSLars Ellenberg * Either links the page chain back to the global pool, 30045bb912bSLars Ellenberg * or returns all pages to the system. */ 301b30ab791SAndreas Gruenbacher static void drbd_free_pages(struct drbd_device *device, struct page *page, int is_net) 302b411b363SPhilipp Reisner { 303b30ab791SAndreas Gruenbacher atomic_t *a = is_net ? &device->pp_in_use_by_net : &device->pp_in_use; 304b411b363SPhilipp Reisner int i; 305435f0740SLars Ellenberg 306a73ff323SLars Ellenberg if (page == NULL) 307a73ff323SLars Ellenberg return; 308a73ff323SLars Ellenberg 3091816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 31045bb912bSLars Ellenberg i = page_chain_free(page); 31145bb912bSLars Ellenberg else { 31245bb912bSLars Ellenberg struct page *tmp; 31345bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 314b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 31545bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 31645bb912bSLars Ellenberg drbd_pp_vacant += i; 317b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 318b411b363SPhilipp Reisner } 319435f0740SLars Ellenberg i = atomic_sub_return(i, a); 32045bb912bSLars Ellenberg if (i < 0) 321d0180171SAndreas Gruenbacher drbd_warn(device, "ASSERTION FAILED: %s: %d < 0\n", 322435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 323b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 324b411b363SPhilipp Reisner } 325b411b363SPhilipp Reisner 326b411b363SPhilipp Reisner /* 327b411b363SPhilipp Reisner You need to hold the req_lock: 328b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 329b411b363SPhilipp Reisner 330b411b363SPhilipp Reisner You must not have the req_lock: 3313967deb1SAndreas Gruenbacher drbd_free_peer_req() 3320db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3337721f567SAndreas Gruenbacher drbd_free_peer_reqs() 334b411b363SPhilipp Reisner drbd_ee_fix_bhs() 335a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 336b411b363SPhilipp Reisner drbd_clear_done_ee() 337b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 338b411b363SPhilipp Reisner */ 339b411b363SPhilipp Reisner 340f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 34169a22773SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 342a0fb3c47SLars Ellenberg unsigned int data_size, bool has_payload, gfp_t gfp_mask) __must_hold(local) 343b411b363SPhilipp Reisner { 34469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 345db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 346a73ff323SLars Ellenberg struct page *page = NULL; 34745bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 348b411b363SPhilipp Reisner 349b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_AL_EE)) 350b411b363SPhilipp Reisner return NULL; 351b411b363SPhilipp Reisner 352db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 353db830c46SAndreas Gruenbacher if (!peer_req) { 354b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 355d0180171SAndreas Gruenbacher drbd_err(device, "%s: allocation failed\n", __func__); 356b411b363SPhilipp Reisner return NULL; 357b411b363SPhilipp Reisner } 358b411b363SPhilipp Reisner 359a0fb3c47SLars Ellenberg if (has_payload && data_size) { 36069a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, nr_pages, (gfp_mask & __GFP_WAIT)); 36145bb912bSLars Ellenberg if (!page) 36245bb912bSLars Ellenberg goto fail; 363a73ff323SLars Ellenberg } 364b411b363SPhilipp Reisner 365c5a2c150SLars Ellenberg memset(peer_req, 0, sizeof(*peer_req)); 366c5a2c150SLars Ellenberg INIT_LIST_HEAD(&peer_req->w.list); 367db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 368db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 369db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 370c5a2c150SLars Ellenberg peer_req->submit_jif = jiffies; 371a8cd15baSAndreas Gruenbacher peer_req->peer_device = peer_device; 372db830c46SAndreas Gruenbacher peer_req->pages = page; 3739a8e7753SAndreas Gruenbacher /* 3749a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3759a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3769a8e7753SAndreas Gruenbacher */ 377db830c46SAndreas Gruenbacher peer_req->block_id = id; 378b411b363SPhilipp Reisner 379db830c46SAndreas Gruenbacher return peer_req; 380b411b363SPhilipp Reisner 38145bb912bSLars Ellenberg fail: 382db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 383b411b363SPhilipp Reisner return NULL; 384b411b363SPhilipp Reisner } 385b411b363SPhilipp Reisner 386b30ab791SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_device *device, struct drbd_peer_request *peer_req, 387f6ffca9fSAndreas Gruenbacher int is_net) 388b411b363SPhilipp Reisner { 38921ae5d7fSLars Ellenberg might_sleep(); 390db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 391db830c46SAndreas Gruenbacher kfree(peer_req->digest); 392b30ab791SAndreas Gruenbacher drbd_free_pages(device, peer_req->pages, is_net); 3930b0ba1efSAndreas Gruenbacher D_ASSERT(device, atomic_read(&peer_req->pending_bios) == 0); 3940b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 39521ae5d7fSLars Ellenberg if (!expect(!(peer_req->flags & EE_CALL_AL_COMPLETE_IO))) { 39621ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 39721ae5d7fSLars Ellenberg drbd_al_complete_io(device, &peer_req->i); 39821ae5d7fSLars Ellenberg } 399db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 400b411b363SPhilipp Reisner } 401b411b363SPhilipp Reisner 402b30ab791SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_device *device, struct list_head *list) 403b411b363SPhilipp Reisner { 404b411b363SPhilipp Reisner LIST_HEAD(work_list); 405db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 406b411b363SPhilipp Reisner int count = 0; 407b30ab791SAndreas Gruenbacher int is_net = list == &device->net_ee; 408b411b363SPhilipp Reisner 4090500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 410b411b363SPhilipp Reisner list_splice_init(list, &work_list); 4110500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 412b411b363SPhilipp Reisner 413a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 414b30ab791SAndreas Gruenbacher __drbd_free_peer_req(device, peer_req, is_net); 415b411b363SPhilipp Reisner count++; 416b411b363SPhilipp Reisner } 417b411b363SPhilipp Reisner return count; 418b411b363SPhilipp Reisner } 419b411b363SPhilipp Reisner 420b411b363SPhilipp Reisner /* 421a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 422b411b363SPhilipp Reisner */ 423b30ab791SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_device *device) 424b411b363SPhilipp Reisner { 425b411b363SPhilipp Reisner LIST_HEAD(work_list); 426b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 427db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 428e2b3032bSAndreas Gruenbacher int err = 0; 429b411b363SPhilipp Reisner 4300500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 431b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 432b30ab791SAndreas Gruenbacher list_splice_init(&device->done_ee, &work_list); 4330500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 434b411b363SPhilipp Reisner 435a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 436b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 437b411b363SPhilipp Reisner 438b411b363SPhilipp Reisner /* possible callbacks here: 439d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 440b411b363SPhilipp Reisner * all ignore the last argument. 441b411b363SPhilipp Reisner */ 442a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 443e2b3032bSAndreas Gruenbacher int err2; 444e2b3032bSAndreas Gruenbacher 445b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 446a8cd15baSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 447e2b3032bSAndreas Gruenbacher if (!err) 448e2b3032bSAndreas Gruenbacher err = err2; 449b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 450b411b363SPhilipp Reisner } 451b30ab791SAndreas Gruenbacher wake_up(&device->ee_wait); 452b411b363SPhilipp Reisner 453e2b3032bSAndreas Gruenbacher return err; 454b411b363SPhilipp Reisner } 455b411b363SPhilipp Reisner 456b30ab791SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_device *device, 457d4da1537SAndreas Gruenbacher struct list_head *head) 458b411b363SPhilipp Reisner { 459b411b363SPhilipp Reisner DEFINE_WAIT(wait); 460b411b363SPhilipp Reisner 461b411b363SPhilipp Reisner /* avoids spin_lock/unlock 462b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 463b411b363SPhilipp Reisner while (!list_empty(head)) { 464b30ab791SAndreas Gruenbacher prepare_to_wait(&device->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 4650500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4667eaceaccSJens Axboe io_schedule(); 467b30ab791SAndreas Gruenbacher finish_wait(&device->ee_wait, &wait); 4680500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 469b411b363SPhilipp Reisner } 470b411b363SPhilipp Reisner } 471b411b363SPhilipp Reisner 472b30ab791SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_device *device, 473d4da1537SAndreas Gruenbacher struct list_head *head) 474b411b363SPhilipp Reisner { 4750500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 476b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, head); 4770500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 478b411b363SPhilipp Reisner } 479b411b363SPhilipp Reisner 480dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 481b411b363SPhilipp Reisner { 482b411b363SPhilipp Reisner struct kvec iov = { 483b411b363SPhilipp Reisner .iov_base = buf, 484b411b363SPhilipp Reisner .iov_len = size, 485b411b363SPhilipp Reisner }; 486b411b363SPhilipp Reisner struct msghdr msg = { 487b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 488b411b363SPhilipp Reisner }; 489f730c848SAl Viro return kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); 490b411b363SPhilipp Reisner } 491b411b363SPhilipp Reisner 492bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 493b411b363SPhilipp Reisner { 494b411b363SPhilipp Reisner int rv; 495b411b363SPhilipp Reisner 496bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 497b411b363SPhilipp Reisner 498b411b363SPhilipp Reisner if (rv < 0) { 499b411b363SPhilipp Reisner if (rv == -ECONNRESET) 5001ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 501b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 5021ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 503b411b363SPhilipp Reisner } else if (rv == 0) { 504bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 505b66623e3SPhilipp Reisner long t; 506b66623e3SPhilipp Reisner rcu_read_lock(); 507bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 508b66623e3SPhilipp Reisner rcu_read_unlock(); 509b66623e3SPhilipp Reisner 510bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 511b66623e3SPhilipp Reisner 512599377acSPhilipp Reisner if (t) 513599377acSPhilipp Reisner goto out; 514599377acSPhilipp Reisner } 5151ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 516599377acSPhilipp Reisner } 517599377acSPhilipp Reisner 518b411b363SPhilipp Reisner if (rv != size) 519bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 520b411b363SPhilipp Reisner 521599377acSPhilipp Reisner out: 522b411b363SPhilipp Reisner return rv; 523b411b363SPhilipp Reisner } 524b411b363SPhilipp Reisner 525bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 526c6967746SAndreas Gruenbacher { 527c6967746SAndreas Gruenbacher int err; 528c6967746SAndreas Gruenbacher 529bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 530c6967746SAndreas Gruenbacher if (err != size) { 531c6967746SAndreas Gruenbacher if (err >= 0) 532c6967746SAndreas Gruenbacher err = -EIO; 533c6967746SAndreas Gruenbacher } else 534c6967746SAndreas Gruenbacher err = 0; 535c6967746SAndreas Gruenbacher return err; 536c6967746SAndreas Gruenbacher } 537c6967746SAndreas Gruenbacher 538bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 539a5c31904SAndreas Gruenbacher { 540a5c31904SAndreas Gruenbacher int err; 541a5c31904SAndreas Gruenbacher 542bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 543a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5441ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 545a5c31904SAndreas Gruenbacher return err; 546a5c31904SAndreas Gruenbacher } 547a5c31904SAndreas Gruenbacher 5485dbf1673SLars Ellenberg /* quoting tcp(7): 5495dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5505dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5515dbf1673SLars Ellenberg * This is our wrapper to do so. 5525dbf1673SLars Ellenberg */ 5535dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5545dbf1673SLars Ellenberg unsigned int rcv) 5555dbf1673SLars Ellenberg { 5565dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5575dbf1673SLars Ellenberg if (snd) { 5585dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5595dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5605dbf1673SLars Ellenberg } 5615dbf1673SLars Ellenberg if (rcv) { 5625dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5635dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5645dbf1673SLars Ellenberg } 5655dbf1673SLars Ellenberg } 5665dbf1673SLars Ellenberg 567bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 568b411b363SPhilipp Reisner { 569b411b363SPhilipp Reisner const char *what; 570b411b363SPhilipp Reisner struct socket *sock; 571b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 57244ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 57344ed167dSPhilipp Reisner struct net_conf *nc; 57444ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 57569ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 576b411b363SPhilipp Reisner int disconnect_on_error = 1; 577b411b363SPhilipp Reisner 57844ed167dSPhilipp Reisner rcu_read_lock(); 579bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 58044ed167dSPhilipp Reisner if (!nc) { 58144ed167dSPhilipp Reisner rcu_read_unlock(); 582b411b363SPhilipp Reisner return NULL; 58344ed167dSPhilipp Reisner } 58444ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 58544ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 58669ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 587089c075dSAndreas Gruenbacher rcu_read_unlock(); 58844ed167dSPhilipp Reisner 589bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 590bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 59144ed167dSPhilipp Reisner 592bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 59344ed167dSPhilipp Reisner src_in6.sin6_port = 0; 59444ed167dSPhilipp Reisner else 59544ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 59644ed167dSPhilipp Reisner 597bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 598bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 599b411b363SPhilipp Reisner 600b411b363SPhilipp Reisner what = "sock_create_kern"; 60144ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 602b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 603b411b363SPhilipp Reisner if (err < 0) { 604b411b363SPhilipp Reisner sock = NULL; 605b411b363SPhilipp Reisner goto out; 606b411b363SPhilipp Reisner } 607b411b363SPhilipp Reisner 608b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 60969ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 61044ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 611b411b363SPhilipp Reisner 612b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 613b411b363SPhilipp Reisner * for the outgoing connections. 614b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 615b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 616b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 617b411b363SPhilipp Reisner * a free one dynamically. 618b411b363SPhilipp Reisner */ 619b411b363SPhilipp Reisner what = "bind before connect"; 62044ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 621b411b363SPhilipp Reisner if (err < 0) 622b411b363SPhilipp Reisner goto out; 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 625b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 626b411b363SPhilipp Reisner disconnect_on_error = 0; 627b411b363SPhilipp Reisner what = "connect"; 62844ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 629b411b363SPhilipp Reisner 630b411b363SPhilipp Reisner out: 631b411b363SPhilipp Reisner if (err < 0) { 632b411b363SPhilipp Reisner if (sock) { 633b411b363SPhilipp Reisner sock_release(sock); 634b411b363SPhilipp Reisner sock = NULL; 635b411b363SPhilipp Reisner } 636b411b363SPhilipp Reisner switch (-err) { 637b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 638b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 639b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 640b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 641b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 642b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 643b411b363SPhilipp Reisner disconnect_on_error = 0; 644b411b363SPhilipp Reisner break; 645b411b363SPhilipp Reisner default: 6461ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 647b411b363SPhilipp Reisner } 648b411b363SPhilipp Reisner if (disconnect_on_error) 649bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 650b411b363SPhilipp Reisner } 65144ed167dSPhilipp Reisner 652b411b363SPhilipp Reisner return sock; 653b411b363SPhilipp Reisner } 654b411b363SPhilipp Reisner 6557a426fd8SPhilipp Reisner struct accept_wait_data { 656bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6577a426fd8SPhilipp Reisner struct socket *s_listen; 6587a426fd8SPhilipp Reisner struct completion door_bell; 6597a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6607a426fd8SPhilipp Reisner 6617a426fd8SPhilipp Reisner }; 6627a426fd8SPhilipp Reisner 663715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 664b411b363SPhilipp Reisner { 6657a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 666715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6677a426fd8SPhilipp Reisner 668715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 669715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6707a426fd8SPhilipp Reisner complete(&ad->door_bell); 671715306f6SAndreas Gruenbacher state_change(sk); 6727a426fd8SPhilipp Reisner } 6737a426fd8SPhilipp Reisner 674bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 675b411b363SPhilipp Reisner { 6761f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 67744ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 6781f3e509bSPhilipp Reisner struct socket *s_listen; 67944ed167dSPhilipp Reisner struct net_conf *nc; 680b411b363SPhilipp Reisner const char *what; 681b411b363SPhilipp Reisner 68244ed167dSPhilipp Reisner rcu_read_lock(); 683bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 68444ed167dSPhilipp Reisner if (!nc) { 68544ed167dSPhilipp Reisner rcu_read_unlock(); 6867a426fd8SPhilipp Reisner return -EIO; 68744ed167dSPhilipp Reisner } 68844ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 68944ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 69044ed167dSPhilipp Reisner rcu_read_unlock(); 691b411b363SPhilipp Reisner 692bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 693bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 694b411b363SPhilipp Reisner 695b411b363SPhilipp Reisner what = "sock_create_kern"; 69644ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 697b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 698b411b363SPhilipp Reisner if (err) { 699b411b363SPhilipp Reisner s_listen = NULL; 700b411b363SPhilipp Reisner goto out; 701b411b363SPhilipp Reisner } 702b411b363SPhilipp Reisner 7034a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 70444ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 705b411b363SPhilipp Reisner 706b411b363SPhilipp Reisner what = "bind before listen"; 70744ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 708b411b363SPhilipp Reisner if (err < 0) 709b411b363SPhilipp Reisner goto out; 710b411b363SPhilipp Reisner 7117a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7127a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7137a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 714715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7157a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7167a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 717b411b363SPhilipp Reisner 7182820fd39SPhilipp Reisner what = "listen"; 7192820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7202820fd39SPhilipp Reisner if (err < 0) 7212820fd39SPhilipp Reisner goto out; 7222820fd39SPhilipp Reisner 7237a426fd8SPhilipp Reisner return 0; 724b411b363SPhilipp Reisner out: 725b411b363SPhilipp Reisner if (s_listen) 726b411b363SPhilipp Reisner sock_release(s_listen); 727b411b363SPhilipp Reisner if (err < 0) { 728b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7291ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 730bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 731b411b363SPhilipp Reisner } 732b411b363SPhilipp Reisner } 7331f3e509bSPhilipp Reisner 7347a426fd8SPhilipp Reisner return -EIO; 7351f3e509bSPhilipp Reisner } 7361f3e509bSPhilipp Reisner 737715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 738715306f6SAndreas Gruenbacher { 739715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 740715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 741715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 742715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 743715306f6SAndreas Gruenbacher } 744715306f6SAndreas Gruenbacher 745bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7461f3e509bSPhilipp Reisner { 7471f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7481f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7491f3e509bSPhilipp Reisner struct net_conf *nc; 7501f3e509bSPhilipp Reisner 7511f3e509bSPhilipp Reisner rcu_read_lock(); 752bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7531f3e509bSPhilipp Reisner if (!nc) { 7541f3e509bSPhilipp Reisner rcu_read_unlock(); 7551f3e509bSPhilipp Reisner return NULL; 7561f3e509bSPhilipp Reisner } 7571f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7581f3e509bSPhilipp Reisner rcu_read_unlock(); 7591f3e509bSPhilipp Reisner 7601f3e509bSPhilipp Reisner timeo = connect_int * HZ; 76138b682b2SAkinobu Mita /* 28.5% random jitter */ 76238b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7631f3e509bSPhilipp Reisner 7647a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7657a426fd8SPhilipp Reisner if (err <= 0) 7667a426fd8SPhilipp Reisner return NULL; 7671f3e509bSPhilipp Reisner 7687a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 769b411b363SPhilipp Reisner if (err < 0) { 770b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7711ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 772bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 773b411b363SPhilipp Reisner } 774b411b363SPhilipp Reisner } 775b411b363SPhilipp Reisner 776715306f6SAndreas Gruenbacher if (s_estab) 777715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 778b411b363SPhilipp Reisner 779b411b363SPhilipp Reisner return s_estab; 780b411b363SPhilipp Reisner } 781b411b363SPhilipp Reisner 782bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 783b411b363SPhilipp Reisner 784bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 7859f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7869f5bdc33SAndreas Gruenbacher { 787bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 7889f5bdc33SAndreas Gruenbacher return -EIO; 789bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 790b411b363SPhilipp Reisner } 791b411b363SPhilipp Reisner 792bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 793b411b363SPhilipp Reisner { 794bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 7959f5bdc33SAndreas Gruenbacher struct packet_info pi; 7964920e37aSPhilipp Reisner struct net_conf *nc; 7979f5bdc33SAndreas Gruenbacher int err; 798b411b363SPhilipp Reisner 7994920e37aSPhilipp Reisner rcu_read_lock(); 8004920e37aSPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8014920e37aSPhilipp Reisner if (!nc) { 8024920e37aSPhilipp Reisner rcu_read_unlock(); 8034920e37aSPhilipp Reisner return -EIO; 8044920e37aSPhilipp Reisner } 8054920e37aSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo * 4 * HZ / 10; 8064920e37aSPhilipp Reisner rcu_read_unlock(); 8074920e37aSPhilipp Reisner 808bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 8099f5bdc33SAndreas Gruenbacher if (err != header_size) { 8109f5bdc33SAndreas Gruenbacher if (err >= 0) 8119f5bdc33SAndreas Gruenbacher err = -EIO; 8129f5bdc33SAndreas Gruenbacher return err; 8139f5bdc33SAndreas Gruenbacher } 814bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8159f5bdc33SAndreas Gruenbacher if (err) 8169f5bdc33SAndreas Gruenbacher return err; 8179f5bdc33SAndreas Gruenbacher return pi.cmd; 818b411b363SPhilipp Reisner } 819b411b363SPhilipp Reisner 820b411b363SPhilipp Reisner /** 821b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 822b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 823b411b363SPhilipp Reisner */ 8245d0b17f1SPhilipp Reisner static bool drbd_socket_okay(struct socket **sock) 825b411b363SPhilipp Reisner { 826b411b363SPhilipp Reisner int rr; 827b411b363SPhilipp Reisner char tb[4]; 828b411b363SPhilipp Reisner 829b411b363SPhilipp Reisner if (!*sock) 83081e84650SAndreas Gruenbacher return false; 831b411b363SPhilipp Reisner 832dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 833b411b363SPhilipp Reisner 834b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 83581e84650SAndreas Gruenbacher return true; 836b411b363SPhilipp Reisner } else { 837b411b363SPhilipp Reisner sock_release(*sock); 838b411b363SPhilipp Reisner *sock = NULL; 83981e84650SAndreas Gruenbacher return false; 840b411b363SPhilipp Reisner } 841b411b363SPhilipp Reisner } 8425d0b17f1SPhilipp Reisner 8435d0b17f1SPhilipp Reisner static bool connection_established(struct drbd_connection *connection, 8445d0b17f1SPhilipp Reisner struct socket **sock1, 8455d0b17f1SPhilipp Reisner struct socket **sock2) 8465d0b17f1SPhilipp Reisner { 8475d0b17f1SPhilipp Reisner struct net_conf *nc; 8485d0b17f1SPhilipp Reisner int timeout; 8495d0b17f1SPhilipp Reisner bool ok; 8505d0b17f1SPhilipp Reisner 8515d0b17f1SPhilipp Reisner if (!*sock1 || !*sock2) 8525d0b17f1SPhilipp Reisner return false; 8535d0b17f1SPhilipp Reisner 8545d0b17f1SPhilipp Reisner rcu_read_lock(); 8555d0b17f1SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8565d0b17f1SPhilipp Reisner timeout = (nc->sock_check_timeo ?: nc->ping_timeo) * HZ / 10; 8575d0b17f1SPhilipp Reisner rcu_read_unlock(); 8585d0b17f1SPhilipp Reisner schedule_timeout_interruptible(timeout); 8595d0b17f1SPhilipp Reisner 8605d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock1); 8615d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock2) && ok; 8625d0b17f1SPhilipp Reisner 8635d0b17f1SPhilipp Reisner return ok; 8645d0b17f1SPhilipp Reisner } 8655d0b17f1SPhilipp Reisner 8662325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8672325eb66SPhilipp Reisner in a connection */ 86869a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 869907599e0SPhilipp Reisner { 87069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 8710829f5edSAndreas Gruenbacher int err; 872907599e0SPhilipp Reisner 873b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 874b30ab791SAndreas Gruenbacher device->peer_seq = 0; 875907599e0SPhilipp Reisner 87669a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 87769a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 878b30ab791SAndreas Gruenbacher &device->own_state_mutex; 8798410da8fSPhilipp Reisner 88069a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 8810829f5edSAndreas Gruenbacher if (!err) 88269a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 8830829f5edSAndreas Gruenbacher if (!err) 88469a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 8850829f5edSAndreas Gruenbacher if (!err) 88669a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 887b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 888b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 889b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 890b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 8910829f5edSAndreas Gruenbacher return err; 892907599e0SPhilipp Reisner } 893b411b363SPhilipp Reisner 894b411b363SPhilipp Reisner /* 895b411b363SPhilipp Reisner * return values: 896b411b363SPhilipp Reisner * 1 yes, we have a valid connection 897b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 898b411b363SPhilipp Reisner * -1 peer talks different language, 899b411b363SPhilipp Reisner * no point in trying again, please go standalone. 900b411b363SPhilipp Reisner * -2 We do not have a network config... 901b411b363SPhilipp Reisner */ 902bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 903b411b363SPhilipp Reisner { 9047da35862SPhilipp Reisner struct drbd_socket sock, msock; 905c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 90644ed167dSPhilipp Reisner struct net_conf *nc; 9075d0b17f1SPhilipp Reisner int vnr, timeout, h; 9085d0b17f1SPhilipp Reisner bool discard_my_data, ok; 909197296ffSPhilipp Reisner enum drbd_state_rv rv; 9107a426fd8SPhilipp Reisner struct accept_wait_data ad = { 911bde89a9eSAndreas Gruenbacher .connection = connection, 9127a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 9137a426fd8SPhilipp Reisner }; 914b411b363SPhilipp Reisner 915bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 916bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 917b411b363SPhilipp Reisner return -2; 918b411b363SPhilipp Reisner 9197da35862SPhilipp Reisner mutex_init(&sock.mutex); 920bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 921bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 9227da35862SPhilipp Reisner sock.socket = NULL; 9237da35862SPhilipp Reisner mutex_init(&msock.mutex); 924bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 925bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 9267da35862SPhilipp Reisner msock.socket = NULL; 9277da35862SPhilipp Reisner 9280916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 929bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 930b411b363SPhilipp Reisner 931bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 9327a426fd8SPhilipp Reisner return 0; 933b411b363SPhilipp Reisner 934b411b363SPhilipp Reisner do { 9352bf89621SAndreas Gruenbacher struct socket *s; 936b411b363SPhilipp Reisner 937bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 938b411b363SPhilipp Reisner if (s) { 9397da35862SPhilipp Reisner if (!sock.socket) { 9407da35862SPhilipp Reisner sock.socket = s; 941bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9427da35862SPhilipp Reisner } else if (!msock.socket) { 943bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9447da35862SPhilipp Reisner msock.socket = s; 945bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 946b411b363SPhilipp Reisner } else { 9471ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 948b411b363SPhilipp Reisner goto out_release_sockets; 949b411b363SPhilipp Reisner } 950b411b363SPhilipp Reisner } 951b411b363SPhilipp Reisner 9525d0b17f1SPhilipp Reisner if (connection_established(connection, &sock.socket, &msock.socket)) 953b411b363SPhilipp Reisner break; 954b411b363SPhilipp Reisner 955b411b363SPhilipp Reisner retry: 956bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 957b411b363SPhilipp Reisner if (s) { 958bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9597da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9607da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 96192f14951SPhilipp Reisner switch (fp) { 962e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9637da35862SPhilipp Reisner if (sock.socket) { 9641ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9657da35862SPhilipp Reisner sock_release(sock.socket); 96680c6eed4SPhilipp Reisner sock.socket = s; 96780c6eed4SPhilipp Reisner goto randomize; 968b411b363SPhilipp Reisner } 9697da35862SPhilipp Reisner sock.socket = s; 970b411b363SPhilipp Reisner break; 971e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 972bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 9737da35862SPhilipp Reisner if (msock.socket) { 9741ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 9757da35862SPhilipp Reisner sock_release(msock.socket); 97680c6eed4SPhilipp Reisner msock.socket = s; 97780c6eed4SPhilipp Reisner goto randomize; 978b411b363SPhilipp Reisner } 9797da35862SPhilipp Reisner msock.socket = s; 980b411b363SPhilipp Reisner break; 981b411b363SPhilipp Reisner default: 9821ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 983b411b363SPhilipp Reisner sock_release(s); 98480c6eed4SPhilipp Reisner randomize: 98538b682b2SAkinobu Mita if (prandom_u32() & 1) 986b411b363SPhilipp Reisner goto retry; 987b411b363SPhilipp Reisner } 988b411b363SPhilipp Reisner } 989b411b363SPhilipp Reisner 990bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 991b411b363SPhilipp Reisner goto out_release_sockets; 992b411b363SPhilipp Reisner if (signal_pending(current)) { 993b411b363SPhilipp Reisner flush_signals(current); 994b411b363SPhilipp Reisner smp_rmb(); 995bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 996b411b363SPhilipp Reisner goto out_release_sockets; 997b411b363SPhilipp Reisner } 998b411b363SPhilipp Reisner 9995d0b17f1SPhilipp Reisner ok = connection_established(connection, &sock.socket, &msock.socket); 1000b666dbf8SPhilipp Reisner } while (!ok); 1001b411b363SPhilipp Reisner 10027a426fd8SPhilipp Reisner if (ad.s_listen) 10037a426fd8SPhilipp Reisner sock_release(ad.s_listen); 1004b411b363SPhilipp Reisner 100598683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 100698683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 1007b411b363SPhilipp Reisner 10087da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 10097da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 1010b411b363SPhilipp Reisner 10117da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 10127da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 1013b411b363SPhilipp Reisner 1014b411b363SPhilipp Reisner /* NOT YET ... 1015bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 10167da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10176038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1018b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 101944ed167dSPhilipp Reisner rcu_read_lock(); 1020bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 1021b411b363SPhilipp Reisner 10227da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10237da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 102444ed167dSPhilipp Reisner 10257da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 102644ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 102708b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 102844ed167dSPhilipp Reisner rcu_read_unlock(); 102944ed167dSPhilipp Reisner 10307da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1031b411b363SPhilipp Reisner 1032b411b363SPhilipp Reisner /* we don't want delays. 103325985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10347da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10357da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1036b411b363SPhilipp Reisner 1037bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1038bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1039bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1040b411b363SPhilipp Reisner 1041bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1042b411b363SPhilipp Reisner if (h <= 0) 1043b411b363SPhilipp Reisner return h; 1044b411b363SPhilipp Reisner 1045bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1046b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1047bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1048b10d96cbSJohannes Thoma case -1: 10491ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1050b411b363SPhilipp Reisner return -1; 1051b10d96cbSJohannes Thoma case 0: 10521ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1053b10d96cbSJohannes Thoma return 0; 1054b411b363SPhilipp Reisner } 1055b411b363SPhilipp Reisner } 1056b411b363SPhilipp Reisner 1057bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1058bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1059b411b363SPhilipp Reisner 1060bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10617e2455c1SPhilipp Reisner return -1; 10621e86ac48SPhilipp Reisner 106313c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 106413c76abaSPhilipp Reisner * being promoted to Primary. 106513c76abaSPhilipp Reisner * 106613c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 106713c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 106813c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 106913c76abaSPhilipp Reisner */ 107031007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 107131007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 107231007745SPhilipp Reisner 107331007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 107431007745SPhilipp Reisner 107531007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 107631007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 107731007745SPhilipp Reisner 107831007745SPhilipp Reisner rcu_read_lock(); 107931007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 108031007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 108131007745SPhilipp Reisner kref_get(&device->kref); 108231007745SPhilipp Reisner rcu_read_unlock(); 108313c76abaSPhilipp Reisner 108408b165baSPhilipp Reisner if (discard_my_data) 1085b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 108608b165baSPhilipp Reisner else 1087b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 108808b165baSPhilipp Reisner 108969a22773SAndreas Gruenbacher drbd_connected(peer_device); 109005a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1091c141ebdaSPhilipp Reisner rcu_read_lock(); 1092c141ebdaSPhilipp Reisner } 1093c141ebdaSPhilipp Reisner rcu_read_unlock(); 1094c141ebdaSPhilipp Reisner 1095bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1096bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1097bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 10981e86ac48SPhilipp Reisner return 0; 1099a1096a6eSPhilipp Reisner } 11001e86ac48SPhilipp Reisner 1101bde89a9eSAndreas Gruenbacher drbd_thread_start(&connection->asender); 1102b411b363SPhilipp Reisner 11030500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 110408b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 110508b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 110608b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 110708b165baSPhilipp Reisner * just to clear a single value. */ 1108bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 11090500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 111008b165baSPhilipp Reisner 1111d3fcb490SPhilipp Reisner return h; 1112b411b363SPhilipp Reisner 1113b411b363SPhilipp Reisner out_release_sockets: 11147a426fd8SPhilipp Reisner if (ad.s_listen) 11157a426fd8SPhilipp Reisner sock_release(ad.s_listen); 11167da35862SPhilipp Reisner if (sock.socket) 11177da35862SPhilipp Reisner sock_release(sock.socket); 11187da35862SPhilipp Reisner if (msock.socket) 11197da35862SPhilipp Reisner sock_release(msock.socket); 1120b411b363SPhilipp Reisner return -1; 1121b411b363SPhilipp Reisner } 1122b411b363SPhilipp Reisner 1123bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1124b411b363SPhilipp Reisner { 1125bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1126b411b363SPhilipp Reisner 11270c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11280c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11290c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11300c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11311ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11320c8e36d9SAndreas Gruenbacher return -EINVAL; 113302918be2SPhilipp Reisner } 11340c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11350c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11360c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11370c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1138e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1139e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1140e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1141b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1142eefc2f7dSPhilipp Reisner pi->vnr = 0; 1143e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1144e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1145e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1146e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1147e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 114877351055SPhilipp Reisner pi->vnr = 0; 114902918be2SPhilipp Reisner } else { 11501ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1151e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1152bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11538172f3e9SAndreas Gruenbacher return -EINVAL; 1154b411b363SPhilipp Reisner } 1155e658983aSAndreas Gruenbacher pi->data = header + header_size; 11568172f3e9SAndreas Gruenbacher return 0; 1157b411b363SPhilipp Reisner } 1158b411b363SPhilipp Reisner 1159bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1160257d0af6SPhilipp Reisner { 1161bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 116269bc7bc3SAndreas Gruenbacher int err; 1163257d0af6SPhilipp Reisner 1164bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1165a5c31904SAndreas Gruenbacher if (err) 116669bc7bc3SAndreas Gruenbacher return err; 1167257d0af6SPhilipp Reisner 1168bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1169bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1170b411b363SPhilipp Reisner 117169bc7bc3SAndreas Gruenbacher return err; 1172b411b363SPhilipp Reisner } 1173b411b363SPhilipp Reisner 1174bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1175b411b363SPhilipp Reisner { 1176b411b363SPhilipp Reisner int rv; 1177c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 11784b0007c0SPhilipp Reisner int vnr; 1179b411b363SPhilipp Reisner 1180e9526580SPhilipp Reisner if (connection->resource->write_ordering >= WO_bdev_flush) { 1181615e087fSLars Ellenberg rcu_read_lock(); 1182c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1183c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1184c06ece6bSAndreas Gruenbacher 1185b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1186615e087fSLars Ellenberg continue; 1187b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1188615e087fSLars Ellenberg rcu_read_unlock(); 11894b0007c0SPhilipp Reisner 1190f418815fSLars Ellenberg /* Right now, we have only this one synchronous code path 1191f418815fSLars Ellenberg * for flushes between request epochs. 1192f418815fSLars Ellenberg * We may want to make those asynchronous, 1193f418815fSLars Ellenberg * or at least parallelize the flushes to the volume devices. 1194f418815fSLars Ellenberg */ 1195f418815fSLars Ellenberg device->flush_jif = jiffies; 1196f418815fSLars Ellenberg set_bit(FLUSH_PENDING, &device->flags); 1197b30ab791SAndreas Gruenbacher rv = blkdev_issue_flush(device->ldev->backing_bdev, 1198615e087fSLars Ellenberg GFP_NOIO, NULL); 1199f418815fSLars Ellenberg clear_bit(FLUSH_PENDING, &device->flags); 1200b411b363SPhilipp Reisner if (rv) { 1201d0180171SAndreas Gruenbacher drbd_info(device, "local disk flush failed with status %d\n", rv); 1202b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1203b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1204b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 12058fe39aacSPhilipp Reisner drbd_bump_write_ordering(connection->resource, NULL, WO_drain_io); 1206b411b363SPhilipp Reisner } 1207b30ab791SAndreas Gruenbacher put_ldev(device); 120805a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1209615e087fSLars Ellenberg 1210615e087fSLars Ellenberg rcu_read_lock(); 1211615e087fSLars Ellenberg if (rv) 12124b0007c0SPhilipp Reisner break; 1213b411b363SPhilipp Reisner } 1214615e087fSLars Ellenberg rcu_read_unlock(); 1215b411b363SPhilipp Reisner } 1216b411b363SPhilipp Reisner } 1217b411b363SPhilipp Reisner 1218b411b363SPhilipp Reisner /** 1219b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1220b30ab791SAndreas Gruenbacher * @device: DRBD device. 1221b411b363SPhilipp Reisner * @epoch: Epoch object. 1222b411b363SPhilipp Reisner * @ev: Epoch event. 1223b411b363SPhilipp Reisner */ 1224bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1225b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1226b411b363SPhilipp Reisner enum epoch_event ev) 1227b411b363SPhilipp Reisner { 12282451fc3bSPhilipp Reisner int epoch_size; 1229b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1230b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1231b411b363SPhilipp Reisner 1232bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1233b411b363SPhilipp Reisner do { 1234b411b363SPhilipp Reisner next_epoch = NULL; 1235b411b363SPhilipp Reisner 1236b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1237b411b363SPhilipp Reisner 1238b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1239b411b363SPhilipp Reisner case EV_PUT: 1240b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1241b411b363SPhilipp Reisner break; 1242b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1243b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1244b411b363SPhilipp Reisner break; 1245b411b363SPhilipp Reisner case EV_BECAME_LAST: 1246b411b363SPhilipp Reisner /* nothing to do*/ 1247b411b363SPhilipp Reisner break; 1248b411b363SPhilipp Reisner } 1249b411b363SPhilipp Reisner 1250b411b363SPhilipp Reisner if (epoch_size != 0 && 1251b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 125280f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1253b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1254bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1255bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1256bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1257b411b363SPhilipp Reisner } 12589ed57dcbSLars Ellenberg #if 0 12599ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12609ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 126180f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1262bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 12639ed57dcbSLars Ellenberg #endif 1264b411b363SPhilipp Reisner 1265bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1266b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1267b411b363SPhilipp Reisner list_del(&epoch->list); 1268b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1269bde89a9eSAndreas Gruenbacher connection->epochs--; 1270b411b363SPhilipp Reisner kfree(epoch); 1271b411b363SPhilipp Reisner 1272b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1273b411b363SPhilipp Reisner rv = FE_DESTROYED; 1274b411b363SPhilipp Reisner } else { 1275b411b363SPhilipp Reisner epoch->flags = 0; 1276b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1277698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1278b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1279b411b363SPhilipp Reisner rv = FE_RECYCLED; 1280b411b363SPhilipp Reisner } 1281b411b363SPhilipp Reisner } 1282b411b363SPhilipp Reisner 1283b411b363SPhilipp Reisner if (!next_epoch) 1284b411b363SPhilipp Reisner break; 1285b411b363SPhilipp Reisner 1286b411b363SPhilipp Reisner epoch = next_epoch; 1287b411b363SPhilipp Reisner } while (1); 1288b411b363SPhilipp Reisner 1289bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1290b411b363SPhilipp Reisner 1291b411b363SPhilipp Reisner return rv; 1292b411b363SPhilipp Reisner } 1293b411b363SPhilipp Reisner 12948fe39aacSPhilipp Reisner static enum write_ordering_e 12958fe39aacSPhilipp Reisner max_allowed_wo(struct drbd_backing_dev *bdev, enum write_ordering_e wo) 12968fe39aacSPhilipp Reisner { 12978fe39aacSPhilipp Reisner struct disk_conf *dc; 12988fe39aacSPhilipp Reisner 12998fe39aacSPhilipp Reisner dc = rcu_dereference(bdev->disk_conf); 13008fe39aacSPhilipp Reisner 13018fe39aacSPhilipp Reisner if (wo == WO_bdev_flush && !dc->disk_flushes) 13028fe39aacSPhilipp Reisner wo = WO_drain_io; 13038fe39aacSPhilipp Reisner if (wo == WO_drain_io && !dc->disk_drain) 13048fe39aacSPhilipp Reisner wo = WO_none; 13058fe39aacSPhilipp Reisner 13068fe39aacSPhilipp Reisner return wo; 13078fe39aacSPhilipp Reisner } 13088fe39aacSPhilipp Reisner 1309b411b363SPhilipp Reisner /** 1310b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1311bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1312b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1313b411b363SPhilipp Reisner */ 13148fe39aacSPhilipp Reisner void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, 13158fe39aacSPhilipp Reisner enum write_ordering_e wo) 1316b411b363SPhilipp Reisner { 1317e9526580SPhilipp Reisner struct drbd_device *device; 1318b411b363SPhilipp Reisner enum write_ordering_e pwo; 13194b0007c0SPhilipp Reisner int vnr; 1320b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1321b411b363SPhilipp Reisner [WO_none] = "none", 1322b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1323b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1324b411b363SPhilipp Reisner }; 1325b411b363SPhilipp Reisner 1326e9526580SPhilipp Reisner pwo = resource->write_ordering; 132770df7092SLars Ellenberg if (wo != WO_bdev_flush) 1328b411b363SPhilipp Reisner wo = min(pwo, wo); 1329daeda1ccSPhilipp Reisner rcu_read_lock(); 1330e9526580SPhilipp Reisner idr_for_each_entry(&resource->devices, device, vnr) { 13318fe39aacSPhilipp Reisner if (get_ldev(device)) { 13328fe39aacSPhilipp Reisner wo = max_allowed_wo(device->ldev, wo); 13338fe39aacSPhilipp Reisner if (device->ldev == bdev) 13348fe39aacSPhilipp Reisner bdev = NULL; 1335b30ab791SAndreas Gruenbacher put_ldev(device); 13364b0007c0SPhilipp Reisner } 13378fe39aacSPhilipp Reisner } 13388fe39aacSPhilipp Reisner 13398fe39aacSPhilipp Reisner if (bdev) 13408fe39aacSPhilipp Reisner wo = max_allowed_wo(bdev, wo); 13418fe39aacSPhilipp Reisner 134270df7092SLars Ellenberg rcu_read_unlock(); 134370df7092SLars Ellenberg 1344e9526580SPhilipp Reisner resource->write_ordering = wo; 1345e9526580SPhilipp Reisner if (pwo != resource->write_ordering || wo == WO_bdev_flush) 1346e9526580SPhilipp Reisner drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]); 1347b411b363SPhilipp Reisner } 1348b411b363SPhilipp Reisner 1349b411b363SPhilipp Reisner /** 1350fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1351b30ab791SAndreas Gruenbacher * @device: DRBD device. 1352db830c46SAndreas Gruenbacher * @peer_req: peer request 135345bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 135410f6d992SLars Ellenberg * 135510f6d992SLars Ellenberg * May spread the pages to multiple bios, 135610f6d992SLars Ellenberg * depending on bio_add_page restrictions. 135710f6d992SLars Ellenberg * 135810f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 135910f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 136010f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 136110f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 136210f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 136310f6d992SLars Ellenberg * on certain Xen deployments. 136445bb912bSLars Ellenberg */ 136545bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1366b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1367fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 136845bb912bSLars Ellenberg const unsigned rw, const int fault_type) 136945bb912bSLars Ellenberg { 137045bb912bSLars Ellenberg struct bio *bios = NULL; 137145bb912bSLars Ellenberg struct bio *bio; 1372db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1373db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 137411f8b2b6SAndreas Gruenbacher unsigned data_size = peer_req->i.size; 137545bb912bSLars Ellenberg unsigned n_bios = 0; 137611f8b2b6SAndreas Gruenbacher unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 137710f6d992SLars Ellenberg int err = -ENOMEM; 137845bb912bSLars Ellenberg 1379a0fb3c47SLars Ellenberg if (peer_req->flags & EE_IS_TRIM_USE_ZEROOUT) { 1380a0fb3c47SLars Ellenberg /* wait for all pending IO completions, before we start 1381a0fb3c47SLars Ellenberg * zeroing things out. */ 1382a0fb3c47SLars Ellenberg conn_wait_active_ee_empty(first_peer_device(device)->connection); 138345d2933cSLars Ellenberg /* add it to the active list now, 138445d2933cSLars Ellenberg * so we can find it to present it in debugfs */ 138521ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 138621ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 138745d2933cSLars Ellenberg spin_lock_irq(&device->resource->req_lock); 138845d2933cSLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 138945d2933cSLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 1390a0fb3c47SLars Ellenberg if (blkdev_issue_zeroout(device->ldev->backing_bdev, 139111f8b2b6SAndreas Gruenbacher sector, data_size >> 9, GFP_NOIO)) 1392a0fb3c47SLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 1393a0fb3c47SLars Ellenberg drbd_endio_write_sec_final(peer_req); 1394a0fb3c47SLars Ellenberg return 0; 1395a0fb3c47SLars Ellenberg } 1396a0fb3c47SLars Ellenberg 139754ed4ed8SLars Ellenberg /* Discards don't have any payload. 139854ed4ed8SLars Ellenberg * But the scsi layer still expects a bio_vec it can use internally, 139954ed4ed8SLars Ellenberg * see sd_setup_discard_cmnd() and blk_add_request_payload(). */ 1400a0fb3c47SLars Ellenberg if (peer_req->flags & EE_IS_TRIM) 140154ed4ed8SLars Ellenberg nr_pages = 1; 1402a0fb3c47SLars Ellenberg 140345bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 140445bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 140545bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 14069476f39dSLars Ellenberg * request in more than one bio. 14079476f39dSLars Ellenberg * 14089476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 14099476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 14109476f39dSLars Ellenberg */ 141145bb912bSLars Ellenberg next_bio: 141245bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 141345bb912bSLars Ellenberg if (!bio) { 1414a0fb3c47SLars Ellenberg drbd_err(device, "submit_ee: Allocation of a bio failed (nr_pages=%u)\n", nr_pages); 141545bb912bSLars Ellenberg goto fail; 141645bb912bSLars Ellenberg } 1417db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 14184f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 1419b30ab791SAndreas Gruenbacher bio->bi_bdev = device->ldev->backing_bdev; 142045bb912bSLars Ellenberg bio->bi_rw = rw; 1421db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1422fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 142345bb912bSLars Ellenberg 142445bb912bSLars Ellenberg bio->bi_next = bios; 142545bb912bSLars Ellenberg bios = bio; 142645bb912bSLars Ellenberg ++n_bios; 142745bb912bSLars Ellenberg 1428a0fb3c47SLars Ellenberg if (rw & REQ_DISCARD) { 142911f8b2b6SAndreas Gruenbacher bio->bi_iter.bi_size = data_size; 1430a0fb3c47SLars Ellenberg goto submit; 1431a0fb3c47SLars Ellenberg } 1432a0fb3c47SLars Ellenberg 143345bb912bSLars Ellenberg page_chain_for_each(page) { 143411f8b2b6SAndreas Gruenbacher unsigned len = min_t(unsigned, data_size, PAGE_SIZE); 143545bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 143610f6d992SLars Ellenberg /* A single page must always be possible! 143710f6d992SLars Ellenberg * But in case it fails anyways, 143810f6d992SLars Ellenberg * we deal with it, and complain (below). */ 143910f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 1440d0180171SAndreas Gruenbacher drbd_err(device, 144110f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 144210f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 14434f024f37SKent Overstreet len, (uint64_t)bio->bi_iter.bi_sector); 144410f6d992SLars Ellenberg err = -ENOSPC; 144510f6d992SLars Ellenberg goto fail; 144610f6d992SLars Ellenberg } 144745bb912bSLars Ellenberg goto next_bio; 144845bb912bSLars Ellenberg } 144911f8b2b6SAndreas Gruenbacher data_size -= len; 145045bb912bSLars Ellenberg sector += len >> 9; 145145bb912bSLars Ellenberg --nr_pages; 145245bb912bSLars Ellenberg } 145311f8b2b6SAndreas Gruenbacher D_ASSERT(device, data_size == 0); 1454a0fb3c47SLars Ellenberg submit: 1455a0fb3c47SLars Ellenberg D_ASSERT(device, page == NULL); 145645bb912bSLars Ellenberg 1457db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 145821ae5d7fSLars Ellenberg /* for debugfs: update timestamp, mark as submitted */ 145921ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 146021ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 146145bb912bSLars Ellenberg do { 146245bb912bSLars Ellenberg bio = bios; 146345bb912bSLars Ellenberg bios = bios->bi_next; 146445bb912bSLars Ellenberg bio->bi_next = NULL; 146545bb912bSLars Ellenberg 1466b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 146745bb912bSLars Ellenberg } while (bios); 146845bb912bSLars Ellenberg return 0; 146945bb912bSLars Ellenberg 147045bb912bSLars Ellenberg fail: 147145bb912bSLars Ellenberg while (bios) { 147245bb912bSLars Ellenberg bio = bios; 147345bb912bSLars Ellenberg bios = bios->bi_next; 147445bb912bSLars Ellenberg bio_put(bio); 147545bb912bSLars Ellenberg } 147610f6d992SLars Ellenberg return err; 147745bb912bSLars Ellenberg } 147845bb912bSLars Ellenberg 1479b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1480db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 148153840641SAndreas Gruenbacher { 1482db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 148353840641SAndreas Gruenbacher 1484b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 148553840641SAndreas Gruenbacher drbd_clear_interval(i); 148653840641SAndreas Gruenbacher 14876c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 148853840641SAndreas Gruenbacher if (i->waiting) 1489b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 149053840641SAndreas Gruenbacher } 149153840641SAndreas Gruenbacher 1492bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 149377fede51SPhilipp Reisner { 1494c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 149577fede51SPhilipp Reisner int vnr; 149677fede51SPhilipp Reisner 149777fede51SPhilipp Reisner rcu_read_lock(); 1498c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1499c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1500c06ece6bSAndreas Gruenbacher 1501b30ab791SAndreas Gruenbacher kref_get(&device->kref); 150277fede51SPhilipp Reisner rcu_read_unlock(); 1503b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 150405a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 150577fede51SPhilipp Reisner rcu_read_lock(); 150677fede51SPhilipp Reisner } 150777fede51SPhilipp Reisner rcu_read_unlock(); 150877fede51SPhilipp Reisner } 150977fede51SPhilipp Reisner 15109f4fe9adSAndreas Gruenbacher static struct drbd_peer_device * 15119f4fe9adSAndreas Gruenbacher conn_peer_device(struct drbd_connection *connection, int volume_number) 15129f4fe9adSAndreas Gruenbacher { 15139f4fe9adSAndreas Gruenbacher return idr_find(&connection->peer_devices, volume_number); 15149f4fe9adSAndreas Gruenbacher } 15159f4fe9adSAndreas Gruenbacher 1516bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1517b411b363SPhilipp Reisner { 15182451fc3bSPhilipp Reisner int rv; 1519e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1520b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1521b411b363SPhilipp Reisner 15229ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 15239ed57dcbSLars Ellenberg * not a specific (peer)device. 15249ed57dcbSLars Ellenberg */ 1525bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1526bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1527bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1528b411b363SPhilipp Reisner 1529b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1530b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1531b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1532b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1533b411b363SPhilipp Reisner * completed. */ 1534e9526580SPhilipp Reisner switch (connection->resource->write_ordering) { 1535b411b363SPhilipp Reisner case WO_none: 1536b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 153782bc0194SAndreas Gruenbacher return 0; 1538b411b363SPhilipp Reisner 1539b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1540b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1541b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 15422451fc3bSPhilipp Reisner if (epoch) 15432451fc3bSPhilipp Reisner break; 15442451fc3bSPhilipp Reisner else 15451ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 15462451fc3bSPhilipp Reisner /* Fall through */ 15472451fc3bSPhilipp Reisner 15482451fc3bSPhilipp Reisner case WO_bdev_flush: 15492451fc3bSPhilipp Reisner case WO_drain_io: 1550bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1551bde89a9eSAndreas Gruenbacher drbd_flush(connection); 15522451fc3bSPhilipp Reisner 1553bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 15542451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 15552451fc3bSPhilipp Reisner if (epoch) 15562451fc3bSPhilipp Reisner break; 1557b411b363SPhilipp Reisner } 1558b411b363SPhilipp Reisner 155982bc0194SAndreas Gruenbacher return 0; 15602451fc3bSPhilipp Reisner default: 1561e9526580SPhilipp Reisner drbd_err(connection, "Strangeness in connection->write_ordering %d\n", 1562e9526580SPhilipp Reisner connection->resource->write_ordering); 156382bc0194SAndreas Gruenbacher return -EIO; 1564b411b363SPhilipp Reisner } 1565b411b363SPhilipp Reisner 1566b411b363SPhilipp Reisner epoch->flags = 0; 1567b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1568b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1569b411b363SPhilipp Reisner 1570bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1571bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1572bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1573bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1574bde89a9eSAndreas Gruenbacher connection->epochs++; 1575b411b363SPhilipp Reisner } else { 1576b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1577b411b363SPhilipp Reisner kfree(epoch); 1578b411b363SPhilipp Reisner } 1579bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1580b411b363SPhilipp Reisner 158182bc0194SAndreas Gruenbacher return 0; 1582b411b363SPhilipp Reisner } 1583b411b363SPhilipp Reisner 1584b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1585b411b363SPhilipp Reisner * and from receive_Data */ 1586f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 158769a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1588a0fb3c47SLars Ellenberg struct packet_info *pi) __must_hold(local) 1589b411b363SPhilipp Reisner { 159069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1591b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1592db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1593b411b363SPhilipp Reisner struct page *page; 159411f8b2b6SAndreas Gruenbacher int digest_size, err; 159511f8b2b6SAndreas Gruenbacher unsigned int data_size = pi->size, ds; 159669a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 159769a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 15986b4388acSPhilipp Reisner unsigned long *data; 1599a0fb3c47SLars Ellenberg struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; 1600b411b363SPhilipp Reisner 160111f8b2b6SAndreas Gruenbacher digest_size = 0; 1602a0fb3c47SLars Ellenberg if (!trim && peer_device->connection->peer_integrity_tfm) { 160311f8b2b6SAndreas Gruenbacher digest_size = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 16049f5bdc33SAndreas Gruenbacher /* 16059f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 16069f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 16079f5bdc33SAndreas Gruenbacher */ 160811f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1609a5c31904SAndreas Gruenbacher if (err) 1610b411b363SPhilipp Reisner return NULL; 161111f8b2b6SAndreas Gruenbacher data_size -= digest_size; 161288104ca4SAndreas Gruenbacher } 1613b411b363SPhilipp Reisner 1614a0fb3c47SLars Ellenberg if (trim) { 1615a0fb3c47SLars Ellenberg D_ASSERT(peer_device, data_size == 0); 1616a0fb3c47SLars Ellenberg data_size = be32_to_cpu(trim->size); 1617a0fb3c47SLars Ellenberg } 1618a0fb3c47SLars Ellenberg 1619841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1620841ce241SAndreas Gruenbacher return NULL; 1621a0fb3c47SLars Ellenberg /* prepare for larger trim requests. */ 1622a0fb3c47SLars Ellenberg if (!trim && !expect(data_size <= DRBD_MAX_BIO_SIZE)) 1623841ce241SAndreas Gruenbacher return NULL; 1624b411b363SPhilipp Reisner 16256666032aSLars Ellenberg /* even though we trust out peer, 16266666032aSLars Ellenberg * we sometimes have to double check. */ 16276666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1628d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1629fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 16306666032aSLars Ellenberg (unsigned long long)capacity, 16316666032aSLars Ellenberg (unsigned long long)sector, data_size); 16326666032aSLars Ellenberg return NULL; 16336666032aSLars Ellenberg } 16346666032aSLars Ellenberg 1635b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1636b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1637b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1638a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, id, sector, data_size, trim == NULL, GFP_NOIO); 1639db830c46SAndreas Gruenbacher if (!peer_req) 1640b411b363SPhilipp Reisner return NULL; 164145bb912bSLars Ellenberg 164221ae5d7fSLars Ellenberg peer_req->flags |= EE_WRITE; 1643a0fb3c47SLars Ellenberg if (trim) 164481a3537aSLars Ellenberg return peer_req; 1645a73ff323SLars Ellenberg 1646b411b363SPhilipp Reisner ds = data_size; 1647db830c46SAndreas Gruenbacher page = peer_req->pages; 164845bb912bSLars Ellenberg page_chain_for_each(page) { 164945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 16506b4388acSPhilipp Reisner data = kmap(page); 165169a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1652b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1653d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 16546b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 16556b4388acSPhilipp Reisner } 1656b411b363SPhilipp Reisner kunmap(page); 1657a5c31904SAndreas Gruenbacher if (err) { 1658b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1659b411b363SPhilipp Reisner return NULL; 1660b411b363SPhilipp Reisner } 1661a5c31904SAndreas Gruenbacher ds -= len; 1662b411b363SPhilipp Reisner } 1663b411b363SPhilipp Reisner 166411f8b2b6SAndreas Gruenbacher if (digest_size) { 166569a22773SAndreas Gruenbacher drbd_csum_ee(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv); 166611f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 1667d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1668470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1669b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1670b411b363SPhilipp Reisner return NULL; 1671b411b363SPhilipp Reisner } 1672b411b363SPhilipp Reisner } 1673b30ab791SAndreas Gruenbacher device->recv_cnt += data_size >> 9; 1674db830c46SAndreas Gruenbacher return peer_req; 1675b411b363SPhilipp Reisner } 1676b411b363SPhilipp Reisner 1677b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1678b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1679b411b363SPhilipp Reisner */ 168069a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1681b411b363SPhilipp Reisner { 1682b411b363SPhilipp Reisner struct page *page; 1683a5c31904SAndreas Gruenbacher int err = 0; 1684b411b363SPhilipp Reisner void *data; 1685b411b363SPhilipp Reisner 1686c3470cdeSLars Ellenberg if (!data_size) 1687fc5be839SAndreas Gruenbacher return 0; 1688c3470cdeSLars Ellenberg 168969a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1690b411b363SPhilipp Reisner 1691b411b363SPhilipp Reisner data = kmap(page); 1692b411b363SPhilipp Reisner while (data_size) { 1693fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1694fc5be839SAndreas Gruenbacher 169569a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1696a5c31904SAndreas Gruenbacher if (err) 1697b411b363SPhilipp Reisner break; 1698a5c31904SAndreas Gruenbacher data_size -= len; 1699b411b363SPhilipp Reisner } 1700b411b363SPhilipp Reisner kunmap(page); 170169a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1702fc5be839SAndreas Gruenbacher return err; 1703b411b363SPhilipp Reisner } 1704b411b363SPhilipp Reisner 170569a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1706b411b363SPhilipp Reisner sector_t sector, int data_size) 1707b411b363SPhilipp Reisner { 17087988613bSKent Overstreet struct bio_vec bvec; 17097988613bSKent Overstreet struct bvec_iter iter; 1710b411b363SPhilipp Reisner struct bio *bio; 171111f8b2b6SAndreas Gruenbacher int digest_size, err, expect; 171269a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 171369a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1714b411b363SPhilipp Reisner 171511f8b2b6SAndreas Gruenbacher digest_size = 0; 171669a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 171711f8b2b6SAndreas Gruenbacher digest_size = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 171811f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1719a5c31904SAndreas Gruenbacher if (err) 1720a5c31904SAndreas Gruenbacher return err; 172111f8b2b6SAndreas Gruenbacher data_size -= digest_size; 172288104ca4SAndreas Gruenbacher } 1723b411b363SPhilipp Reisner 1724b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1725b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 172669a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1727b411b363SPhilipp Reisner 1728b411b363SPhilipp Reisner bio = req->master_bio; 172969a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1730b411b363SPhilipp Reisner 17317988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 17327988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 17337988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 173469a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 17357988613bSKent Overstreet kunmap(bvec.bv_page); 1736a5c31904SAndreas Gruenbacher if (err) 1737a5c31904SAndreas Gruenbacher return err; 1738a5c31904SAndreas Gruenbacher data_size -= expect; 1739b411b363SPhilipp Reisner } 1740b411b363SPhilipp Reisner 174111f8b2b6SAndreas Gruenbacher if (digest_size) { 174269a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 174311f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 174469a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 174528284cefSAndreas Gruenbacher return -EINVAL; 1746b411b363SPhilipp Reisner } 1747b411b363SPhilipp Reisner } 1748b411b363SPhilipp Reisner 174969a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 175028284cefSAndreas Gruenbacher return 0; 1751b411b363SPhilipp Reisner } 1752b411b363SPhilipp Reisner 1753a990be46SAndreas Gruenbacher /* 1754a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1755a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1756a990be46SAndreas Gruenbacher */ 175799920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1758b411b363SPhilipp Reisner { 17598050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1760a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1761a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1762a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1763db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 176499920dc5SAndreas Gruenbacher int err; 1765b411b363SPhilipp Reisner 17660b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1767b411b363SPhilipp Reisner 1768db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1769b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1770a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 1771b411b363SPhilipp Reisner } else { 1772b411b363SPhilipp Reisner /* Record failure to sync */ 1773b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 1774b411b363SPhilipp Reisner 1775a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1776b411b363SPhilipp Reisner } 1777b30ab791SAndreas Gruenbacher dec_unacked(device); 1778b411b363SPhilipp Reisner 177999920dc5SAndreas Gruenbacher return err; 1780b411b363SPhilipp Reisner } 1781b411b363SPhilipp Reisner 178269a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 1783a0fb3c47SLars Ellenberg struct packet_info *pi) __releases(local) 1784b411b363SPhilipp Reisner { 178569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1786db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1787b411b363SPhilipp Reisner 1788a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi); 1789db830c46SAndreas Gruenbacher if (!peer_req) 179045bb912bSLars Ellenberg goto fail; 1791b411b363SPhilipp Reisner 1792b30ab791SAndreas Gruenbacher dec_rs_pending(device); 1793b411b363SPhilipp Reisner 1794b30ab791SAndreas Gruenbacher inc_unacked(device); 1795b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1796b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1797b411b363SPhilipp Reisner 1798a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 179921ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 180045bb912bSLars Ellenberg 18010500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1802b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->sync_ee); 18030500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1804b411b363SPhilipp Reisner 1805a0fb3c47SLars Ellenberg atomic_add(pi->size >> 9, &device->rs_sect_ev); 1806b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1807e1c1b0fcSAndreas Gruenbacher return 0; 180845bb912bSLars Ellenberg 180910f6d992SLars Ellenberg /* don't care for the reason here */ 1810d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 18110500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1812a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 18130500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 181422cc37a9SLars Ellenberg 1815b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 181645bb912bSLars Ellenberg fail: 1817b30ab791SAndreas Gruenbacher put_ldev(device); 1818e1c1b0fcSAndreas Gruenbacher return -EIO; 1819b411b363SPhilipp Reisner } 1820b411b363SPhilipp Reisner 1821668eebc6SAndreas Gruenbacher static struct drbd_request * 1822b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 1823bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1824b411b363SPhilipp Reisner { 1825b411b363SPhilipp Reisner struct drbd_request *req; 1826668eebc6SAndreas Gruenbacher 1827bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1828bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 18295e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1830668eebc6SAndreas Gruenbacher return req; 1831c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1832d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 1833c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1834c3afd8f5SAndreas Gruenbacher } 1835668eebc6SAndreas Gruenbacher return NULL; 1836668eebc6SAndreas Gruenbacher } 1837668eebc6SAndreas Gruenbacher 1838bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 1839b411b363SPhilipp Reisner { 18409f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1841b30ab791SAndreas Gruenbacher struct drbd_device *device; 1842b411b363SPhilipp Reisner struct drbd_request *req; 1843b411b363SPhilipp Reisner sector_t sector; 184482bc0194SAndreas Gruenbacher int err; 1845e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 18464a76b161SAndreas Gruenbacher 18479f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 18489f4fe9adSAndreas Gruenbacher if (!peer_device) 18494a76b161SAndreas Gruenbacher return -EIO; 18509f4fe9adSAndreas Gruenbacher device = peer_device->device; 1851b411b363SPhilipp Reisner 1852b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1853b411b363SPhilipp Reisner 18540500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1855b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 18560500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1857c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 185882bc0194SAndreas Gruenbacher return -EIO; 1859b411b363SPhilipp Reisner 186024c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1861b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1862b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 186369a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 186482bc0194SAndreas Gruenbacher if (!err) 18658554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1866b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1867b411b363SPhilipp Reisner * I don't think we may complete this just yet 1868b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1869b411b363SPhilipp Reisner 187082bc0194SAndreas Gruenbacher return err; 1871b411b363SPhilipp Reisner } 1872b411b363SPhilipp Reisner 1873bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 1874b411b363SPhilipp Reisner { 18759f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1876b30ab791SAndreas Gruenbacher struct drbd_device *device; 1877b411b363SPhilipp Reisner sector_t sector; 187882bc0194SAndreas Gruenbacher int err; 1879e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 18804a76b161SAndreas Gruenbacher 18819f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 18829f4fe9adSAndreas Gruenbacher if (!peer_device) 18834a76b161SAndreas Gruenbacher return -EIO; 18849f4fe9adSAndreas Gruenbacher device = peer_device->device; 1885b411b363SPhilipp Reisner 1886b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 18870b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 1888b411b363SPhilipp Reisner 1889b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 1890b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1891b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1892fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1893a0fb3c47SLars Ellenberg err = recv_resync_read(peer_device, sector, pi); 1894b411b363SPhilipp Reisner } else { 1895b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1896d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 1897b411b363SPhilipp Reisner 189869a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 1899b411b363SPhilipp Reisner 190069a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 1901b411b363SPhilipp Reisner } 1902b411b363SPhilipp Reisner 1903b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 1904778f271dSPhilipp Reisner 190582bc0194SAndreas Gruenbacher return err; 1906b411b363SPhilipp Reisner } 1907b411b363SPhilipp Reisner 1908b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 19097be8da07SAndreas Gruenbacher sector_t sector, int size) 1910b411b363SPhilipp Reisner { 19117be8da07SAndreas Gruenbacher struct drbd_interval *i; 19127be8da07SAndreas Gruenbacher struct drbd_request *req; 1913b411b363SPhilipp Reisner 1914b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 19157be8da07SAndreas Gruenbacher if (!i->local) 19167be8da07SAndreas Gruenbacher continue; 19177be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 19187be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 19197be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 19207be8da07SAndreas Gruenbacher continue; 19212312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 19222312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1923d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 19247be8da07SAndreas Gruenbacher } 19257be8da07SAndreas Gruenbacher } 19267be8da07SAndreas Gruenbacher 1927a990be46SAndreas Gruenbacher /* 1928a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1929b411b363SPhilipp Reisner */ 193099920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1931b411b363SPhilipp Reisner { 19328050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1933a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1934a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1935a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1936db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 193799920dc5SAndreas Gruenbacher int err = 0, pcmd; 1938b411b363SPhilipp Reisner 1939303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1940db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1941b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 1942b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 1943db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1944b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1945a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 1946b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1947b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1948b411b363SPhilipp Reisner } else { 1949a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1950b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1951b411b363SPhilipp Reisner * maybe assert this? */ 1952b411b363SPhilipp Reisner } 1953b30ab791SAndreas Gruenbacher dec_unacked(device); 1954b411b363SPhilipp Reisner } 195508d0dabfSLars Ellenberg 1956b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1957b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1958302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 19590500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 19600b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 1961b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 19627be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 1963b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 19640500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1965bb3bfe96SAndreas Gruenbacher } else 19660b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1967b411b363SPhilipp Reisner 1968a6b32bc3SAndreas Gruenbacher drbd_may_finish_epoch(first_peer_device(device)->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1969b411b363SPhilipp Reisner 197099920dc5SAndreas Gruenbacher return err; 1971b411b363SPhilipp Reisner } 1972b411b363SPhilipp Reisner 1973a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1974b411b363SPhilipp Reisner { 19758050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1976a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1977a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 197899920dc5SAndreas Gruenbacher int err; 1979b411b363SPhilipp Reisner 1980a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 1981a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 1982b411b363SPhilipp Reisner 198399920dc5SAndreas Gruenbacher return err; 1984b411b363SPhilipp Reisner } 1985b411b363SPhilipp Reisner 1986d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 1987b6a370baSPhilipp Reisner { 1988a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 19897be8da07SAndreas Gruenbacher } 1990b6a370baSPhilipp Reisner 199199920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 19927be8da07SAndreas Gruenbacher { 1993a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 1994a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1995a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 19967be8da07SAndreas Gruenbacher 1997a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 1998d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 19997be8da07SAndreas Gruenbacher } 20007be8da07SAndreas Gruenbacher 20013e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 20023e394da1SAndreas Gruenbacher { 20033e394da1SAndreas Gruenbacher /* 20043e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 20053e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 20063e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 20073e394da1SAndreas Gruenbacher */ 20083e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 20093e394da1SAndreas Gruenbacher } 20103e394da1SAndreas Gruenbacher 20113e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 20123e394da1SAndreas Gruenbacher { 20133e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 20143e394da1SAndreas Gruenbacher } 20153e394da1SAndreas Gruenbacher 201669a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 20173e394da1SAndreas Gruenbacher { 201869a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 20193c13b680SLars Ellenberg unsigned int newest_peer_seq; 20203e394da1SAndreas Gruenbacher 202169a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 2022b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2023b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 2024b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 2025b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2026b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 20273c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 2028b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 20293e394da1SAndreas Gruenbacher } 20307be8da07SAndreas Gruenbacher } 20313e394da1SAndreas Gruenbacher 2032d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 2033d93f6302SLars Ellenberg { 2034d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 2035d93f6302SLars Ellenberg } 2036d93f6302SLars Ellenberg 2037d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 2038b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 2039d93f6302SLars Ellenberg { 2040d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 2041b6a370baSPhilipp Reisner bool rv = 0; 2042b6a370baSPhilipp Reisner 20430500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2044a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 2045d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 2046d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 2047b6a370baSPhilipp Reisner rv = 1; 2048b6a370baSPhilipp Reisner break; 2049b6a370baSPhilipp Reisner } 2050b6a370baSPhilipp Reisner } 20510500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2052b6a370baSPhilipp Reisner 2053b6a370baSPhilipp Reisner return rv; 2054b6a370baSPhilipp Reisner } 2055b6a370baSPhilipp Reisner 2056b411b363SPhilipp Reisner /* Called from receive_Data. 2057b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 2058b411b363SPhilipp Reisner * 2059b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 2060b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 2061b411b363SPhilipp Reisner * been sent. 2062b411b363SPhilipp Reisner * 2063b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 2064b411b363SPhilipp Reisner * 2065b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 2066b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 2067b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 2068b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 2069b411b363SPhilipp Reisner * 2070b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 2071b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 2072b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 2073b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 2074b411b363SPhilipp Reisner * 2075b411b363SPhilipp Reisner * returns 0 if we may process the packet, 2076b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 207769a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 2078b411b363SPhilipp Reisner { 207969a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2080b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2081b411b363SPhilipp Reisner long timeout; 2082b874d231SPhilipp Reisner int ret = 0, tp; 20837be8da07SAndreas Gruenbacher 208469a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 20857be8da07SAndreas Gruenbacher return 0; 20867be8da07SAndreas Gruenbacher 2087b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2088b411b363SPhilipp Reisner for (;;) { 2089b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 2090b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 2091b411b363SPhilipp Reisner break; 20927be8da07SAndreas Gruenbacher } 2093b874d231SPhilipp Reisner 2094b411b363SPhilipp Reisner if (signal_pending(current)) { 2095b411b363SPhilipp Reisner ret = -ERESTARTSYS; 2096b411b363SPhilipp Reisner break; 2097b411b363SPhilipp Reisner } 2098b874d231SPhilipp Reisner 2099b874d231SPhilipp Reisner rcu_read_lock(); 2100a6b32bc3SAndreas Gruenbacher tp = rcu_dereference(first_peer_device(device)->connection->net_conf)->two_primaries; 2101b874d231SPhilipp Reisner rcu_read_unlock(); 2102b874d231SPhilipp Reisner 2103b874d231SPhilipp Reisner if (!tp) 2104b874d231SPhilipp Reisner break; 2105b874d231SPhilipp Reisner 2106b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2107b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2108b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 210944ed167dSPhilipp Reisner rcu_read_lock(); 211069a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 211144ed167dSPhilipp Reisner rcu_read_unlock(); 211271b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2113b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 21147be8da07SAndreas Gruenbacher if (!timeout) { 2115b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2116d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2117b411b363SPhilipp Reisner break; 2118b411b363SPhilipp Reisner } 2119b411b363SPhilipp Reisner } 2120b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2121b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2122b411b363SPhilipp Reisner return ret; 2123b411b363SPhilipp Reisner } 2124b411b363SPhilipp Reisner 2125688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2126688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2127688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 212881f0ffd2SAndreas Gruenbacher static unsigned long wire_flags_to_bio(u32 dpf) 212976d2e7ecSPhilipp Reisner { 213076d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 213176d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2132688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 213376d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 213476d2e7ecSPhilipp Reisner } 213576d2e7ecSPhilipp Reisner 2136b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 21377be8da07SAndreas Gruenbacher unsigned int size) 2138b411b363SPhilipp Reisner { 21397be8da07SAndreas Gruenbacher struct drbd_interval *i; 21407be8da07SAndreas Gruenbacher 21417be8da07SAndreas Gruenbacher repeat: 2142b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21437be8da07SAndreas Gruenbacher struct drbd_request *req; 21447be8da07SAndreas Gruenbacher struct bio_and_error m; 21457be8da07SAndreas Gruenbacher 21467be8da07SAndreas Gruenbacher if (!i->local) 21477be8da07SAndreas Gruenbacher continue; 21487be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 21497be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 21507be8da07SAndreas Gruenbacher continue; 21517be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 21527be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 21530500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 21547be8da07SAndreas Gruenbacher if (m.bio) 2155b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 21560500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 21577be8da07SAndreas Gruenbacher goto repeat; 21587be8da07SAndreas Gruenbacher } 21597be8da07SAndreas Gruenbacher } 21607be8da07SAndreas Gruenbacher 2161b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 21627be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 21637be8da07SAndreas Gruenbacher { 2164e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2165bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 21667be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 21677be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 21687be8da07SAndreas Gruenbacher struct drbd_interval *i; 21697be8da07SAndreas Gruenbacher bool equal; 21707be8da07SAndreas Gruenbacher int err; 21717be8da07SAndreas Gruenbacher 21727be8da07SAndreas Gruenbacher /* 21737be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 21747be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 21757be8da07SAndreas Gruenbacher */ 2176b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 21777be8da07SAndreas Gruenbacher 21787be8da07SAndreas Gruenbacher repeat: 2179b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21807be8da07SAndreas Gruenbacher if (i == &peer_req->i) 21817be8da07SAndreas Gruenbacher continue; 218208d0dabfSLars Ellenberg if (i->completed) 218308d0dabfSLars Ellenberg continue; 21847be8da07SAndreas Gruenbacher 21857be8da07SAndreas Gruenbacher if (!i->local) { 21867be8da07SAndreas Gruenbacher /* 21877be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 21887be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 21897be8da07SAndreas Gruenbacher * earlier peer request to complete. 21907be8da07SAndreas Gruenbacher */ 2191b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 21927be8da07SAndreas Gruenbacher if (err) 21937be8da07SAndreas Gruenbacher goto out; 21947be8da07SAndreas Gruenbacher goto repeat; 21957be8da07SAndreas Gruenbacher } 21967be8da07SAndreas Gruenbacher 21977be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 21987be8da07SAndreas Gruenbacher if (resolve_conflicts) { 21997be8da07SAndreas Gruenbacher /* 22007be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2201d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2202d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2203d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 22047be8da07SAndreas Gruenbacher */ 2205d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 22067be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 22077be8da07SAndreas Gruenbacher 22087be8da07SAndreas Gruenbacher if (!equal) 2209d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 22107be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 22117be8da07SAndreas Gruenbacher "assuming %s came first\n", 22127be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 22137be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2214d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 22157be8da07SAndreas Gruenbacher 2216a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 22177be8da07SAndreas Gruenbacher e_send_retry_write; 2218a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2219e33b32deSAndreas Gruenbacher wake_asender(connection); 22207be8da07SAndreas Gruenbacher 22217be8da07SAndreas Gruenbacher err = -ENOENT; 22227be8da07SAndreas Gruenbacher goto out; 22237be8da07SAndreas Gruenbacher } else { 22247be8da07SAndreas Gruenbacher struct drbd_request *req = 22257be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 22267be8da07SAndreas Gruenbacher 22277be8da07SAndreas Gruenbacher if (!equal) 2228d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 22297be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 22307be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 22317be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 22327be8da07SAndreas Gruenbacher 22337be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 22347be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 22357be8da07SAndreas Gruenbacher /* 22367be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2237d4dabbe2SLars Ellenberg * decide if this request has been superseded 2238d4dabbe2SLars Ellenberg * or needs to be retried. 2239d4dabbe2SLars Ellenberg * Requests that have been superseded will 22407be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 22417be8da07SAndreas Gruenbacher * 22427be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 22437be8da07SAndreas Gruenbacher * request to finish locally before submitting 22447be8da07SAndreas Gruenbacher * the conflicting peer request. 22457be8da07SAndreas Gruenbacher */ 2246b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 22477be8da07SAndreas Gruenbacher if (err) { 2248e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2249b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 22507be8da07SAndreas Gruenbacher goto out; 22517be8da07SAndreas Gruenbacher } 22527be8da07SAndreas Gruenbacher goto repeat; 22537be8da07SAndreas Gruenbacher } 22547be8da07SAndreas Gruenbacher /* 22557be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 22567be8da07SAndreas Gruenbacher * the new peer request has completed. 22577be8da07SAndreas Gruenbacher */ 22587be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 22597be8da07SAndreas Gruenbacher } 22607be8da07SAndreas Gruenbacher } 22617be8da07SAndreas Gruenbacher err = 0; 22627be8da07SAndreas Gruenbacher 22637be8da07SAndreas Gruenbacher out: 22647be8da07SAndreas Gruenbacher if (err) 2265b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 22667be8da07SAndreas Gruenbacher return err; 22677be8da07SAndreas Gruenbacher } 22687be8da07SAndreas Gruenbacher 2269b411b363SPhilipp Reisner /* mirrored write */ 2270bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2271b411b363SPhilipp Reisner { 22729f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2273b30ab791SAndreas Gruenbacher struct drbd_device *device; 227421ae5d7fSLars Ellenberg struct net_conf *nc; 2275b411b363SPhilipp Reisner sector_t sector; 2276db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2277e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 22787be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2279b411b363SPhilipp Reisner int rw = WRITE; 2280b411b363SPhilipp Reisner u32 dp_flags; 2281302bdeaeSPhilipp Reisner int err, tp; 22827be8da07SAndreas Gruenbacher 22839f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 22849f4fe9adSAndreas Gruenbacher if (!peer_device) 22854a76b161SAndreas Gruenbacher return -EIO; 22869f4fe9adSAndreas Gruenbacher device = peer_device->device; 2287b411b363SPhilipp Reisner 2288b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 228982bc0194SAndreas Gruenbacher int err2; 2290b411b363SPhilipp Reisner 229169a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 229269a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2293bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 229469a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 229582bc0194SAndreas Gruenbacher if (!err) 229682bc0194SAndreas Gruenbacher err = err2; 229782bc0194SAndreas Gruenbacher return err; 2298b411b363SPhilipp Reisner } 2299b411b363SPhilipp Reisner 2300fcefa62eSAndreas Gruenbacher /* 2301fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2302fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2303fcefa62eSAndreas Gruenbacher * end of this function. 2304fcefa62eSAndreas Gruenbacher */ 2305b411b363SPhilipp Reisner 2306b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2307a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, p->block_id, sector, pi); 2308db830c46SAndreas Gruenbacher if (!peer_req) { 2309b30ab791SAndreas Gruenbacher put_ldev(device); 231082bc0194SAndreas Gruenbacher return -EIO; 2311b411b363SPhilipp Reisner } 2312b411b363SPhilipp Reisner 2313a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 231421ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 231521ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 2316b411b363SPhilipp Reisner 2317688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 231881f0ffd2SAndreas Gruenbacher rw |= wire_flags_to_bio(dp_flags); 2319a0fb3c47SLars Ellenberg if (pi->cmd == P_TRIM) { 2320a0fb3c47SLars Ellenberg struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); 2321a0fb3c47SLars Ellenberg peer_req->flags |= EE_IS_TRIM; 2322a0fb3c47SLars Ellenberg if (!blk_queue_discard(q)) 2323a0fb3c47SLars Ellenberg peer_req->flags |= EE_IS_TRIM_USE_ZEROOUT; 2324a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->i.size > 0); 2325a0fb3c47SLars Ellenberg D_ASSERT(peer_device, rw & REQ_DISCARD); 2326a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->pages == NULL); 2327a0fb3c47SLars Ellenberg } else if (peer_req->pages == NULL) { 23280b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 23290b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2330a73ff323SLars Ellenberg } 2331688593c5SLars Ellenberg 2332688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2333db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2334688593c5SLars Ellenberg 2335bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2336bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2337db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2338db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2339bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2340b411b363SPhilipp Reisner 2341302bdeaeSPhilipp Reisner rcu_read_lock(); 234221ae5d7fSLars Ellenberg nc = rcu_dereference(peer_device->connection->net_conf); 234321ae5d7fSLars Ellenberg tp = nc->two_primaries; 234421ae5d7fSLars Ellenberg if (peer_device->connection->agreed_pro_version < 100) { 234521ae5d7fSLars Ellenberg switch (nc->wire_protocol) { 234621ae5d7fSLars Ellenberg case DRBD_PROT_C: 234721ae5d7fSLars Ellenberg dp_flags |= DP_SEND_WRITE_ACK; 234821ae5d7fSLars Ellenberg break; 234921ae5d7fSLars Ellenberg case DRBD_PROT_B: 235021ae5d7fSLars Ellenberg dp_flags |= DP_SEND_RECEIVE_ACK; 235121ae5d7fSLars Ellenberg break; 235221ae5d7fSLars Ellenberg } 235321ae5d7fSLars Ellenberg } 2354302bdeaeSPhilipp Reisner rcu_read_unlock(); 235521ae5d7fSLars Ellenberg 235621ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_WRITE_ACK) { 235721ae5d7fSLars Ellenberg peer_req->flags |= EE_SEND_WRITE_ACK; 235821ae5d7fSLars Ellenberg inc_unacked(device); 235921ae5d7fSLars Ellenberg /* corresponding dec_unacked() in e_end_block() 236021ae5d7fSLars Ellenberg * respective _drbd_clear_done_ee */ 236121ae5d7fSLars Ellenberg } 236221ae5d7fSLars Ellenberg 236321ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_RECEIVE_ACK) { 236421ae5d7fSLars Ellenberg /* I really don't like it that the receiver thread 236521ae5d7fSLars Ellenberg * sends on the msock, but anyways */ 236621ae5d7fSLars Ellenberg drbd_send_ack(first_peer_device(device), P_RECV_ACK, peer_req); 236721ae5d7fSLars Ellenberg } 236821ae5d7fSLars Ellenberg 2369302bdeaeSPhilipp Reisner if (tp) { 237021ae5d7fSLars Ellenberg /* two primaries implies protocol C */ 237121ae5d7fSLars Ellenberg D_ASSERT(device, dp_flags & DP_SEND_WRITE_ACK); 2372302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 237369a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 23747be8da07SAndreas Gruenbacher if (err) 2375b411b363SPhilipp Reisner goto out_interrupted; 23760500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2377b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 23787be8da07SAndreas Gruenbacher if (err) { 23790500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 23807be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2381b30ab791SAndreas Gruenbacher put_ldev(device); 238282bc0194SAndreas Gruenbacher return 0; 2383b411b363SPhilipp Reisner } 2384b411b363SPhilipp Reisner goto out_interrupted; 2385b411b363SPhilipp Reisner } 2386b874d231SPhilipp Reisner } else { 238769a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 23880500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2389b874d231SPhilipp Reisner } 2390a0fb3c47SLars Ellenberg /* if we use the zeroout fallback code, we process synchronously 2391a0fb3c47SLars Ellenberg * and we wait for all pending requests, respectively wait for 2392a0fb3c47SLars Ellenberg * active_ee to become empty in drbd_submit_peer_request(); 2393a0fb3c47SLars Ellenberg * better not add ourselves here. */ 2394a0fb3c47SLars Ellenberg if ((peer_req->flags & EE_IS_TRIM_USE_ZEROOUT) == 0) 2395b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 23960500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2397b411b363SPhilipp Reisner 2398b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2399b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2400b6a370baSPhilipp Reisner 2401b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2402b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2403b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2404db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 24054dd726f0SLars Ellenberg drbd_al_begin_io(device, &peer_req->i); 240621ae5d7fSLars Ellenberg peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2407b411b363SPhilipp Reisner } 2408b411b363SPhilipp Reisner 2409b30ab791SAndreas Gruenbacher err = drbd_submit_peer_request(device, peer_req, rw, DRBD_FAULT_DT_WR); 241082bc0194SAndreas Gruenbacher if (!err) 241182bc0194SAndreas Gruenbacher return 0; 2412b411b363SPhilipp Reisner 241310f6d992SLars Ellenberg /* don't care for the reason here */ 2414d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 24150500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2416a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2417b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 24180500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 241921ae5d7fSLars Ellenberg if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) { 242021ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 2421b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 242221ae5d7fSLars Ellenberg } 242322cc37a9SLars Ellenberg 2424b411b363SPhilipp Reisner out_interrupted: 2425bde89a9eSAndreas Gruenbacher drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT + EV_CLEANUP); 2426b30ab791SAndreas Gruenbacher put_ldev(device); 2427b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 242882bc0194SAndreas Gruenbacher return err; 2429b411b363SPhilipp Reisner } 2430b411b363SPhilipp Reisner 24310f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 24320f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 24330f0601f4SLars Ellenberg * 24340f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 24350f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 24360f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 24370f0601f4SLars Ellenberg * activity, it obviously is "busy". 24380f0601f4SLars Ellenberg * 24390f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 24400f0601f4SLars Ellenberg * to have a short time average so we can react faster. 24410f0601f4SLars Ellenberg */ 2442ad3fee79SLars Ellenberg bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector, 2443ad3fee79SLars Ellenberg bool throttle_if_app_is_waiting) 2444e8299874SLars Ellenberg { 2445e8299874SLars Ellenberg struct lc_element *tmp; 2446ad3fee79SLars Ellenberg bool throttle = drbd_rs_c_min_rate_throttle(device); 2447e8299874SLars Ellenberg 2448ad3fee79SLars Ellenberg if (!throttle || throttle_if_app_is_waiting) 2449ad3fee79SLars Ellenberg return throttle; 2450e8299874SLars Ellenberg 2451e8299874SLars Ellenberg spin_lock_irq(&device->al_lock); 2452e8299874SLars Ellenberg tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2453e8299874SLars Ellenberg if (tmp) { 2454e8299874SLars Ellenberg struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2455e8299874SLars Ellenberg if (test_bit(BME_PRIORITY, &bm_ext->flags)) 2456e8299874SLars Ellenberg throttle = false; 2457ad3fee79SLars Ellenberg /* Do not slow down if app IO is already waiting for this extent, 2458ad3fee79SLars Ellenberg * and our progress is necessary for application IO to complete. */ 2459e8299874SLars Ellenberg } 2460e8299874SLars Ellenberg spin_unlock_irq(&device->al_lock); 2461e8299874SLars Ellenberg 2462e8299874SLars Ellenberg return throttle; 2463e8299874SLars Ellenberg } 2464e8299874SLars Ellenberg 2465e8299874SLars Ellenberg bool drbd_rs_c_min_rate_throttle(struct drbd_device *device) 24660f0601f4SLars Ellenberg { 2467b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 24680f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2469daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2470e8299874SLars Ellenberg int curr_events; 2471daeda1ccSPhilipp Reisner 2472daeda1ccSPhilipp Reisner rcu_read_lock(); 2473b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2474daeda1ccSPhilipp Reisner rcu_read_unlock(); 24750f0601f4SLars Ellenberg 24760f0601f4SLars Ellenberg /* feature disabled? */ 2477daeda1ccSPhilipp Reisner if (c_min_rate == 0) 2478e8299874SLars Ellenberg return false; 2479e3555d85SPhilipp Reisner 24800f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 24810f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2482b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2483ad3fee79SLars Ellenberg 2484ad3fee79SLars Ellenberg if (atomic_read(&device->ap_actlog_cnt) 2485ff8bd88bSLars Ellenberg || curr_events - device->rs_last_events > 64) { 24860f0601f4SLars Ellenberg unsigned long rs_left; 24870f0601f4SLars Ellenberg int i; 24880f0601f4SLars Ellenberg 2489b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 24900f0601f4SLars Ellenberg 24910f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 24920f0601f4SLars Ellenberg * approx. */ 2493b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 24942649f080SLars Ellenberg 2495b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2496b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 24972649f080SLars Ellenberg else 2498b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 24990f0601f4SLars Ellenberg 2500b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 25010f0601f4SLars Ellenberg if (!dt) 25020f0601f4SLars Ellenberg dt++; 2503b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 25040f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 25050f0601f4SLars Ellenberg 2506daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 2507e8299874SLars Ellenberg return true; 25080f0601f4SLars Ellenberg } 2509e8299874SLars Ellenberg return false; 25100f0601f4SLars Ellenberg } 25110f0601f4SLars Ellenberg 2512bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2513b411b363SPhilipp Reisner { 25149f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2515b30ab791SAndreas Gruenbacher struct drbd_device *device; 2516b411b363SPhilipp Reisner sector_t sector; 25174a76b161SAndreas Gruenbacher sector_t capacity; 2518db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2519b411b363SPhilipp Reisner struct digest_info *di = NULL; 2520b18b37beSPhilipp Reisner int size, verb; 2521b411b363SPhilipp Reisner unsigned int fault_type; 2522e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 25234a76b161SAndreas Gruenbacher 25249f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 25259f4fe9adSAndreas Gruenbacher if (!peer_device) 25264a76b161SAndreas Gruenbacher return -EIO; 25279f4fe9adSAndreas Gruenbacher device = peer_device->device; 2528b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2529b411b363SPhilipp Reisner 2530b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2531b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2532b411b363SPhilipp Reisner 2533c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2534d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2535b411b363SPhilipp Reisner (unsigned long long)sector, size); 253682bc0194SAndreas Gruenbacher return -EINVAL; 2537b411b363SPhilipp Reisner } 2538b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2539d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2540b411b363SPhilipp Reisner (unsigned long long)sector, size); 254182bc0194SAndreas Gruenbacher return -EINVAL; 2542b411b363SPhilipp Reisner } 2543b411b363SPhilipp Reisner 2544b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2545b18b37beSPhilipp Reisner verb = 1; 2546e2857216SAndreas Gruenbacher switch (pi->cmd) { 2547b18b37beSPhilipp Reisner case P_DATA_REQUEST: 254869a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2549b18b37beSPhilipp Reisner break; 2550b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2551b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2552b18b37beSPhilipp Reisner case P_OV_REQUEST: 255369a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2554b18b37beSPhilipp Reisner break; 2555b18b37beSPhilipp Reisner case P_OV_REPLY: 2556b18b37beSPhilipp Reisner verb = 0; 2557b30ab791SAndreas Gruenbacher dec_rs_pending(device); 255869a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2559b18b37beSPhilipp Reisner break; 2560b18b37beSPhilipp Reisner default: 256149ba9b1bSAndreas Gruenbacher BUG(); 2562b18b37beSPhilipp Reisner } 2563b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2564d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2565b411b363SPhilipp Reisner "no local data.\n"); 2566b18b37beSPhilipp Reisner 2567a821cc4aSLars Ellenberg /* drain possibly payload */ 256869a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2569b411b363SPhilipp Reisner } 2570b411b363SPhilipp Reisner 2571b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2572b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2573b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2574a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, 2575a0fb3c47SLars Ellenberg true /* has real payload */, GFP_NOIO); 2576db830c46SAndreas Gruenbacher if (!peer_req) { 2577b30ab791SAndreas Gruenbacher put_ldev(device); 257882bc0194SAndreas Gruenbacher return -ENOMEM; 2579b411b363SPhilipp Reisner } 2580b411b363SPhilipp Reisner 2581e2857216SAndreas Gruenbacher switch (pi->cmd) { 2582b411b363SPhilipp Reisner case P_DATA_REQUEST: 2583a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2584b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 258580a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 258621ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 258780a40e43SLars Ellenberg goto submit; 258880a40e43SLars Ellenberg 2589b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2590a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2591b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 25925f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2593b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2594b411b363SPhilipp Reisner break; 2595b411b363SPhilipp Reisner 2596b411b363SPhilipp Reisner case P_OV_REPLY: 2597b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2598b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2599e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2600b411b363SPhilipp Reisner if (!di) 2601b411b363SPhilipp Reisner goto out_free_e; 2602b411b363SPhilipp Reisner 2603e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2604b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2605b411b363SPhilipp Reisner 2606db830c46SAndreas Gruenbacher peer_req->digest = di; 2607db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2608c36c3cedSLars Ellenberg 26099f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2610b411b363SPhilipp Reisner goto out_free_e; 2611b411b363SPhilipp Reisner 2612e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 26139f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2614a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 26155f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2616b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2617aaaba345SLars Ellenberg /* remember to report stats in drbd_resync_finished */ 2618aaaba345SLars Ellenberg device->use_csums = true; 2619e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 26202649f080SLars Ellenberg /* track progress, we may need to throttle */ 2621b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2622a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2623b30ab791SAndreas Gruenbacher dec_rs_pending(device); 26240f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 26250f0601f4SLars Ellenberg * but accounting still needs to be done. */ 26260f0601f4SLars Ellenberg goto submit_for_resync; 2627b411b363SPhilipp Reisner } 2628b411b363SPhilipp Reisner break; 2629b411b363SPhilipp Reisner 2630b411b363SPhilipp Reisner case P_OV_REQUEST: 2631b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 26329f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2633de228bbaSLars Ellenberg unsigned long now = jiffies; 2634de228bbaSLars Ellenberg int i; 2635b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2636b30ab791SAndreas Gruenbacher device->ov_position = sector; 2637b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2638b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2639de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2640b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2641b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2642de228bbaSLars Ellenberg } 2643d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2644b411b363SPhilipp Reisner (unsigned long long)sector); 2645b411b363SPhilipp Reisner } 2646a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2647b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2648b411b363SPhilipp Reisner break; 2649b411b363SPhilipp Reisner 2650b411b363SPhilipp Reisner default: 265149ba9b1bSAndreas Gruenbacher BUG(); 2652b411b363SPhilipp Reisner } 2653b411b363SPhilipp Reisner 26540f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 26550f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 26560f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 26570f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 26580f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 26590f0601f4SLars Ellenberg * 26600f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 26610f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 26620f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 26630f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 26640f0601f4SLars Ellenberg * a while, anyways. 26650f0601f4SLars Ellenberg */ 2666b411b363SPhilipp Reisner 26670f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 26680f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 26690f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 26700f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 26710f0601f4SLars Ellenberg * 26720f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 26730f0601f4SLars Ellenberg * we would also throttle its application reads. 26740f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 26750f0601f4SLars Ellenberg */ 2676c5a2c150SLars Ellenberg 2677c5a2c150SLars Ellenberg /* Even though this may be a resync request, we do add to "read_ee"; 2678c5a2c150SLars Ellenberg * "sync_ee" is only used for resync WRITEs. 2679c5a2c150SLars Ellenberg * Add to list early, so debugfs can find this request 2680c5a2c150SLars Ellenberg * even if we have to sleep below. */ 2681c5a2c150SLars Ellenberg spin_lock_irq(&device->resource->req_lock); 2682c5a2c150SLars Ellenberg list_add_tail(&peer_req->w.list, &device->read_ee); 2683c5a2c150SLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 2684c5a2c150SLars Ellenberg 2685944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_should_slow_down); 2686ad3fee79SLars Ellenberg if (device->state.peer != R_PRIMARY 2687ad3fee79SLars Ellenberg && drbd_rs_should_slow_down(device, sector, false)) 2688e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2689944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_begin_io); 2690b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 269180a40e43SLars Ellenberg goto out_free_e; 2692b411b363SPhilipp Reisner 26930f0601f4SLars Ellenberg submit_for_resync: 2694b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 26950f0601f4SLars Ellenberg 269680a40e43SLars Ellenberg submit: 2697944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_submit_peer_request); 2698b30ab791SAndreas Gruenbacher inc_unacked(device); 2699b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, READ, fault_type) == 0) 270082bc0194SAndreas Gruenbacher return 0; 2701b411b363SPhilipp Reisner 270210f6d992SLars Ellenberg /* don't care for the reason here */ 2703d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 2704c5a2c150SLars Ellenberg 2705c5a2c150SLars Ellenberg out_free_e: 27060500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2707a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 27080500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 270922cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 271022cc37a9SLars Ellenberg 2711b30ab791SAndreas Gruenbacher put_ldev(device); 2712b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 271382bc0194SAndreas Gruenbacher return -EIO; 2714b411b363SPhilipp Reisner } 2715b411b363SPhilipp Reisner 271669a22773SAndreas Gruenbacher /** 271769a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 271869a22773SAndreas Gruenbacher */ 271969a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2720b411b363SPhilipp Reisner { 272169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2722b411b363SPhilipp Reisner int self, peer, rv = -100; 2723b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 272444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2725b411b363SPhilipp Reisner 2726b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2727b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2728b411b363SPhilipp Reisner 2729b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2730b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2731b411b363SPhilipp Reisner 273244ed167dSPhilipp Reisner rcu_read_lock(); 273369a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 273444ed167dSPhilipp Reisner rcu_read_unlock(); 273544ed167dSPhilipp Reisner switch (after_sb_0p) { 2736b411b363SPhilipp Reisner case ASB_CONSENSUS: 2737b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2738b411b363SPhilipp Reisner case ASB_CALL_HELPER: 273944ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2740d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2741b411b363SPhilipp Reisner break; 2742b411b363SPhilipp Reisner case ASB_DISCONNECT: 2743b411b363SPhilipp Reisner break; 2744b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2745b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2746b411b363SPhilipp Reisner rv = -1; 2747b411b363SPhilipp Reisner break; 2748b411b363SPhilipp Reisner } 2749b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2750b411b363SPhilipp Reisner rv = 1; 2751b411b363SPhilipp Reisner break; 2752b411b363SPhilipp Reisner } 2753b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2754b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2755b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2756b411b363SPhilipp Reisner rv = 1; 2757b411b363SPhilipp Reisner break; 2758b411b363SPhilipp Reisner } 2759b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2760b411b363SPhilipp Reisner rv = -1; 2761b411b363SPhilipp Reisner break; 2762b411b363SPhilipp Reisner } 2763b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2764d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 2765b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2766b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2767b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 276869a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2769b411b363SPhilipp Reisner ? -1 : 1; 2770b411b363SPhilipp Reisner break; 2771b411b363SPhilipp Reisner } else { 2772b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2773b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2774b411b363SPhilipp Reisner } 277544ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2776b411b363SPhilipp Reisner break; 2777b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2778b411b363SPhilipp Reisner if (ch_self < ch_peer) 2779b411b363SPhilipp Reisner rv = -1; 2780b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2781b411b363SPhilipp Reisner rv = 1; 2782b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2783b411b363SPhilipp Reisner /* Well, then use something else. */ 278469a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2785b411b363SPhilipp Reisner ? -1 : 1; 2786b411b363SPhilipp Reisner break; 2787b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2788b411b363SPhilipp Reisner rv = -1; 2789b411b363SPhilipp Reisner break; 2790b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2791b411b363SPhilipp Reisner rv = 1; 2792b411b363SPhilipp Reisner } 2793b411b363SPhilipp Reisner 2794b411b363SPhilipp Reisner return rv; 2795b411b363SPhilipp Reisner } 2796b411b363SPhilipp Reisner 279769a22773SAndreas Gruenbacher /** 279869a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 279969a22773SAndreas Gruenbacher */ 280069a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 2801b411b363SPhilipp Reisner { 280269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 28036184ea21SAndreas Gruenbacher int hg, rv = -100; 280444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2805b411b363SPhilipp Reisner 280644ed167dSPhilipp Reisner rcu_read_lock(); 280769a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 280844ed167dSPhilipp Reisner rcu_read_unlock(); 280944ed167dSPhilipp Reisner switch (after_sb_1p) { 2810b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2811b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2812b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2813b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2814b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 281544ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2816d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2817b411b363SPhilipp Reisner break; 2818b411b363SPhilipp Reisner case ASB_DISCONNECT: 2819b411b363SPhilipp Reisner break; 2820b411b363SPhilipp Reisner case ASB_CONSENSUS: 282169a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2822b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 2823b411b363SPhilipp Reisner rv = hg; 2824b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 2825b411b363SPhilipp Reisner rv = hg; 2826b411b363SPhilipp Reisner break; 2827b411b363SPhilipp Reisner case ASB_VIOLENTLY: 282869a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2829b411b363SPhilipp Reisner break; 2830b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2831b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 2832b411b363SPhilipp Reisner case ASB_CALL_HELPER: 283369a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2834b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 2835bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2836bb437946SAndreas Gruenbacher 2837b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2838b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2839b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2840b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2841bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2842b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2843b411b363SPhilipp Reisner } else { 2844d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2845b411b363SPhilipp Reisner rv = hg; 2846b411b363SPhilipp Reisner } 2847b411b363SPhilipp Reisner } else 2848b411b363SPhilipp Reisner rv = hg; 2849b411b363SPhilipp Reisner } 2850b411b363SPhilipp Reisner 2851b411b363SPhilipp Reisner return rv; 2852b411b363SPhilipp Reisner } 2853b411b363SPhilipp Reisner 285469a22773SAndreas Gruenbacher /** 285569a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 285669a22773SAndreas Gruenbacher */ 285769a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 2858b411b363SPhilipp Reisner { 285969a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 28606184ea21SAndreas Gruenbacher int hg, rv = -100; 286144ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2862b411b363SPhilipp Reisner 286344ed167dSPhilipp Reisner rcu_read_lock(); 286469a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 286544ed167dSPhilipp Reisner rcu_read_unlock(); 286644ed167dSPhilipp Reisner switch (after_sb_2p) { 2867b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2868b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2869b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2870b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2871b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2872b411b363SPhilipp Reisner case ASB_CONSENSUS: 2873b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 287444ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2875d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2876b411b363SPhilipp Reisner break; 2877b411b363SPhilipp Reisner case ASB_VIOLENTLY: 287869a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2879b411b363SPhilipp Reisner break; 2880b411b363SPhilipp Reisner case ASB_DISCONNECT: 2881b411b363SPhilipp Reisner break; 2882b411b363SPhilipp Reisner case ASB_CALL_HELPER: 288369a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2884b411b363SPhilipp Reisner if (hg == -1) { 2885bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2886bb437946SAndreas Gruenbacher 2887b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2888b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2889b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2890b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2891bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2892b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2893b411b363SPhilipp Reisner } else { 2894d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2895b411b363SPhilipp Reisner rv = hg; 2896b411b363SPhilipp Reisner } 2897b411b363SPhilipp Reisner } else 2898b411b363SPhilipp Reisner rv = hg; 2899b411b363SPhilipp Reisner } 2900b411b363SPhilipp Reisner 2901b411b363SPhilipp Reisner return rv; 2902b411b363SPhilipp Reisner } 2903b411b363SPhilipp Reisner 2904b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 2905b411b363SPhilipp Reisner u64 bits, u64 flags) 2906b411b363SPhilipp Reisner { 2907b411b363SPhilipp Reisner if (!uuid) { 2908d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 2909b411b363SPhilipp Reisner return; 2910b411b363SPhilipp Reisner } 2911d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2912b411b363SPhilipp Reisner text, 2913b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2914b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2915b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2916b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2917b411b363SPhilipp Reisner (unsigned long long)bits, 2918b411b363SPhilipp Reisner (unsigned long long)flags); 2919b411b363SPhilipp Reisner } 2920b411b363SPhilipp Reisner 2921b411b363SPhilipp Reisner /* 2922b411b363SPhilipp Reisner 100 after split brain try auto recover 2923b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2924b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2925b411b363SPhilipp Reisner 0 no Sync 2926b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2927b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2928b411b363SPhilipp Reisner -100 after split brain, disconnect 2929b411b363SPhilipp Reisner -1000 unrelated data 29304a23f264SPhilipp Reisner -1091 requires proto 91 29314a23f264SPhilipp Reisner -1096 requires proto 96 2932b411b363SPhilipp Reisner */ 293344a4d551SLars Ellenberg static int drbd_uuid_compare(struct drbd_device *const device, int *rule_nr) __must_hold(local) 2934b411b363SPhilipp Reisner { 293544a4d551SLars Ellenberg struct drbd_peer_device *const peer_device = first_peer_device(device); 293644a4d551SLars Ellenberg struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; 2937b411b363SPhilipp Reisner u64 self, peer; 2938b411b363SPhilipp Reisner int i, j; 2939b411b363SPhilipp Reisner 2940b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2941b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2942b411b363SPhilipp Reisner 2943b411b363SPhilipp Reisner *rule_nr = 10; 2944b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2945b411b363SPhilipp Reisner return 0; 2946b411b363SPhilipp Reisner 2947b411b363SPhilipp Reisner *rule_nr = 20; 2948b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2949b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2950b411b363SPhilipp Reisner return -2; 2951b411b363SPhilipp Reisner 2952b411b363SPhilipp Reisner *rule_nr = 30; 2953b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2954b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2955b411b363SPhilipp Reisner return 2; 2956b411b363SPhilipp Reisner 2957b411b363SPhilipp Reisner if (self == peer) { 2958b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2959b411b363SPhilipp Reisner 2960b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2961b411b363SPhilipp Reisner 296244a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 29634a23f264SPhilipp Reisner return -1091; 2964b411b363SPhilipp Reisner 2965b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2966b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2967d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2968b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 2969b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 2970b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 2971b411b363SPhilipp Reisner 2972b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 2973b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 2974b411b363SPhilipp Reisner *rule_nr = 34; 2975b411b363SPhilipp Reisner } else { 2976d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 2977b411b363SPhilipp Reisner *rule_nr = 36; 2978b411b363SPhilipp Reisner } 2979b411b363SPhilipp Reisner 2980b411b363SPhilipp Reisner return 1; 2981b411b363SPhilipp Reisner } 2982b411b363SPhilipp Reisner 2983b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 2984b411b363SPhilipp Reisner 298544a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 29864a23f264SPhilipp Reisner return -1091; 2987b411b363SPhilipp Reisner 2988b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 2989b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2990d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2991b411b363SPhilipp Reisner 2992b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 2993b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 2994b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 2995b411b363SPhilipp Reisner 2996b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 2997b411b363SPhilipp Reisner *rule_nr = 35; 2998b411b363SPhilipp Reisner } else { 2999d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 3000b411b363SPhilipp Reisner *rule_nr = 37; 3001b411b363SPhilipp Reisner } 3002b411b363SPhilipp Reisner 3003b411b363SPhilipp Reisner return -1; 3004b411b363SPhilipp Reisner } 3005b411b363SPhilipp Reisner 3006b411b363SPhilipp Reisner /* Common power [off|failure] */ 3007b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 3008b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 3009b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 3010b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 3011b411b363SPhilipp Reisner *rule_nr = 40; 3012b411b363SPhilipp Reisner 3013b411b363SPhilipp Reisner switch (rct) { 3014b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 3015b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 3016b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 3017b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 301844a4d551SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); 3019b411b363SPhilipp Reisner return dc ? -1 : 1; 3020b411b363SPhilipp Reisner } 3021b411b363SPhilipp Reisner } 3022b411b363SPhilipp Reisner 3023b411b363SPhilipp Reisner *rule_nr = 50; 3024b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3025b411b363SPhilipp Reisner if (self == peer) 3026b411b363SPhilipp Reisner return -1; 3027b411b363SPhilipp Reisner 3028b411b363SPhilipp Reisner *rule_nr = 51; 3029b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 3030b411b363SPhilipp Reisner if (self == peer) { 303144a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3032b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 3033b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 3034b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 3035b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3036b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 3037b411b363SPhilipp Reisner 303844a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 30394a23f264SPhilipp Reisner return -1091; 3040b411b363SPhilipp Reisner 3041b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 3042b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 30434a23f264SPhilipp Reisner 3044d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 3045b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 30464a23f264SPhilipp Reisner 3047b411b363SPhilipp Reisner return -1; 3048b411b363SPhilipp Reisner } 3049b411b363SPhilipp Reisner } 3050b411b363SPhilipp Reisner 3051b411b363SPhilipp Reisner *rule_nr = 60; 3052b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3053b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3054b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 3055b411b363SPhilipp Reisner if (self == peer) 3056b411b363SPhilipp Reisner return -2; 3057b411b363SPhilipp Reisner } 3058b411b363SPhilipp Reisner 3059b411b363SPhilipp Reisner *rule_nr = 70; 3060b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3061b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3062b411b363SPhilipp Reisner if (self == peer) 3063b411b363SPhilipp Reisner return 1; 3064b411b363SPhilipp Reisner 3065b411b363SPhilipp Reisner *rule_nr = 71; 3066b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 3067b411b363SPhilipp Reisner if (self == peer) { 306844a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3069b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 3070b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 3071b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 3072b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3073b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 3074b411b363SPhilipp Reisner 307544a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 30764a23f264SPhilipp Reisner return -1091; 3077b411b363SPhilipp Reisner 3078b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 3079b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 3080b411b363SPhilipp Reisner 3081d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 3082b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3083b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3084b411b363SPhilipp Reisner 3085b411b363SPhilipp Reisner return 1; 3086b411b363SPhilipp Reisner } 3087b411b363SPhilipp Reisner } 3088b411b363SPhilipp Reisner 3089b411b363SPhilipp Reisner 3090b411b363SPhilipp Reisner *rule_nr = 80; 3091b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3092b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3093b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3094b411b363SPhilipp Reisner if (self == peer) 3095b411b363SPhilipp Reisner return 2; 3096b411b363SPhilipp Reisner } 3097b411b363SPhilipp Reisner 3098b411b363SPhilipp Reisner *rule_nr = 90; 3099b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3100b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3101b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 3102b411b363SPhilipp Reisner return 100; 3103b411b363SPhilipp Reisner 3104b411b363SPhilipp Reisner *rule_nr = 100; 3105b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3106b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3107b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 3108b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 3109b411b363SPhilipp Reisner if (self == peer) 3110b411b363SPhilipp Reisner return -100; 3111b411b363SPhilipp Reisner } 3112b411b363SPhilipp Reisner } 3113b411b363SPhilipp Reisner 3114b411b363SPhilipp Reisner return -1000; 3115b411b363SPhilipp Reisner } 3116b411b363SPhilipp Reisner 3117b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 3118b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 3119b411b363SPhilipp Reisner */ 312069a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 312169a22773SAndreas Gruenbacher enum drbd_role peer_role, 3122b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 3123b411b363SPhilipp Reisner { 312469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 3125b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 3126b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 312744ed167dSPhilipp Reisner struct net_conf *nc; 31286dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 3129b411b363SPhilipp Reisner 3130b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 3131b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 3132b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 3133b411b363SPhilipp Reisner 3134d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 31359f2247bbSPhilipp Reisner 3136b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 3137b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 3138b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 3139b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3140b411b363SPhilipp Reisner 3141b30ab791SAndreas Gruenbacher hg = drbd_uuid_compare(device, &rule_nr); 3142b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 3143b411b363SPhilipp Reisner 3144d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 3145b411b363SPhilipp Reisner 3146b411b363SPhilipp Reisner if (hg == -1000) { 3147d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3148b411b363SPhilipp Reisner return C_MASK; 3149b411b363SPhilipp Reisner } 31504a23f264SPhilipp Reisner if (hg < -1000) { 3151d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3152b411b363SPhilipp Reisner return C_MASK; 3153b411b363SPhilipp Reisner } 3154b411b363SPhilipp Reisner 3155b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3156b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3157b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3158b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3159b411b363SPhilipp Reisner if (f) 3160b411b363SPhilipp Reisner hg = hg*2; 3161d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3162b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3163b411b363SPhilipp Reisner } 3164b411b363SPhilipp Reisner 31653a11a487SAdam Gandelman if (abs(hg) == 100) 3166b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 31673a11a487SAdam Gandelman 316844ed167dSPhilipp Reisner rcu_read_lock(); 316969a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 317044ed167dSPhilipp Reisner 317144ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3172b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3173b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3174b411b363SPhilipp Reisner int forced = (hg == -100); 3175b411b363SPhilipp Reisner 3176b411b363SPhilipp Reisner switch (pcount) { 3177b411b363SPhilipp Reisner case 0: 317869a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3179b411b363SPhilipp Reisner break; 3180b411b363SPhilipp Reisner case 1: 318169a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3182b411b363SPhilipp Reisner break; 3183b411b363SPhilipp Reisner case 2: 318469a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3185b411b363SPhilipp Reisner break; 3186b411b363SPhilipp Reisner } 3187b411b363SPhilipp Reisner if (abs(hg) < 100) { 3188d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3189b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3190b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3191b411b363SPhilipp Reisner if (forced) { 3192d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3193b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3194b411b363SPhilipp Reisner hg = hg*2; 3195b411b363SPhilipp Reisner } 3196b411b363SPhilipp Reisner } 3197b411b363SPhilipp Reisner } 3198b411b363SPhilipp Reisner 3199b411b363SPhilipp Reisner if (hg == -100) { 3200b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3201b411b363SPhilipp Reisner hg = -1; 3202b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3203b411b363SPhilipp Reisner hg = 1; 3204b411b363SPhilipp Reisner 3205b411b363SPhilipp Reisner if (abs(hg) < 100) 3206d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3207b411b363SPhilipp Reisner "Sync from %s node\n", 3208b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3209b411b363SPhilipp Reisner } 321044ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 32116dff2902SAndreas Gruenbacher tentative = nc->tentative; 321244ed167dSPhilipp Reisner rcu_read_unlock(); 3213b411b363SPhilipp Reisner 3214b411b363SPhilipp Reisner if (hg == -100) { 3215580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3216580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3217580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3218580b9767SLars Ellenberg * to that disk, in a way... */ 3219d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3220b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3221b411b363SPhilipp Reisner return C_MASK; 3222b411b363SPhilipp Reisner } 3223b411b363SPhilipp Reisner 3224b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3225d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3226b411b363SPhilipp Reisner return C_MASK; 3227b411b363SPhilipp Reisner } 3228b411b363SPhilipp Reisner 3229b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3230b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 323144ed167dSPhilipp Reisner switch (rr_conflict) { 3232b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3233b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3234b411b363SPhilipp Reisner /* fall through */ 3235b411b363SPhilipp Reisner case ASB_DISCONNECT: 3236d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3237b411b363SPhilipp Reisner return C_MASK; 3238b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3239d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3240b411b363SPhilipp Reisner "assumption\n"); 3241b411b363SPhilipp Reisner } 3242b411b363SPhilipp Reisner } 3243b411b363SPhilipp Reisner 324469a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3245cf14c2e9SPhilipp Reisner if (hg == 0) 3246d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3247cf14c2e9SPhilipp Reisner else 3248d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3249cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3250cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3251cf14c2e9SPhilipp Reisner return C_MASK; 3252cf14c2e9SPhilipp Reisner } 3253cf14c2e9SPhilipp Reisner 3254b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3255d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3256b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 325720ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3258b411b363SPhilipp Reisner return C_MASK; 3259b411b363SPhilipp Reisner } 3260b411b363SPhilipp Reisner 3261b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3262b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3263b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3264b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3265b411b363SPhilipp Reisner } else { 3266b411b363SPhilipp Reisner rv = C_CONNECTED; 3267b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3268d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3269b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3270b411b363SPhilipp Reisner } 3271b411b363SPhilipp Reisner } 3272b411b363SPhilipp Reisner 3273b411b363SPhilipp Reisner return rv; 3274b411b363SPhilipp Reisner } 3275b411b363SPhilipp Reisner 3276f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3277b411b363SPhilipp Reisner { 3278b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3279f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3280f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3281b411b363SPhilipp Reisner 3282b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3283f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3284f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3285b411b363SPhilipp Reisner 3286b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3287f179d76dSPhilipp Reisner return peer; 3288b411b363SPhilipp Reisner } 3289b411b363SPhilipp Reisner 3290bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3291b411b363SPhilipp Reisner { 3292e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3293036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3294036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3295036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3296036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3297accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 32987aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3299b411b363SPhilipp Reisner 3300b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3301b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3302b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3303b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3304b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3305cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 33066139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3307cf14c2e9SPhilipp Reisner 3308bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 330986db0618SAndreas Gruenbacher int err; 331086db0618SAndreas Gruenbacher 331188104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 331286db0618SAndreas Gruenbacher return -EIO; 3313bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 331486db0618SAndreas Gruenbacher if (err) 331586db0618SAndreas Gruenbacher return err; 331688104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3317036b17eaSPhilipp Reisner } 331886db0618SAndreas Gruenbacher 33197d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3320bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3321cf14c2e9SPhilipp Reisner 3322cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3323bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3324b411b363SPhilipp Reisner 332544ed167dSPhilipp Reisner rcu_read_lock(); 3326bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 332744ed167dSPhilipp Reisner 3328036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 33291ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 333044ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3331b411b363SPhilipp Reisner } 3332b411b363SPhilipp Reisner 3333f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 33341ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 333544ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3336b411b363SPhilipp Reisner } 3337b411b363SPhilipp Reisner 3338f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 33391ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 334044ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3341b411b363SPhilipp Reisner } 3342b411b363SPhilipp Reisner 3343f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 33441ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 334544ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3346b411b363SPhilipp Reisner } 3347b411b363SPhilipp Reisner 33486139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 33491ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 335044ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3351b411b363SPhilipp Reisner } 3352b411b363SPhilipp Reisner 335344ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 33541ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 335544ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3356b411b363SPhilipp Reisner } 3357b411b363SPhilipp Reisner 3358036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 33591ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3360036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3361036b17eaSPhilipp Reisner } 3362036b17eaSPhilipp Reisner 336386db0618SAndreas Gruenbacher rcu_read_unlock(); 3364fbc12f45SAndreas Gruenbacher } 33657d4c782cSAndreas Gruenbacher 33667d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 33677d4c782cSAndreas Gruenbacher int hash_size; 33687d4c782cSAndreas Gruenbacher 33697d4c782cSAndreas Gruenbacher /* 33707d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 33717d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 33727d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 33737d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 33747d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 33757d4c782cSAndreas Gruenbacher * change. 33767d4c782cSAndreas Gruenbacher */ 33777d4c782cSAndreas Gruenbacher 33787d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 33797d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 33801ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 33817d4c782cSAndreas Gruenbacher integrity_alg); 3382b411b363SPhilipp Reisner goto disconnect; 3383b411b363SPhilipp Reisner } 3384b411b363SPhilipp Reisner 33857d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 33867d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 33877d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 33887d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 33891ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 33907d4c782cSAndreas Gruenbacher goto disconnect; 33917d4c782cSAndreas Gruenbacher } 33927d4c782cSAndreas Gruenbacher } 33937d4c782cSAndreas Gruenbacher 33947d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 33957d4c782cSAndreas Gruenbacher if (!new_net_conf) { 33961ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3397b411b363SPhilipp Reisner goto disconnect; 3398b411b363SPhilipp Reisner } 3399b411b363SPhilipp Reisner 3400bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 34010500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3402bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 34037d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3404b411b363SPhilipp Reisner 34057d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 34067d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 34077d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 34087d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 34097d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3410b411b363SPhilipp Reisner 3411bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 34120500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3413bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3414b411b363SPhilipp Reisner 3415bde89a9eSAndreas Gruenbacher crypto_free_hash(connection->peer_integrity_tfm); 3416bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3417bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3418bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3419bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3420bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3421b411b363SPhilipp Reisner 34227d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 34231ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 34247d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3425b411b363SPhilipp Reisner 34267d4c782cSAndreas Gruenbacher synchronize_rcu(); 34277d4c782cSAndreas Gruenbacher kfree(old_net_conf); 342882bc0194SAndreas Gruenbacher return 0; 3429b411b363SPhilipp Reisner 343044ed167dSPhilipp Reisner disconnect_rcu_unlock: 343144ed167dSPhilipp Reisner rcu_read_unlock(); 3432b411b363SPhilipp Reisner disconnect: 3433b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3434036b17eaSPhilipp Reisner kfree(int_dig_in); 3435036b17eaSPhilipp Reisner kfree(int_dig_vv); 3436bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 343782bc0194SAndreas Gruenbacher return -EIO; 3438b411b363SPhilipp Reisner } 3439b411b363SPhilipp Reisner 3440b411b363SPhilipp Reisner /* helper function 3441b411b363SPhilipp Reisner * input: alg name, feature name 3442b411b363SPhilipp Reisner * return: NULL (alg name was "") 3443b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3444b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 34458ce953aaSLars Ellenberg static struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3446b411b363SPhilipp Reisner const char *alg, const char *name) 3447b411b363SPhilipp Reisner { 3448b411b363SPhilipp Reisner struct crypto_hash *tfm; 3449b411b363SPhilipp Reisner 3450b411b363SPhilipp Reisner if (!alg[0]) 3451b411b363SPhilipp Reisner return NULL; 3452b411b363SPhilipp Reisner 3453b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3454b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3455d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3456b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3457b411b363SPhilipp Reisner return tfm; 3458b411b363SPhilipp Reisner } 3459b411b363SPhilipp Reisner return tfm; 3460b411b363SPhilipp Reisner } 3461b411b363SPhilipp Reisner 3462bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3463b411b363SPhilipp Reisner { 3464bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 34654a76b161SAndreas Gruenbacher int size = pi->size; 34664a76b161SAndreas Gruenbacher 34674a76b161SAndreas Gruenbacher while (size) { 34684a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3469bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 34704a76b161SAndreas Gruenbacher if (s <= 0) { 34714a76b161SAndreas Gruenbacher if (s < 0) 34724a76b161SAndreas Gruenbacher return s; 34734a76b161SAndreas Gruenbacher break; 34744a76b161SAndreas Gruenbacher } 34754a76b161SAndreas Gruenbacher size -= s; 34764a76b161SAndreas Gruenbacher } 34774a76b161SAndreas Gruenbacher if (size) 34784a76b161SAndreas Gruenbacher return -EIO; 34794a76b161SAndreas Gruenbacher return 0; 34804a76b161SAndreas Gruenbacher } 34814a76b161SAndreas Gruenbacher 34824a76b161SAndreas Gruenbacher /* 34834a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 34844a76b161SAndreas Gruenbacher * 34854a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 34864a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 34874a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 34884a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 34894a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 34904a76b161SAndreas Gruenbacher * 34914a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 34924a76b161SAndreas Gruenbacher */ 3493bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 34944a76b161SAndreas Gruenbacher { 34951ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 34962fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3497bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 34984a76b161SAndreas Gruenbacher } 34994a76b161SAndreas Gruenbacher 3500bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 35014a76b161SAndreas Gruenbacher { 35029f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3503b30ab791SAndreas Gruenbacher struct drbd_device *device; 3504e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3505b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3506b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3507b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 35082ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3509813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3510bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3511813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3512778f271dSPhilipp Reisner int fifo_size = 0; 351382bc0194SAndreas Gruenbacher int err; 3514b411b363SPhilipp Reisner 35159f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 35169f4fe9adSAndreas Gruenbacher if (!peer_device) 3517bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 35189f4fe9adSAndreas Gruenbacher device = peer_device->device; 3519b411b363SPhilipp Reisner 3520b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3521b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3522b411b363SPhilipp Reisner + SHARED_SECRET_MAX 35238e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 35248e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3525b411b363SPhilipp Reisner 3526e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3527d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3528e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 352982bc0194SAndreas Gruenbacher return -EIO; 3530b411b363SPhilipp Reisner } 3531b411b363SPhilipp Reisner 3532b411b363SPhilipp Reisner if (apv <= 88) { 3533e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3534e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 35358e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3536e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3537e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 35380b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 35398e26f9ccSPhilipp Reisner } else { 3540e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3541e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 35420b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3543b411b363SPhilipp Reisner } 3544b411b363SPhilipp Reisner 3545b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3546e658983aSAndreas Gruenbacher p = pi->data; 3547b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3548b411b363SPhilipp Reisner 35499f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 355082bc0194SAndreas Gruenbacher if (err) 355182bc0194SAndreas Gruenbacher return err; 3552b411b363SPhilipp Reisner 35530500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 35549f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3555b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3556daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3557daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3558b30ab791SAndreas Gruenbacher put_ldev(device); 35590500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3560d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3561daeda1ccSPhilipp Reisner return -ENOMEM; 3562f399002eSLars Ellenberg } 3563b411b363SPhilipp Reisner 3564b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3565daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3566daeda1ccSPhilipp Reisner 35676394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3568813472ceSPhilipp Reisner } 3569b411b363SPhilipp Reisner 3570b411b363SPhilipp Reisner if (apv >= 88) { 3571b411b363SPhilipp Reisner if (apv == 88) { 35725de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3573d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 35745de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3575b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3576813472ceSPhilipp Reisner err = -EIO; 3577813472ceSPhilipp Reisner goto reconnect; 3578b411b363SPhilipp Reisner } 3579b411b363SPhilipp Reisner 35809f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3581813472ceSPhilipp Reisner if (err) 3582813472ceSPhilipp Reisner goto reconnect; 3583b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3584b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 35850b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3586b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3587b411b363SPhilipp Reisner 3588b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3589b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3590b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 35910b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 35920b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3593b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3594b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3595b411b363SPhilipp Reisner } 3596b411b363SPhilipp Reisner 35972ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3598b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3599d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 36002ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3601b411b363SPhilipp Reisner goto disconnect; 3602b411b363SPhilipp Reisner } 3603b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3604b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3605b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3606b411b363SPhilipp Reisner verify_tfm = NULL; 3607b411b363SPhilipp Reisner goto disconnect; 3608b411b363SPhilipp Reisner } 3609b411b363SPhilipp Reisner } 3610b411b363SPhilipp Reisner 36112ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3612b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3613d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 36142ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3615b411b363SPhilipp Reisner goto disconnect; 3616b411b363SPhilipp Reisner } 3617b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3618b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3619b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3620b411b363SPhilipp Reisner csums_tfm = NULL; 3621b411b363SPhilipp Reisner goto disconnect; 3622b411b363SPhilipp Reisner } 3623b411b363SPhilipp Reisner } 3624b411b363SPhilipp Reisner 3625813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3626daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3627daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3628daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3629daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3630778f271dSPhilipp Reisner 3631daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3632b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3633813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3634813472ceSPhilipp Reisner if (!new_plan) { 3635d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3636b30ab791SAndreas Gruenbacher put_ldev(device); 3637778f271dSPhilipp Reisner goto disconnect; 3638778f271dSPhilipp Reisner } 3639778f271dSPhilipp Reisner } 36408e26f9ccSPhilipp Reisner } 3641b411b363SPhilipp Reisner 364291fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 36432ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 36442ec91e0eSPhilipp Reisner if (!new_net_conf) { 3645d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 364691fd4dadSPhilipp Reisner goto disconnect; 364791fd4dadSPhilipp Reisner } 364891fd4dadSPhilipp Reisner 36492ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 365091fd4dadSPhilipp Reisner 3651b411b363SPhilipp Reisner if (verify_tfm) { 36522ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 36532ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 36549f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->verify_tfm); 36559f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3656d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3657b411b363SPhilipp Reisner } 3658b411b363SPhilipp Reisner if (csums_tfm) { 36592ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 36602ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 36619f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->csums_tfm); 36629f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3663d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3664b411b363SPhilipp Reisner } 3665bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3666778f271dSPhilipp Reisner } 3667b411b363SPhilipp Reisner } 3668b411b363SPhilipp Reisner 3669813472ceSPhilipp Reisner if (new_disk_conf) { 3670b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3671b30ab791SAndreas Gruenbacher put_ldev(device); 3672b411b363SPhilipp Reisner } 3673813472ceSPhilipp Reisner 3674813472ceSPhilipp Reisner if (new_plan) { 3675b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3676b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3677813472ceSPhilipp Reisner } 3678daeda1ccSPhilipp Reisner 36790500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3680daeda1ccSPhilipp Reisner synchronize_rcu(); 3681daeda1ccSPhilipp Reisner if (new_net_conf) 3682daeda1ccSPhilipp Reisner kfree(old_net_conf); 3683daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3684813472ceSPhilipp Reisner kfree(old_plan); 3685daeda1ccSPhilipp Reisner 368682bc0194SAndreas Gruenbacher return 0; 3687b411b363SPhilipp Reisner 3688813472ceSPhilipp Reisner reconnect: 3689813472ceSPhilipp Reisner if (new_disk_conf) { 3690b30ab791SAndreas Gruenbacher put_ldev(device); 3691813472ceSPhilipp Reisner kfree(new_disk_conf); 3692813472ceSPhilipp Reisner } 36930500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3694813472ceSPhilipp Reisner return -EIO; 3695813472ceSPhilipp Reisner 3696b411b363SPhilipp Reisner disconnect: 3697813472ceSPhilipp Reisner kfree(new_plan); 3698813472ceSPhilipp Reisner if (new_disk_conf) { 3699b30ab791SAndreas Gruenbacher put_ldev(device); 3700813472ceSPhilipp Reisner kfree(new_disk_conf); 3701813472ceSPhilipp Reisner } 37020500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3703b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3704b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3705b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3706b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3707b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 37089f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 370982bc0194SAndreas Gruenbacher return -EIO; 3710b411b363SPhilipp Reisner } 3711b411b363SPhilipp Reisner 3712b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3713b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 3714b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3715b411b363SPhilipp Reisner { 3716b411b363SPhilipp Reisner sector_t d; 3717b411b363SPhilipp Reisner if (a == 0 || b == 0) 3718b411b363SPhilipp Reisner return; 3719b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3720b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3721d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 3722b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3723b411b363SPhilipp Reisner } 3724b411b363SPhilipp Reisner 3725bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 3726b411b363SPhilipp Reisner { 37279f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3728b30ab791SAndreas Gruenbacher struct drbd_device *device; 3729e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3730e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 37316a8d68b1SLars Ellenberg sector_t p_size, p_usize, p_csize, my_usize; 3732b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3733e89b591cSPhilipp Reisner enum dds_flags ddsf; 3734b411b363SPhilipp Reisner 37359f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 37369f4fe9adSAndreas Gruenbacher if (!peer_device) 3737bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 37389f4fe9adSAndreas Gruenbacher device = peer_device->device; 37394a76b161SAndreas Gruenbacher 3740b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3741b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 37426a8d68b1SLars Ellenberg p_csize = be64_to_cpu(p->c_size); 3743b411b363SPhilipp Reisner 3744b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3745b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3746b30ab791SAndreas Gruenbacher device->p_size = p_size; 3747b411b363SPhilipp Reisner 3748b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3749daeda1ccSPhilipp Reisner rcu_read_lock(); 3750b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 3751daeda1ccSPhilipp Reisner rcu_read_unlock(); 3752daeda1ccSPhilipp Reisner 3753b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 3754b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 3755b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 3756daeda1ccSPhilipp Reisner p_usize, my_usize); 3757b411b363SPhilipp Reisner 3758b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3759b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3760b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 3761daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3762b411b363SPhilipp Reisner 3763b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3764b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3765b30ab791SAndreas Gruenbacher if (drbd_new_dev_size(device, device->ldev, p_usize, 0) < 3766b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) && 3767b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 3768b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 3769d0180171SAndreas Gruenbacher drbd_err(device, "The peer's disk size is too small!\n"); 37709f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 3771b30ab791SAndreas Gruenbacher put_ldev(device); 377282bc0194SAndreas Gruenbacher return -EIO; 3773b411b363SPhilipp Reisner } 3774daeda1ccSPhilipp Reisner 3775daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3776daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3777daeda1ccSPhilipp Reisner 3778daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3779daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3780d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3781b30ab791SAndreas Gruenbacher put_ldev(device); 3782daeda1ccSPhilipp Reisner return -ENOMEM; 3783daeda1ccSPhilipp Reisner } 3784daeda1ccSPhilipp Reisner 37850500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3786b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3787daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3788daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3789daeda1ccSPhilipp Reisner 3790b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 37910500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3792daeda1ccSPhilipp Reisner synchronize_rcu(); 3793daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3794daeda1ccSPhilipp Reisner 3795d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 3796daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3797daeda1ccSPhilipp Reisner } 3798daeda1ccSPhilipp Reisner 3799b30ab791SAndreas Gruenbacher put_ldev(device); 3800b411b363SPhilipp Reisner } 3801b411b363SPhilipp Reisner 380220c68fdeSLars Ellenberg device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 380320c68fdeSLars Ellenberg /* Leave drbd_reconsider_max_bio_size() before drbd_determine_dev_size(). 380420c68fdeSLars Ellenberg In case we cleared the QUEUE_FLAG_DISCARD from our queue in 380520c68fdeSLars Ellenberg drbd_reconsider_max_bio_size(), we can be sure that after 380620c68fdeSLars Ellenberg drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */ 380720c68fdeSLars Ellenberg 3808e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3809b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 38108fe39aacSPhilipp Reisner drbd_reconsider_max_bio_size(device, device->ldev); 3811b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 3812b30ab791SAndreas Gruenbacher put_ldev(device); 3813e96c9633SPhilipp Reisner if (dd == DS_ERROR) 381482bc0194SAndreas Gruenbacher return -EIO; 3815b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3816b411b363SPhilipp Reisner } else { 38176a8d68b1SLars Ellenberg /* 38186a8d68b1SLars Ellenberg * I am diskless, need to accept the peer's *current* size. 38196a8d68b1SLars Ellenberg * I must NOT accept the peers backing disk size, 38206a8d68b1SLars Ellenberg * it may have been larger than mine all along... 38216a8d68b1SLars Ellenberg * 38226a8d68b1SLars Ellenberg * At this point, the peer knows more about my disk, or at 38236a8d68b1SLars Ellenberg * least about what we last agreed upon, than myself. 38246a8d68b1SLars Ellenberg * So if his c_size is less than his d_size, the most likely 38256a8d68b1SLars Ellenberg * reason is that *my* d_size was smaller last time we checked. 38266a8d68b1SLars Ellenberg * 38276a8d68b1SLars Ellenberg * However, if he sends a zero current size, 38286a8d68b1SLars Ellenberg * take his (user-capped or) backing disk size anyways. 38296a8d68b1SLars Ellenberg */ 38308fe39aacSPhilipp Reisner drbd_reconsider_max_bio_size(device, NULL); 38316a8d68b1SLars Ellenberg drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); 3832b411b363SPhilipp Reisner } 3833b411b363SPhilipp Reisner 3834b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3835b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 3836b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 3837b411b363SPhilipp Reisner ldsc = 1; 3838b411b363SPhilipp Reisner } 3839b411b363SPhilipp Reisner 3840b30ab791SAndreas Gruenbacher put_ldev(device); 3841b411b363SPhilipp Reisner } 3842b411b363SPhilipp Reisner 3843b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 3844b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3845b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 3846b411b363SPhilipp Reisner /* we have different sizes, probably peer 3847b411b363SPhilipp Reisner * needs to know my new size... */ 384869a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 3849b411b363SPhilipp Reisner } 3850b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 3851b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 3852b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 3853b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 3854e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3855d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 3856b411b363SPhilipp Reisner else 3857b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 3858e89b591cSPhilipp Reisner } else 3859b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 3860b411b363SPhilipp Reisner } 3861b411b363SPhilipp Reisner } 3862b411b363SPhilipp Reisner 386382bc0194SAndreas Gruenbacher return 0; 3864b411b363SPhilipp Reisner } 3865b411b363SPhilipp Reisner 3866bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 3867b411b363SPhilipp Reisner { 38689f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3869b30ab791SAndreas Gruenbacher struct drbd_device *device; 3870e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3871b411b363SPhilipp Reisner u64 *p_uuid; 387262b0da3aSLars Ellenberg int i, updated_uuids = 0; 3873b411b363SPhilipp Reisner 38749f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38759f4fe9adSAndreas Gruenbacher if (!peer_device) 3876bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 38779f4fe9adSAndreas Gruenbacher device = peer_device->device; 38784a76b161SAndreas Gruenbacher 3879b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3880063eacf8SJing Wang if (!p_uuid) { 3881d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 3882063eacf8SJing Wang return false; 3883063eacf8SJing Wang } 3884b411b363SPhilipp Reisner 3885b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3886b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3887b411b363SPhilipp Reisner 3888b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 3889b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 3890b411b363SPhilipp Reisner 3891b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 3892b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 3893b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 3894b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3895d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 3896b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 38979f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 389882bc0194SAndreas Gruenbacher return -EIO; 3899b411b363SPhilipp Reisner } 3900b411b363SPhilipp Reisner 3901b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3902b411b363SPhilipp Reisner int skip_initial_sync = 3903b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 39049f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 3905b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3906b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3907b411b363SPhilipp Reisner if (skip_initial_sync) { 3908d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 3909b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 391020ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 391120ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3912b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 3913b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 3914b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3915b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3916b30ab791SAndreas Gruenbacher drbd_md_sync(device); 391762b0da3aSLars Ellenberg updated_uuids = 1; 3918b411b363SPhilipp Reisner } 3919b30ab791SAndreas Gruenbacher put_ldev(device); 3920b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 3921b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 392218a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 392318a50fa2SPhilipp Reisner for me. */ 3924b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 3925b411b363SPhilipp Reisner } 3926b411b363SPhilipp Reisner 3927b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3928b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3929b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3930b411b363SPhilipp Reisner new disk state... */ 3931b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 3932b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 3933b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 3934b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 393562b0da3aSLars Ellenberg 393662b0da3aSLars Ellenberg if (updated_uuids) 3937b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 3938b411b363SPhilipp Reisner 393982bc0194SAndreas Gruenbacher return 0; 3940b411b363SPhilipp Reisner } 3941b411b363SPhilipp Reisner 3942b411b363SPhilipp Reisner /** 3943b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3944b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3945b411b363SPhilipp Reisner */ 3946b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3947b411b363SPhilipp Reisner { 3948b411b363SPhilipp Reisner union drbd_state ms; 3949b411b363SPhilipp Reisner 3950b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3951369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3952b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3953b411b363SPhilipp Reisner 3954b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3955b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3956b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3957b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3958b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3959b411b363SPhilipp Reisner }; 3960b411b363SPhilipp Reisner 3961b411b363SPhilipp Reisner ms.i = ps.i; 3962b411b363SPhilipp Reisner 3963b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3964b411b363SPhilipp Reisner ms.peer = ps.role; 3965b411b363SPhilipp Reisner ms.role = ps.peer; 3966b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3967b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3968b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3969b411b363SPhilipp Reisner 3970b411b363SPhilipp Reisner return ms; 3971b411b363SPhilipp Reisner } 3972b411b363SPhilipp Reisner 3973bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 3974b411b363SPhilipp Reisner { 39759f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3976b30ab791SAndreas Gruenbacher struct drbd_device *device; 3977e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3978b411b363SPhilipp Reisner union drbd_state mask, val; 3979bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3980b411b363SPhilipp Reisner 39819f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 39829f4fe9adSAndreas Gruenbacher if (!peer_device) 39834a76b161SAndreas Gruenbacher return -EIO; 39849f4fe9adSAndreas Gruenbacher device = peer_device->device; 39854a76b161SAndreas Gruenbacher 3986b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3987b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3988b411b363SPhilipp Reisner 39899f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 3990b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 399169a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 399282bc0194SAndreas Gruenbacher return 0; 3993b411b363SPhilipp Reisner } 3994b411b363SPhilipp Reisner 3995b411b363SPhilipp Reisner mask = convert_state(mask); 3996b411b363SPhilipp Reisner val = convert_state(val); 3997b411b363SPhilipp Reisner 3998b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 399969a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 4000047cd4a6SPhilipp Reisner 4001b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4002b411b363SPhilipp Reisner 400382bc0194SAndreas Gruenbacher return 0; 4004b411b363SPhilipp Reisner } 4005b411b363SPhilipp Reisner 4006bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 4007b411b363SPhilipp Reisner { 4008e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4009dfafcc8aSPhilipp Reisner union drbd_state mask, val; 4010dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 4011dfafcc8aSPhilipp Reisner 4012dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4013dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 4014dfafcc8aSPhilipp Reisner 4015bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 4016bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 4017bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 401882bc0194SAndreas Gruenbacher return 0; 4019dfafcc8aSPhilipp Reisner } 4020dfafcc8aSPhilipp Reisner 4021dfafcc8aSPhilipp Reisner mask = convert_state(mask); 4022dfafcc8aSPhilipp Reisner val = convert_state(val); 4023dfafcc8aSPhilipp Reisner 4024bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 4025bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 4026dfafcc8aSPhilipp Reisner 402782bc0194SAndreas Gruenbacher return 0; 4028dfafcc8aSPhilipp Reisner } 4029dfafcc8aSPhilipp Reisner 4030bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 4031b411b363SPhilipp Reisner { 40329f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4033b30ab791SAndreas Gruenbacher struct drbd_device *device; 4034e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 40354ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 4036b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 403765d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 4038b411b363SPhilipp Reisner int rv; 4039b411b363SPhilipp Reisner 40409f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 40419f4fe9adSAndreas Gruenbacher if (!peer_device) 4042bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 40439f4fe9adSAndreas Gruenbacher device = peer_device->device; 40444a76b161SAndreas Gruenbacher 4045b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 4046b411b363SPhilipp Reisner 4047b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 4048b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 4049b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 4050d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 4051b411b363SPhilipp Reisner } 4052b411b363SPhilipp Reisner 40530500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4054b411b363SPhilipp Reisner retry: 4055b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 40560500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4057b411b363SPhilipp Reisner 4058545752d5SLars Ellenberg /* If some other part of the code (asender thread, timeout) 4059545752d5SLars Ellenberg * already decided to close the connection again, 4060545752d5SLars Ellenberg * we must not "re-establish" it here. */ 4061545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 406258ffa580SLars Ellenberg return -ECONNRESET; 4063545752d5SLars Ellenberg 406440424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 406540424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 406640424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 406740424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 406840424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 406940424e4aSLars Ellenberg */ 407040424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 407140424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 4072e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 4073e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 4074e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 4075e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 4076e9ef7bb6SLars Ellenberg * syncing states. 4077e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 4078e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 4079e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 4080e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 4081e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 4082e9ef7bb6SLars Ellenberg 4083e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 4084e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 4085e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 4086e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 4087e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 4088b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 4089b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 409082bc0194SAndreas Gruenbacher return 0; 4091e9ef7bb6SLars Ellenberg } 4092e9ef7bb6SLars Ellenberg } 4093e9ef7bb6SLars Ellenberg 409402b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 409502b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 409602b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 4097b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 4098b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 409958ffa580SLars Ellenberg return 0; 410002b91b55SLars Ellenberg } 410102b91b55SLars Ellenberg 4102e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 4103e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 4104e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 4105e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 4106e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 4107e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 4108e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 4109e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 4110e9ef7bb6SLars Ellenberg 41114ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 41124ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4113b411b363SPhilipp Reisner 411467531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 411567531718SPhilipp Reisner ns.conn = C_BEHIND; 411667531718SPhilipp Reisner 4117b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 4118b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 4119b411b363SPhilipp Reisner int cr; /* consider resync */ 4120b411b363SPhilipp Reisner 4121b411b363SPhilipp Reisner /* if we established a new connection */ 41224ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 4123b411b363SPhilipp Reisner /* if we had an established connection 4124b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 41254ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4126b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 41274ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 4128b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 4129b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 4130b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 4131b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 4132b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 41334ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4134b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 4135b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 4136b411b363SPhilipp Reisner 4137b411b363SPhilipp Reisner if (cr) 413869a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 4139b411b363SPhilipp Reisner 4140b30ab791SAndreas Gruenbacher put_ldev(device); 41414ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 41424ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4143b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 4144b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 4145b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 4146d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 4147b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 4148580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 4149b411b363SPhilipp Reisner } else { 41509f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 415182bc0194SAndreas Gruenbacher return -EIO; 41520b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 41539f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 415482bc0194SAndreas Gruenbacher return -EIO; 4155b411b363SPhilipp Reisner } 4156b411b363SPhilipp Reisner } 4157b411b363SPhilipp Reisner } 4158b411b363SPhilipp Reisner 41590500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4160b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 4161b411b363SPhilipp Reisner goto retry; 4162b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 4163b411b363SPhilipp Reisner ns.peer = peer_state.role; 4164b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4165b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 41664ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4167b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 41684ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4169b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4170b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 41718554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4172481c6f50SPhilipp Reisner for temporal network outages! */ 41730500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4174d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 41759f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4176b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4177b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 41789f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 417982bc0194SAndreas Gruenbacher return -EIO; 4180481c6f50SPhilipp Reisner } 4181b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4182b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 41830500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4184b411b363SPhilipp Reisner 4185b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 41869f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 418782bc0194SAndreas Gruenbacher return -EIO; 4188b411b363SPhilipp Reisner } 4189b411b363SPhilipp Reisner 41904ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 41914ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4192b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4193b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4194b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4195b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 419669a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 419769a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4198b411b363SPhilipp Reisner } 4199b411b363SPhilipp Reisner } 4200b411b363SPhilipp Reisner 4201b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4202b411b363SPhilipp Reisner 4203b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4204b411b363SPhilipp Reisner 420582bc0194SAndreas Gruenbacher return 0; 4206b411b363SPhilipp Reisner } 4207b411b363SPhilipp Reisner 4208bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4209b411b363SPhilipp Reisner { 42109f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4211b30ab791SAndreas Gruenbacher struct drbd_device *device; 4212e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 42134a76b161SAndreas Gruenbacher 42149f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42159f4fe9adSAndreas Gruenbacher if (!peer_device) 42164a76b161SAndreas Gruenbacher return -EIO; 42179f4fe9adSAndreas Gruenbacher device = peer_device->device; 4218b411b363SPhilipp Reisner 4219b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4220b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4221b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4222b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4223b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4224b411b363SPhilipp Reisner 42250b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4226b411b363SPhilipp Reisner 4227b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4228b411b363SPhilipp Reisner _not_ be rotated into the history */ 4229b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4230b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4231b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4232b411b363SPhilipp Reisner 4233b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4234b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4235b411b363SPhilipp Reisner 4236b30ab791SAndreas Gruenbacher put_ldev(device); 4237b411b363SPhilipp Reisner } else 4238d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4239b411b363SPhilipp Reisner 424082bc0194SAndreas Gruenbacher return 0; 4241b411b363SPhilipp Reisner } 4242b411b363SPhilipp Reisner 42432c46407dSAndreas Gruenbacher /** 42442c46407dSAndreas Gruenbacher * receive_bitmap_plain 42452c46407dSAndreas Gruenbacher * 42462c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 42472c46407dSAndreas Gruenbacher * code upon failure. 42482c46407dSAndreas Gruenbacher */ 42492c46407dSAndreas Gruenbacher static int 425069a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4251e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4252b411b363SPhilipp Reisner { 425350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 425469a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4255e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 425650d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4257e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 42582c46407dSAndreas Gruenbacher int err; 4259b411b363SPhilipp Reisner 426050d0b1adSAndreas Gruenbacher if (want != size) { 426169a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 42622c46407dSAndreas Gruenbacher return -EIO; 4263b411b363SPhilipp Reisner } 4264b411b363SPhilipp Reisner if (want == 0) 42652c46407dSAndreas Gruenbacher return 0; 426669a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 426782bc0194SAndreas Gruenbacher if (err) 42682c46407dSAndreas Gruenbacher return err; 4269b411b363SPhilipp Reisner 427069a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4271b411b363SPhilipp Reisner 4272b411b363SPhilipp Reisner c->word_offset += num_words; 4273b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4274b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4275b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4276b411b363SPhilipp Reisner 42772c46407dSAndreas Gruenbacher return 1; 4278b411b363SPhilipp Reisner } 4279b411b363SPhilipp Reisner 4280a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4281a02d1240SAndreas Gruenbacher { 4282a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4283a02d1240SAndreas Gruenbacher } 4284a02d1240SAndreas Gruenbacher 4285a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4286a02d1240SAndreas Gruenbacher { 4287a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4288a02d1240SAndreas Gruenbacher } 4289a02d1240SAndreas Gruenbacher 4290a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4291a02d1240SAndreas Gruenbacher { 4292a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4293a02d1240SAndreas Gruenbacher } 4294a02d1240SAndreas Gruenbacher 42952c46407dSAndreas Gruenbacher /** 42962c46407dSAndreas Gruenbacher * recv_bm_rle_bits 42972c46407dSAndreas Gruenbacher * 42982c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 42992c46407dSAndreas Gruenbacher * code upon failure. 43002c46407dSAndreas Gruenbacher */ 43012c46407dSAndreas Gruenbacher static int 430269a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4303b411b363SPhilipp Reisner struct p_compressed_bm *p, 4304c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4305c6d25cfeSPhilipp Reisner unsigned int len) 4306b411b363SPhilipp Reisner { 4307b411b363SPhilipp Reisner struct bitstream bs; 4308b411b363SPhilipp Reisner u64 look_ahead; 4309b411b363SPhilipp Reisner u64 rl; 4310b411b363SPhilipp Reisner u64 tmp; 4311b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4312b411b363SPhilipp Reisner unsigned long e; 4313a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4314b411b363SPhilipp Reisner int have; 4315b411b363SPhilipp Reisner int bits; 4316b411b363SPhilipp Reisner 4317a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4318b411b363SPhilipp Reisner 4319b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4320b411b363SPhilipp Reisner if (bits < 0) 43212c46407dSAndreas Gruenbacher return -EIO; 4322b411b363SPhilipp Reisner 4323b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4324b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4325b411b363SPhilipp Reisner if (bits <= 0) 43262c46407dSAndreas Gruenbacher return -EIO; 4327b411b363SPhilipp Reisner 4328b411b363SPhilipp Reisner if (toggle) { 4329b411b363SPhilipp Reisner e = s + rl -1; 4330b411b363SPhilipp Reisner if (e >= c->bm_bits) { 433169a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 43322c46407dSAndreas Gruenbacher return -EIO; 4333b411b363SPhilipp Reisner } 433469a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4335b411b363SPhilipp Reisner } 4336b411b363SPhilipp Reisner 4337b411b363SPhilipp Reisner if (have < bits) { 433869a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4339b411b363SPhilipp Reisner have, bits, look_ahead, 4340b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4341b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 43422c46407dSAndreas Gruenbacher return -EIO; 4343b411b363SPhilipp Reisner } 4344d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4345d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4346b411b363SPhilipp Reisner look_ahead >>= bits; 4347d2da5b0cSLars Ellenberg else 4348d2da5b0cSLars Ellenberg look_ahead = 0; 4349b411b363SPhilipp Reisner have -= bits; 4350b411b363SPhilipp Reisner 4351b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4352b411b363SPhilipp Reisner if (bits < 0) 43532c46407dSAndreas Gruenbacher return -EIO; 4354b411b363SPhilipp Reisner look_ahead |= tmp << have; 4355b411b363SPhilipp Reisner have += bits; 4356b411b363SPhilipp Reisner } 4357b411b363SPhilipp Reisner 4358b411b363SPhilipp Reisner c->bit_offset = s; 4359b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4360b411b363SPhilipp Reisner 43612c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4362b411b363SPhilipp Reisner } 4363b411b363SPhilipp Reisner 43642c46407dSAndreas Gruenbacher /** 43652c46407dSAndreas Gruenbacher * decode_bitmap_c 43662c46407dSAndreas Gruenbacher * 43672c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 43682c46407dSAndreas Gruenbacher * code upon failure. 43692c46407dSAndreas Gruenbacher */ 43702c46407dSAndreas Gruenbacher static int 437169a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4372b411b363SPhilipp Reisner struct p_compressed_bm *p, 4373c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4374c6d25cfeSPhilipp Reisner unsigned int len) 4375b411b363SPhilipp Reisner { 4376a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 437769a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4378b411b363SPhilipp Reisner 4379b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4380b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4381b411b363SPhilipp Reisner * during all our tests. */ 4382b411b363SPhilipp Reisner 438369a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 438469a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 43852c46407dSAndreas Gruenbacher return -EIO; 4386b411b363SPhilipp Reisner } 4387b411b363SPhilipp Reisner 4388b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4389b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4390b411b363SPhilipp Reisner { 4391b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4392a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 439350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 439450d0b1adSAndreas Gruenbacher unsigned int plain = 439550d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 439650d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 439750d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 439850d0b1adSAndreas Gruenbacher unsigned int r; 4399b411b363SPhilipp Reisner 4400b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4401b411b363SPhilipp Reisner if (total == 0) 4402b411b363SPhilipp Reisner return; 4403b411b363SPhilipp Reisner 4404b411b363SPhilipp Reisner /* don't report if not compressed */ 4405b411b363SPhilipp Reisner if (total >= plain) 4406b411b363SPhilipp Reisner return; 4407b411b363SPhilipp Reisner 4408b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4409b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4410b411b363SPhilipp Reisner : (1000 * total / plain); 4411b411b363SPhilipp Reisner 4412b411b363SPhilipp Reisner if (r > 1000) 4413b411b363SPhilipp Reisner r = 1000; 4414b411b363SPhilipp Reisner 4415b411b363SPhilipp Reisner r = 1000 - r; 4416d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4417b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4418b411b363SPhilipp Reisner direction, 4419b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4420b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4421b411b363SPhilipp Reisner total, r/10, r % 10); 4422b411b363SPhilipp Reisner } 4423b411b363SPhilipp Reisner 4424b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4425b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4426b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4427b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4428b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4429b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4430b411b363SPhilipp Reisner 4431b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4432bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4433b411b363SPhilipp Reisner { 44349f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4435b30ab791SAndreas Gruenbacher struct drbd_device *device; 4436b411b363SPhilipp Reisner struct bm_xfer_ctx c; 44372c46407dSAndreas Gruenbacher int err; 44384a76b161SAndreas Gruenbacher 44399f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 44409f4fe9adSAndreas Gruenbacher if (!peer_device) 44414a76b161SAndreas Gruenbacher return -EIO; 44429f4fe9adSAndreas Gruenbacher device = peer_device->device; 4443b411b363SPhilipp Reisner 4444b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 444520ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 444620ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4447b411b363SPhilipp Reisner 4448b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4449b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4450b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4451b411b363SPhilipp Reisner }; 4452b411b363SPhilipp Reisner 44532c46407dSAndreas Gruenbacher for(;;) { 4454e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 445569a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4456e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4457b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4458b411b363SPhilipp Reisner * and the feature is enabled! */ 4459e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4460b411b363SPhilipp Reisner 4461bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4462d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 446382bc0194SAndreas Gruenbacher err = -EIO; 4464b411b363SPhilipp Reisner goto out; 4465b411b363SPhilipp Reisner } 4466e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4467d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 446882bc0194SAndreas Gruenbacher err = -EIO; 446978fcbdaeSAndreas Gruenbacher goto out; 4470b411b363SPhilipp Reisner } 44719f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4472e658983aSAndreas Gruenbacher if (err) 4473e658983aSAndreas Gruenbacher goto out; 447469a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4475b411b363SPhilipp Reisner } else { 4476d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 447782bc0194SAndreas Gruenbacher err = -EIO; 4478b411b363SPhilipp Reisner goto out; 4479b411b363SPhilipp Reisner } 4480b411b363SPhilipp Reisner 4481e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4482bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4483b411b363SPhilipp Reisner 44842c46407dSAndreas Gruenbacher if (err <= 0) { 44852c46407dSAndreas Gruenbacher if (err < 0) 44862c46407dSAndreas Gruenbacher goto out; 4487b411b363SPhilipp Reisner break; 44882c46407dSAndreas Gruenbacher } 44899f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 449082bc0194SAndreas Gruenbacher if (err) 4491b411b363SPhilipp Reisner goto out; 44922c46407dSAndreas Gruenbacher } 4493b411b363SPhilipp Reisner 4494b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4495b411b363SPhilipp Reisner 4496b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4497de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4498de1f8e4aSAndreas Gruenbacher 4499b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 450082bc0194SAndreas Gruenbacher if (err) 4501b411b363SPhilipp Reisner goto out; 4502b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4503b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 45040b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4505b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4506b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4507b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4508d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4509b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4510b411b363SPhilipp Reisner } 451182bc0194SAndreas Gruenbacher err = 0; 4512b411b363SPhilipp Reisner 4513b411b363SPhilipp Reisner out: 4514b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4515b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4516b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 451782bc0194SAndreas Gruenbacher return err; 4518b411b363SPhilipp Reisner } 4519b411b363SPhilipp Reisner 4520bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4521b411b363SPhilipp Reisner { 45221ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4523e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4524b411b363SPhilipp Reisner 4525bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4526b411b363SPhilipp Reisner } 4527b411b363SPhilipp Reisner 4528bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4529b411b363SPhilipp Reisner { 4530b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4531b411b363SPhilipp Reisner * with the data requests being unplugged */ 4532bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4533b411b363SPhilipp Reisner 453482bc0194SAndreas Gruenbacher return 0; 4535b411b363SPhilipp Reisner } 4536b411b363SPhilipp Reisner 4537bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 453873a01a18SPhilipp Reisner { 45399f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4540b30ab791SAndreas Gruenbacher struct drbd_device *device; 4541e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 45424a76b161SAndreas Gruenbacher 45439f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 45449f4fe9adSAndreas Gruenbacher if (!peer_device) 45454a76b161SAndreas Gruenbacher return -EIO; 45469f4fe9adSAndreas Gruenbacher device = peer_device->device; 454773a01a18SPhilipp Reisner 4548b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4549f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4550f735e363SLars Ellenberg case C_WF_BITMAP_T: 4551f735e363SLars Ellenberg case C_BEHIND: 4552f735e363SLars Ellenberg break; 4553f735e363SLars Ellenberg default: 4554d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4555b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4556f735e363SLars Ellenberg } 4557f735e363SLars Ellenberg 4558b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 455973a01a18SPhilipp Reisner 456082bc0194SAndreas Gruenbacher return 0; 456173a01a18SPhilipp Reisner } 456273a01a18SPhilipp Reisner 456302918be2SPhilipp Reisner struct data_cmd { 456402918be2SPhilipp Reisner int expect_payload; 456502918be2SPhilipp Reisner size_t pkt_size; 4566bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4567b411b363SPhilipp Reisner }; 4568b411b363SPhilipp Reisner 456902918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 457002918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 457102918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 457202918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 457302918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4574e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4575e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4576e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 457702918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 457802918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4579e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4580e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 458102918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 458202918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 458302918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 458402918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 458502918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 458602918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 458702918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 458802918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 458902918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 459002918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 459173a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 45924a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4593036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 4594a0fb3c47SLars Ellenberg [P_TRIM] = { 0, sizeof(struct p_trim), receive_Data }, 459502918be2SPhilipp Reisner }; 459602918be2SPhilipp Reisner 4597bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4598b411b363SPhilipp Reisner { 459977351055SPhilipp Reisner struct packet_info pi; 460002918be2SPhilipp Reisner size_t shs; /* sub header size */ 460182bc0194SAndreas Gruenbacher int err; 4602b411b363SPhilipp Reisner 4603bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 4604deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4605deebe195SAndreas Gruenbacher 4606bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4607944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_header); 4608bde89a9eSAndreas Gruenbacher if (drbd_recv_header(connection, &pi)) 460902918be2SPhilipp Reisner goto err_out; 461002918be2SPhilipp Reisner 4611deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 46124a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 46131ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 46142fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 461502918be2SPhilipp Reisner goto err_out; 46160b33a916SLars Ellenberg } 4617b411b363SPhilipp Reisner 4618e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4619e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 46201ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 46212fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4622c13f7e1aSLars Ellenberg goto err_out; 4623c13f7e1aSLars Ellenberg } 4624c13f7e1aSLars Ellenberg 4625c13f7e1aSLars Ellenberg if (shs) { 4626944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_all_warn); 4627bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 4628a5c31904SAndreas Gruenbacher if (err) 462902918be2SPhilipp Reisner goto err_out; 4630e2857216SAndreas Gruenbacher pi.size -= shs; 4631b411b363SPhilipp Reisner } 463202918be2SPhilipp Reisner 4633944410e9SLars Ellenberg update_receiver_timing_details(connection, cmd->fn); 4634bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 46354a76b161SAndreas Gruenbacher if (err) { 46361ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 46379f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 463802918be2SPhilipp Reisner goto err_out; 463902918be2SPhilipp Reisner } 464002918be2SPhilipp Reisner } 464182bc0194SAndreas Gruenbacher return; 464202918be2SPhilipp Reisner 464302918be2SPhilipp Reisner err_out: 4644bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4645b411b363SPhilipp Reisner } 4646b411b363SPhilipp Reisner 4647bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 4648f70b3511SPhilipp Reisner { 4649c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4650bbeb641cSPhilipp Reisner enum drbd_conns oc; 4651376694a0SPhilipp Reisner int vnr; 4652f70b3511SPhilipp Reisner 4653bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 4654b411b363SPhilipp Reisner return; 4655b411b363SPhilipp Reisner 4656545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4657545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4658545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4659545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4660545752d5SLars Ellenberg */ 4661bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4662545752d5SLars Ellenberg 4663b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4664bde89a9eSAndreas Gruenbacher drbd_thread_stop(&connection->asender); 4665bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 4666360cc740SPhilipp Reisner 4667c141ebdaSPhilipp Reisner rcu_read_lock(); 4668c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 4669c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4670b30ab791SAndreas Gruenbacher kref_get(&device->kref); 4671c141ebdaSPhilipp Reisner rcu_read_unlock(); 467269a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 4673c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 4674c141ebdaSPhilipp Reisner rcu_read_lock(); 4675c141ebdaSPhilipp Reisner } 4676c141ebdaSPhilipp Reisner rcu_read_unlock(); 4677c141ebdaSPhilipp Reisner 4678bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 46791ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 468012038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4681bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 4682bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 468312038a3aSPhilipp Reisner 46841ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 4685360cc740SPhilipp Reisner 4686bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 4687bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 4688cb703454SPhilipp Reisner 46890500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 4690bde89a9eSAndreas Gruenbacher oc = connection->cstate; 4691bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4692bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4693bbeb641cSPhilipp Reisner 46940500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 4695360cc740SPhilipp Reisner 4696f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4697bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4698360cc740SPhilipp Reisner } 4699360cc740SPhilipp Reisner 470069a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 4701360cc740SPhilipp Reisner { 470269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4703360cc740SPhilipp Reisner unsigned int i; 4704b411b363SPhilipp Reisner 470585719573SPhilipp Reisner /* wait for current activity to cease. */ 47060500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4707b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 4708b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 4709b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 47100500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4711b411b363SPhilipp Reisner 4712b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4713b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4714b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4715b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4716b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4717b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4718b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4719b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4720b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4721b411b363SPhilipp Reisner * on the fly. */ 4722b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4723b30ab791SAndreas Gruenbacher device->rs_total = 0; 4724b30ab791SAndreas Gruenbacher device->rs_failed = 0; 4725b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 4726b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 4727b411b363SPhilipp Reisner 4728b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 4729b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 4730b411b363SPhilipp Reisner 4731b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4732b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4733b411b363SPhilipp Reisner * to be "canceled" */ 4734b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4735b411b363SPhilipp Reisner 4736b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 4737b411b363SPhilipp Reisner 4738d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4739d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4740d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4741b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4742d10b4ea3SPhilipp Reisner 474308332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 474408332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 4745b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4746b411b363SPhilipp Reisner 4747b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4748b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 4749b411b363SPhilipp Reisner 4750b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 475169a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 4752b411b363SPhilipp Reisner 4753b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4754b411b363SPhilipp Reisner 475520ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 475620ceb2b2SLars Ellenberg * if any. */ 4757b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, !test_bit(BITMAP_IO, &device->flags)); 475820ceb2b2SLars Ellenberg 4759b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4760b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4761b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4762b411b363SPhilipp Reisner * 4763b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4764b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4765b411b363SPhilipp Reisner */ 4766b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 4767b411b363SPhilipp Reisner if (i) 4768d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 4769b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 4770435f0740SLars Ellenberg if (i) 4771d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 4772b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 4773b411b363SPhilipp Reisner if (i) 4774d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 4775b411b363SPhilipp Reisner 47760b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 47770b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 47780b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 47790b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 4780b411b363SPhilipp Reisner 4781360cc740SPhilipp Reisner return 0; 4782b411b363SPhilipp Reisner } 4783b411b363SPhilipp Reisner 4784b411b363SPhilipp Reisner /* 4785b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4786b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4787b411b363SPhilipp Reisner * 4788b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4789b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4790b411b363SPhilipp Reisner * 4791b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4792b411b363SPhilipp Reisner */ 4793bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 4794b411b363SPhilipp Reisner { 47959f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 47969f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4797b411b363SPhilipp Reisner 4798bde89a9eSAndreas Gruenbacher sock = &connection->data; 4799bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 48009f5bdc33SAndreas Gruenbacher if (!p) 4801e8d17b01SAndreas Gruenbacher return -EIO; 4802b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4803b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4804b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 480520c68fdeSLars Ellenberg p->feature_flags = cpu_to_be32(PRO_FEATURES); 4806bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4807b411b363SPhilipp Reisner } 4808b411b363SPhilipp Reisner 4809b411b363SPhilipp Reisner /* 4810b411b363SPhilipp Reisner * return values: 4811b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4812b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4813b411b363SPhilipp Reisner * -1 peer talks different language, 4814b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4815b411b363SPhilipp Reisner */ 4816bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 4817b411b363SPhilipp Reisner { 4818bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 4819e658983aSAndreas Gruenbacher struct p_connection_features *p; 4820e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 482177351055SPhilipp Reisner struct packet_info pi; 4822a5c31904SAndreas Gruenbacher int err; 4823b411b363SPhilipp Reisner 4824bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 4825e8d17b01SAndreas Gruenbacher if (err) 4826b411b363SPhilipp Reisner return 0; 4827b411b363SPhilipp Reisner 4828bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 482969bc7bc3SAndreas Gruenbacher if (err) 4830b411b363SPhilipp Reisner return 0; 4831b411b363SPhilipp Reisner 48326038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 48331ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 483477351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4835b411b363SPhilipp Reisner return -1; 4836b411b363SPhilipp Reisner } 4837b411b363SPhilipp Reisner 483877351055SPhilipp Reisner if (pi.size != expect) { 48391ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 484077351055SPhilipp Reisner expect, pi.size); 4841b411b363SPhilipp Reisner return -1; 4842b411b363SPhilipp Reisner } 4843b411b363SPhilipp Reisner 4844e658983aSAndreas Gruenbacher p = pi.data; 4845bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 4846a5c31904SAndreas Gruenbacher if (err) 4847b411b363SPhilipp Reisner return 0; 4848b411b363SPhilipp Reisner 4849b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4850b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4851b411b363SPhilipp Reisner if (p->protocol_max == 0) 4852b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4853b411b363SPhilipp Reisner 4854b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4855b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4856b411b363SPhilipp Reisner goto incompat; 4857b411b363SPhilipp Reisner 4858bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 485920c68fdeSLars Ellenberg connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); 4860b411b363SPhilipp Reisner 48611ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 4862bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 4863b411b363SPhilipp Reisner 486420c68fdeSLars Ellenberg drbd_info(connection, "Agreed to%ssupport TRIM on protocol level\n", 486520c68fdeSLars Ellenberg connection->agreed_features & FF_TRIM ? " " : " not "); 486620c68fdeSLars Ellenberg 4867b411b363SPhilipp Reisner return 1; 4868b411b363SPhilipp Reisner 4869b411b363SPhilipp Reisner incompat: 48701ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 4871b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4872b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4873b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4874b411b363SPhilipp Reisner return -1; 4875b411b363SPhilipp Reisner } 4876b411b363SPhilipp Reisner 4877b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4878bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4879b411b363SPhilipp Reisner { 48801ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 48811ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4882b10d96cbSJohannes Thoma return -1; 4883b411b363SPhilipp Reisner } 4884b411b363SPhilipp Reisner #else 4885b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4886b10d96cbSJohannes Thoma 4887b10d96cbSJohannes Thoma /* Return value: 4888b10d96cbSJohannes Thoma 1 - auth succeeded, 4889b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4890b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4891b10d96cbSJohannes Thoma */ 4892b10d96cbSJohannes Thoma 4893bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4894b411b363SPhilipp Reisner { 48959f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4896b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4897b411b363SPhilipp Reisner struct scatterlist sg; 4898b411b363SPhilipp Reisner char *response = NULL; 4899b411b363SPhilipp Reisner char *right_response = NULL; 4900b411b363SPhilipp Reisner char *peers_ch = NULL; 490144ed167dSPhilipp Reisner unsigned int key_len; 490244ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4903b411b363SPhilipp Reisner unsigned int resp_size; 4904b411b363SPhilipp Reisner struct hash_desc desc; 490577351055SPhilipp Reisner struct packet_info pi; 490644ed167dSPhilipp Reisner struct net_conf *nc; 490769bc7bc3SAndreas Gruenbacher int err, rv; 4908b411b363SPhilipp Reisner 49099f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 49109f5bdc33SAndreas Gruenbacher 491144ed167dSPhilipp Reisner rcu_read_lock(); 4912bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 491344ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 491444ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 491544ed167dSPhilipp Reisner rcu_read_unlock(); 491644ed167dSPhilipp Reisner 4917bde89a9eSAndreas Gruenbacher desc.tfm = connection->cram_hmac_tfm; 4918b411b363SPhilipp Reisner desc.flags = 0; 4919b411b363SPhilipp Reisner 4920bde89a9eSAndreas Gruenbacher rv = crypto_hash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 4921b411b363SPhilipp Reisner if (rv) { 49221ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_setkey() failed with %d\n", rv); 4923b10d96cbSJohannes Thoma rv = -1; 4924b411b363SPhilipp Reisner goto fail; 4925b411b363SPhilipp Reisner } 4926b411b363SPhilipp Reisner 4927b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4928b411b363SPhilipp Reisner 4929bde89a9eSAndreas Gruenbacher sock = &connection->data; 4930bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 49319f5bdc33SAndreas Gruenbacher rv = 0; 49329f5bdc33SAndreas Gruenbacher goto fail; 49339f5bdc33SAndreas Gruenbacher } 4934bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 49359f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4936b411b363SPhilipp Reisner if (!rv) 4937b411b363SPhilipp Reisner goto fail; 4938b411b363SPhilipp Reisner 4939bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 494069bc7bc3SAndreas Gruenbacher if (err) { 4941b411b363SPhilipp Reisner rv = 0; 4942b411b363SPhilipp Reisner goto fail; 4943b411b363SPhilipp Reisner } 4944b411b363SPhilipp Reisner 494577351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 49461ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 494777351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4948b411b363SPhilipp Reisner rv = 0; 4949b411b363SPhilipp Reisner goto fail; 4950b411b363SPhilipp Reisner } 4951b411b363SPhilipp Reisner 495277351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 49531ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 4954b10d96cbSJohannes Thoma rv = -1; 4955b411b363SPhilipp Reisner goto fail; 4956b411b363SPhilipp Reisner } 4957b411b363SPhilipp Reisner 495867cca286SPhilipp Reisner if (pi.size < CHALLENGE_LEN) { 495967cca286SPhilipp Reisner drbd_err(connection, "AuthChallenge payload too small.\n"); 496067cca286SPhilipp Reisner rv = -1; 496167cca286SPhilipp Reisner goto fail; 496267cca286SPhilipp Reisner } 496367cca286SPhilipp Reisner 496477351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4965b411b363SPhilipp Reisner if (peers_ch == NULL) { 49661ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 4967b10d96cbSJohannes Thoma rv = -1; 4968b411b363SPhilipp Reisner goto fail; 4969b411b363SPhilipp Reisner } 4970b411b363SPhilipp Reisner 4971bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 4972a5c31904SAndreas Gruenbacher if (err) { 4973b411b363SPhilipp Reisner rv = 0; 4974b411b363SPhilipp Reisner goto fail; 4975b411b363SPhilipp Reisner } 4976b411b363SPhilipp Reisner 497767cca286SPhilipp Reisner if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) { 497867cca286SPhilipp Reisner drbd_err(connection, "Peer presented the same challenge!\n"); 497967cca286SPhilipp Reisner rv = -1; 498067cca286SPhilipp Reisner goto fail; 498167cca286SPhilipp Reisner } 498267cca286SPhilipp Reisner 4983bde89a9eSAndreas Gruenbacher resp_size = crypto_hash_digestsize(connection->cram_hmac_tfm); 4984b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4985b411b363SPhilipp Reisner if (response == NULL) { 49861ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 4987b10d96cbSJohannes Thoma rv = -1; 4988b411b363SPhilipp Reisner goto fail; 4989b411b363SPhilipp Reisner } 4990b411b363SPhilipp Reisner 4991b411b363SPhilipp Reisner sg_init_table(&sg, 1); 499277351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4993b411b363SPhilipp Reisner 4994b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4995b411b363SPhilipp Reisner if (rv) { 49961ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4997b10d96cbSJohannes Thoma rv = -1; 4998b411b363SPhilipp Reisner goto fail; 4999b411b363SPhilipp Reisner } 5000b411b363SPhilipp Reisner 5001bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 50029f5bdc33SAndreas Gruenbacher rv = 0; 50039f5bdc33SAndreas Gruenbacher goto fail; 50049f5bdc33SAndreas Gruenbacher } 5005bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 50069f5bdc33SAndreas Gruenbacher response, resp_size); 5007b411b363SPhilipp Reisner if (!rv) 5008b411b363SPhilipp Reisner goto fail; 5009b411b363SPhilipp Reisner 5010bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 501169bc7bc3SAndreas Gruenbacher if (err) { 5012b411b363SPhilipp Reisner rv = 0; 5013b411b363SPhilipp Reisner goto fail; 5014b411b363SPhilipp Reisner } 5015b411b363SPhilipp Reisner 501677351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 50171ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 501877351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5019b411b363SPhilipp Reisner rv = 0; 5020b411b363SPhilipp Reisner goto fail; 5021b411b363SPhilipp Reisner } 5022b411b363SPhilipp Reisner 502377351055SPhilipp Reisner if (pi.size != resp_size) { 50241ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 5025b411b363SPhilipp Reisner rv = 0; 5026b411b363SPhilipp Reisner goto fail; 5027b411b363SPhilipp Reisner } 5028b411b363SPhilipp Reisner 5029bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 5030a5c31904SAndreas Gruenbacher if (err) { 5031b411b363SPhilipp Reisner rv = 0; 5032b411b363SPhilipp Reisner goto fail; 5033b411b363SPhilipp Reisner } 5034b411b363SPhilipp Reisner 5035b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 50362d1ee87dSJulia Lawall if (right_response == NULL) { 50371ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 5038b10d96cbSJohannes Thoma rv = -1; 5039b411b363SPhilipp Reisner goto fail; 5040b411b363SPhilipp Reisner } 5041b411b363SPhilipp Reisner 5042b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 5043b411b363SPhilipp Reisner 5044b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 5045b411b363SPhilipp Reisner if (rv) { 50461ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5047b10d96cbSJohannes Thoma rv = -1; 5048b411b363SPhilipp Reisner goto fail; 5049b411b363SPhilipp Reisner } 5050b411b363SPhilipp Reisner 5051b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 5052b411b363SPhilipp Reisner 5053b411b363SPhilipp Reisner if (rv) 50541ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 505544ed167dSPhilipp Reisner resp_size); 5056b10d96cbSJohannes Thoma else 5057b10d96cbSJohannes Thoma rv = -1; 5058b411b363SPhilipp Reisner 5059b411b363SPhilipp Reisner fail: 5060b411b363SPhilipp Reisner kfree(peers_ch); 5061b411b363SPhilipp Reisner kfree(response); 5062b411b363SPhilipp Reisner kfree(right_response); 5063b411b363SPhilipp Reisner 5064b411b363SPhilipp Reisner return rv; 5065b411b363SPhilipp Reisner } 5066b411b363SPhilipp Reisner #endif 5067b411b363SPhilipp Reisner 50688fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 5069b411b363SPhilipp Reisner { 5070bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5071b411b363SPhilipp Reisner int h; 5072b411b363SPhilipp Reisner 50731ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 5074b411b363SPhilipp Reisner 5075b411b363SPhilipp Reisner do { 5076bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 5077b411b363SPhilipp Reisner if (h == 0) { 5078bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 507920ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 5080b411b363SPhilipp Reisner } 5081b411b363SPhilipp Reisner if (h == -1) { 50821ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 5083bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5084b411b363SPhilipp Reisner } 5085b411b363SPhilipp Reisner } while (h == 0); 5086b411b363SPhilipp Reisner 508791fd4dadSPhilipp Reisner if (h > 0) 5088bde89a9eSAndreas Gruenbacher drbdd(connection); 5089b411b363SPhilipp Reisner 5090bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 5091b411b363SPhilipp Reisner 50921ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 5093b411b363SPhilipp Reisner return 0; 5094b411b363SPhilipp Reisner } 5095b411b363SPhilipp Reisner 5096b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 5097b411b363SPhilipp Reisner 5098bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5099b411b363SPhilipp Reisner { 5100e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5101b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5102b411b363SPhilipp Reisner 5103b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 5104bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 5105b411b363SPhilipp Reisner } else { 5106bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 51071ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 5108fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5109fc3b10a4SPhilipp Reisner } 5110bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5111e4f78edeSPhilipp Reisner 51122735a594SAndreas Gruenbacher return 0; 5113fc3b10a4SPhilipp Reisner } 5114e4f78edeSPhilipp Reisner 5115bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5116e4f78edeSPhilipp Reisner { 51179f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5118b30ab791SAndreas Gruenbacher struct drbd_device *device; 5119e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5120e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5121e4f78edeSPhilipp Reisner 51229f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51239f4fe9adSAndreas Gruenbacher if (!peer_device) 51242735a594SAndreas Gruenbacher return -EIO; 51259f4fe9adSAndreas Gruenbacher device = peer_device->device; 51261952e916SAndreas Gruenbacher 5127bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 51280b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 5129bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 51304d0fc3fdSPhilipp Reisner } 51314d0fc3fdSPhilipp Reisner 5132e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 5133b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 5134e4f78edeSPhilipp Reisner } else { 5135b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 5136d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 5137b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5138b411b363SPhilipp Reisner } 5139b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 5140b411b363SPhilipp Reisner 51412735a594SAndreas Gruenbacher return 0; 5142b411b363SPhilipp Reisner } 5143b411b363SPhilipp Reisner 5144bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 5145b411b363SPhilipp Reisner { 5146bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 5147b411b363SPhilipp Reisner 5148b411b363SPhilipp Reisner } 5149b411b363SPhilipp Reisner 5150bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 5151b411b363SPhilipp Reisner { 5152b411b363SPhilipp Reisner /* restore idle timeout */ 5153bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 5154bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 5155bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5156b411b363SPhilipp Reisner 51572735a594SAndreas Gruenbacher return 0; 5158b411b363SPhilipp Reisner } 5159b411b363SPhilipp Reisner 5160bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 5161b411b363SPhilipp Reisner { 51629f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5163b30ab791SAndreas Gruenbacher struct drbd_device *device; 5164e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5165b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5166b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5167b411b363SPhilipp Reisner 51689f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51699f4fe9adSAndreas Gruenbacher if (!peer_device) 51702735a594SAndreas Gruenbacher return -EIO; 51719f4fe9adSAndreas Gruenbacher device = peer_device->device; 51721952e916SAndreas Gruenbacher 51739f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 5174b411b363SPhilipp Reisner 517569a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5176b411b363SPhilipp Reisner 5177b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 5178b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5179b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5180b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 5181b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 5182b30ab791SAndreas Gruenbacher put_ldev(device); 51831d53f09eSLars Ellenberg } 5184b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5185b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5186b411b363SPhilipp Reisner 51872735a594SAndreas Gruenbacher return 0; 5188b411b363SPhilipp Reisner } 5189b411b363SPhilipp Reisner 5190bc9c5c41SAndreas Gruenbacher static int 5191b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5192bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5193bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5194b411b363SPhilipp Reisner { 5195b411b363SPhilipp Reisner struct drbd_request *req; 5196b411b363SPhilipp Reisner struct bio_and_error m; 5197b411b363SPhilipp Reisner 51980500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5199b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5200b411b363SPhilipp Reisner if (unlikely(!req)) { 52010500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 520285997675SAndreas Gruenbacher return -EIO; 5203b411b363SPhilipp Reisner } 5204b411b363SPhilipp Reisner __req_mod(req, what, &m); 52050500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5206b411b363SPhilipp Reisner 5207b411b363SPhilipp Reisner if (m.bio) 5208b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 520985997675SAndreas Gruenbacher return 0; 5210b411b363SPhilipp Reisner } 5211b411b363SPhilipp Reisner 5212bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5213b411b363SPhilipp Reisner { 52149f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5215b30ab791SAndreas Gruenbacher struct drbd_device *device; 5216e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5217b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5218b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5219b411b363SPhilipp Reisner enum drbd_req_event what; 5220b411b363SPhilipp Reisner 52219f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52229f4fe9adSAndreas Gruenbacher if (!peer_device) 52232735a594SAndreas Gruenbacher return -EIO; 52249f4fe9adSAndreas Gruenbacher device = peer_device->device; 52251952e916SAndreas Gruenbacher 522669a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5227b411b363SPhilipp Reisner 5228579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5229b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5230b30ab791SAndreas Gruenbacher dec_rs_pending(device); 52312735a594SAndreas Gruenbacher return 0; 5232b411b363SPhilipp Reisner } 5233e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5234b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 52358554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5236b411b363SPhilipp Reisner break; 5237b411b363SPhilipp Reisner case P_WRITE_ACK: 52388554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5239b411b363SPhilipp Reisner break; 5240b411b363SPhilipp Reisner case P_RECV_ACK: 52418554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5242b411b363SPhilipp Reisner break; 5243d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5244d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 52457be8da07SAndreas Gruenbacher break; 52467be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 52477be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5248b411b363SPhilipp Reisner break; 5249b411b363SPhilipp Reisner default: 52502735a594SAndreas Gruenbacher BUG(); 5251b411b363SPhilipp Reisner } 5252b411b363SPhilipp Reisner 5253b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5254b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5255bc9c5c41SAndreas Gruenbacher what, false); 5256b411b363SPhilipp Reisner } 5257b411b363SPhilipp Reisner 5258bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5259b411b363SPhilipp Reisner { 52609f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5261b30ab791SAndreas Gruenbacher struct drbd_device *device; 5262e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5263b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 52642deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 526585997675SAndreas Gruenbacher int err; 5266b411b363SPhilipp Reisner 52679f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52689f4fe9adSAndreas Gruenbacher if (!peer_device) 52692735a594SAndreas Gruenbacher return -EIO; 52709f4fe9adSAndreas Gruenbacher device = peer_device->device; 5271b411b363SPhilipp Reisner 527269a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5273b411b363SPhilipp Reisner 5274579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5275b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5276b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 52772735a594SAndreas Gruenbacher return 0; 5278b411b363SPhilipp Reisner } 52792deb8336SPhilipp Reisner 5280b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5281b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5282303d1448SPhilipp Reisner NEG_ACKED, true); 528385997675SAndreas Gruenbacher if (err) { 52842deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 52852deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5286c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 52872deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 52882deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5289b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 52902deb8336SPhilipp Reisner } 52912735a594SAndreas Gruenbacher return 0; 5292b411b363SPhilipp Reisner } 5293b411b363SPhilipp Reisner 5294bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5295b411b363SPhilipp Reisner { 52969f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5297b30ab791SAndreas Gruenbacher struct drbd_device *device; 5298e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5299b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5300b411b363SPhilipp Reisner 53019f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 53029f4fe9adSAndreas Gruenbacher if (!peer_device) 53032735a594SAndreas Gruenbacher return -EIO; 53049f4fe9adSAndreas Gruenbacher device = peer_device->device; 53051952e916SAndreas Gruenbacher 530669a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 53077be8da07SAndreas Gruenbacher 5308d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5309b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5310b411b363SPhilipp Reisner 5311b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5312b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 53138554df1cSAndreas Gruenbacher NEG_ACKED, false); 5314b411b363SPhilipp Reisner } 5315b411b363SPhilipp Reisner 5316bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5317b411b363SPhilipp Reisner { 53189f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5319b30ab791SAndreas Gruenbacher struct drbd_device *device; 5320b411b363SPhilipp Reisner sector_t sector; 5321b411b363SPhilipp Reisner int size; 5322e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 53231952e916SAndreas Gruenbacher 53249f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 53259f4fe9adSAndreas Gruenbacher if (!peer_device) 53262735a594SAndreas Gruenbacher return -EIO; 53279f4fe9adSAndreas Gruenbacher device = peer_device->device; 5328b411b363SPhilipp Reisner 5329b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5330b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5331b411b363SPhilipp Reisner 533269a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5333b411b363SPhilipp Reisner 5334b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5335b411b363SPhilipp Reisner 5336b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5337b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5338e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5339d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5340b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5341d612d309SPhilipp Reisner case P_RS_CANCEL: 5342d612d309SPhilipp Reisner break; 5343d612d309SPhilipp Reisner default: 53442735a594SAndreas Gruenbacher BUG(); 5345d612d309SPhilipp Reisner } 5346b30ab791SAndreas Gruenbacher put_ldev(device); 5347b411b363SPhilipp Reisner } 5348b411b363SPhilipp Reisner 53492735a594SAndreas Gruenbacher return 0; 5350b411b363SPhilipp Reisner } 5351b411b363SPhilipp Reisner 5352bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5353b411b363SPhilipp Reisner { 5354e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5355c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 53569ed57dcbSLars Ellenberg int vnr; 5357b411b363SPhilipp Reisner 5358bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5359b411b363SPhilipp Reisner 53609ed57dcbSLars Ellenberg rcu_read_lock(); 5361c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5362c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5363c06ece6bSAndreas Gruenbacher 5364b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5365b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5366b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5367b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5368b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5369c4752ef1SPhilipp Reisner } 53709ed57dcbSLars Ellenberg } 53719ed57dcbSLars Ellenberg rcu_read_unlock(); 5372c4752ef1SPhilipp Reisner 53732735a594SAndreas Gruenbacher return 0; 5374b411b363SPhilipp Reisner } 5375b411b363SPhilipp Reisner 5376bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5377b411b363SPhilipp Reisner { 53789f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5379b30ab791SAndreas Gruenbacher struct drbd_device *device; 5380e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 538184b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5382b411b363SPhilipp Reisner sector_t sector; 5383b411b363SPhilipp Reisner int size; 5384b411b363SPhilipp Reisner 53859f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 53869f4fe9adSAndreas Gruenbacher if (!peer_device) 53872735a594SAndreas Gruenbacher return -EIO; 53889f4fe9adSAndreas Gruenbacher device = peer_device->device; 53891952e916SAndreas Gruenbacher 5390b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5391b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5392b411b363SPhilipp Reisner 539369a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5394b411b363SPhilipp Reisner 5395b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5396b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5397b411b363SPhilipp Reisner else 5398b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5399b411b363SPhilipp Reisner 5400b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 54012735a594SAndreas Gruenbacher return 0; 54021d53f09eSLars Ellenberg 5403b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5404b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5405b411b363SPhilipp Reisner 5406b30ab791SAndreas Gruenbacher --device->ov_left; 5407ea5442afSLars Ellenberg 5408ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5409b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5410b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5411ea5442afSLars Ellenberg 5412b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 541384b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 541484b8c06bSAndreas Gruenbacher if (dw) { 541584b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 541684b8c06bSAndreas Gruenbacher dw->device = device; 541784b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5418b411b363SPhilipp Reisner } else { 541984b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5420b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5421b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5422b411b363SPhilipp Reisner } 5423b411b363SPhilipp Reisner } 5424b30ab791SAndreas Gruenbacher put_ldev(device); 54252735a594SAndreas Gruenbacher return 0; 5426b411b363SPhilipp Reisner } 5427b411b363SPhilipp Reisner 5428bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 54290ced55a3SPhilipp Reisner { 54302735a594SAndreas Gruenbacher return 0; 54310ced55a3SPhilipp Reisner } 54320ced55a3SPhilipp Reisner 5433bde89a9eSAndreas Gruenbacher static int connection_finish_peer_reqs(struct drbd_connection *connection) 543432862ec7SPhilipp Reisner { 5435c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5436c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 543732862ec7SPhilipp Reisner 543832862ec7SPhilipp Reisner do { 5439bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 544032862ec7SPhilipp Reisner flush_signals(current); 5441c141ebdaSPhilipp Reisner 5442c141ebdaSPhilipp Reisner rcu_read_lock(); 5443c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5444c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5445b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5446c141ebdaSPhilipp Reisner rcu_read_unlock(); 5447b30ab791SAndreas Gruenbacher if (drbd_finish_peer_reqs(device)) { 544805a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5449c141ebdaSPhilipp Reisner return 1; 5450082a3439SPhilipp Reisner } 545105a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5452c141ebdaSPhilipp Reisner rcu_read_lock(); 5453d3fcb490SPhilipp Reisner } 5454bde89a9eSAndreas Gruenbacher set_bit(SIGNAL_ASENDER, &connection->flags); 5455082a3439SPhilipp Reisner 54560500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5457c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5458c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5459b30ab791SAndreas Gruenbacher not_empty = !list_empty(&device->done_ee); 5460082a3439SPhilipp Reisner if (not_empty) 5461082a3439SPhilipp Reisner break; 5462082a3439SPhilipp Reisner } 54630500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5464c141ebdaSPhilipp Reisner rcu_read_unlock(); 546532862ec7SPhilipp Reisner } while (not_empty); 546632862ec7SPhilipp Reisner 546732862ec7SPhilipp Reisner return 0; 5468b411b363SPhilipp Reisner } 5469b411b363SPhilipp Reisner 5470b411b363SPhilipp Reisner struct asender_cmd { 5471b411b363SPhilipp Reisner size_t pkt_size; 5472bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5473b411b363SPhilipp Reisner }; 5474b411b363SPhilipp Reisner 5475b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 5476e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5477e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5478b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5479b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5480b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5481d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5482b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5483b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5484b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5485b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5486b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5487b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5488b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 548902918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5490d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 54911952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 54921952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5493b411b363SPhilipp Reisner }; 5494b411b363SPhilipp Reisner 5495b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5496b411b363SPhilipp Reisner { 5497bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5498b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 549977351055SPhilipp Reisner struct packet_info pi; 5500257d0af6SPhilipp Reisner int rv; 5501bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5502b411b363SPhilipp Reisner int received = 0; 5503bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 550452b061a4SAndreas Gruenbacher int expect = header_size; 550544ed167dSPhilipp Reisner bool ping_timeout_active = false; 550644ed167dSPhilipp Reisner struct net_conf *nc; 5507bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 55083990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5509b411b363SPhilipp Reisner 55103990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 55113990e04dSPhilipp Reisner if (rv < 0) 55121ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_asender: ERROR set priority, ret=%d\n", rv); 5513b411b363SPhilipp Reisner 5514e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 551580822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 551644ed167dSPhilipp Reisner 551744ed167dSPhilipp Reisner rcu_read_lock(); 5518bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 551944ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5520bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 552144ed167dSPhilipp Reisner ping_int = nc->ping_int; 552244ed167dSPhilipp Reisner rcu_read_unlock(); 552344ed167dSPhilipp Reisner 5524bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5525bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 55261ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5527841ce241SAndreas Gruenbacher goto reconnect; 5528841ce241SAndreas Gruenbacher } 5529bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 553044ed167dSPhilipp Reisner ping_timeout_active = true; 5531b411b363SPhilipp Reisner } 5532b411b363SPhilipp Reisner 553332862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 553432862ec7SPhilipp Reisner much to send */ 5535bb77d34eSAndreas Gruenbacher if (tcp_cork) 5536bde89a9eSAndreas Gruenbacher drbd_tcp_cork(connection->meta.socket); 5537bde89a9eSAndreas Gruenbacher if (connection_finish_peer_reqs(connection)) { 55381ec861ebSAndreas Gruenbacher drbd_err(connection, "connection_finish_peer_reqs() failed\n"); 5539b411b363SPhilipp Reisner goto reconnect; 5540b411b363SPhilipp Reisner } 5541b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5542bb77d34eSAndreas Gruenbacher if (tcp_cork) 5543bde89a9eSAndreas Gruenbacher drbd_tcp_uncork(connection->meta.socket); 5544b411b363SPhilipp Reisner 5545b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5546b411b363SPhilipp Reisner if (signal_pending(current)) 5547b411b363SPhilipp Reisner continue; 5548b411b363SPhilipp Reisner 5549bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5550bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5551b411b363SPhilipp Reisner 5552b411b363SPhilipp Reisner flush_signals(current); 5553b411b363SPhilipp Reisner 5554b411b363SPhilipp Reisner /* Note: 5555b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5556b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5557b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5558b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5559b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5560b411b363SPhilipp Reisner * rv == expected: full header or command 5561b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5562b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5563b411b363SPhilipp Reisner */ 5564abde9cc6SLars Ellenberg received_more: 5565b411b363SPhilipp Reisner if (likely(rv > 0)) { 5566b411b363SPhilipp Reisner received += rv; 5567b411b363SPhilipp Reisner buf += rv; 5568b411b363SPhilipp Reisner } else if (rv == 0) { 5569bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5570b66623e3SPhilipp Reisner long t; 5571b66623e3SPhilipp Reisner rcu_read_lock(); 5572bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5573b66623e3SPhilipp Reisner rcu_read_unlock(); 5574b66623e3SPhilipp Reisner 5575bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5576bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5577b66623e3SPhilipp Reisner t); 5578599377acSPhilipp Reisner if (t) 5579599377acSPhilipp Reisner break; 5580599377acSPhilipp Reisner } 55811ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5582b411b363SPhilipp Reisner goto reconnect; 5583b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5584cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5585cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5586bde89a9eSAndreas Gruenbacher if (time_after(connection->last_received, 5587bde89a9eSAndreas Gruenbacher jiffies - connection->meta.socket->sk->sk_rcvtimeo)) 5588cb6518cbSLars Ellenberg continue; 5589f36af18cSLars Ellenberg if (ping_timeout_active) { 55901ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5591b411b363SPhilipp Reisner goto reconnect; 5592b411b363SPhilipp Reisner } 5593bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5594b411b363SPhilipp Reisner continue; 5595b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5596b411b363SPhilipp Reisner continue; 5597b411b363SPhilipp Reisner } else { 55981ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5599b411b363SPhilipp Reisner goto reconnect; 5600b411b363SPhilipp Reisner } 5601b411b363SPhilipp Reisner 5602b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5603bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5604b411b363SPhilipp Reisner goto reconnect; 56057201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 56061952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 56071ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 56082fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5609b411b363SPhilipp Reisner goto disconnect; 5610b411b363SPhilipp Reisner } 5611e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 561252b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 56131ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 561477351055SPhilipp Reisner pi.cmd, pi.size); 5615b411b363SPhilipp Reisner goto reconnect; 5616b411b363SPhilipp Reisner } 5617257d0af6SPhilipp Reisner } 5618b411b363SPhilipp Reisner if (received == expect) { 56192735a594SAndreas Gruenbacher bool err; 5620a4fbda8eSPhilipp Reisner 5621bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 56222735a594SAndreas Gruenbacher if (err) { 56231ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5624b411b363SPhilipp Reisner goto reconnect; 56251952e916SAndreas Gruenbacher } 5626b411b363SPhilipp Reisner 5627bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5628f36af18cSLars Ellenberg 562944ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 563044ed167dSPhilipp Reisner /* restore idle timeout */ 5631bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 563244ed167dSPhilipp Reisner ping_timeout_active = false; 563344ed167dSPhilipp Reisner } 5634b411b363SPhilipp Reisner 5635bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5636b411b363SPhilipp Reisner received = 0; 563752b061a4SAndreas Gruenbacher expect = header_size; 5638b411b363SPhilipp Reisner cmd = NULL; 5639b411b363SPhilipp Reisner } 5640abde9cc6SLars Ellenberg if (test_bit(SEND_PING, &connection->flags)) 5641abde9cc6SLars Ellenberg continue; 5642abde9cc6SLars Ellenberg rv = drbd_recv_short(connection->meta.socket, buf, expect-received, MSG_DONTWAIT); 5643abde9cc6SLars Ellenberg if (rv > 0) 5644abde9cc6SLars Ellenberg goto received_more; 5645b411b363SPhilipp Reisner } 5646b411b363SPhilipp Reisner 5647b411b363SPhilipp Reisner if (0) { 5648b411b363SPhilipp Reisner reconnect: 5649bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5650bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5651b411b363SPhilipp Reisner } 5652b411b363SPhilipp Reisner if (0) { 5653b411b363SPhilipp Reisner disconnect: 5654bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5655b411b363SPhilipp Reisner } 5656bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5657b411b363SPhilipp Reisner 56581ec861ebSAndreas Gruenbacher drbd_info(connection, "asender terminated\n"); 5659b411b363SPhilipp Reisner 5660b411b363SPhilipp Reisner return 0; 5661b411b363SPhilipp Reisner } 5662