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 365db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 366db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 367db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 368db830c46SAndreas Gruenbacher peer_req->i.local = false; 369db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 370b411b363SPhilipp Reisner 371db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 372a8cd15baSAndreas Gruenbacher peer_req->peer_device = peer_device; 373db830c46SAndreas Gruenbacher peer_req->pages = page; 374db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 375db830c46SAndreas Gruenbacher peer_req->flags = 0; 3769a8e7753SAndreas Gruenbacher /* 3779a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3789a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3799a8e7753SAndreas Gruenbacher */ 380db830c46SAndreas Gruenbacher peer_req->block_id = id; 381b411b363SPhilipp Reisner 382db830c46SAndreas Gruenbacher return peer_req; 383b411b363SPhilipp Reisner 38445bb912bSLars Ellenberg fail: 385db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 386b411b363SPhilipp Reisner return NULL; 387b411b363SPhilipp Reisner } 388b411b363SPhilipp Reisner 389b30ab791SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_device *device, struct drbd_peer_request *peer_req, 390f6ffca9fSAndreas Gruenbacher int is_net) 391b411b363SPhilipp Reisner { 392db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 393db830c46SAndreas Gruenbacher kfree(peer_req->digest); 394b30ab791SAndreas Gruenbacher drbd_free_pages(device, peer_req->pages, is_net); 3950b0ba1efSAndreas Gruenbacher D_ASSERT(device, atomic_read(&peer_req->pending_bios) == 0); 3960b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 397db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 398b411b363SPhilipp Reisner } 399b411b363SPhilipp Reisner 400b30ab791SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_device *device, struct list_head *list) 401b411b363SPhilipp Reisner { 402b411b363SPhilipp Reisner LIST_HEAD(work_list); 403db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 404b411b363SPhilipp Reisner int count = 0; 405b30ab791SAndreas Gruenbacher int is_net = list == &device->net_ee; 406b411b363SPhilipp Reisner 4070500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 408b411b363SPhilipp Reisner list_splice_init(list, &work_list); 4090500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 410b411b363SPhilipp Reisner 411a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 412b30ab791SAndreas Gruenbacher __drbd_free_peer_req(device, peer_req, is_net); 413b411b363SPhilipp Reisner count++; 414b411b363SPhilipp Reisner } 415b411b363SPhilipp Reisner return count; 416b411b363SPhilipp Reisner } 417b411b363SPhilipp Reisner 418b411b363SPhilipp Reisner /* 419a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 420b411b363SPhilipp Reisner */ 421b30ab791SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_device *device) 422b411b363SPhilipp Reisner { 423b411b363SPhilipp Reisner LIST_HEAD(work_list); 424b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 425db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 426e2b3032bSAndreas Gruenbacher int err = 0; 427b411b363SPhilipp Reisner 4280500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 429b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 430b30ab791SAndreas Gruenbacher list_splice_init(&device->done_ee, &work_list); 4310500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 432b411b363SPhilipp Reisner 433a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 434b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 435b411b363SPhilipp Reisner 436b411b363SPhilipp Reisner /* possible callbacks here: 437d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 438b411b363SPhilipp Reisner * all ignore the last argument. 439b411b363SPhilipp Reisner */ 440a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 441e2b3032bSAndreas Gruenbacher int err2; 442e2b3032bSAndreas Gruenbacher 443b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 444a8cd15baSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 445e2b3032bSAndreas Gruenbacher if (!err) 446e2b3032bSAndreas Gruenbacher err = err2; 447b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 448b411b363SPhilipp Reisner } 449b30ab791SAndreas Gruenbacher wake_up(&device->ee_wait); 450b411b363SPhilipp Reisner 451e2b3032bSAndreas Gruenbacher return err; 452b411b363SPhilipp Reisner } 453b411b363SPhilipp Reisner 454b30ab791SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_device *device, 455d4da1537SAndreas Gruenbacher struct list_head *head) 456b411b363SPhilipp Reisner { 457b411b363SPhilipp Reisner DEFINE_WAIT(wait); 458b411b363SPhilipp Reisner 459b411b363SPhilipp Reisner /* avoids spin_lock/unlock 460b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 461b411b363SPhilipp Reisner while (!list_empty(head)) { 462b30ab791SAndreas Gruenbacher prepare_to_wait(&device->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 4630500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4647eaceaccSJens Axboe io_schedule(); 465b30ab791SAndreas Gruenbacher finish_wait(&device->ee_wait, &wait); 4660500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 467b411b363SPhilipp Reisner } 468b411b363SPhilipp Reisner } 469b411b363SPhilipp Reisner 470b30ab791SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_device *device, 471d4da1537SAndreas Gruenbacher struct list_head *head) 472b411b363SPhilipp Reisner { 4730500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 474b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, head); 4750500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 476b411b363SPhilipp Reisner } 477b411b363SPhilipp Reisner 478dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 479b411b363SPhilipp Reisner { 480b411b363SPhilipp Reisner struct kvec iov = { 481b411b363SPhilipp Reisner .iov_base = buf, 482b411b363SPhilipp Reisner .iov_len = size, 483b411b363SPhilipp Reisner }; 484b411b363SPhilipp Reisner struct msghdr msg = { 485b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 486b411b363SPhilipp Reisner }; 487f730c848SAl Viro return kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); 488b411b363SPhilipp Reisner } 489b411b363SPhilipp Reisner 490bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 491b411b363SPhilipp Reisner { 492b411b363SPhilipp Reisner int rv; 493b411b363SPhilipp Reisner 494bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 495b411b363SPhilipp Reisner 496b411b363SPhilipp Reisner if (rv < 0) { 497b411b363SPhilipp Reisner if (rv == -ECONNRESET) 4981ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 499b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 5001ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 501b411b363SPhilipp Reisner } else if (rv == 0) { 502bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 503b66623e3SPhilipp Reisner long t; 504b66623e3SPhilipp Reisner rcu_read_lock(); 505bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 506b66623e3SPhilipp Reisner rcu_read_unlock(); 507b66623e3SPhilipp Reisner 508bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 509b66623e3SPhilipp Reisner 510599377acSPhilipp Reisner if (t) 511599377acSPhilipp Reisner goto out; 512599377acSPhilipp Reisner } 5131ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 514599377acSPhilipp Reisner } 515599377acSPhilipp Reisner 516b411b363SPhilipp Reisner if (rv != size) 517bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 518b411b363SPhilipp Reisner 519599377acSPhilipp Reisner out: 520b411b363SPhilipp Reisner return rv; 521b411b363SPhilipp Reisner } 522b411b363SPhilipp Reisner 523bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 524c6967746SAndreas Gruenbacher { 525c6967746SAndreas Gruenbacher int err; 526c6967746SAndreas Gruenbacher 527bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 528c6967746SAndreas Gruenbacher if (err != size) { 529c6967746SAndreas Gruenbacher if (err >= 0) 530c6967746SAndreas Gruenbacher err = -EIO; 531c6967746SAndreas Gruenbacher } else 532c6967746SAndreas Gruenbacher err = 0; 533c6967746SAndreas Gruenbacher return err; 534c6967746SAndreas Gruenbacher } 535c6967746SAndreas Gruenbacher 536bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 537a5c31904SAndreas Gruenbacher { 538a5c31904SAndreas Gruenbacher int err; 539a5c31904SAndreas Gruenbacher 540bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 541a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5421ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 543a5c31904SAndreas Gruenbacher return err; 544a5c31904SAndreas Gruenbacher } 545a5c31904SAndreas Gruenbacher 5465dbf1673SLars Ellenberg /* quoting tcp(7): 5475dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5485dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5495dbf1673SLars Ellenberg * This is our wrapper to do so. 5505dbf1673SLars Ellenberg */ 5515dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5525dbf1673SLars Ellenberg unsigned int rcv) 5535dbf1673SLars Ellenberg { 5545dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5555dbf1673SLars Ellenberg if (snd) { 5565dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5575dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5585dbf1673SLars Ellenberg } 5595dbf1673SLars Ellenberg if (rcv) { 5605dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5615dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5625dbf1673SLars Ellenberg } 5635dbf1673SLars Ellenberg } 5645dbf1673SLars Ellenberg 565bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 566b411b363SPhilipp Reisner { 567b411b363SPhilipp Reisner const char *what; 568b411b363SPhilipp Reisner struct socket *sock; 569b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 57044ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 57144ed167dSPhilipp Reisner struct net_conf *nc; 57244ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 57369ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 574b411b363SPhilipp Reisner int disconnect_on_error = 1; 575b411b363SPhilipp Reisner 57644ed167dSPhilipp Reisner rcu_read_lock(); 577bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 57844ed167dSPhilipp Reisner if (!nc) { 57944ed167dSPhilipp Reisner rcu_read_unlock(); 580b411b363SPhilipp Reisner return NULL; 58144ed167dSPhilipp Reisner } 58244ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 58344ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 58469ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 585089c075dSAndreas Gruenbacher rcu_read_unlock(); 58644ed167dSPhilipp Reisner 587bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 588bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 58944ed167dSPhilipp Reisner 590bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 59144ed167dSPhilipp Reisner src_in6.sin6_port = 0; 59244ed167dSPhilipp Reisner else 59344ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 59444ed167dSPhilipp Reisner 595bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 596bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 597b411b363SPhilipp Reisner 598b411b363SPhilipp Reisner what = "sock_create_kern"; 59944ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 600b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 601b411b363SPhilipp Reisner if (err < 0) { 602b411b363SPhilipp Reisner sock = NULL; 603b411b363SPhilipp Reisner goto out; 604b411b363SPhilipp Reisner } 605b411b363SPhilipp Reisner 606b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 60769ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 60844ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 609b411b363SPhilipp Reisner 610b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 611b411b363SPhilipp Reisner * for the outgoing connections. 612b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 613b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 614b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 615b411b363SPhilipp Reisner * a free one dynamically. 616b411b363SPhilipp Reisner */ 617b411b363SPhilipp Reisner what = "bind before connect"; 61844ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 619b411b363SPhilipp Reisner if (err < 0) 620b411b363SPhilipp Reisner goto out; 621b411b363SPhilipp Reisner 622b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 623b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 624b411b363SPhilipp Reisner disconnect_on_error = 0; 625b411b363SPhilipp Reisner what = "connect"; 62644ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 627b411b363SPhilipp Reisner 628b411b363SPhilipp Reisner out: 629b411b363SPhilipp Reisner if (err < 0) { 630b411b363SPhilipp Reisner if (sock) { 631b411b363SPhilipp Reisner sock_release(sock); 632b411b363SPhilipp Reisner sock = NULL; 633b411b363SPhilipp Reisner } 634b411b363SPhilipp Reisner switch (-err) { 635b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 636b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 637b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 638b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 639b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 640b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 641b411b363SPhilipp Reisner disconnect_on_error = 0; 642b411b363SPhilipp Reisner break; 643b411b363SPhilipp Reisner default: 6441ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 645b411b363SPhilipp Reisner } 646b411b363SPhilipp Reisner if (disconnect_on_error) 647bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 648b411b363SPhilipp Reisner } 64944ed167dSPhilipp Reisner 650b411b363SPhilipp Reisner return sock; 651b411b363SPhilipp Reisner } 652b411b363SPhilipp Reisner 6537a426fd8SPhilipp Reisner struct accept_wait_data { 654bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6557a426fd8SPhilipp Reisner struct socket *s_listen; 6567a426fd8SPhilipp Reisner struct completion door_bell; 6577a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6587a426fd8SPhilipp Reisner 6597a426fd8SPhilipp Reisner }; 6607a426fd8SPhilipp Reisner 661715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 662b411b363SPhilipp Reisner { 6637a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 664715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6657a426fd8SPhilipp Reisner 666715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 667715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6687a426fd8SPhilipp Reisner complete(&ad->door_bell); 669715306f6SAndreas Gruenbacher state_change(sk); 6707a426fd8SPhilipp Reisner } 6717a426fd8SPhilipp Reisner 672bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 673b411b363SPhilipp Reisner { 6741f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 67544ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 6761f3e509bSPhilipp Reisner struct socket *s_listen; 67744ed167dSPhilipp Reisner struct net_conf *nc; 678b411b363SPhilipp Reisner const char *what; 679b411b363SPhilipp Reisner 68044ed167dSPhilipp Reisner rcu_read_lock(); 681bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 68244ed167dSPhilipp Reisner if (!nc) { 68344ed167dSPhilipp Reisner rcu_read_unlock(); 6847a426fd8SPhilipp Reisner return -EIO; 68544ed167dSPhilipp Reisner } 68644ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 68744ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 68844ed167dSPhilipp Reisner rcu_read_unlock(); 689b411b363SPhilipp Reisner 690bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 691bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 692b411b363SPhilipp Reisner 693b411b363SPhilipp Reisner what = "sock_create_kern"; 69444ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 695b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 696b411b363SPhilipp Reisner if (err) { 697b411b363SPhilipp Reisner s_listen = NULL; 698b411b363SPhilipp Reisner goto out; 699b411b363SPhilipp Reisner } 700b411b363SPhilipp Reisner 7014a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 70244ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 703b411b363SPhilipp Reisner 704b411b363SPhilipp Reisner what = "bind before listen"; 70544ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 706b411b363SPhilipp Reisner if (err < 0) 707b411b363SPhilipp Reisner goto out; 708b411b363SPhilipp Reisner 7097a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7107a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7117a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 712715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7137a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7147a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 715b411b363SPhilipp Reisner 7162820fd39SPhilipp Reisner what = "listen"; 7172820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7182820fd39SPhilipp Reisner if (err < 0) 7192820fd39SPhilipp Reisner goto out; 7202820fd39SPhilipp Reisner 7217a426fd8SPhilipp Reisner return 0; 722b411b363SPhilipp Reisner out: 723b411b363SPhilipp Reisner if (s_listen) 724b411b363SPhilipp Reisner sock_release(s_listen); 725b411b363SPhilipp Reisner if (err < 0) { 726b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7271ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 728bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 729b411b363SPhilipp Reisner } 730b411b363SPhilipp Reisner } 7311f3e509bSPhilipp Reisner 7327a426fd8SPhilipp Reisner return -EIO; 7331f3e509bSPhilipp Reisner } 7341f3e509bSPhilipp Reisner 735715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 736715306f6SAndreas Gruenbacher { 737715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 738715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 739715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 740715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 741715306f6SAndreas Gruenbacher } 742715306f6SAndreas Gruenbacher 743bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7441f3e509bSPhilipp Reisner { 7451f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7461f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7471f3e509bSPhilipp Reisner struct net_conf *nc; 7481f3e509bSPhilipp Reisner 7491f3e509bSPhilipp Reisner rcu_read_lock(); 750bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7511f3e509bSPhilipp Reisner if (!nc) { 7521f3e509bSPhilipp Reisner rcu_read_unlock(); 7531f3e509bSPhilipp Reisner return NULL; 7541f3e509bSPhilipp Reisner } 7551f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7561f3e509bSPhilipp Reisner rcu_read_unlock(); 7571f3e509bSPhilipp Reisner 7581f3e509bSPhilipp Reisner timeo = connect_int * HZ; 75938b682b2SAkinobu Mita /* 28.5% random jitter */ 76038b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7611f3e509bSPhilipp Reisner 7627a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7637a426fd8SPhilipp Reisner if (err <= 0) 7647a426fd8SPhilipp Reisner return NULL; 7651f3e509bSPhilipp Reisner 7667a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 767b411b363SPhilipp Reisner if (err < 0) { 768b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7691ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 770bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 771b411b363SPhilipp Reisner } 772b411b363SPhilipp Reisner } 773b411b363SPhilipp Reisner 774715306f6SAndreas Gruenbacher if (s_estab) 775715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 776b411b363SPhilipp Reisner 777b411b363SPhilipp Reisner return s_estab; 778b411b363SPhilipp Reisner } 779b411b363SPhilipp Reisner 780bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 781b411b363SPhilipp Reisner 782bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 7839f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7849f5bdc33SAndreas Gruenbacher { 785bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 7869f5bdc33SAndreas Gruenbacher return -EIO; 787bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 788b411b363SPhilipp Reisner } 789b411b363SPhilipp Reisner 790bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 791b411b363SPhilipp Reisner { 792bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 7939f5bdc33SAndreas Gruenbacher struct packet_info pi; 7944920e37aSPhilipp Reisner struct net_conf *nc; 7959f5bdc33SAndreas Gruenbacher int err; 796b411b363SPhilipp Reisner 7974920e37aSPhilipp Reisner rcu_read_lock(); 7984920e37aSPhilipp Reisner nc = rcu_dereference(connection->net_conf); 7994920e37aSPhilipp Reisner if (!nc) { 8004920e37aSPhilipp Reisner rcu_read_unlock(); 8014920e37aSPhilipp Reisner return -EIO; 8024920e37aSPhilipp Reisner } 8034920e37aSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo * 4 * HZ / 10; 8044920e37aSPhilipp Reisner rcu_read_unlock(); 8054920e37aSPhilipp Reisner 806bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 8079f5bdc33SAndreas Gruenbacher if (err != header_size) { 8089f5bdc33SAndreas Gruenbacher if (err >= 0) 8099f5bdc33SAndreas Gruenbacher err = -EIO; 8109f5bdc33SAndreas Gruenbacher return err; 8119f5bdc33SAndreas Gruenbacher } 812bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8139f5bdc33SAndreas Gruenbacher if (err) 8149f5bdc33SAndreas Gruenbacher return err; 8159f5bdc33SAndreas Gruenbacher return pi.cmd; 816b411b363SPhilipp Reisner } 817b411b363SPhilipp Reisner 818b411b363SPhilipp Reisner /** 819b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 820b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 821b411b363SPhilipp Reisner */ 822dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 823b411b363SPhilipp Reisner { 824b411b363SPhilipp Reisner int rr; 825b411b363SPhilipp Reisner char tb[4]; 826b411b363SPhilipp Reisner 827b411b363SPhilipp Reisner if (!*sock) 82881e84650SAndreas Gruenbacher return false; 829b411b363SPhilipp Reisner 830dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 831b411b363SPhilipp Reisner 832b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 83381e84650SAndreas Gruenbacher return true; 834b411b363SPhilipp Reisner } else { 835b411b363SPhilipp Reisner sock_release(*sock); 836b411b363SPhilipp Reisner *sock = NULL; 83781e84650SAndreas Gruenbacher return false; 838b411b363SPhilipp Reisner } 839b411b363SPhilipp Reisner } 8402325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8412325eb66SPhilipp Reisner in a connection */ 84269a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 843907599e0SPhilipp Reisner { 84469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 8450829f5edSAndreas Gruenbacher int err; 846907599e0SPhilipp Reisner 847b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 848b30ab791SAndreas Gruenbacher device->peer_seq = 0; 849907599e0SPhilipp Reisner 85069a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 85169a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 852b30ab791SAndreas Gruenbacher &device->own_state_mutex; 8538410da8fSPhilipp Reisner 85469a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 8550829f5edSAndreas Gruenbacher if (!err) 85669a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 8570829f5edSAndreas Gruenbacher if (!err) 85869a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 8590829f5edSAndreas Gruenbacher if (!err) 86069a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 861b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 862b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 863b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 864b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 8650829f5edSAndreas Gruenbacher return err; 866907599e0SPhilipp Reisner } 867b411b363SPhilipp Reisner 868b411b363SPhilipp Reisner /* 869b411b363SPhilipp Reisner * return values: 870b411b363SPhilipp Reisner * 1 yes, we have a valid connection 871b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 872b411b363SPhilipp Reisner * -1 peer talks different language, 873b411b363SPhilipp Reisner * no point in trying again, please go standalone. 874b411b363SPhilipp Reisner * -2 We do not have a network config... 875b411b363SPhilipp Reisner */ 876bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 877b411b363SPhilipp Reisner { 8787da35862SPhilipp Reisner struct drbd_socket sock, msock; 879c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 88044ed167dSPhilipp Reisner struct net_conf *nc; 88192f14951SPhilipp Reisner int vnr, timeout, h, ok; 88208b165baSPhilipp Reisner bool discard_my_data; 883197296ffSPhilipp Reisner enum drbd_state_rv rv; 8847a426fd8SPhilipp Reisner struct accept_wait_data ad = { 885bde89a9eSAndreas Gruenbacher .connection = connection, 8867a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8877a426fd8SPhilipp Reisner }; 888b411b363SPhilipp Reisner 889bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 890bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 891b411b363SPhilipp Reisner return -2; 892b411b363SPhilipp Reisner 8937da35862SPhilipp Reisner mutex_init(&sock.mutex); 894bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 895bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 8967da35862SPhilipp Reisner sock.socket = NULL; 8977da35862SPhilipp Reisner mutex_init(&msock.mutex); 898bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 899bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 9007da35862SPhilipp Reisner msock.socket = NULL; 9017da35862SPhilipp Reisner 9020916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 903bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 904b411b363SPhilipp Reisner 905bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 9067a426fd8SPhilipp Reisner return 0; 907b411b363SPhilipp Reisner 908b411b363SPhilipp Reisner do { 9092bf89621SAndreas Gruenbacher struct socket *s; 910b411b363SPhilipp Reisner 911bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 912b411b363SPhilipp Reisner if (s) { 9137da35862SPhilipp Reisner if (!sock.socket) { 9147da35862SPhilipp Reisner sock.socket = s; 915bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9167da35862SPhilipp Reisner } else if (!msock.socket) { 917bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9187da35862SPhilipp Reisner msock.socket = s; 919bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 920b411b363SPhilipp Reisner } else { 9211ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 922b411b363SPhilipp Reisner goto out_release_sockets; 923b411b363SPhilipp Reisner } 924b411b363SPhilipp Reisner } 925b411b363SPhilipp Reisner 9267da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9277da35862SPhilipp Reisner rcu_read_lock(); 928bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 9297da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9307da35862SPhilipp Reisner rcu_read_unlock(); 9317da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9327da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9337da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 934b411b363SPhilipp Reisner if (ok) 935b411b363SPhilipp Reisner break; 936b411b363SPhilipp Reisner } 937b411b363SPhilipp Reisner 938b411b363SPhilipp Reisner retry: 939bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 940b411b363SPhilipp Reisner if (s) { 941bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9427da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9437da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 94492f14951SPhilipp Reisner switch (fp) { 945e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9467da35862SPhilipp Reisner if (sock.socket) { 9471ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9487da35862SPhilipp Reisner sock_release(sock.socket); 94980c6eed4SPhilipp Reisner sock.socket = s; 95080c6eed4SPhilipp Reisner goto randomize; 951b411b363SPhilipp Reisner } 9527da35862SPhilipp Reisner sock.socket = s; 953b411b363SPhilipp Reisner break; 954e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 955bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 9567da35862SPhilipp Reisner if (msock.socket) { 9571ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 9587da35862SPhilipp Reisner sock_release(msock.socket); 95980c6eed4SPhilipp Reisner msock.socket = s; 96080c6eed4SPhilipp Reisner goto randomize; 961b411b363SPhilipp Reisner } 9627da35862SPhilipp Reisner msock.socket = s; 963b411b363SPhilipp Reisner break; 964b411b363SPhilipp Reisner default: 9651ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 966b411b363SPhilipp Reisner sock_release(s); 96780c6eed4SPhilipp Reisner randomize: 96838b682b2SAkinobu Mita if (prandom_u32() & 1) 969b411b363SPhilipp Reisner goto retry; 970b411b363SPhilipp Reisner } 971b411b363SPhilipp Reisner } 972b411b363SPhilipp Reisner 973bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 974b411b363SPhilipp Reisner goto out_release_sockets; 975b411b363SPhilipp Reisner if (signal_pending(current)) { 976b411b363SPhilipp Reisner flush_signals(current); 977b411b363SPhilipp Reisner smp_rmb(); 978bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 979b411b363SPhilipp Reisner goto out_release_sockets; 980b411b363SPhilipp Reisner } 981b411b363SPhilipp Reisner 9827da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9837da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 984b666dbf8SPhilipp Reisner } while (!ok); 985b411b363SPhilipp Reisner 9867a426fd8SPhilipp Reisner if (ad.s_listen) 9877a426fd8SPhilipp Reisner sock_release(ad.s_listen); 988b411b363SPhilipp Reisner 98998683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 99098683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 991b411b363SPhilipp Reisner 9927da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9937da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 994b411b363SPhilipp Reisner 9957da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9967da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 997b411b363SPhilipp Reisner 998b411b363SPhilipp Reisner /* NOT YET ... 999bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 10007da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10016038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1002b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 100344ed167dSPhilipp Reisner rcu_read_lock(); 1004bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 1005b411b363SPhilipp Reisner 10067da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10077da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 100844ed167dSPhilipp Reisner 10097da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 101044ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 101108b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 101244ed167dSPhilipp Reisner rcu_read_unlock(); 101344ed167dSPhilipp Reisner 10147da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1015b411b363SPhilipp Reisner 1016b411b363SPhilipp Reisner /* we don't want delays. 101725985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10187da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10197da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1020b411b363SPhilipp Reisner 1021bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1022bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1023bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1024b411b363SPhilipp Reisner 1025bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1026b411b363SPhilipp Reisner if (h <= 0) 1027b411b363SPhilipp Reisner return h; 1028b411b363SPhilipp Reisner 1029bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1030b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1031bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1032b10d96cbSJohannes Thoma case -1: 10331ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1034b411b363SPhilipp Reisner return -1; 1035b10d96cbSJohannes Thoma case 0: 10361ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1037b10d96cbSJohannes Thoma return 0; 1038b411b363SPhilipp Reisner } 1039b411b363SPhilipp Reisner } 1040b411b363SPhilipp Reisner 1041bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1042bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1043b411b363SPhilipp Reisner 1044bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10457e2455c1SPhilipp Reisner return -1; 10461e86ac48SPhilipp Reisner 104713c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 104813c76abaSPhilipp Reisner * being promoted to Primary. 104913c76abaSPhilipp Reisner * 105013c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 105113c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 105213c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 105313c76abaSPhilipp Reisner */ 105431007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 105531007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 105631007745SPhilipp Reisner 105731007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 105831007745SPhilipp Reisner 105931007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 106031007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 106131007745SPhilipp Reisner 106231007745SPhilipp Reisner rcu_read_lock(); 106331007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 106431007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 106531007745SPhilipp Reisner kref_get(&device->kref); 106631007745SPhilipp Reisner rcu_read_unlock(); 106713c76abaSPhilipp Reisner 106808b165baSPhilipp Reisner if (discard_my_data) 1069b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 107008b165baSPhilipp Reisner else 1071b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 107208b165baSPhilipp Reisner 107369a22773SAndreas Gruenbacher drbd_connected(peer_device); 107405a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1075c141ebdaSPhilipp Reisner rcu_read_lock(); 1076c141ebdaSPhilipp Reisner } 1077c141ebdaSPhilipp Reisner rcu_read_unlock(); 1078c141ebdaSPhilipp Reisner 1079bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1080bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1081bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 10821e86ac48SPhilipp Reisner return 0; 1083a1096a6eSPhilipp Reisner } 10841e86ac48SPhilipp Reisner 1085bde89a9eSAndreas Gruenbacher drbd_thread_start(&connection->asender); 1086b411b363SPhilipp Reisner 10870500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 108808b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 108908b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 109008b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 109108b165baSPhilipp Reisner * just to clear a single value. */ 1092bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 10930500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 109408b165baSPhilipp Reisner 1095d3fcb490SPhilipp Reisner return h; 1096b411b363SPhilipp Reisner 1097b411b363SPhilipp Reisner out_release_sockets: 10987a426fd8SPhilipp Reisner if (ad.s_listen) 10997a426fd8SPhilipp Reisner sock_release(ad.s_listen); 11007da35862SPhilipp Reisner if (sock.socket) 11017da35862SPhilipp Reisner sock_release(sock.socket); 11027da35862SPhilipp Reisner if (msock.socket) 11037da35862SPhilipp Reisner sock_release(msock.socket); 1104b411b363SPhilipp Reisner return -1; 1105b411b363SPhilipp Reisner } 1106b411b363SPhilipp Reisner 1107bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1108b411b363SPhilipp Reisner { 1109bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1110b411b363SPhilipp Reisner 11110c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11120c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11130c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11140c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11151ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11160c8e36d9SAndreas Gruenbacher return -EINVAL; 111702918be2SPhilipp Reisner } 11180c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11190c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11200c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11210c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1122e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1123e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1124e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1125b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1126eefc2f7dSPhilipp Reisner pi->vnr = 0; 1127e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1128e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1129e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1130e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1131e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 113277351055SPhilipp Reisner pi->vnr = 0; 113302918be2SPhilipp Reisner } else { 11341ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1135e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1136bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11378172f3e9SAndreas Gruenbacher return -EINVAL; 1138b411b363SPhilipp Reisner } 1139e658983aSAndreas Gruenbacher pi->data = header + header_size; 11408172f3e9SAndreas Gruenbacher return 0; 1141b411b363SPhilipp Reisner } 1142b411b363SPhilipp Reisner 1143bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1144257d0af6SPhilipp Reisner { 1145bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 114669bc7bc3SAndreas Gruenbacher int err; 1147257d0af6SPhilipp Reisner 1148bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1149a5c31904SAndreas Gruenbacher if (err) 115069bc7bc3SAndreas Gruenbacher return err; 1151257d0af6SPhilipp Reisner 1152bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1153bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1154b411b363SPhilipp Reisner 115569bc7bc3SAndreas Gruenbacher return err; 1156b411b363SPhilipp Reisner } 1157b411b363SPhilipp Reisner 1158bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1159b411b363SPhilipp Reisner { 1160b411b363SPhilipp Reisner int rv; 1161c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 11624b0007c0SPhilipp Reisner int vnr; 1163b411b363SPhilipp Reisner 1164e9526580SPhilipp Reisner if (connection->resource->write_ordering >= WO_bdev_flush) { 1165615e087fSLars Ellenberg rcu_read_lock(); 1166c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1167c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1168c06ece6bSAndreas Gruenbacher 1169b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1170615e087fSLars Ellenberg continue; 1171b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1172615e087fSLars Ellenberg rcu_read_unlock(); 11734b0007c0SPhilipp Reisner 1174b30ab791SAndreas Gruenbacher rv = blkdev_issue_flush(device->ldev->backing_bdev, 1175615e087fSLars Ellenberg GFP_NOIO, NULL); 1176b411b363SPhilipp Reisner if (rv) { 1177d0180171SAndreas Gruenbacher drbd_info(device, "local disk flush failed with status %d\n", rv); 1178b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1179b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1180b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11818fe39aacSPhilipp Reisner drbd_bump_write_ordering(connection->resource, NULL, WO_drain_io); 1182b411b363SPhilipp Reisner } 1183b30ab791SAndreas Gruenbacher put_ldev(device); 118405a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1185615e087fSLars Ellenberg 1186615e087fSLars Ellenberg rcu_read_lock(); 1187615e087fSLars Ellenberg if (rv) 11884b0007c0SPhilipp Reisner break; 1189b411b363SPhilipp Reisner } 1190615e087fSLars Ellenberg rcu_read_unlock(); 1191b411b363SPhilipp Reisner } 1192b411b363SPhilipp Reisner } 1193b411b363SPhilipp Reisner 1194b411b363SPhilipp Reisner /** 1195b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1196b30ab791SAndreas Gruenbacher * @device: DRBD device. 1197b411b363SPhilipp Reisner * @epoch: Epoch object. 1198b411b363SPhilipp Reisner * @ev: Epoch event. 1199b411b363SPhilipp Reisner */ 1200bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1201b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1202b411b363SPhilipp Reisner enum epoch_event ev) 1203b411b363SPhilipp Reisner { 12042451fc3bSPhilipp Reisner int epoch_size; 1205b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1206b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1207b411b363SPhilipp Reisner 1208bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1209b411b363SPhilipp Reisner do { 1210b411b363SPhilipp Reisner next_epoch = NULL; 1211b411b363SPhilipp Reisner 1212b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1213b411b363SPhilipp Reisner 1214b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1215b411b363SPhilipp Reisner case EV_PUT: 1216b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1217b411b363SPhilipp Reisner break; 1218b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1219b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1220b411b363SPhilipp Reisner break; 1221b411b363SPhilipp Reisner case EV_BECAME_LAST: 1222b411b363SPhilipp Reisner /* nothing to do*/ 1223b411b363SPhilipp Reisner break; 1224b411b363SPhilipp Reisner } 1225b411b363SPhilipp Reisner 1226b411b363SPhilipp Reisner if (epoch_size != 0 && 1227b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 122880f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1229b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1230bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1231bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1232bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1233b411b363SPhilipp Reisner } 12349ed57dcbSLars Ellenberg #if 0 12359ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12369ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 123780f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1238bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 12399ed57dcbSLars Ellenberg #endif 1240b411b363SPhilipp Reisner 1241bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1242b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1243b411b363SPhilipp Reisner list_del(&epoch->list); 1244b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1245bde89a9eSAndreas Gruenbacher connection->epochs--; 1246b411b363SPhilipp Reisner kfree(epoch); 1247b411b363SPhilipp Reisner 1248b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1249b411b363SPhilipp Reisner rv = FE_DESTROYED; 1250b411b363SPhilipp Reisner } else { 1251b411b363SPhilipp Reisner epoch->flags = 0; 1252b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1253698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1254b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1255b411b363SPhilipp Reisner rv = FE_RECYCLED; 1256b411b363SPhilipp Reisner } 1257b411b363SPhilipp Reisner } 1258b411b363SPhilipp Reisner 1259b411b363SPhilipp Reisner if (!next_epoch) 1260b411b363SPhilipp Reisner break; 1261b411b363SPhilipp Reisner 1262b411b363SPhilipp Reisner epoch = next_epoch; 1263b411b363SPhilipp Reisner } while (1); 1264b411b363SPhilipp Reisner 1265bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1266b411b363SPhilipp Reisner 1267b411b363SPhilipp Reisner return rv; 1268b411b363SPhilipp Reisner } 1269b411b363SPhilipp Reisner 12708fe39aacSPhilipp Reisner static enum write_ordering_e 12718fe39aacSPhilipp Reisner max_allowed_wo(struct drbd_backing_dev *bdev, enum write_ordering_e wo) 12728fe39aacSPhilipp Reisner { 12738fe39aacSPhilipp Reisner struct disk_conf *dc; 12748fe39aacSPhilipp Reisner 12758fe39aacSPhilipp Reisner dc = rcu_dereference(bdev->disk_conf); 12768fe39aacSPhilipp Reisner 12778fe39aacSPhilipp Reisner if (wo == WO_bdev_flush && !dc->disk_flushes) 12788fe39aacSPhilipp Reisner wo = WO_drain_io; 12798fe39aacSPhilipp Reisner if (wo == WO_drain_io && !dc->disk_drain) 12808fe39aacSPhilipp Reisner wo = WO_none; 12818fe39aacSPhilipp Reisner 12828fe39aacSPhilipp Reisner return wo; 12838fe39aacSPhilipp Reisner } 12848fe39aacSPhilipp Reisner 1285b411b363SPhilipp Reisner /** 1286b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1287bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1288b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1289b411b363SPhilipp Reisner */ 12908fe39aacSPhilipp Reisner void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, 12918fe39aacSPhilipp Reisner enum write_ordering_e wo) 1292b411b363SPhilipp Reisner { 1293e9526580SPhilipp Reisner struct drbd_device *device; 1294b411b363SPhilipp Reisner enum write_ordering_e pwo; 12954b0007c0SPhilipp Reisner int vnr; 1296b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1297b411b363SPhilipp Reisner [WO_none] = "none", 1298b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1299b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1300b411b363SPhilipp Reisner }; 1301b411b363SPhilipp Reisner 1302e9526580SPhilipp Reisner pwo = resource->write_ordering; 130370df7092SLars Ellenberg if (wo != WO_bdev_flush) 1304b411b363SPhilipp Reisner wo = min(pwo, wo); 1305daeda1ccSPhilipp Reisner rcu_read_lock(); 1306e9526580SPhilipp Reisner idr_for_each_entry(&resource->devices, device, vnr) { 13078fe39aacSPhilipp Reisner if (get_ldev(device)) { 13088fe39aacSPhilipp Reisner wo = max_allowed_wo(device->ldev, wo); 13098fe39aacSPhilipp Reisner if (device->ldev == bdev) 13108fe39aacSPhilipp Reisner bdev = NULL; 1311b30ab791SAndreas Gruenbacher put_ldev(device); 13124b0007c0SPhilipp Reisner } 13138fe39aacSPhilipp Reisner } 13148fe39aacSPhilipp Reisner 13158fe39aacSPhilipp Reisner if (bdev) 13168fe39aacSPhilipp Reisner wo = max_allowed_wo(bdev, wo); 13178fe39aacSPhilipp Reisner 131870df7092SLars Ellenberg rcu_read_unlock(); 131970df7092SLars Ellenberg 1320e9526580SPhilipp Reisner resource->write_ordering = wo; 1321e9526580SPhilipp Reisner if (pwo != resource->write_ordering || wo == WO_bdev_flush) 1322e9526580SPhilipp Reisner drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]); 1323b411b363SPhilipp Reisner } 1324b411b363SPhilipp Reisner 1325b411b363SPhilipp Reisner /** 1326fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1327b30ab791SAndreas Gruenbacher * @device: DRBD device. 1328db830c46SAndreas Gruenbacher * @peer_req: peer request 132945bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 133010f6d992SLars Ellenberg * 133110f6d992SLars Ellenberg * May spread the pages to multiple bios, 133210f6d992SLars Ellenberg * depending on bio_add_page restrictions. 133310f6d992SLars Ellenberg * 133410f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 133510f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 133610f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 133710f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 133810f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 133910f6d992SLars Ellenberg * on certain Xen deployments. 134045bb912bSLars Ellenberg */ 134145bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1342b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1343fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 134445bb912bSLars Ellenberg const unsigned rw, const int fault_type) 134545bb912bSLars Ellenberg { 134645bb912bSLars Ellenberg struct bio *bios = NULL; 134745bb912bSLars Ellenberg struct bio *bio; 1348db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1349db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1350db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 135145bb912bSLars Ellenberg unsigned n_bios = 0; 135245bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 135310f6d992SLars Ellenberg int err = -ENOMEM; 135445bb912bSLars Ellenberg 1355a0fb3c47SLars Ellenberg if (peer_req->flags & EE_IS_TRIM_USE_ZEROOUT) { 1356a0fb3c47SLars Ellenberg /* wait for all pending IO completions, before we start 1357a0fb3c47SLars Ellenberg * zeroing things out. */ 1358a0fb3c47SLars Ellenberg conn_wait_active_ee_empty(first_peer_device(device)->connection); 1359a0fb3c47SLars Ellenberg if (blkdev_issue_zeroout(device->ldev->backing_bdev, 1360a0fb3c47SLars Ellenberg sector, ds >> 9, GFP_NOIO)) 1361a0fb3c47SLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 1362a0fb3c47SLars Ellenberg drbd_endio_write_sec_final(peer_req); 1363a0fb3c47SLars Ellenberg return 0; 1364a0fb3c47SLars Ellenberg } 1365a0fb3c47SLars Ellenberg 136654ed4ed8SLars Ellenberg /* Discards don't have any payload. 136754ed4ed8SLars Ellenberg * But the scsi layer still expects a bio_vec it can use internally, 136854ed4ed8SLars Ellenberg * see sd_setup_discard_cmnd() and blk_add_request_payload(). */ 1369a0fb3c47SLars Ellenberg if (peer_req->flags & EE_IS_TRIM) 137054ed4ed8SLars Ellenberg nr_pages = 1; 1371a0fb3c47SLars Ellenberg 137245bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 137345bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 137445bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 13759476f39dSLars Ellenberg * request in more than one bio. 13769476f39dSLars Ellenberg * 13779476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 13789476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 13799476f39dSLars Ellenberg */ 138045bb912bSLars Ellenberg next_bio: 138145bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 138245bb912bSLars Ellenberg if (!bio) { 1383a0fb3c47SLars Ellenberg drbd_err(device, "submit_ee: Allocation of a bio failed (nr_pages=%u)\n", nr_pages); 138445bb912bSLars Ellenberg goto fail; 138545bb912bSLars Ellenberg } 1386db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 13874f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 1388b30ab791SAndreas Gruenbacher bio->bi_bdev = device->ldev->backing_bdev; 138945bb912bSLars Ellenberg bio->bi_rw = rw; 1390db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1391fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 139245bb912bSLars Ellenberg 139345bb912bSLars Ellenberg bio->bi_next = bios; 139445bb912bSLars Ellenberg bios = bio; 139545bb912bSLars Ellenberg ++n_bios; 139645bb912bSLars Ellenberg 1397a0fb3c47SLars Ellenberg if (rw & REQ_DISCARD) { 1398a0fb3c47SLars Ellenberg bio->bi_iter.bi_size = ds; 1399a0fb3c47SLars Ellenberg goto submit; 1400a0fb3c47SLars Ellenberg } 1401a0fb3c47SLars Ellenberg 140245bb912bSLars Ellenberg page_chain_for_each(page) { 140345bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 140445bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 140510f6d992SLars Ellenberg /* A single page must always be possible! 140610f6d992SLars Ellenberg * But in case it fails anyways, 140710f6d992SLars Ellenberg * we deal with it, and complain (below). */ 140810f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 1409d0180171SAndreas Gruenbacher drbd_err(device, 141010f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 141110f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 14124f024f37SKent Overstreet len, (uint64_t)bio->bi_iter.bi_sector); 141310f6d992SLars Ellenberg err = -ENOSPC; 141410f6d992SLars Ellenberg goto fail; 141510f6d992SLars Ellenberg } 141645bb912bSLars Ellenberg goto next_bio; 141745bb912bSLars Ellenberg } 141845bb912bSLars Ellenberg ds -= len; 141945bb912bSLars Ellenberg sector += len >> 9; 142045bb912bSLars Ellenberg --nr_pages; 142145bb912bSLars Ellenberg } 14220b0ba1efSAndreas Gruenbacher D_ASSERT(device, ds == 0); 1423a0fb3c47SLars Ellenberg submit: 1424a0fb3c47SLars Ellenberg D_ASSERT(device, page == NULL); 142545bb912bSLars Ellenberg 1426db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 142745bb912bSLars Ellenberg do { 142845bb912bSLars Ellenberg bio = bios; 142945bb912bSLars Ellenberg bios = bios->bi_next; 143045bb912bSLars Ellenberg bio->bi_next = NULL; 143145bb912bSLars Ellenberg 1432b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 143345bb912bSLars Ellenberg } while (bios); 143445bb912bSLars Ellenberg return 0; 143545bb912bSLars Ellenberg 143645bb912bSLars Ellenberg fail: 143745bb912bSLars Ellenberg while (bios) { 143845bb912bSLars Ellenberg bio = bios; 143945bb912bSLars Ellenberg bios = bios->bi_next; 144045bb912bSLars Ellenberg bio_put(bio); 144145bb912bSLars Ellenberg } 144210f6d992SLars Ellenberg return err; 144345bb912bSLars Ellenberg } 144445bb912bSLars Ellenberg 1445b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1446db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 144753840641SAndreas Gruenbacher { 1448db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 144953840641SAndreas Gruenbacher 1450b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 145153840641SAndreas Gruenbacher drbd_clear_interval(i); 145253840641SAndreas Gruenbacher 14536c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 145453840641SAndreas Gruenbacher if (i->waiting) 1455b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 145653840641SAndreas Gruenbacher } 145753840641SAndreas Gruenbacher 1458bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 145977fede51SPhilipp Reisner { 1460c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 146177fede51SPhilipp Reisner int vnr; 146277fede51SPhilipp Reisner 146377fede51SPhilipp Reisner rcu_read_lock(); 1464c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1465c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1466c06ece6bSAndreas Gruenbacher 1467b30ab791SAndreas Gruenbacher kref_get(&device->kref); 146877fede51SPhilipp Reisner rcu_read_unlock(); 1469b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 147005a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 147177fede51SPhilipp Reisner rcu_read_lock(); 147277fede51SPhilipp Reisner } 147377fede51SPhilipp Reisner rcu_read_unlock(); 147477fede51SPhilipp Reisner } 147577fede51SPhilipp Reisner 14769f4fe9adSAndreas Gruenbacher static struct drbd_peer_device * 14779f4fe9adSAndreas Gruenbacher conn_peer_device(struct drbd_connection *connection, int volume_number) 14789f4fe9adSAndreas Gruenbacher { 14799f4fe9adSAndreas Gruenbacher return idr_find(&connection->peer_devices, volume_number); 14809f4fe9adSAndreas Gruenbacher } 14819f4fe9adSAndreas Gruenbacher 1482bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1483b411b363SPhilipp Reisner { 14842451fc3bSPhilipp Reisner int rv; 1485e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1486b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1487b411b363SPhilipp Reisner 14889ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14899ed57dcbSLars Ellenberg * not a specific (peer)device. 14909ed57dcbSLars Ellenberg */ 1491bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1492bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1493bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1494b411b363SPhilipp Reisner 1495b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1496b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1497b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1498b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1499b411b363SPhilipp Reisner * completed. */ 1500e9526580SPhilipp Reisner switch (connection->resource->write_ordering) { 1501b411b363SPhilipp Reisner case WO_none: 1502b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 150382bc0194SAndreas Gruenbacher return 0; 1504b411b363SPhilipp Reisner 1505b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1506b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1507b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 15082451fc3bSPhilipp Reisner if (epoch) 15092451fc3bSPhilipp Reisner break; 15102451fc3bSPhilipp Reisner else 15111ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 15122451fc3bSPhilipp Reisner /* Fall through */ 15132451fc3bSPhilipp Reisner 15142451fc3bSPhilipp Reisner case WO_bdev_flush: 15152451fc3bSPhilipp Reisner case WO_drain_io: 1516bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1517bde89a9eSAndreas Gruenbacher drbd_flush(connection); 15182451fc3bSPhilipp Reisner 1519bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 15202451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 15212451fc3bSPhilipp Reisner if (epoch) 15222451fc3bSPhilipp Reisner break; 1523b411b363SPhilipp Reisner } 1524b411b363SPhilipp Reisner 152582bc0194SAndreas Gruenbacher return 0; 15262451fc3bSPhilipp Reisner default: 1527e9526580SPhilipp Reisner drbd_err(connection, "Strangeness in connection->write_ordering %d\n", 1528e9526580SPhilipp Reisner connection->resource->write_ordering); 152982bc0194SAndreas Gruenbacher return -EIO; 1530b411b363SPhilipp Reisner } 1531b411b363SPhilipp Reisner 1532b411b363SPhilipp Reisner epoch->flags = 0; 1533b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1534b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1535b411b363SPhilipp Reisner 1536bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1537bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1538bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1539bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1540bde89a9eSAndreas Gruenbacher connection->epochs++; 1541b411b363SPhilipp Reisner } else { 1542b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1543b411b363SPhilipp Reisner kfree(epoch); 1544b411b363SPhilipp Reisner } 1545bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1546b411b363SPhilipp Reisner 154782bc0194SAndreas Gruenbacher return 0; 1548b411b363SPhilipp Reisner } 1549b411b363SPhilipp Reisner 1550b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1551b411b363SPhilipp Reisner * and from receive_Data */ 1552f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 155369a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1554a0fb3c47SLars Ellenberg struct packet_info *pi) __must_hold(local) 1555b411b363SPhilipp Reisner { 155669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1557b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1558db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1559b411b363SPhilipp Reisner struct page *page; 1560a5c31904SAndreas Gruenbacher int dgs, ds, err; 1561a0fb3c47SLars Ellenberg int data_size = pi->size; 156269a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 156369a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 15646b4388acSPhilipp Reisner unsigned long *data; 1565a0fb3c47SLars Ellenberg struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; 1566b411b363SPhilipp Reisner 156788104ca4SAndreas Gruenbacher dgs = 0; 1568a0fb3c47SLars Ellenberg if (!trim && peer_device->connection->peer_integrity_tfm) { 156969a22773SAndreas Gruenbacher dgs = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 15709f5bdc33SAndreas Gruenbacher /* 15719f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15729f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15739f5bdc33SAndreas Gruenbacher */ 157469a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, dgs); 1575a5c31904SAndreas Gruenbacher if (err) 1576b411b363SPhilipp Reisner return NULL; 1577b411b363SPhilipp Reisner data_size -= dgs; 157888104ca4SAndreas Gruenbacher } 1579b411b363SPhilipp Reisner 1580a0fb3c47SLars Ellenberg if (trim) { 1581a0fb3c47SLars Ellenberg D_ASSERT(peer_device, data_size == 0); 1582a0fb3c47SLars Ellenberg data_size = be32_to_cpu(trim->size); 1583a0fb3c47SLars Ellenberg } 1584a0fb3c47SLars Ellenberg 1585841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1586841ce241SAndreas Gruenbacher return NULL; 1587a0fb3c47SLars Ellenberg /* prepare for larger trim requests. */ 1588a0fb3c47SLars Ellenberg if (!trim && !expect(data_size <= DRBD_MAX_BIO_SIZE)) 1589841ce241SAndreas Gruenbacher return NULL; 1590b411b363SPhilipp Reisner 15916666032aSLars Ellenberg /* even though we trust out peer, 15926666032aSLars Ellenberg * we sometimes have to double check. */ 15936666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1594d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1595fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15966666032aSLars Ellenberg (unsigned long long)capacity, 15976666032aSLars Ellenberg (unsigned long long)sector, data_size); 15986666032aSLars Ellenberg return NULL; 15996666032aSLars Ellenberg } 16006666032aSLars Ellenberg 1601b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1602b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1603b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1604a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, id, sector, data_size, trim == NULL, GFP_NOIO); 1605db830c46SAndreas Gruenbacher if (!peer_req) 1606b411b363SPhilipp Reisner return NULL; 160745bb912bSLars Ellenberg 1608a0fb3c47SLars Ellenberg if (trim) 160981a3537aSLars Ellenberg return peer_req; 1610a73ff323SLars Ellenberg 1611b411b363SPhilipp Reisner ds = data_size; 1612db830c46SAndreas Gruenbacher page = peer_req->pages; 161345bb912bSLars Ellenberg page_chain_for_each(page) { 161445bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 16156b4388acSPhilipp Reisner data = kmap(page); 161669a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1617b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1618d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 16196b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 16206b4388acSPhilipp Reisner } 1621b411b363SPhilipp Reisner kunmap(page); 1622a5c31904SAndreas Gruenbacher if (err) { 1623b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1624b411b363SPhilipp Reisner return NULL; 1625b411b363SPhilipp Reisner } 1626a5c31904SAndreas Gruenbacher ds -= len; 1627b411b363SPhilipp Reisner } 1628b411b363SPhilipp Reisner 1629b411b363SPhilipp Reisner if (dgs) { 163069a22773SAndreas Gruenbacher drbd_csum_ee(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv); 1631b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1632d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1633470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1634b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1635b411b363SPhilipp Reisner return NULL; 1636b411b363SPhilipp Reisner } 1637b411b363SPhilipp Reisner } 1638b30ab791SAndreas Gruenbacher device->recv_cnt += data_size>>9; 1639db830c46SAndreas Gruenbacher return peer_req; 1640b411b363SPhilipp Reisner } 1641b411b363SPhilipp Reisner 1642b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1643b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1644b411b363SPhilipp Reisner */ 164569a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1646b411b363SPhilipp Reisner { 1647b411b363SPhilipp Reisner struct page *page; 1648a5c31904SAndreas Gruenbacher int err = 0; 1649b411b363SPhilipp Reisner void *data; 1650b411b363SPhilipp Reisner 1651c3470cdeSLars Ellenberg if (!data_size) 1652fc5be839SAndreas Gruenbacher return 0; 1653c3470cdeSLars Ellenberg 165469a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1655b411b363SPhilipp Reisner 1656b411b363SPhilipp Reisner data = kmap(page); 1657b411b363SPhilipp Reisner while (data_size) { 1658fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1659fc5be839SAndreas Gruenbacher 166069a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1661a5c31904SAndreas Gruenbacher if (err) 1662b411b363SPhilipp Reisner break; 1663a5c31904SAndreas Gruenbacher data_size -= len; 1664b411b363SPhilipp Reisner } 1665b411b363SPhilipp Reisner kunmap(page); 166669a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1667fc5be839SAndreas Gruenbacher return err; 1668b411b363SPhilipp Reisner } 1669b411b363SPhilipp Reisner 167069a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1671b411b363SPhilipp Reisner sector_t sector, int data_size) 1672b411b363SPhilipp Reisner { 16737988613bSKent Overstreet struct bio_vec bvec; 16747988613bSKent Overstreet struct bvec_iter iter; 1675b411b363SPhilipp Reisner struct bio *bio; 16767988613bSKent Overstreet int dgs, err, expect; 167769a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 167869a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1679b411b363SPhilipp Reisner 168088104ca4SAndreas Gruenbacher dgs = 0; 168169a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 168269a22773SAndreas Gruenbacher dgs = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 168369a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, dgs); 1684a5c31904SAndreas Gruenbacher if (err) 1685a5c31904SAndreas Gruenbacher return err; 1686b411b363SPhilipp Reisner data_size -= dgs; 168788104ca4SAndreas Gruenbacher } 1688b411b363SPhilipp Reisner 1689b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1690b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 169169a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1692b411b363SPhilipp Reisner 1693b411b363SPhilipp Reisner bio = req->master_bio; 169469a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1695b411b363SPhilipp Reisner 16967988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 16977988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 16987988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 169969a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 17007988613bSKent Overstreet kunmap(bvec.bv_page); 1701a5c31904SAndreas Gruenbacher if (err) 1702a5c31904SAndreas Gruenbacher return err; 1703a5c31904SAndreas Gruenbacher data_size -= expect; 1704b411b363SPhilipp Reisner } 1705b411b363SPhilipp Reisner 1706b411b363SPhilipp Reisner if (dgs) { 170769a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 1708b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 170969a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 171028284cefSAndreas Gruenbacher return -EINVAL; 1711b411b363SPhilipp Reisner } 1712b411b363SPhilipp Reisner } 1713b411b363SPhilipp Reisner 171469a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 171528284cefSAndreas Gruenbacher return 0; 1716b411b363SPhilipp Reisner } 1717b411b363SPhilipp Reisner 1718a990be46SAndreas Gruenbacher /* 1719a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1720a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1721a990be46SAndreas Gruenbacher */ 172299920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1723b411b363SPhilipp Reisner { 17248050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1725a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1726a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1727a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1728db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 172999920dc5SAndreas Gruenbacher int err; 1730b411b363SPhilipp Reisner 17310b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1732b411b363SPhilipp Reisner 1733db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1734b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1735a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 1736b411b363SPhilipp Reisner } else { 1737b411b363SPhilipp Reisner /* Record failure to sync */ 1738b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 1739b411b363SPhilipp Reisner 1740a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1741b411b363SPhilipp Reisner } 1742b30ab791SAndreas Gruenbacher dec_unacked(device); 1743b411b363SPhilipp Reisner 174499920dc5SAndreas Gruenbacher return err; 1745b411b363SPhilipp Reisner } 1746b411b363SPhilipp Reisner 174769a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 1748a0fb3c47SLars Ellenberg struct packet_info *pi) __releases(local) 1749b411b363SPhilipp Reisner { 175069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1751db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1752b411b363SPhilipp Reisner 1753a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi); 1754db830c46SAndreas Gruenbacher if (!peer_req) 175545bb912bSLars Ellenberg goto fail; 1756b411b363SPhilipp Reisner 1757b30ab791SAndreas Gruenbacher dec_rs_pending(device); 1758b411b363SPhilipp Reisner 1759b30ab791SAndreas Gruenbacher inc_unacked(device); 1760b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1761b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1762b411b363SPhilipp Reisner 1763a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 176445bb912bSLars Ellenberg 17650500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1766a8cd15baSAndreas Gruenbacher list_add(&peer_req->w.list, &device->sync_ee); 17670500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1768b411b363SPhilipp Reisner 1769a0fb3c47SLars Ellenberg atomic_add(pi->size >> 9, &device->rs_sect_ev); 1770b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1771e1c1b0fcSAndreas Gruenbacher return 0; 177245bb912bSLars Ellenberg 177310f6d992SLars Ellenberg /* don't care for the reason here */ 1774d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 17750500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1776a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 17770500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 177822cc37a9SLars Ellenberg 1779b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 178045bb912bSLars Ellenberg fail: 1781b30ab791SAndreas Gruenbacher put_ldev(device); 1782e1c1b0fcSAndreas Gruenbacher return -EIO; 1783b411b363SPhilipp Reisner } 1784b411b363SPhilipp Reisner 1785668eebc6SAndreas Gruenbacher static struct drbd_request * 1786b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 1787bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1788b411b363SPhilipp Reisner { 1789b411b363SPhilipp Reisner struct drbd_request *req; 1790668eebc6SAndreas Gruenbacher 1791bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1792bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17935e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1794668eebc6SAndreas Gruenbacher return req; 1795c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1796d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 1797c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1798c3afd8f5SAndreas Gruenbacher } 1799668eebc6SAndreas Gruenbacher return NULL; 1800668eebc6SAndreas Gruenbacher } 1801668eebc6SAndreas Gruenbacher 1802bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 1803b411b363SPhilipp Reisner { 18049f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1805b30ab791SAndreas Gruenbacher struct drbd_device *device; 1806b411b363SPhilipp Reisner struct drbd_request *req; 1807b411b363SPhilipp Reisner sector_t sector; 180882bc0194SAndreas Gruenbacher int err; 1809e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 18104a76b161SAndreas Gruenbacher 18119f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 18129f4fe9adSAndreas Gruenbacher if (!peer_device) 18134a76b161SAndreas Gruenbacher return -EIO; 18149f4fe9adSAndreas Gruenbacher device = peer_device->device; 1815b411b363SPhilipp Reisner 1816b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1817b411b363SPhilipp Reisner 18180500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1819b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 18200500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1821c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 182282bc0194SAndreas Gruenbacher return -EIO; 1823b411b363SPhilipp Reisner 182424c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1825b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1826b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 182769a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 182882bc0194SAndreas Gruenbacher if (!err) 18298554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1830b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1831b411b363SPhilipp Reisner * I don't think we may complete this just yet 1832b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1833b411b363SPhilipp Reisner 183482bc0194SAndreas Gruenbacher return err; 1835b411b363SPhilipp Reisner } 1836b411b363SPhilipp Reisner 1837bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 1838b411b363SPhilipp Reisner { 18399f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1840b30ab791SAndreas Gruenbacher struct drbd_device *device; 1841b411b363SPhilipp Reisner sector_t sector; 184282bc0194SAndreas Gruenbacher int err; 1843e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 18444a76b161SAndreas Gruenbacher 18459f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 18469f4fe9adSAndreas Gruenbacher if (!peer_device) 18474a76b161SAndreas Gruenbacher return -EIO; 18489f4fe9adSAndreas Gruenbacher device = peer_device->device; 1849b411b363SPhilipp Reisner 1850b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 18510b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 1852b411b363SPhilipp Reisner 1853b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 1854b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1855b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1856fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1857a0fb3c47SLars Ellenberg err = recv_resync_read(peer_device, sector, pi); 1858b411b363SPhilipp Reisner } else { 1859b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1860d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 1861b411b363SPhilipp Reisner 186269a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 1863b411b363SPhilipp Reisner 186469a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 1865b411b363SPhilipp Reisner } 1866b411b363SPhilipp Reisner 1867b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 1868778f271dSPhilipp Reisner 186982bc0194SAndreas Gruenbacher return err; 1870b411b363SPhilipp Reisner } 1871b411b363SPhilipp Reisner 1872b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 18737be8da07SAndreas Gruenbacher sector_t sector, int size) 1874b411b363SPhilipp Reisner { 18757be8da07SAndreas Gruenbacher struct drbd_interval *i; 18767be8da07SAndreas Gruenbacher struct drbd_request *req; 1877b411b363SPhilipp Reisner 1878b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 18797be8da07SAndreas Gruenbacher if (!i->local) 18807be8da07SAndreas Gruenbacher continue; 18817be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18827be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18837be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18847be8da07SAndreas Gruenbacher continue; 18852312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18862312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1887d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 18887be8da07SAndreas Gruenbacher } 18897be8da07SAndreas Gruenbacher } 18907be8da07SAndreas Gruenbacher 1891a990be46SAndreas Gruenbacher /* 1892a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1893b411b363SPhilipp Reisner */ 189499920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1895b411b363SPhilipp Reisner { 18968050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1897a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1898a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1899a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1900db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 190199920dc5SAndreas Gruenbacher int err = 0, pcmd; 1902b411b363SPhilipp Reisner 1903303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1904db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1905b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 1906b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 1907db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1908b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1909a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 1910b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1911b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1912b411b363SPhilipp Reisner } else { 1913a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1914b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1915b411b363SPhilipp Reisner * maybe assert this? */ 1916b411b363SPhilipp Reisner } 1917b30ab791SAndreas Gruenbacher dec_unacked(device); 1918b411b363SPhilipp Reisner } 1919b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1920b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1921302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 19220500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 19230b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 1924b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 19257be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 1926b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 19270500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1928bb3bfe96SAndreas Gruenbacher } else 19290b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1930b411b363SPhilipp Reisner 1931a6b32bc3SAndreas Gruenbacher drbd_may_finish_epoch(first_peer_device(device)->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1932b411b363SPhilipp Reisner 193399920dc5SAndreas Gruenbacher return err; 1934b411b363SPhilipp Reisner } 1935b411b363SPhilipp Reisner 1936a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1937b411b363SPhilipp Reisner { 19388050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1939a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1940a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 194199920dc5SAndreas Gruenbacher int err; 1942b411b363SPhilipp Reisner 1943a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 1944a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 1945b411b363SPhilipp Reisner 194699920dc5SAndreas Gruenbacher return err; 1947b411b363SPhilipp Reisner } 1948b411b363SPhilipp Reisner 1949d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 1950b6a370baSPhilipp Reisner { 1951a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 19527be8da07SAndreas Gruenbacher } 1953b6a370baSPhilipp Reisner 195499920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 19557be8da07SAndreas Gruenbacher { 1956a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 1957a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1958a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 19597be8da07SAndreas Gruenbacher 1960a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 1961d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 19627be8da07SAndreas Gruenbacher } 19637be8da07SAndreas Gruenbacher 19643e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 19653e394da1SAndreas Gruenbacher { 19663e394da1SAndreas Gruenbacher /* 19673e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 19683e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 19693e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 19703e394da1SAndreas Gruenbacher */ 19713e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 19723e394da1SAndreas Gruenbacher } 19733e394da1SAndreas Gruenbacher 19743e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 19753e394da1SAndreas Gruenbacher { 19763e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 19773e394da1SAndreas Gruenbacher } 19783e394da1SAndreas Gruenbacher 197969a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 19803e394da1SAndreas Gruenbacher { 198169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 19823c13b680SLars Ellenberg unsigned int newest_peer_seq; 19833e394da1SAndreas Gruenbacher 198469a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 1985b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 1986b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 1987b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 1988b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 1989b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 19903c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 1991b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 19923e394da1SAndreas Gruenbacher } 19937be8da07SAndreas Gruenbacher } 19943e394da1SAndreas Gruenbacher 1995d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1996d93f6302SLars Ellenberg { 1997d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1998d93f6302SLars Ellenberg } 1999d93f6302SLars Ellenberg 2000d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 2001b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 2002d93f6302SLars Ellenberg { 2003d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 2004b6a370baSPhilipp Reisner bool rv = 0; 2005b6a370baSPhilipp Reisner 20060500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2007a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 2008d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 2009d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 2010b6a370baSPhilipp Reisner rv = 1; 2011b6a370baSPhilipp Reisner break; 2012b6a370baSPhilipp Reisner } 2013b6a370baSPhilipp Reisner } 20140500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2015b6a370baSPhilipp Reisner 2016b6a370baSPhilipp Reisner return rv; 2017b6a370baSPhilipp Reisner } 2018b6a370baSPhilipp Reisner 2019b411b363SPhilipp Reisner /* Called from receive_Data. 2020b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 2021b411b363SPhilipp Reisner * 2022b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 2023b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 2024b411b363SPhilipp Reisner * been sent. 2025b411b363SPhilipp Reisner * 2026b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 2027b411b363SPhilipp Reisner * 2028b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 2029b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 2030b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 2031b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 2032b411b363SPhilipp Reisner * 2033b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 2034b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 2035b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 2036b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 2037b411b363SPhilipp Reisner * 2038b411b363SPhilipp Reisner * returns 0 if we may process the packet, 2039b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 204069a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 2041b411b363SPhilipp Reisner { 204269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2043b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2044b411b363SPhilipp Reisner long timeout; 2045b874d231SPhilipp Reisner int ret = 0, tp; 20467be8da07SAndreas Gruenbacher 204769a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 20487be8da07SAndreas Gruenbacher return 0; 20497be8da07SAndreas Gruenbacher 2050b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2051b411b363SPhilipp Reisner for (;;) { 2052b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 2053b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 2054b411b363SPhilipp Reisner break; 20557be8da07SAndreas Gruenbacher } 2056b874d231SPhilipp Reisner 2057b411b363SPhilipp Reisner if (signal_pending(current)) { 2058b411b363SPhilipp Reisner ret = -ERESTARTSYS; 2059b411b363SPhilipp Reisner break; 2060b411b363SPhilipp Reisner } 2061b874d231SPhilipp Reisner 2062b874d231SPhilipp Reisner rcu_read_lock(); 2063a6b32bc3SAndreas Gruenbacher tp = rcu_dereference(first_peer_device(device)->connection->net_conf)->two_primaries; 2064b874d231SPhilipp Reisner rcu_read_unlock(); 2065b874d231SPhilipp Reisner 2066b874d231SPhilipp Reisner if (!tp) 2067b874d231SPhilipp Reisner break; 2068b874d231SPhilipp Reisner 2069b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2070b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2071b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 207244ed167dSPhilipp Reisner rcu_read_lock(); 207369a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 207444ed167dSPhilipp Reisner rcu_read_unlock(); 207571b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2076b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 20777be8da07SAndreas Gruenbacher if (!timeout) { 2078b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2079d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2080b411b363SPhilipp Reisner break; 2081b411b363SPhilipp Reisner } 2082b411b363SPhilipp Reisner } 2083b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2084b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2085b411b363SPhilipp Reisner return ret; 2086b411b363SPhilipp Reisner } 2087b411b363SPhilipp Reisner 2088688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2089688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2090688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 209181f0ffd2SAndreas Gruenbacher static unsigned long wire_flags_to_bio(u32 dpf) 209276d2e7ecSPhilipp Reisner { 209376d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 209476d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2095688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 209676d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 209776d2e7ecSPhilipp Reisner } 209876d2e7ecSPhilipp Reisner 2099b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 21007be8da07SAndreas Gruenbacher unsigned int size) 2101b411b363SPhilipp Reisner { 21027be8da07SAndreas Gruenbacher struct drbd_interval *i; 21037be8da07SAndreas Gruenbacher 21047be8da07SAndreas Gruenbacher repeat: 2105b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21067be8da07SAndreas Gruenbacher struct drbd_request *req; 21077be8da07SAndreas Gruenbacher struct bio_and_error m; 21087be8da07SAndreas Gruenbacher 21097be8da07SAndreas Gruenbacher if (!i->local) 21107be8da07SAndreas Gruenbacher continue; 21117be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 21127be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 21137be8da07SAndreas Gruenbacher continue; 21147be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 21157be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 21160500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 21177be8da07SAndreas Gruenbacher if (m.bio) 2118b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 21190500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 21207be8da07SAndreas Gruenbacher goto repeat; 21217be8da07SAndreas Gruenbacher } 21227be8da07SAndreas Gruenbacher } 21237be8da07SAndreas Gruenbacher 2124b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 21257be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 21267be8da07SAndreas Gruenbacher { 2127e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2128bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 21297be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 21307be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 21317be8da07SAndreas Gruenbacher struct drbd_interval *i; 21327be8da07SAndreas Gruenbacher bool equal; 21337be8da07SAndreas Gruenbacher int err; 21347be8da07SAndreas Gruenbacher 21357be8da07SAndreas Gruenbacher /* 21367be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 21377be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 21387be8da07SAndreas Gruenbacher */ 2139b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 21407be8da07SAndreas Gruenbacher 21417be8da07SAndreas Gruenbacher repeat: 2142b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21437be8da07SAndreas Gruenbacher if (i == &peer_req->i) 21447be8da07SAndreas Gruenbacher continue; 21457be8da07SAndreas Gruenbacher 21467be8da07SAndreas Gruenbacher if (!i->local) { 21477be8da07SAndreas Gruenbacher /* 21487be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 21497be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 21507be8da07SAndreas Gruenbacher * earlier peer request to complete. 21517be8da07SAndreas Gruenbacher */ 2152b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 21537be8da07SAndreas Gruenbacher if (err) 21547be8da07SAndreas Gruenbacher goto out; 21557be8da07SAndreas Gruenbacher goto repeat; 21567be8da07SAndreas Gruenbacher } 21577be8da07SAndreas Gruenbacher 21587be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 21597be8da07SAndreas Gruenbacher if (resolve_conflicts) { 21607be8da07SAndreas Gruenbacher /* 21617be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2162d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2163d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2164d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 21657be8da07SAndreas Gruenbacher */ 2166d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 21677be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 21687be8da07SAndreas Gruenbacher 21697be8da07SAndreas Gruenbacher if (!equal) 2170d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21717be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 21727be8da07SAndreas Gruenbacher "assuming %s came first\n", 21737be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21747be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2175d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 21767be8da07SAndreas Gruenbacher 2177b30ab791SAndreas Gruenbacher inc_unacked(device); 2178a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 21797be8da07SAndreas Gruenbacher e_send_retry_write; 2180a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2181e33b32deSAndreas Gruenbacher wake_asender(connection); 21827be8da07SAndreas Gruenbacher 21837be8da07SAndreas Gruenbacher err = -ENOENT; 21847be8da07SAndreas Gruenbacher goto out; 21857be8da07SAndreas Gruenbacher } else { 21867be8da07SAndreas Gruenbacher struct drbd_request *req = 21877be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21887be8da07SAndreas Gruenbacher 21897be8da07SAndreas Gruenbacher if (!equal) 2190d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21917be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21927be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21937be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21947be8da07SAndreas Gruenbacher 21957be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21967be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21977be8da07SAndreas Gruenbacher /* 21987be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2199d4dabbe2SLars Ellenberg * decide if this request has been superseded 2200d4dabbe2SLars Ellenberg * or needs to be retried. 2201d4dabbe2SLars Ellenberg * Requests that have been superseded will 22027be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 22037be8da07SAndreas Gruenbacher * 22047be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 22057be8da07SAndreas Gruenbacher * request to finish locally before submitting 22067be8da07SAndreas Gruenbacher * the conflicting peer request. 22077be8da07SAndreas Gruenbacher */ 2208b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 22097be8da07SAndreas Gruenbacher if (err) { 2210e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2211b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 22127be8da07SAndreas Gruenbacher goto out; 22137be8da07SAndreas Gruenbacher } 22147be8da07SAndreas Gruenbacher goto repeat; 22157be8da07SAndreas Gruenbacher } 22167be8da07SAndreas Gruenbacher /* 22177be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 22187be8da07SAndreas Gruenbacher * the new peer request has completed. 22197be8da07SAndreas Gruenbacher */ 22207be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 22217be8da07SAndreas Gruenbacher } 22227be8da07SAndreas Gruenbacher } 22237be8da07SAndreas Gruenbacher err = 0; 22247be8da07SAndreas Gruenbacher 22257be8da07SAndreas Gruenbacher out: 22267be8da07SAndreas Gruenbacher if (err) 2227b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 22287be8da07SAndreas Gruenbacher return err; 22297be8da07SAndreas Gruenbacher } 22307be8da07SAndreas Gruenbacher 2231b411b363SPhilipp Reisner /* mirrored write */ 2232bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2233b411b363SPhilipp Reisner { 22349f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2235b30ab791SAndreas Gruenbacher struct drbd_device *device; 2236b411b363SPhilipp Reisner sector_t sector; 2237db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2238e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 22397be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2240b411b363SPhilipp Reisner int rw = WRITE; 2241b411b363SPhilipp Reisner u32 dp_flags; 2242302bdeaeSPhilipp Reisner int err, tp; 22437be8da07SAndreas Gruenbacher 22449f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 22459f4fe9adSAndreas Gruenbacher if (!peer_device) 22464a76b161SAndreas Gruenbacher return -EIO; 22479f4fe9adSAndreas Gruenbacher device = peer_device->device; 2248b411b363SPhilipp Reisner 2249b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 225082bc0194SAndreas Gruenbacher int err2; 2251b411b363SPhilipp Reisner 225269a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 225369a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2254bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 225569a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 225682bc0194SAndreas Gruenbacher if (!err) 225782bc0194SAndreas Gruenbacher err = err2; 225882bc0194SAndreas Gruenbacher return err; 2259b411b363SPhilipp Reisner } 2260b411b363SPhilipp Reisner 2261fcefa62eSAndreas Gruenbacher /* 2262fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2263fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2264fcefa62eSAndreas Gruenbacher * end of this function. 2265fcefa62eSAndreas Gruenbacher */ 2266b411b363SPhilipp Reisner 2267b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2268a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, p->block_id, sector, pi); 2269db830c46SAndreas Gruenbacher if (!peer_req) { 2270b30ab791SAndreas Gruenbacher put_ldev(device); 227182bc0194SAndreas Gruenbacher return -EIO; 2272b411b363SPhilipp Reisner } 2273b411b363SPhilipp Reisner 2274a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 2275b411b363SPhilipp Reisner 2276688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 227781f0ffd2SAndreas Gruenbacher rw |= wire_flags_to_bio(dp_flags); 2278a0fb3c47SLars Ellenberg if (pi->cmd == P_TRIM) { 2279a0fb3c47SLars Ellenberg struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); 2280a0fb3c47SLars Ellenberg peer_req->flags |= EE_IS_TRIM; 2281a0fb3c47SLars Ellenberg if (!blk_queue_discard(q)) 2282a0fb3c47SLars Ellenberg peer_req->flags |= EE_IS_TRIM_USE_ZEROOUT; 2283a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->i.size > 0); 2284a0fb3c47SLars Ellenberg D_ASSERT(peer_device, rw & REQ_DISCARD); 2285a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->pages == NULL); 2286a0fb3c47SLars Ellenberg } else if (peer_req->pages == NULL) { 22870b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 22880b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2289a73ff323SLars Ellenberg } 2290688593c5SLars Ellenberg 2291688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2292db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2293688593c5SLars Ellenberg 2294bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2295bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2296db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2297db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2298bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2299b411b363SPhilipp Reisner 2300302bdeaeSPhilipp Reisner rcu_read_lock(); 23019f4fe9adSAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2302302bdeaeSPhilipp Reisner rcu_read_unlock(); 2303302bdeaeSPhilipp Reisner if (tp) { 2304302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 230569a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 23067be8da07SAndreas Gruenbacher if (err) 2307b411b363SPhilipp Reisner goto out_interrupted; 23080500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2309b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 23107be8da07SAndreas Gruenbacher if (err) { 23110500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 23127be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2313b30ab791SAndreas Gruenbacher put_ldev(device); 231482bc0194SAndreas Gruenbacher return 0; 2315b411b363SPhilipp Reisner } 2316b411b363SPhilipp Reisner goto out_interrupted; 2317b411b363SPhilipp Reisner } 2318b874d231SPhilipp Reisner } else { 231969a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 23200500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2321b874d231SPhilipp Reisner } 2322a0fb3c47SLars Ellenberg /* if we use the zeroout fallback code, we process synchronously 2323a0fb3c47SLars Ellenberg * and we wait for all pending requests, respectively wait for 2324a0fb3c47SLars Ellenberg * active_ee to become empty in drbd_submit_peer_request(); 2325a0fb3c47SLars Ellenberg * better not add ourselves here. */ 2326a0fb3c47SLars Ellenberg if ((peer_req->flags & EE_IS_TRIM_USE_ZEROOUT) == 0) 2327a8cd15baSAndreas Gruenbacher list_add(&peer_req->w.list, &device->active_ee); 23280500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2329b411b363SPhilipp Reisner 2330b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2331b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2332b6a370baSPhilipp Reisner 23339f4fe9adSAndreas Gruenbacher if (peer_device->connection->agreed_pro_version < 100) { 233444ed167dSPhilipp Reisner rcu_read_lock(); 23359f4fe9adSAndreas Gruenbacher switch (rcu_dereference(peer_device->connection->net_conf)->wire_protocol) { 2336b411b363SPhilipp Reisner case DRBD_PROT_C: 2337303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2338303d1448SPhilipp Reisner break; 2339303d1448SPhilipp Reisner case DRBD_PROT_B: 2340303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2341303d1448SPhilipp Reisner break; 2342303d1448SPhilipp Reisner } 234344ed167dSPhilipp Reisner rcu_read_unlock(); 2344303d1448SPhilipp Reisner } 2345303d1448SPhilipp Reisner 2346303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2347303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2348b30ab791SAndreas Gruenbacher inc_unacked(device); 2349b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2350b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2351303d1448SPhilipp Reisner } 2352303d1448SPhilipp Reisner 2353303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2354b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2355b411b363SPhilipp Reisner * sends on the msock, but anyways */ 235669a22773SAndreas Gruenbacher drbd_send_ack(first_peer_device(device), P_RECV_ACK, peer_req); 2357b411b363SPhilipp Reisner } 2358b411b363SPhilipp Reisner 2359b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2360b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2361b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2362db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2363db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 23644dd726f0SLars Ellenberg drbd_al_begin_io(device, &peer_req->i); 2365b411b363SPhilipp Reisner } 2366b411b363SPhilipp Reisner 2367b30ab791SAndreas Gruenbacher err = drbd_submit_peer_request(device, peer_req, rw, DRBD_FAULT_DT_WR); 236882bc0194SAndreas Gruenbacher if (!err) 236982bc0194SAndreas Gruenbacher return 0; 2370b411b363SPhilipp Reisner 237110f6d992SLars Ellenberg /* don't care for the reason here */ 2372d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 23730500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2374a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2375b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 23760500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2377db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2378b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 237922cc37a9SLars Ellenberg 2380b411b363SPhilipp Reisner out_interrupted: 2381bde89a9eSAndreas Gruenbacher drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT + EV_CLEANUP); 2382b30ab791SAndreas Gruenbacher put_ldev(device); 2383b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 238482bc0194SAndreas Gruenbacher return err; 2385b411b363SPhilipp Reisner } 2386b411b363SPhilipp Reisner 23870f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 23880f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 23890f0601f4SLars Ellenberg * 23900f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 23910f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 23920f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 23930f0601f4SLars Ellenberg * activity, it obviously is "busy". 23940f0601f4SLars Ellenberg * 23950f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 23960f0601f4SLars Ellenberg * to have a short time average so we can react faster. 23970f0601f4SLars Ellenberg */ 2398e8299874SLars Ellenberg bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector) 2399e8299874SLars Ellenberg { 2400e8299874SLars Ellenberg struct lc_element *tmp; 2401e8299874SLars Ellenberg bool throttle = true; 2402e8299874SLars Ellenberg 2403e8299874SLars Ellenberg if (!drbd_rs_c_min_rate_throttle(device)) 2404e8299874SLars Ellenberg return false; 2405e8299874SLars Ellenberg 2406e8299874SLars Ellenberg spin_lock_irq(&device->al_lock); 2407e8299874SLars Ellenberg tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2408e8299874SLars Ellenberg if (tmp) { 2409e8299874SLars Ellenberg struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2410e8299874SLars Ellenberg if (test_bit(BME_PRIORITY, &bm_ext->flags)) 2411e8299874SLars Ellenberg throttle = false; 2412e8299874SLars Ellenberg /* Do not slow down if app IO is already waiting for this extent */ 2413e8299874SLars Ellenberg } 2414e8299874SLars Ellenberg spin_unlock_irq(&device->al_lock); 2415e8299874SLars Ellenberg 2416e8299874SLars Ellenberg return throttle; 2417e8299874SLars Ellenberg } 2418e8299874SLars Ellenberg 2419e8299874SLars Ellenberg bool drbd_rs_c_min_rate_throttle(struct drbd_device *device) 24200f0601f4SLars Ellenberg { 2421b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 24220f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2423daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2424e8299874SLars Ellenberg int curr_events; 2425daeda1ccSPhilipp Reisner 2426daeda1ccSPhilipp Reisner rcu_read_lock(); 2427b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2428daeda1ccSPhilipp Reisner rcu_read_unlock(); 24290f0601f4SLars Ellenberg 24300f0601f4SLars Ellenberg /* feature disabled? */ 2431daeda1ccSPhilipp Reisner if (c_min_rate == 0) 2432e8299874SLars Ellenberg return false; 2433e3555d85SPhilipp Reisner 24340f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 24350f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2436b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2437b30ab791SAndreas Gruenbacher if (!device->rs_last_events || curr_events - device->rs_last_events > 64) { 24380f0601f4SLars Ellenberg unsigned long rs_left; 24390f0601f4SLars Ellenberg int i; 24400f0601f4SLars Ellenberg 2441b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 24420f0601f4SLars Ellenberg 24430f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 24440f0601f4SLars Ellenberg * approx. */ 2445b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 24462649f080SLars Ellenberg 2447b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2448b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 24492649f080SLars Ellenberg else 2450b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 24510f0601f4SLars Ellenberg 2452b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 24530f0601f4SLars Ellenberg if (!dt) 24540f0601f4SLars Ellenberg dt++; 2455b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 24560f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 24570f0601f4SLars Ellenberg 2458daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 2459e8299874SLars Ellenberg return true; 24600f0601f4SLars Ellenberg } 2461e8299874SLars Ellenberg return false; 24620f0601f4SLars Ellenberg } 24630f0601f4SLars Ellenberg 2464bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2465b411b363SPhilipp Reisner { 24669f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2467b30ab791SAndreas Gruenbacher struct drbd_device *device; 2468b411b363SPhilipp Reisner sector_t sector; 24694a76b161SAndreas Gruenbacher sector_t capacity; 2470db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2471b411b363SPhilipp Reisner struct digest_info *di = NULL; 2472b18b37beSPhilipp Reisner int size, verb; 2473b411b363SPhilipp Reisner unsigned int fault_type; 2474e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 24754a76b161SAndreas Gruenbacher 24769f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 24779f4fe9adSAndreas Gruenbacher if (!peer_device) 24784a76b161SAndreas Gruenbacher return -EIO; 24799f4fe9adSAndreas Gruenbacher device = peer_device->device; 2480b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2481b411b363SPhilipp Reisner 2482b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2483b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2484b411b363SPhilipp Reisner 2485c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2486d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2487b411b363SPhilipp Reisner (unsigned long long)sector, size); 248882bc0194SAndreas Gruenbacher return -EINVAL; 2489b411b363SPhilipp Reisner } 2490b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2491d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2492b411b363SPhilipp Reisner (unsigned long long)sector, size); 249382bc0194SAndreas Gruenbacher return -EINVAL; 2494b411b363SPhilipp Reisner } 2495b411b363SPhilipp Reisner 2496b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2497b18b37beSPhilipp Reisner verb = 1; 2498e2857216SAndreas Gruenbacher switch (pi->cmd) { 2499b18b37beSPhilipp Reisner case P_DATA_REQUEST: 250069a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2501b18b37beSPhilipp Reisner break; 2502b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2503b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2504b18b37beSPhilipp Reisner case P_OV_REQUEST: 250569a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2506b18b37beSPhilipp Reisner break; 2507b18b37beSPhilipp Reisner case P_OV_REPLY: 2508b18b37beSPhilipp Reisner verb = 0; 2509b30ab791SAndreas Gruenbacher dec_rs_pending(device); 251069a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2511b18b37beSPhilipp Reisner break; 2512b18b37beSPhilipp Reisner default: 251349ba9b1bSAndreas Gruenbacher BUG(); 2514b18b37beSPhilipp Reisner } 2515b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2516d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2517b411b363SPhilipp Reisner "no local data.\n"); 2518b18b37beSPhilipp Reisner 2519a821cc4aSLars Ellenberg /* drain possibly payload */ 252069a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2521b411b363SPhilipp Reisner } 2522b411b363SPhilipp Reisner 2523b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2524b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2525b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2526a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, 2527a0fb3c47SLars Ellenberg true /* has real payload */, GFP_NOIO); 2528db830c46SAndreas Gruenbacher if (!peer_req) { 2529b30ab791SAndreas Gruenbacher put_ldev(device); 253082bc0194SAndreas Gruenbacher return -ENOMEM; 2531b411b363SPhilipp Reisner } 2532b411b363SPhilipp Reisner 2533e2857216SAndreas Gruenbacher switch (pi->cmd) { 2534b411b363SPhilipp Reisner case P_DATA_REQUEST: 2535a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2536b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 253780a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 253880a40e43SLars Ellenberg goto submit; 253980a40e43SLars Ellenberg 2540b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2541a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2542b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 25435f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2544b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2545b411b363SPhilipp Reisner break; 2546b411b363SPhilipp Reisner 2547b411b363SPhilipp Reisner case P_OV_REPLY: 2548b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2549b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2550e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2551b411b363SPhilipp Reisner if (!di) 2552b411b363SPhilipp Reisner goto out_free_e; 2553b411b363SPhilipp Reisner 2554e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2555b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2556b411b363SPhilipp Reisner 2557db830c46SAndreas Gruenbacher peer_req->digest = di; 2558db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2559c36c3cedSLars Ellenberg 25609f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2561b411b363SPhilipp Reisner goto out_free_e; 2562b411b363SPhilipp Reisner 2563e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 25649f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2565a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 25665f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2567b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2568aaaba345SLars Ellenberg /* remember to report stats in drbd_resync_finished */ 2569aaaba345SLars Ellenberg device->use_csums = true; 2570e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 25712649f080SLars Ellenberg /* track progress, we may need to throttle */ 2572b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2573a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2574b30ab791SAndreas Gruenbacher dec_rs_pending(device); 25750f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 25760f0601f4SLars Ellenberg * but accounting still needs to be done. */ 25770f0601f4SLars Ellenberg goto submit_for_resync; 2578b411b363SPhilipp Reisner } 2579b411b363SPhilipp Reisner break; 2580b411b363SPhilipp Reisner 2581b411b363SPhilipp Reisner case P_OV_REQUEST: 2582b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 25839f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2584de228bbaSLars Ellenberg unsigned long now = jiffies; 2585de228bbaSLars Ellenberg int i; 2586b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2587b30ab791SAndreas Gruenbacher device->ov_position = sector; 2588b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2589b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2590de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2591b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2592b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2593de228bbaSLars Ellenberg } 2594d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2595b411b363SPhilipp Reisner (unsigned long long)sector); 2596b411b363SPhilipp Reisner } 2597a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2598b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2599b411b363SPhilipp Reisner break; 2600b411b363SPhilipp Reisner 2601b411b363SPhilipp Reisner default: 260249ba9b1bSAndreas Gruenbacher BUG(); 2603b411b363SPhilipp Reisner } 2604b411b363SPhilipp Reisner 26050f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 26060f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 26070f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 26080f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 26090f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 26100f0601f4SLars Ellenberg * 26110f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 26120f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 26130f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 26140f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 26150f0601f4SLars Ellenberg * a while, anyways. 26160f0601f4SLars Ellenberg */ 2617b411b363SPhilipp Reisner 26180f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 26190f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 26200f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 26210f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 26220f0601f4SLars Ellenberg * 26230f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 26240f0601f4SLars Ellenberg * we would also throttle its application reads. 26250f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 26260f0601f4SLars Ellenberg */ 2627b30ab791SAndreas Gruenbacher if (device->state.peer != R_PRIMARY && drbd_rs_should_slow_down(device, sector)) 2628e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2629b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 263080a40e43SLars Ellenberg goto out_free_e; 2631b411b363SPhilipp Reisner 26320f0601f4SLars Ellenberg submit_for_resync: 2633b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 26340f0601f4SLars Ellenberg 263580a40e43SLars Ellenberg submit: 2636b30ab791SAndreas Gruenbacher inc_unacked(device); 26370500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2638a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->read_ee); 26390500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2640b411b363SPhilipp Reisner 2641b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, READ, fault_type) == 0) 264282bc0194SAndreas Gruenbacher return 0; 2643b411b363SPhilipp Reisner 264410f6d992SLars Ellenberg /* don't care for the reason here */ 2645d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 26460500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2647a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 26480500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 264922cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 265022cc37a9SLars Ellenberg 2651b411b363SPhilipp Reisner out_free_e: 2652b30ab791SAndreas Gruenbacher put_ldev(device); 2653b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 265482bc0194SAndreas Gruenbacher return -EIO; 2655b411b363SPhilipp Reisner } 2656b411b363SPhilipp Reisner 265769a22773SAndreas Gruenbacher /** 265869a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 265969a22773SAndreas Gruenbacher */ 266069a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2661b411b363SPhilipp Reisner { 266269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2663b411b363SPhilipp Reisner int self, peer, rv = -100; 2664b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 266544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2666b411b363SPhilipp Reisner 2667b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2668b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2669b411b363SPhilipp Reisner 2670b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2671b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2672b411b363SPhilipp Reisner 267344ed167dSPhilipp Reisner rcu_read_lock(); 267469a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 267544ed167dSPhilipp Reisner rcu_read_unlock(); 267644ed167dSPhilipp Reisner switch (after_sb_0p) { 2677b411b363SPhilipp Reisner case ASB_CONSENSUS: 2678b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2679b411b363SPhilipp Reisner case ASB_CALL_HELPER: 268044ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2681d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2682b411b363SPhilipp Reisner break; 2683b411b363SPhilipp Reisner case ASB_DISCONNECT: 2684b411b363SPhilipp Reisner break; 2685b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2686b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2687b411b363SPhilipp Reisner rv = -1; 2688b411b363SPhilipp Reisner break; 2689b411b363SPhilipp Reisner } 2690b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2691b411b363SPhilipp Reisner rv = 1; 2692b411b363SPhilipp Reisner break; 2693b411b363SPhilipp Reisner } 2694b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2695b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2696b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2697b411b363SPhilipp Reisner rv = 1; 2698b411b363SPhilipp Reisner break; 2699b411b363SPhilipp Reisner } 2700b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2701b411b363SPhilipp Reisner rv = -1; 2702b411b363SPhilipp Reisner break; 2703b411b363SPhilipp Reisner } 2704b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2705d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 2706b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2707b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2708b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 270969a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2710b411b363SPhilipp Reisner ? -1 : 1; 2711b411b363SPhilipp Reisner break; 2712b411b363SPhilipp Reisner } else { 2713b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2714b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2715b411b363SPhilipp Reisner } 271644ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2717b411b363SPhilipp Reisner break; 2718b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2719b411b363SPhilipp Reisner if (ch_self < ch_peer) 2720b411b363SPhilipp Reisner rv = -1; 2721b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2722b411b363SPhilipp Reisner rv = 1; 2723b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2724b411b363SPhilipp Reisner /* Well, then use something else. */ 272569a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2726b411b363SPhilipp Reisner ? -1 : 1; 2727b411b363SPhilipp Reisner break; 2728b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2729b411b363SPhilipp Reisner rv = -1; 2730b411b363SPhilipp Reisner break; 2731b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2732b411b363SPhilipp Reisner rv = 1; 2733b411b363SPhilipp Reisner } 2734b411b363SPhilipp Reisner 2735b411b363SPhilipp Reisner return rv; 2736b411b363SPhilipp Reisner } 2737b411b363SPhilipp Reisner 273869a22773SAndreas Gruenbacher /** 273969a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 274069a22773SAndreas Gruenbacher */ 274169a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 2742b411b363SPhilipp Reisner { 274369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 27446184ea21SAndreas Gruenbacher int hg, rv = -100; 274544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2746b411b363SPhilipp Reisner 274744ed167dSPhilipp Reisner rcu_read_lock(); 274869a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 274944ed167dSPhilipp Reisner rcu_read_unlock(); 275044ed167dSPhilipp Reisner switch (after_sb_1p) { 2751b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2752b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2753b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2754b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2755b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 275644ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2757d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2758b411b363SPhilipp Reisner break; 2759b411b363SPhilipp Reisner case ASB_DISCONNECT: 2760b411b363SPhilipp Reisner break; 2761b411b363SPhilipp Reisner case ASB_CONSENSUS: 276269a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2763b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 2764b411b363SPhilipp Reisner rv = hg; 2765b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 2766b411b363SPhilipp Reisner rv = hg; 2767b411b363SPhilipp Reisner break; 2768b411b363SPhilipp Reisner case ASB_VIOLENTLY: 276969a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2770b411b363SPhilipp Reisner break; 2771b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2772b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 2773b411b363SPhilipp Reisner case ASB_CALL_HELPER: 277469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2775b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 2776bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2777bb437946SAndreas Gruenbacher 2778b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2779b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2780b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2781b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2782bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2783b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2784b411b363SPhilipp Reisner } else { 2785d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2786b411b363SPhilipp Reisner rv = hg; 2787b411b363SPhilipp Reisner } 2788b411b363SPhilipp Reisner } else 2789b411b363SPhilipp Reisner rv = hg; 2790b411b363SPhilipp Reisner } 2791b411b363SPhilipp Reisner 2792b411b363SPhilipp Reisner return rv; 2793b411b363SPhilipp Reisner } 2794b411b363SPhilipp Reisner 279569a22773SAndreas Gruenbacher /** 279669a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 279769a22773SAndreas Gruenbacher */ 279869a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 2799b411b363SPhilipp Reisner { 280069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 28016184ea21SAndreas Gruenbacher int hg, rv = -100; 280244ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2803b411b363SPhilipp Reisner 280444ed167dSPhilipp Reisner rcu_read_lock(); 280569a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 280644ed167dSPhilipp Reisner rcu_read_unlock(); 280744ed167dSPhilipp Reisner switch (after_sb_2p) { 2808b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2809b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2810b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2811b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2812b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2813b411b363SPhilipp Reisner case ASB_CONSENSUS: 2814b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 281544ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2816d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2817b411b363SPhilipp Reisner break; 2818b411b363SPhilipp Reisner case ASB_VIOLENTLY: 281969a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2820b411b363SPhilipp Reisner break; 2821b411b363SPhilipp Reisner case ASB_DISCONNECT: 2822b411b363SPhilipp Reisner break; 2823b411b363SPhilipp Reisner case ASB_CALL_HELPER: 282469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2825b411b363SPhilipp Reisner if (hg == -1) { 2826bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2827bb437946SAndreas Gruenbacher 2828b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2829b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2830b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2831b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2832bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2833b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2834b411b363SPhilipp Reisner } else { 2835d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2836b411b363SPhilipp Reisner rv = hg; 2837b411b363SPhilipp Reisner } 2838b411b363SPhilipp Reisner } else 2839b411b363SPhilipp Reisner rv = hg; 2840b411b363SPhilipp Reisner } 2841b411b363SPhilipp Reisner 2842b411b363SPhilipp Reisner return rv; 2843b411b363SPhilipp Reisner } 2844b411b363SPhilipp Reisner 2845b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 2846b411b363SPhilipp Reisner u64 bits, u64 flags) 2847b411b363SPhilipp Reisner { 2848b411b363SPhilipp Reisner if (!uuid) { 2849d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 2850b411b363SPhilipp Reisner return; 2851b411b363SPhilipp Reisner } 2852d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2853b411b363SPhilipp Reisner text, 2854b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2855b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2856b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2857b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2858b411b363SPhilipp Reisner (unsigned long long)bits, 2859b411b363SPhilipp Reisner (unsigned long long)flags); 2860b411b363SPhilipp Reisner } 2861b411b363SPhilipp Reisner 2862b411b363SPhilipp Reisner /* 2863b411b363SPhilipp Reisner 100 after split brain try auto recover 2864b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2865b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2866b411b363SPhilipp Reisner 0 no Sync 2867b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2868b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2869b411b363SPhilipp Reisner -100 after split brain, disconnect 2870b411b363SPhilipp Reisner -1000 unrelated data 28714a23f264SPhilipp Reisner -1091 requires proto 91 28724a23f264SPhilipp Reisner -1096 requires proto 96 2873b411b363SPhilipp Reisner */ 287444a4d551SLars Ellenberg static int drbd_uuid_compare(struct drbd_device *const device, int *rule_nr) __must_hold(local) 2875b411b363SPhilipp Reisner { 287644a4d551SLars Ellenberg struct drbd_peer_device *const peer_device = first_peer_device(device); 287744a4d551SLars Ellenberg struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; 2878b411b363SPhilipp Reisner u64 self, peer; 2879b411b363SPhilipp Reisner int i, j; 2880b411b363SPhilipp Reisner 2881b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2882b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2883b411b363SPhilipp Reisner 2884b411b363SPhilipp Reisner *rule_nr = 10; 2885b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2886b411b363SPhilipp Reisner return 0; 2887b411b363SPhilipp Reisner 2888b411b363SPhilipp Reisner *rule_nr = 20; 2889b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2890b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2891b411b363SPhilipp Reisner return -2; 2892b411b363SPhilipp Reisner 2893b411b363SPhilipp Reisner *rule_nr = 30; 2894b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2895b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2896b411b363SPhilipp Reisner return 2; 2897b411b363SPhilipp Reisner 2898b411b363SPhilipp Reisner if (self == peer) { 2899b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2900b411b363SPhilipp Reisner 2901b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2902b411b363SPhilipp Reisner 290344a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 29044a23f264SPhilipp Reisner return -1091; 2905b411b363SPhilipp Reisner 2906b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2907b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2908d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2909b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 2910b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 2911b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 2912b411b363SPhilipp Reisner 2913b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 2914b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 2915b411b363SPhilipp Reisner *rule_nr = 34; 2916b411b363SPhilipp Reisner } else { 2917d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 2918b411b363SPhilipp Reisner *rule_nr = 36; 2919b411b363SPhilipp Reisner } 2920b411b363SPhilipp Reisner 2921b411b363SPhilipp Reisner return 1; 2922b411b363SPhilipp Reisner } 2923b411b363SPhilipp Reisner 2924b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 2925b411b363SPhilipp Reisner 292644a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 29274a23f264SPhilipp Reisner return -1091; 2928b411b363SPhilipp Reisner 2929b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 2930b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2931d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2932b411b363SPhilipp Reisner 2933b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 2934b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 2935b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 2936b411b363SPhilipp Reisner 2937b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 2938b411b363SPhilipp Reisner *rule_nr = 35; 2939b411b363SPhilipp Reisner } else { 2940d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 2941b411b363SPhilipp Reisner *rule_nr = 37; 2942b411b363SPhilipp Reisner } 2943b411b363SPhilipp Reisner 2944b411b363SPhilipp Reisner return -1; 2945b411b363SPhilipp Reisner } 2946b411b363SPhilipp Reisner 2947b411b363SPhilipp Reisner /* Common power [off|failure] */ 2948b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 2949b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 2950b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2951b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2952b411b363SPhilipp Reisner *rule_nr = 40; 2953b411b363SPhilipp Reisner 2954b411b363SPhilipp Reisner switch (rct) { 2955b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2956b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2957b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2958b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 295944a4d551SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); 2960b411b363SPhilipp Reisner return dc ? -1 : 1; 2961b411b363SPhilipp Reisner } 2962b411b363SPhilipp Reisner } 2963b411b363SPhilipp Reisner 2964b411b363SPhilipp Reisner *rule_nr = 50; 2965b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 2966b411b363SPhilipp Reisner if (self == peer) 2967b411b363SPhilipp Reisner return -1; 2968b411b363SPhilipp Reisner 2969b411b363SPhilipp Reisner *rule_nr = 51; 2970b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 2971b411b363SPhilipp Reisner if (self == peer) { 297244a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 2973b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 2974b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 2975b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 2976b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2977b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2978b411b363SPhilipp Reisner 297944a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 29804a23f264SPhilipp Reisner return -1091; 2981b411b363SPhilipp Reisner 2982b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 2983b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 29844a23f264SPhilipp Reisner 2985d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 2986b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 29874a23f264SPhilipp Reisner 2988b411b363SPhilipp Reisner return -1; 2989b411b363SPhilipp Reisner } 2990b411b363SPhilipp Reisner } 2991b411b363SPhilipp Reisner 2992b411b363SPhilipp Reisner *rule_nr = 60; 2993b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2994b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2995b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 2996b411b363SPhilipp Reisner if (self == peer) 2997b411b363SPhilipp Reisner return -2; 2998b411b363SPhilipp Reisner } 2999b411b363SPhilipp Reisner 3000b411b363SPhilipp Reisner *rule_nr = 70; 3001b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3002b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3003b411b363SPhilipp Reisner if (self == peer) 3004b411b363SPhilipp Reisner return 1; 3005b411b363SPhilipp Reisner 3006b411b363SPhilipp Reisner *rule_nr = 71; 3007b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 3008b411b363SPhilipp Reisner if (self == peer) { 300944a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3010b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 3011b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 3012b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 3013b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3014b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 3015b411b363SPhilipp Reisner 301644a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 30174a23f264SPhilipp Reisner return -1091; 3018b411b363SPhilipp Reisner 3019b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 3020b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 3021b411b363SPhilipp Reisner 3022d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 3023b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3024b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3025b411b363SPhilipp Reisner 3026b411b363SPhilipp Reisner return 1; 3027b411b363SPhilipp Reisner } 3028b411b363SPhilipp Reisner } 3029b411b363SPhilipp Reisner 3030b411b363SPhilipp Reisner 3031b411b363SPhilipp Reisner *rule_nr = 80; 3032b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3033b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3034b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3035b411b363SPhilipp Reisner if (self == peer) 3036b411b363SPhilipp Reisner return 2; 3037b411b363SPhilipp Reisner } 3038b411b363SPhilipp Reisner 3039b411b363SPhilipp Reisner *rule_nr = 90; 3040b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3041b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3042b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 3043b411b363SPhilipp Reisner return 100; 3044b411b363SPhilipp Reisner 3045b411b363SPhilipp Reisner *rule_nr = 100; 3046b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3047b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3048b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 3049b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 3050b411b363SPhilipp Reisner if (self == peer) 3051b411b363SPhilipp Reisner return -100; 3052b411b363SPhilipp Reisner } 3053b411b363SPhilipp Reisner } 3054b411b363SPhilipp Reisner 3055b411b363SPhilipp Reisner return -1000; 3056b411b363SPhilipp Reisner } 3057b411b363SPhilipp Reisner 3058b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 3059b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 3060b411b363SPhilipp Reisner */ 306169a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 306269a22773SAndreas Gruenbacher enum drbd_role peer_role, 3063b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 3064b411b363SPhilipp Reisner { 306569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 3066b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 3067b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 306844ed167dSPhilipp Reisner struct net_conf *nc; 30696dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 3070b411b363SPhilipp Reisner 3071b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 3072b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 3073b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 3074b411b363SPhilipp Reisner 3075d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 30769f2247bbSPhilipp Reisner 3077b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 3078b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 3079b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 3080b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3081b411b363SPhilipp Reisner 3082b30ab791SAndreas Gruenbacher hg = drbd_uuid_compare(device, &rule_nr); 3083b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 3084b411b363SPhilipp Reisner 3085d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 3086b411b363SPhilipp Reisner 3087b411b363SPhilipp Reisner if (hg == -1000) { 3088d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3089b411b363SPhilipp Reisner return C_MASK; 3090b411b363SPhilipp Reisner } 30914a23f264SPhilipp Reisner if (hg < -1000) { 3092d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3093b411b363SPhilipp Reisner return C_MASK; 3094b411b363SPhilipp Reisner } 3095b411b363SPhilipp Reisner 3096b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3097b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3098b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3099b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3100b411b363SPhilipp Reisner if (f) 3101b411b363SPhilipp Reisner hg = hg*2; 3102d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3103b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3104b411b363SPhilipp Reisner } 3105b411b363SPhilipp Reisner 31063a11a487SAdam Gandelman if (abs(hg) == 100) 3107b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 31083a11a487SAdam Gandelman 310944ed167dSPhilipp Reisner rcu_read_lock(); 311069a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 311144ed167dSPhilipp Reisner 311244ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3113b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3114b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3115b411b363SPhilipp Reisner int forced = (hg == -100); 3116b411b363SPhilipp Reisner 3117b411b363SPhilipp Reisner switch (pcount) { 3118b411b363SPhilipp Reisner case 0: 311969a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3120b411b363SPhilipp Reisner break; 3121b411b363SPhilipp Reisner case 1: 312269a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3123b411b363SPhilipp Reisner break; 3124b411b363SPhilipp Reisner case 2: 312569a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3126b411b363SPhilipp Reisner break; 3127b411b363SPhilipp Reisner } 3128b411b363SPhilipp Reisner if (abs(hg) < 100) { 3129d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3130b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3131b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3132b411b363SPhilipp Reisner if (forced) { 3133d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3134b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3135b411b363SPhilipp Reisner hg = hg*2; 3136b411b363SPhilipp Reisner } 3137b411b363SPhilipp Reisner } 3138b411b363SPhilipp Reisner } 3139b411b363SPhilipp Reisner 3140b411b363SPhilipp Reisner if (hg == -100) { 3141b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3142b411b363SPhilipp Reisner hg = -1; 3143b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3144b411b363SPhilipp Reisner hg = 1; 3145b411b363SPhilipp Reisner 3146b411b363SPhilipp Reisner if (abs(hg) < 100) 3147d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3148b411b363SPhilipp Reisner "Sync from %s node\n", 3149b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3150b411b363SPhilipp Reisner } 315144ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 31526dff2902SAndreas Gruenbacher tentative = nc->tentative; 315344ed167dSPhilipp Reisner rcu_read_unlock(); 3154b411b363SPhilipp Reisner 3155b411b363SPhilipp Reisner if (hg == -100) { 3156580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3157580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3158580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3159580b9767SLars Ellenberg * to that disk, in a way... */ 3160d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3161b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3162b411b363SPhilipp Reisner return C_MASK; 3163b411b363SPhilipp Reisner } 3164b411b363SPhilipp Reisner 3165b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3166d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3167b411b363SPhilipp Reisner return C_MASK; 3168b411b363SPhilipp Reisner } 3169b411b363SPhilipp Reisner 3170b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3171b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 317244ed167dSPhilipp Reisner switch (rr_conflict) { 3173b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3174b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3175b411b363SPhilipp Reisner /* fall through */ 3176b411b363SPhilipp Reisner case ASB_DISCONNECT: 3177d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3178b411b363SPhilipp Reisner return C_MASK; 3179b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3180d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3181b411b363SPhilipp Reisner "assumption\n"); 3182b411b363SPhilipp Reisner } 3183b411b363SPhilipp Reisner } 3184b411b363SPhilipp Reisner 318569a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3186cf14c2e9SPhilipp Reisner if (hg == 0) 3187d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3188cf14c2e9SPhilipp Reisner else 3189d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3190cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3191cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3192cf14c2e9SPhilipp Reisner return C_MASK; 3193cf14c2e9SPhilipp Reisner } 3194cf14c2e9SPhilipp Reisner 3195b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3196d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3197b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 319820ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3199b411b363SPhilipp Reisner return C_MASK; 3200b411b363SPhilipp Reisner } 3201b411b363SPhilipp Reisner 3202b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3203b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3204b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3205b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3206b411b363SPhilipp Reisner } else { 3207b411b363SPhilipp Reisner rv = C_CONNECTED; 3208b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3209d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3210b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3211b411b363SPhilipp Reisner } 3212b411b363SPhilipp Reisner } 3213b411b363SPhilipp Reisner 3214b411b363SPhilipp Reisner return rv; 3215b411b363SPhilipp Reisner } 3216b411b363SPhilipp Reisner 3217f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3218b411b363SPhilipp Reisner { 3219b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3220f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3221f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3222b411b363SPhilipp Reisner 3223b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3224f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3225f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3226b411b363SPhilipp Reisner 3227b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3228f179d76dSPhilipp Reisner return peer; 3229b411b363SPhilipp Reisner } 3230b411b363SPhilipp Reisner 3231bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3232b411b363SPhilipp Reisner { 3233e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3234036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3235036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3236036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3237036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3238accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 32397aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3240b411b363SPhilipp Reisner 3241b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3242b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3243b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3244b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3245b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3246cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 32476139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3248cf14c2e9SPhilipp Reisner 3249bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 325086db0618SAndreas Gruenbacher int err; 325186db0618SAndreas Gruenbacher 325288104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 325386db0618SAndreas Gruenbacher return -EIO; 3254bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 325586db0618SAndreas Gruenbacher if (err) 325686db0618SAndreas Gruenbacher return err; 325788104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3258036b17eaSPhilipp Reisner } 325986db0618SAndreas Gruenbacher 32607d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3261bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3262cf14c2e9SPhilipp Reisner 3263cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3264bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3265b411b363SPhilipp Reisner 326644ed167dSPhilipp Reisner rcu_read_lock(); 3267bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 326844ed167dSPhilipp Reisner 3269036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 32701ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 327144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3272b411b363SPhilipp Reisner } 3273b411b363SPhilipp Reisner 3274f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 32751ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 327644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3277b411b363SPhilipp Reisner } 3278b411b363SPhilipp Reisner 3279f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 32801ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 328144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3282b411b363SPhilipp Reisner } 3283b411b363SPhilipp Reisner 3284f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 32851ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 328644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3287b411b363SPhilipp Reisner } 3288b411b363SPhilipp Reisner 32896139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 32901ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 329144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3292b411b363SPhilipp Reisner } 3293b411b363SPhilipp Reisner 329444ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 32951ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 329644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3297b411b363SPhilipp Reisner } 3298b411b363SPhilipp Reisner 3299036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 33001ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3301036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3302036b17eaSPhilipp Reisner } 3303036b17eaSPhilipp Reisner 330486db0618SAndreas Gruenbacher rcu_read_unlock(); 3305fbc12f45SAndreas Gruenbacher } 33067d4c782cSAndreas Gruenbacher 33077d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 33087d4c782cSAndreas Gruenbacher int hash_size; 33097d4c782cSAndreas Gruenbacher 33107d4c782cSAndreas Gruenbacher /* 33117d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 33127d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 33137d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 33147d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 33157d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 33167d4c782cSAndreas Gruenbacher * change. 33177d4c782cSAndreas Gruenbacher */ 33187d4c782cSAndreas Gruenbacher 33197d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 33207d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 33211ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 33227d4c782cSAndreas Gruenbacher integrity_alg); 3323b411b363SPhilipp Reisner goto disconnect; 3324b411b363SPhilipp Reisner } 3325b411b363SPhilipp Reisner 33267d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 33277d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 33287d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 33297d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 33301ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 33317d4c782cSAndreas Gruenbacher goto disconnect; 33327d4c782cSAndreas Gruenbacher } 33337d4c782cSAndreas Gruenbacher } 33347d4c782cSAndreas Gruenbacher 33357d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 33367d4c782cSAndreas Gruenbacher if (!new_net_conf) { 33371ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3338b411b363SPhilipp Reisner goto disconnect; 3339b411b363SPhilipp Reisner } 3340b411b363SPhilipp Reisner 3341bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 33420500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3343bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 33447d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3345b411b363SPhilipp Reisner 33467d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 33477d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 33487d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 33497d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 33507d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3351b411b363SPhilipp Reisner 3352bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 33530500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3354bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3355b411b363SPhilipp Reisner 3356bde89a9eSAndreas Gruenbacher crypto_free_hash(connection->peer_integrity_tfm); 3357bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3358bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3359bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3360bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3361bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3362b411b363SPhilipp Reisner 33637d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 33641ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 33657d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3366b411b363SPhilipp Reisner 33677d4c782cSAndreas Gruenbacher synchronize_rcu(); 33687d4c782cSAndreas Gruenbacher kfree(old_net_conf); 336982bc0194SAndreas Gruenbacher return 0; 3370b411b363SPhilipp Reisner 337144ed167dSPhilipp Reisner disconnect_rcu_unlock: 337244ed167dSPhilipp Reisner rcu_read_unlock(); 3373b411b363SPhilipp Reisner disconnect: 3374b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3375036b17eaSPhilipp Reisner kfree(int_dig_in); 3376036b17eaSPhilipp Reisner kfree(int_dig_vv); 3377bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 337882bc0194SAndreas Gruenbacher return -EIO; 3379b411b363SPhilipp Reisner } 3380b411b363SPhilipp Reisner 3381b411b363SPhilipp Reisner /* helper function 3382b411b363SPhilipp Reisner * input: alg name, feature name 3383b411b363SPhilipp Reisner * return: NULL (alg name was "") 3384b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3385b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 33868ce953aaSLars Ellenberg static struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3387b411b363SPhilipp Reisner const char *alg, const char *name) 3388b411b363SPhilipp Reisner { 3389b411b363SPhilipp Reisner struct crypto_hash *tfm; 3390b411b363SPhilipp Reisner 3391b411b363SPhilipp Reisner if (!alg[0]) 3392b411b363SPhilipp Reisner return NULL; 3393b411b363SPhilipp Reisner 3394b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3395b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3396d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3397b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3398b411b363SPhilipp Reisner return tfm; 3399b411b363SPhilipp Reisner } 3400b411b363SPhilipp Reisner return tfm; 3401b411b363SPhilipp Reisner } 3402b411b363SPhilipp Reisner 3403bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3404b411b363SPhilipp Reisner { 3405bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 34064a76b161SAndreas Gruenbacher int size = pi->size; 34074a76b161SAndreas Gruenbacher 34084a76b161SAndreas Gruenbacher while (size) { 34094a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3410bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 34114a76b161SAndreas Gruenbacher if (s <= 0) { 34124a76b161SAndreas Gruenbacher if (s < 0) 34134a76b161SAndreas Gruenbacher return s; 34144a76b161SAndreas Gruenbacher break; 34154a76b161SAndreas Gruenbacher } 34164a76b161SAndreas Gruenbacher size -= s; 34174a76b161SAndreas Gruenbacher } 34184a76b161SAndreas Gruenbacher if (size) 34194a76b161SAndreas Gruenbacher return -EIO; 34204a76b161SAndreas Gruenbacher return 0; 34214a76b161SAndreas Gruenbacher } 34224a76b161SAndreas Gruenbacher 34234a76b161SAndreas Gruenbacher /* 34244a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 34254a76b161SAndreas Gruenbacher * 34264a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 34274a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 34284a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 34294a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 34304a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 34314a76b161SAndreas Gruenbacher * 34324a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 34334a76b161SAndreas Gruenbacher */ 3434bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 34354a76b161SAndreas Gruenbacher { 34361ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 34372fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3438bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 34394a76b161SAndreas Gruenbacher } 34404a76b161SAndreas Gruenbacher 3441bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 34424a76b161SAndreas Gruenbacher { 34439f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3444b30ab791SAndreas Gruenbacher struct drbd_device *device; 3445e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3446b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3447b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3448b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 34492ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3450813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3451bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3452813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3453778f271dSPhilipp Reisner int fifo_size = 0; 345482bc0194SAndreas Gruenbacher int err; 3455b411b363SPhilipp Reisner 34569f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 34579f4fe9adSAndreas Gruenbacher if (!peer_device) 3458bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 34599f4fe9adSAndreas Gruenbacher device = peer_device->device; 3460b411b363SPhilipp Reisner 3461b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3462b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3463b411b363SPhilipp Reisner + SHARED_SECRET_MAX 34648e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 34658e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3466b411b363SPhilipp Reisner 3467e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3468d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3469e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 347082bc0194SAndreas Gruenbacher return -EIO; 3471b411b363SPhilipp Reisner } 3472b411b363SPhilipp Reisner 3473b411b363SPhilipp Reisner if (apv <= 88) { 3474e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3475e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 34768e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3477e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3478e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 34790b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 34808e26f9ccSPhilipp Reisner } else { 3481e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3482e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 34830b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3484b411b363SPhilipp Reisner } 3485b411b363SPhilipp Reisner 3486b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3487e658983aSAndreas Gruenbacher p = pi->data; 3488b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3489b411b363SPhilipp Reisner 34909f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 349182bc0194SAndreas Gruenbacher if (err) 349282bc0194SAndreas Gruenbacher return err; 3493b411b363SPhilipp Reisner 34940500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 34959f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3496b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3497daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3498daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3499b30ab791SAndreas Gruenbacher put_ldev(device); 35000500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3501d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3502daeda1ccSPhilipp Reisner return -ENOMEM; 3503f399002eSLars Ellenberg } 3504b411b363SPhilipp Reisner 3505b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3506daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3507daeda1ccSPhilipp Reisner 35086394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3509813472ceSPhilipp Reisner } 3510b411b363SPhilipp Reisner 3511b411b363SPhilipp Reisner if (apv >= 88) { 3512b411b363SPhilipp Reisner if (apv == 88) { 35135de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3514d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 35155de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3516b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3517813472ceSPhilipp Reisner err = -EIO; 3518813472ceSPhilipp Reisner goto reconnect; 3519b411b363SPhilipp Reisner } 3520b411b363SPhilipp Reisner 35219f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3522813472ceSPhilipp Reisner if (err) 3523813472ceSPhilipp Reisner goto reconnect; 3524b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3525b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 35260b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3527b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3528b411b363SPhilipp Reisner 3529b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3530b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3531b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 35320b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 35330b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3534b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3535b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3536b411b363SPhilipp Reisner } 3537b411b363SPhilipp Reisner 35382ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3539b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3540d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 35412ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3542b411b363SPhilipp Reisner goto disconnect; 3543b411b363SPhilipp Reisner } 3544b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3545b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3546b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3547b411b363SPhilipp Reisner verify_tfm = NULL; 3548b411b363SPhilipp Reisner goto disconnect; 3549b411b363SPhilipp Reisner } 3550b411b363SPhilipp Reisner } 3551b411b363SPhilipp Reisner 35522ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3553b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3554d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 35552ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3556b411b363SPhilipp Reisner goto disconnect; 3557b411b363SPhilipp Reisner } 3558b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3559b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3560b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3561b411b363SPhilipp Reisner csums_tfm = NULL; 3562b411b363SPhilipp Reisner goto disconnect; 3563b411b363SPhilipp Reisner } 3564b411b363SPhilipp Reisner } 3565b411b363SPhilipp Reisner 3566813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3567daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3568daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3569daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3570daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3571778f271dSPhilipp Reisner 3572daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3573b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3574813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3575813472ceSPhilipp Reisner if (!new_plan) { 3576d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3577b30ab791SAndreas Gruenbacher put_ldev(device); 3578778f271dSPhilipp Reisner goto disconnect; 3579778f271dSPhilipp Reisner } 3580778f271dSPhilipp Reisner } 35818e26f9ccSPhilipp Reisner } 3582b411b363SPhilipp Reisner 358391fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 35842ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 35852ec91e0eSPhilipp Reisner if (!new_net_conf) { 3586d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 358791fd4dadSPhilipp Reisner goto disconnect; 358891fd4dadSPhilipp Reisner } 358991fd4dadSPhilipp Reisner 35902ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 359191fd4dadSPhilipp Reisner 3592b411b363SPhilipp Reisner if (verify_tfm) { 35932ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 35942ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 35959f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->verify_tfm); 35969f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3597d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3598b411b363SPhilipp Reisner } 3599b411b363SPhilipp Reisner if (csums_tfm) { 36002ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 36012ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 36029f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->csums_tfm); 36039f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3604d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3605b411b363SPhilipp Reisner } 3606bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3607778f271dSPhilipp Reisner } 3608b411b363SPhilipp Reisner } 3609b411b363SPhilipp Reisner 3610813472ceSPhilipp Reisner if (new_disk_conf) { 3611b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3612b30ab791SAndreas Gruenbacher put_ldev(device); 3613b411b363SPhilipp Reisner } 3614813472ceSPhilipp Reisner 3615813472ceSPhilipp Reisner if (new_plan) { 3616b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3617b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3618813472ceSPhilipp Reisner } 3619daeda1ccSPhilipp Reisner 36200500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3621daeda1ccSPhilipp Reisner synchronize_rcu(); 3622daeda1ccSPhilipp Reisner if (new_net_conf) 3623daeda1ccSPhilipp Reisner kfree(old_net_conf); 3624daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3625813472ceSPhilipp Reisner kfree(old_plan); 3626daeda1ccSPhilipp Reisner 362782bc0194SAndreas Gruenbacher return 0; 3628b411b363SPhilipp Reisner 3629813472ceSPhilipp Reisner reconnect: 3630813472ceSPhilipp Reisner if (new_disk_conf) { 3631b30ab791SAndreas Gruenbacher put_ldev(device); 3632813472ceSPhilipp Reisner kfree(new_disk_conf); 3633813472ceSPhilipp Reisner } 36340500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3635813472ceSPhilipp Reisner return -EIO; 3636813472ceSPhilipp Reisner 3637b411b363SPhilipp Reisner disconnect: 3638813472ceSPhilipp Reisner kfree(new_plan); 3639813472ceSPhilipp Reisner if (new_disk_conf) { 3640b30ab791SAndreas Gruenbacher put_ldev(device); 3641813472ceSPhilipp Reisner kfree(new_disk_conf); 3642813472ceSPhilipp Reisner } 36430500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3644b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3645b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3646b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3647b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3648b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 36499f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 365082bc0194SAndreas Gruenbacher return -EIO; 3651b411b363SPhilipp Reisner } 3652b411b363SPhilipp Reisner 3653b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3654b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 3655b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3656b411b363SPhilipp Reisner { 3657b411b363SPhilipp Reisner sector_t d; 3658b411b363SPhilipp Reisner if (a == 0 || b == 0) 3659b411b363SPhilipp Reisner return; 3660b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3661b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3662d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 3663b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3664b411b363SPhilipp Reisner } 3665b411b363SPhilipp Reisner 3666bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 3667b411b363SPhilipp Reisner { 36689f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3669b30ab791SAndreas Gruenbacher struct drbd_device *device; 3670e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3671e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 36726a8d68b1SLars Ellenberg sector_t p_size, p_usize, p_csize, my_usize; 3673b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3674e89b591cSPhilipp Reisner enum dds_flags ddsf; 3675b411b363SPhilipp Reisner 36769f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 36779f4fe9adSAndreas Gruenbacher if (!peer_device) 3678bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 36799f4fe9adSAndreas Gruenbacher device = peer_device->device; 36804a76b161SAndreas Gruenbacher 3681b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3682b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 36836a8d68b1SLars Ellenberg p_csize = be64_to_cpu(p->c_size); 3684b411b363SPhilipp Reisner 3685b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3686b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3687b30ab791SAndreas Gruenbacher device->p_size = p_size; 3688b411b363SPhilipp Reisner 3689b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3690daeda1ccSPhilipp Reisner rcu_read_lock(); 3691b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 3692daeda1ccSPhilipp Reisner rcu_read_unlock(); 3693daeda1ccSPhilipp Reisner 3694b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 3695b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 3696b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 3697daeda1ccSPhilipp Reisner p_usize, my_usize); 3698b411b363SPhilipp Reisner 3699b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3700b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3701b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 3702daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3703b411b363SPhilipp Reisner 3704b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3705b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3706b30ab791SAndreas Gruenbacher if (drbd_new_dev_size(device, device->ldev, p_usize, 0) < 3707b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) && 3708b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 3709b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 3710d0180171SAndreas Gruenbacher drbd_err(device, "The peer's disk size is too small!\n"); 37119f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 3712b30ab791SAndreas Gruenbacher put_ldev(device); 371382bc0194SAndreas Gruenbacher return -EIO; 3714b411b363SPhilipp Reisner } 3715daeda1ccSPhilipp Reisner 3716daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3717daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3718daeda1ccSPhilipp Reisner 3719daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3720daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3721d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3722b30ab791SAndreas Gruenbacher put_ldev(device); 3723daeda1ccSPhilipp Reisner return -ENOMEM; 3724daeda1ccSPhilipp Reisner } 3725daeda1ccSPhilipp Reisner 37260500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3727b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3728daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3729daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3730daeda1ccSPhilipp Reisner 3731b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 37320500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3733daeda1ccSPhilipp Reisner synchronize_rcu(); 3734daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3735daeda1ccSPhilipp Reisner 3736d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 3737daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3738daeda1ccSPhilipp Reisner } 3739daeda1ccSPhilipp Reisner 3740b30ab791SAndreas Gruenbacher put_ldev(device); 3741b411b363SPhilipp Reisner } 3742b411b363SPhilipp Reisner 374320c68fdeSLars Ellenberg device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 374420c68fdeSLars Ellenberg /* Leave drbd_reconsider_max_bio_size() before drbd_determine_dev_size(). 374520c68fdeSLars Ellenberg In case we cleared the QUEUE_FLAG_DISCARD from our queue in 374620c68fdeSLars Ellenberg drbd_reconsider_max_bio_size(), we can be sure that after 374720c68fdeSLars Ellenberg drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */ 374820c68fdeSLars Ellenberg 3749e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3750b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 37518fe39aacSPhilipp Reisner drbd_reconsider_max_bio_size(device, device->ldev); 3752b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 3753b30ab791SAndreas Gruenbacher put_ldev(device); 3754e96c9633SPhilipp Reisner if (dd == DS_ERROR) 375582bc0194SAndreas Gruenbacher return -EIO; 3756b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3757b411b363SPhilipp Reisner } else { 37586a8d68b1SLars Ellenberg /* 37596a8d68b1SLars Ellenberg * I am diskless, need to accept the peer's *current* size. 37606a8d68b1SLars Ellenberg * I must NOT accept the peers backing disk size, 37616a8d68b1SLars Ellenberg * it may have been larger than mine all along... 37626a8d68b1SLars Ellenberg * 37636a8d68b1SLars Ellenberg * At this point, the peer knows more about my disk, or at 37646a8d68b1SLars Ellenberg * least about what we last agreed upon, than myself. 37656a8d68b1SLars Ellenberg * So if his c_size is less than his d_size, the most likely 37666a8d68b1SLars Ellenberg * reason is that *my* d_size was smaller last time we checked. 37676a8d68b1SLars Ellenberg * 37686a8d68b1SLars Ellenberg * However, if he sends a zero current size, 37696a8d68b1SLars Ellenberg * take his (user-capped or) backing disk size anyways. 37706a8d68b1SLars Ellenberg */ 37718fe39aacSPhilipp Reisner drbd_reconsider_max_bio_size(device, NULL); 37726a8d68b1SLars Ellenberg drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); 3773b411b363SPhilipp Reisner } 3774b411b363SPhilipp Reisner 3775b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3776b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 3777b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 3778b411b363SPhilipp Reisner ldsc = 1; 3779b411b363SPhilipp Reisner } 3780b411b363SPhilipp Reisner 3781b30ab791SAndreas Gruenbacher put_ldev(device); 3782b411b363SPhilipp Reisner } 3783b411b363SPhilipp Reisner 3784b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 3785b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3786b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 3787b411b363SPhilipp Reisner /* we have different sizes, probably peer 3788b411b363SPhilipp Reisner * needs to know my new size... */ 378969a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 3790b411b363SPhilipp Reisner } 3791b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 3792b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 3793b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 3794b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 3795e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3796d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 3797b411b363SPhilipp Reisner else 3798b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 3799e89b591cSPhilipp Reisner } else 3800b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 3801b411b363SPhilipp Reisner } 3802b411b363SPhilipp Reisner } 3803b411b363SPhilipp Reisner 380482bc0194SAndreas Gruenbacher return 0; 3805b411b363SPhilipp Reisner } 3806b411b363SPhilipp Reisner 3807bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 3808b411b363SPhilipp Reisner { 38099f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3810b30ab791SAndreas Gruenbacher struct drbd_device *device; 3811e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3812b411b363SPhilipp Reisner u64 *p_uuid; 381362b0da3aSLars Ellenberg int i, updated_uuids = 0; 3814b411b363SPhilipp Reisner 38159f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38169f4fe9adSAndreas Gruenbacher if (!peer_device) 3817bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 38189f4fe9adSAndreas Gruenbacher device = peer_device->device; 38194a76b161SAndreas Gruenbacher 3820b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3821063eacf8SJing Wang if (!p_uuid) { 3822d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 3823063eacf8SJing Wang return false; 3824063eacf8SJing Wang } 3825b411b363SPhilipp Reisner 3826b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3827b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3828b411b363SPhilipp Reisner 3829b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 3830b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 3831b411b363SPhilipp Reisner 3832b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 3833b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 3834b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 3835b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3836d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 3837b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 38389f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 383982bc0194SAndreas Gruenbacher return -EIO; 3840b411b363SPhilipp Reisner } 3841b411b363SPhilipp Reisner 3842b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3843b411b363SPhilipp Reisner int skip_initial_sync = 3844b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 38459f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 3846b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3847b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3848b411b363SPhilipp Reisner if (skip_initial_sync) { 3849d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 3850b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 385120ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 385220ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3853b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 3854b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 3855b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3856b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3857b30ab791SAndreas Gruenbacher drbd_md_sync(device); 385862b0da3aSLars Ellenberg updated_uuids = 1; 3859b411b363SPhilipp Reisner } 3860b30ab791SAndreas Gruenbacher put_ldev(device); 3861b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 3862b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 386318a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 386418a50fa2SPhilipp Reisner for me. */ 3865b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 3866b411b363SPhilipp Reisner } 3867b411b363SPhilipp Reisner 3868b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3869b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3870b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3871b411b363SPhilipp Reisner new disk state... */ 3872b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 3873b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 3874b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 3875b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 387662b0da3aSLars Ellenberg 387762b0da3aSLars Ellenberg if (updated_uuids) 3878b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 3879b411b363SPhilipp Reisner 388082bc0194SAndreas Gruenbacher return 0; 3881b411b363SPhilipp Reisner } 3882b411b363SPhilipp Reisner 3883b411b363SPhilipp Reisner /** 3884b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3885b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3886b411b363SPhilipp Reisner */ 3887b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3888b411b363SPhilipp Reisner { 3889b411b363SPhilipp Reisner union drbd_state ms; 3890b411b363SPhilipp Reisner 3891b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3892369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3893b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3894b411b363SPhilipp Reisner 3895b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3896b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3897b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3898b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3899b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3900b411b363SPhilipp Reisner }; 3901b411b363SPhilipp Reisner 3902b411b363SPhilipp Reisner ms.i = ps.i; 3903b411b363SPhilipp Reisner 3904b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3905b411b363SPhilipp Reisner ms.peer = ps.role; 3906b411b363SPhilipp Reisner ms.role = ps.peer; 3907b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3908b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3909b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3910b411b363SPhilipp Reisner 3911b411b363SPhilipp Reisner return ms; 3912b411b363SPhilipp Reisner } 3913b411b363SPhilipp Reisner 3914bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 3915b411b363SPhilipp Reisner { 39169f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3917b30ab791SAndreas Gruenbacher struct drbd_device *device; 3918e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3919b411b363SPhilipp Reisner union drbd_state mask, val; 3920bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3921b411b363SPhilipp Reisner 39229f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 39239f4fe9adSAndreas Gruenbacher if (!peer_device) 39244a76b161SAndreas Gruenbacher return -EIO; 39259f4fe9adSAndreas Gruenbacher device = peer_device->device; 39264a76b161SAndreas Gruenbacher 3927b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3928b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3929b411b363SPhilipp Reisner 39309f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 3931b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 393269a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 393382bc0194SAndreas Gruenbacher return 0; 3934b411b363SPhilipp Reisner } 3935b411b363SPhilipp Reisner 3936b411b363SPhilipp Reisner mask = convert_state(mask); 3937b411b363SPhilipp Reisner val = convert_state(val); 3938b411b363SPhilipp Reisner 3939b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 394069a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 3941047cd4a6SPhilipp Reisner 3942b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3943b411b363SPhilipp Reisner 394482bc0194SAndreas Gruenbacher return 0; 3945b411b363SPhilipp Reisner } 3946b411b363SPhilipp Reisner 3947bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 3948b411b363SPhilipp Reisner { 3949e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3950dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3951dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3952dfafcc8aSPhilipp Reisner 3953dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3954dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3955dfafcc8aSPhilipp Reisner 3956bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 3957bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 3958bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 395982bc0194SAndreas Gruenbacher return 0; 3960dfafcc8aSPhilipp Reisner } 3961dfafcc8aSPhilipp Reisner 3962dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3963dfafcc8aSPhilipp Reisner val = convert_state(val); 3964dfafcc8aSPhilipp Reisner 3965bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3966bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 3967dfafcc8aSPhilipp Reisner 396882bc0194SAndreas Gruenbacher return 0; 3969dfafcc8aSPhilipp Reisner } 3970dfafcc8aSPhilipp Reisner 3971bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 3972b411b363SPhilipp Reisner { 39739f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3974b30ab791SAndreas Gruenbacher struct drbd_device *device; 3975e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 39764ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3977b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 397865d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3979b411b363SPhilipp Reisner int rv; 3980b411b363SPhilipp Reisner 39819f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 39829f4fe9adSAndreas Gruenbacher if (!peer_device) 3983bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 39849f4fe9adSAndreas Gruenbacher device = peer_device->device; 39854a76b161SAndreas Gruenbacher 3986b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3987b411b363SPhilipp Reisner 3988b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3989b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3990b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3991d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3992b411b363SPhilipp Reisner } 3993b411b363SPhilipp Reisner 39940500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 3995b411b363SPhilipp Reisner retry: 3996b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 39970500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 3998b411b363SPhilipp Reisner 3999545752d5SLars Ellenberg /* If some other part of the code (asender thread, timeout) 4000545752d5SLars Ellenberg * already decided to close the connection again, 4001545752d5SLars Ellenberg * we must not "re-establish" it here. */ 4002545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 400358ffa580SLars Ellenberg return -ECONNRESET; 4004545752d5SLars Ellenberg 400540424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 400640424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 400740424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 400840424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 400940424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 401040424e4aSLars Ellenberg */ 401140424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 401240424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 4013e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 4014e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 4015e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 4016e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 4017e9ef7bb6SLars Ellenberg * syncing states. 4018e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 4019e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 4020e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 4021e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 4022e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 4023e9ef7bb6SLars Ellenberg 4024e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 4025e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 4026e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 4027e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 4028e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 4029b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 4030b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 403182bc0194SAndreas Gruenbacher return 0; 4032e9ef7bb6SLars Ellenberg } 4033e9ef7bb6SLars Ellenberg } 4034e9ef7bb6SLars Ellenberg 403502b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 403602b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 403702b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 4038b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 4039b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 404058ffa580SLars Ellenberg return 0; 404102b91b55SLars Ellenberg } 404202b91b55SLars Ellenberg 4043e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 4044e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 4045e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 4046e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 4047e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 4048e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 4049e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 4050e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 4051e9ef7bb6SLars Ellenberg 40524ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 40534ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4054b411b363SPhilipp Reisner 405567531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 405667531718SPhilipp Reisner ns.conn = C_BEHIND; 405767531718SPhilipp Reisner 4058b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 4059b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 4060b411b363SPhilipp Reisner int cr; /* consider resync */ 4061b411b363SPhilipp Reisner 4062b411b363SPhilipp Reisner /* if we established a new connection */ 40634ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 4064b411b363SPhilipp Reisner /* if we had an established connection 4065b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 40664ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4067b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 40684ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 4069b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 4070b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 4071b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 4072b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 4073b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 40744ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4075b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 4076b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 4077b411b363SPhilipp Reisner 4078b411b363SPhilipp Reisner if (cr) 407969a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 4080b411b363SPhilipp Reisner 4081b30ab791SAndreas Gruenbacher put_ldev(device); 40824ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 40834ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4084b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 4085b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 4086b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 4087d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 4088b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 4089580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 4090b411b363SPhilipp Reisner } else { 40919f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 409282bc0194SAndreas Gruenbacher return -EIO; 40930b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 40949f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 409582bc0194SAndreas Gruenbacher return -EIO; 4096b411b363SPhilipp Reisner } 4097b411b363SPhilipp Reisner } 4098b411b363SPhilipp Reisner } 4099b411b363SPhilipp Reisner 41000500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4101b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 4102b411b363SPhilipp Reisner goto retry; 4103b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 4104b411b363SPhilipp Reisner ns.peer = peer_state.role; 4105b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4106b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 41074ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4108b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 41094ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4110b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4111b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 41128554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4113481c6f50SPhilipp Reisner for temporal network outages! */ 41140500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4115d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 41169f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4117b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4118b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 41199f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 412082bc0194SAndreas Gruenbacher return -EIO; 4121481c6f50SPhilipp Reisner } 4122b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4123b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 41240500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4125b411b363SPhilipp Reisner 4126b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 41279f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 412882bc0194SAndreas Gruenbacher return -EIO; 4129b411b363SPhilipp Reisner } 4130b411b363SPhilipp Reisner 41314ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 41324ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4133b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4134b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4135b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4136b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 413769a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 413869a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4139b411b363SPhilipp Reisner } 4140b411b363SPhilipp Reisner } 4141b411b363SPhilipp Reisner 4142b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4143b411b363SPhilipp Reisner 4144b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4145b411b363SPhilipp Reisner 414682bc0194SAndreas Gruenbacher return 0; 4147b411b363SPhilipp Reisner } 4148b411b363SPhilipp Reisner 4149bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4150b411b363SPhilipp Reisner { 41519f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4152b30ab791SAndreas Gruenbacher struct drbd_device *device; 4153e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 41544a76b161SAndreas Gruenbacher 41559f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 41569f4fe9adSAndreas Gruenbacher if (!peer_device) 41574a76b161SAndreas Gruenbacher return -EIO; 41589f4fe9adSAndreas Gruenbacher device = peer_device->device; 4159b411b363SPhilipp Reisner 4160b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4161b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4162b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4163b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4164b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4165b411b363SPhilipp Reisner 41660b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4167b411b363SPhilipp Reisner 4168b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4169b411b363SPhilipp Reisner _not_ be rotated into the history */ 4170b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4171b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4172b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4173b411b363SPhilipp Reisner 4174b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4175b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4176b411b363SPhilipp Reisner 4177b30ab791SAndreas Gruenbacher put_ldev(device); 4178b411b363SPhilipp Reisner } else 4179d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4180b411b363SPhilipp Reisner 418182bc0194SAndreas Gruenbacher return 0; 4182b411b363SPhilipp Reisner } 4183b411b363SPhilipp Reisner 41842c46407dSAndreas Gruenbacher /** 41852c46407dSAndreas Gruenbacher * receive_bitmap_plain 41862c46407dSAndreas Gruenbacher * 41872c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41882c46407dSAndreas Gruenbacher * code upon failure. 41892c46407dSAndreas Gruenbacher */ 41902c46407dSAndreas Gruenbacher static int 419169a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4192e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4193b411b363SPhilipp Reisner { 419450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 419569a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4196e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 419750d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4198e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 41992c46407dSAndreas Gruenbacher int err; 4200b411b363SPhilipp Reisner 420150d0b1adSAndreas Gruenbacher if (want != size) { 420269a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 42032c46407dSAndreas Gruenbacher return -EIO; 4204b411b363SPhilipp Reisner } 4205b411b363SPhilipp Reisner if (want == 0) 42062c46407dSAndreas Gruenbacher return 0; 420769a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 420882bc0194SAndreas Gruenbacher if (err) 42092c46407dSAndreas Gruenbacher return err; 4210b411b363SPhilipp Reisner 421169a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4212b411b363SPhilipp Reisner 4213b411b363SPhilipp Reisner c->word_offset += num_words; 4214b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4215b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4216b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4217b411b363SPhilipp Reisner 42182c46407dSAndreas Gruenbacher return 1; 4219b411b363SPhilipp Reisner } 4220b411b363SPhilipp Reisner 4221a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4222a02d1240SAndreas Gruenbacher { 4223a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4224a02d1240SAndreas Gruenbacher } 4225a02d1240SAndreas Gruenbacher 4226a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4227a02d1240SAndreas Gruenbacher { 4228a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4229a02d1240SAndreas Gruenbacher } 4230a02d1240SAndreas Gruenbacher 4231a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4232a02d1240SAndreas Gruenbacher { 4233a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4234a02d1240SAndreas Gruenbacher } 4235a02d1240SAndreas Gruenbacher 42362c46407dSAndreas Gruenbacher /** 42372c46407dSAndreas Gruenbacher * recv_bm_rle_bits 42382c46407dSAndreas Gruenbacher * 42392c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 42402c46407dSAndreas Gruenbacher * code upon failure. 42412c46407dSAndreas Gruenbacher */ 42422c46407dSAndreas Gruenbacher static int 424369a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4244b411b363SPhilipp Reisner struct p_compressed_bm *p, 4245c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4246c6d25cfeSPhilipp Reisner unsigned int len) 4247b411b363SPhilipp Reisner { 4248b411b363SPhilipp Reisner struct bitstream bs; 4249b411b363SPhilipp Reisner u64 look_ahead; 4250b411b363SPhilipp Reisner u64 rl; 4251b411b363SPhilipp Reisner u64 tmp; 4252b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4253b411b363SPhilipp Reisner unsigned long e; 4254a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4255b411b363SPhilipp Reisner int have; 4256b411b363SPhilipp Reisner int bits; 4257b411b363SPhilipp Reisner 4258a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4259b411b363SPhilipp Reisner 4260b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4261b411b363SPhilipp Reisner if (bits < 0) 42622c46407dSAndreas Gruenbacher return -EIO; 4263b411b363SPhilipp Reisner 4264b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4265b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4266b411b363SPhilipp Reisner if (bits <= 0) 42672c46407dSAndreas Gruenbacher return -EIO; 4268b411b363SPhilipp Reisner 4269b411b363SPhilipp Reisner if (toggle) { 4270b411b363SPhilipp Reisner e = s + rl -1; 4271b411b363SPhilipp Reisner if (e >= c->bm_bits) { 427269a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 42732c46407dSAndreas Gruenbacher return -EIO; 4274b411b363SPhilipp Reisner } 427569a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4276b411b363SPhilipp Reisner } 4277b411b363SPhilipp Reisner 4278b411b363SPhilipp Reisner if (have < bits) { 427969a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4280b411b363SPhilipp Reisner have, bits, look_ahead, 4281b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4282b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 42832c46407dSAndreas Gruenbacher return -EIO; 4284b411b363SPhilipp Reisner } 4285d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4286d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4287b411b363SPhilipp Reisner look_ahead >>= bits; 4288d2da5b0cSLars Ellenberg else 4289d2da5b0cSLars Ellenberg look_ahead = 0; 4290b411b363SPhilipp Reisner have -= bits; 4291b411b363SPhilipp Reisner 4292b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4293b411b363SPhilipp Reisner if (bits < 0) 42942c46407dSAndreas Gruenbacher return -EIO; 4295b411b363SPhilipp Reisner look_ahead |= tmp << have; 4296b411b363SPhilipp Reisner have += bits; 4297b411b363SPhilipp Reisner } 4298b411b363SPhilipp Reisner 4299b411b363SPhilipp Reisner c->bit_offset = s; 4300b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4301b411b363SPhilipp Reisner 43022c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4303b411b363SPhilipp Reisner } 4304b411b363SPhilipp Reisner 43052c46407dSAndreas Gruenbacher /** 43062c46407dSAndreas Gruenbacher * decode_bitmap_c 43072c46407dSAndreas Gruenbacher * 43082c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 43092c46407dSAndreas Gruenbacher * code upon failure. 43102c46407dSAndreas Gruenbacher */ 43112c46407dSAndreas Gruenbacher static int 431269a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4313b411b363SPhilipp Reisner struct p_compressed_bm *p, 4314c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4315c6d25cfeSPhilipp Reisner unsigned int len) 4316b411b363SPhilipp Reisner { 4317a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 431869a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4319b411b363SPhilipp Reisner 4320b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4321b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4322b411b363SPhilipp Reisner * during all our tests. */ 4323b411b363SPhilipp Reisner 432469a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 432569a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 43262c46407dSAndreas Gruenbacher return -EIO; 4327b411b363SPhilipp Reisner } 4328b411b363SPhilipp Reisner 4329b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4330b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4331b411b363SPhilipp Reisner { 4332b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4333a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 433450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 433550d0b1adSAndreas Gruenbacher unsigned int plain = 433650d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 433750d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 433850d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 433950d0b1adSAndreas Gruenbacher unsigned int r; 4340b411b363SPhilipp Reisner 4341b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4342b411b363SPhilipp Reisner if (total == 0) 4343b411b363SPhilipp Reisner return; 4344b411b363SPhilipp Reisner 4345b411b363SPhilipp Reisner /* don't report if not compressed */ 4346b411b363SPhilipp Reisner if (total >= plain) 4347b411b363SPhilipp Reisner return; 4348b411b363SPhilipp Reisner 4349b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4350b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4351b411b363SPhilipp Reisner : (1000 * total / plain); 4352b411b363SPhilipp Reisner 4353b411b363SPhilipp Reisner if (r > 1000) 4354b411b363SPhilipp Reisner r = 1000; 4355b411b363SPhilipp Reisner 4356b411b363SPhilipp Reisner r = 1000 - r; 4357d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4358b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4359b411b363SPhilipp Reisner direction, 4360b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4361b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4362b411b363SPhilipp Reisner total, r/10, r % 10); 4363b411b363SPhilipp Reisner } 4364b411b363SPhilipp Reisner 4365b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4366b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4367b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4368b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4369b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4370b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4371b411b363SPhilipp Reisner 4372b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4373bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4374b411b363SPhilipp Reisner { 43759f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4376b30ab791SAndreas Gruenbacher struct drbd_device *device; 4377b411b363SPhilipp Reisner struct bm_xfer_ctx c; 43782c46407dSAndreas Gruenbacher int err; 43794a76b161SAndreas Gruenbacher 43809f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 43819f4fe9adSAndreas Gruenbacher if (!peer_device) 43824a76b161SAndreas Gruenbacher return -EIO; 43839f4fe9adSAndreas Gruenbacher device = peer_device->device; 4384b411b363SPhilipp Reisner 4385b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 438620ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 438720ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4388b411b363SPhilipp Reisner 4389b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4390b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4391b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4392b411b363SPhilipp Reisner }; 4393b411b363SPhilipp Reisner 43942c46407dSAndreas Gruenbacher for(;;) { 4395e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 439669a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4397e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4398b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4399b411b363SPhilipp Reisner * and the feature is enabled! */ 4400e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4401b411b363SPhilipp Reisner 4402bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4403d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 440482bc0194SAndreas Gruenbacher err = -EIO; 4405b411b363SPhilipp Reisner goto out; 4406b411b363SPhilipp Reisner } 4407e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4408d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 440982bc0194SAndreas Gruenbacher err = -EIO; 441078fcbdaeSAndreas Gruenbacher goto out; 4411b411b363SPhilipp Reisner } 44129f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4413e658983aSAndreas Gruenbacher if (err) 4414e658983aSAndreas Gruenbacher goto out; 441569a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4416b411b363SPhilipp Reisner } else { 4417d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 441882bc0194SAndreas Gruenbacher err = -EIO; 4419b411b363SPhilipp Reisner goto out; 4420b411b363SPhilipp Reisner } 4421b411b363SPhilipp Reisner 4422e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4423bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4424b411b363SPhilipp Reisner 44252c46407dSAndreas Gruenbacher if (err <= 0) { 44262c46407dSAndreas Gruenbacher if (err < 0) 44272c46407dSAndreas Gruenbacher goto out; 4428b411b363SPhilipp Reisner break; 44292c46407dSAndreas Gruenbacher } 44309f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 443182bc0194SAndreas Gruenbacher if (err) 4432b411b363SPhilipp Reisner goto out; 44332c46407dSAndreas Gruenbacher } 4434b411b363SPhilipp Reisner 4435b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4436b411b363SPhilipp Reisner 4437b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4438de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4439de1f8e4aSAndreas Gruenbacher 4440b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 444182bc0194SAndreas Gruenbacher if (err) 4442b411b363SPhilipp Reisner goto out; 4443b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4444b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 44450b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4446b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4447b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4448b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4449d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4450b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4451b411b363SPhilipp Reisner } 445282bc0194SAndreas Gruenbacher err = 0; 4453b411b363SPhilipp Reisner 4454b411b363SPhilipp Reisner out: 4455b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4456b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4457b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 445882bc0194SAndreas Gruenbacher return err; 4459b411b363SPhilipp Reisner } 4460b411b363SPhilipp Reisner 4461bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4462b411b363SPhilipp Reisner { 44631ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4464e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4465b411b363SPhilipp Reisner 4466bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4467b411b363SPhilipp Reisner } 4468b411b363SPhilipp Reisner 4469bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4470b411b363SPhilipp Reisner { 4471b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4472b411b363SPhilipp Reisner * with the data requests being unplugged */ 4473bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4474b411b363SPhilipp Reisner 447582bc0194SAndreas Gruenbacher return 0; 4476b411b363SPhilipp Reisner } 4477b411b363SPhilipp Reisner 4478bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 447973a01a18SPhilipp Reisner { 44809f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4481b30ab791SAndreas Gruenbacher struct drbd_device *device; 4482e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 44834a76b161SAndreas Gruenbacher 44849f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 44859f4fe9adSAndreas Gruenbacher if (!peer_device) 44864a76b161SAndreas Gruenbacher return -EIO; 44879f4fe9adSAndreas Gruenbacher device = peer_device->device; 448873a01a18SPhilipp Reisner 4489b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4490f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4491f735e363SLars Ellenberg case C_WF_BITMAP_T: 4492f735e363SLars Ellenberg case C_BEHIND: 4493f735e363SLars Ellenberg break; 4494f735e363SLars Ellenberg default: 4495d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4496b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4497f735e363SLars Ellenberg } 4498f735e363SLars Ellenberg 4499b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 450073a01a18SPhilipp Reisner 450182bc0194SAndreas Gruenbacher return 0; 450273a01a18SPhilipp Reisner } 450373a01a18SPhilipp Reisner 450402918be2SPhilipp Reisner struct data_cmd { 450502918be2SPhilipp Reisner int expect_payload; 450602918be2SPhilipp Reisner size_t pkt_size; 4507bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4508b411b363SPhilipp Reisner }; 4509b411b363SPhilipp Reisner 451002918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 451102918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 451202918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 451302918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 451402918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4515e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4516e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4517e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 451802918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 451902918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4520e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4521e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 452202918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 452302918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 452402918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 452502918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 452602918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 452702918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 452802918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 452902918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 453002918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 453102918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 453273a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 45334a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4534036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 4535a0fb3c47SLars Ellenberg [P_TRIM] = { 0, sizeof(struct p_trim), receive_Data }, 453602918be2SPhilipp Reisner }; 453702918be2SPhilipp Reisner 4538bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4539b411b363SPhilipp Reisner { 454077351055SPhilipp Reisner struct packet_info pi; 454102918be2SPhilipp Reisner size_t shs; /* sub header size */ 454282bc0194SAndreas Gruenbacher int err; 4543b411b363SPhilipp Reisner 4544bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 4545deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4546deebe195SAndreas Gruenbacher 4547bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4548bde89a9eSAndreas Gruenbacher if (drbd_recv_header(connection, &pi)) 454902918be2SPhilipp Reisner goto err_out; 455002918be2SPhilipp Reisner 4551deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 45524a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 45531ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 45542fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 455502918be2SPhilipp Reisner goto err_out; 45560b33a916SLars Ellenberg } 4557b411b363SPhilipp Reisner 4558e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4559e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 45601ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 45612fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4562c13f7e1aSLars Ellenberg goto err_out; 4563c13f7e1aSLars Ellenberg } 4564c13f7e1aSLars Ellenberg 4565c13f7e1aSLars Ellenberg if (shs) { 4566bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 4567a5c31904SAndreas Gruenbacher if (err) 456802918be2SPhilipp Reisner goto err_out; 4569e2857216SAndreas Gruenbacher pi.size -= shs; 4570b411b363SPhilipp Reisner } 457102918be2SPhilipp Reisner 4572bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 45734a76b161SAndreas Gruenbacher if (err) { 45741ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 45759f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 457602918be2SPhilipp Reisner goto err_out; 457702918be2SPhilipp Reisner } 457802918be2SPhilipp Reisner } 457982bc0194SAndreas Gruenbacher return; 458002918be2SPhilipp Reisner 458102918be2SPhilipp Reisner err_out: 4582bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4583b411b363SPhilipp Reisner } 4584b411b363SPhilipp Reisner 4585bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 4586f70b3511SPhilipp Reisner { 4587c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4588bbeb641cSPhilipp Reisner enum drbd_conns oc; 4589376694a0SPhilipp Reisner int vnr; 4590f70b3511SPhilipp Reisner 4591bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 4592b411b363SPhilipp Reisner return; 4593b411b363SPhilipp Reisner 4594545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4595545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4596545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4597545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4598545752d5SLars Ellenberg */ 4599bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4600545752d5SLars Ellenberg 4601b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4602bde89a9eSAndreas Gruenbacher drbd_thread_stop(&connection->asender); 4603bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 4604360cc740SPhilipp Reisner 4605c141ebdaSPhilipp Reisner rcu_read_lock(); 4606c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 4607c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4608b30ab791SAndreas Gruenbacher kref_get(&device->kref); 4609c141ebdaSPhilipp Reisner rcu_read_unlock(); 461069a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 4611c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 4612c141ebdaSPhilipp Reisner rcu_read_lock(); 4613c141ebdaSPhilipp Reisner } 4614c141ebdaSPhilipp Reisner rcu_read_unlock(); 4615c141ebdaSPhilipp Reisner 4616bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 46171ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 461812038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4619bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 4620bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 462112038a3aSPhilipp Reisner 46221ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 4623360cc740SPhilipp Reisner 4624bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 4625bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 4626cb703454SPhilipp Reisner 46270500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 4628bde89a9eSAndreas Gruenbacher oc = connection->cstate; 4629bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4630bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4631bbeb641cSPhilipp Reisner 46320500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 4633360cc740SPhilipp Reisner 4634f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4635bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4636360cc740SPhilipp Reisner } 4637360cc740SPhilipp Reisner 463869a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 4639360cc740SPhilipp Reisner { 464069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4641360cc740SPhilipp Reisner unsigned int i; 4642b411b363SPhilipp Reisner 464385719573SPhilipp Reisner /* wait for current activity to cease. */ 46440500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4645b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 4646b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 4647b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 46480500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4649b411b363SPhilipp Reisner 4650b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4651b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4652b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4653b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4654b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4655b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4656b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4657b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4658b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4659b411b363SPhilipp Reisner * on the fly. */ 4660b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4661b30ab791SAndreas Gruenbacher device->rs_total = 0; 4662b30ab791SAndreas Gruenbacher device->rs_failed = 0; 4663b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 4664b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 4665b411b363SPhilipp Reisner 4666b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 4667b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 4668b411b363SPhilipp Reisner 4669b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4670b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4671b411b363SPhilipp Reisner * to be "canceled" */ 4672b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4673b411b363SPhilipp Reisner 4674b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 4675b411b363SPhilipp Reisner 4676d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4677d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4678d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4679b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4680d10b4ea3SPhilipp Reisner 468108332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 468208332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 4683b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4684b411b363SPhilipp Reisner 4685b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4686b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 4687b411b363SPhilipp Reisner 4688b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 468969a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 4690b411b363SPhilipp Reisner 4691b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4692b411b363SPhilipp Reisner 469320ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 469420ceb2b2SLars Ellenberg * if any. */ 4695b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, !test_bit(BITMAP_IO, &device->flags)); 469620ceb2b2SLars Ellenberg 4697b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4698b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4699b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4700b411b363SPhilipp Reisner * 4701b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4702b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4703b411b363SPhilipp Reisner */ 4704b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 4705b411b363SPhilipp Reisner if (i) 4706d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 4707b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 4708435f0740SLars Ellenberg if (i) 4709d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 4710b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 4711b411b363SPhilipp Reisner if (i) 4712d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 4713b411b363SPhilipp Reisner 47140b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 47150b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 47160b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 47170b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 4718b411b363SPhilipp Reisner 4719360cc740SPhilipp Reisner return 0; 4720b411b363SPhilipp Reisner } 4721b411b363SPhilipp Reisner 4722b411b363SPhilipp Reisner /* 4723b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4724b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4725b411b363SPhilipp Reisner * 4726b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4727b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4728b411b363SPhilipp Reisner * 4729b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4730b411b363SPhilipp Reisner */ 4731bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 4732b411b363SPhilipp Reisner { 47339f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 47349f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4735b411b363SPhilipp Reisner 4736bde89a9eSAndreas Gruenbacher sock = &connection->data; 4737bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 47389f5bdc33SAndreas Gruenbacher if (!p) 4739e8d17b01SAndreas Gruenbacher return -EIO; 4740b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4741b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4742b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 474320c68fdeSLars Ellenberg p->feature_flags = cpu_to_be32(PRO_FEATURES); 4744bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4745b411b363SPhilipp Reisner } 4746b411b363SPhilipp Reisner 4747b411b363SPhilipp Reisner /* 4748b411b363SPhilipp Reisner * return values: 4749b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4750b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4751b411b363SPhilipp Reisner * -1 peer talks different language, 4752b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4753b411b363SPhilipp Reisner */ 4754bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 4755b411b363SPhilipp Reisner { 4756bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 4757e658983aSAndreas Gruenbacher struct p_connection_features *p; 4758e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 475977351055SPhilipp Reisner struct packet_info pi; 4760a5c31904SAndreas Gruenbacher int err; 4761b411b363SPhilipp Reisner 4762bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 4763e8d17b01SAndreas Gruenbacher if (err) 4764b411b363SPhilipp Reisner return 0; 4765b411b363SPhilipp Reisner 4766bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 476769bc7bc3SAndreas Gruenbacher if (err) 4768b411b363SPhilipp Reisner return 0; 4769b411b363SPhilipp Reisner 47706038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 47711ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 477277351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4773b411b363SPhilipp Reisner return -1; 4774b411b363SPhilipp Reisner } 4775b411b363SPhilipp Reisner 477677351055SPhilipp Reisner if (pi.size != expect) { 47771ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 477877351055SPhilipp Reisner expect, pi.size); 4779b411b363SPhilipp Reisner return -1; 4780b411b363SPhilipp Reisner } 4781b411b363SPhilipp Reisner 4782e658983aSAndreas Gruenbacher p = pi.data; 4783bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 4784a5c31904SAndreas Gruenbacher if (err) 4785b411b363SPhilipp Reisner return 0; 4786b411b363SPhilipp Reisner 4787b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4788b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4789b411b363SPhilipp Reisner if (p->protocol_max == 0) 4790b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4791b411b363SPhilipp Reisner 4792b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4793b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4794b411b363SPhilipp Reisner goto incompat; 4795b411b363SPhilipp Reisner 4796bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 479720c68fdeSLars Ellenberg connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); 4798b411b363SPhilipp Reisner 47991ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 4800bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 4801b411b363SPhilipp Reisner 480220c68fdeSLars Ellenberg drbd_info(connection, "Agreed to%ssupport TRIM on protocol level\n", 480320c68fdeSLars Ellenberg connection->agreed_features & FF_TRIM ? " " : " not "); 480420c68fdeSLars Ellenberg 4805b411b363SPhilipp Reisner return 1; 4806b411b363SPhilipp Reisner 4807b411b363SPhilipp Reisner incompat: 48081ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 4809b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4810b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4811b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4812b411b363SPhilipp Reisner return -1; 4813b411b363SPhilipp Reisner } 4814b411b363SPhilipp Reisner 4815b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4816bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4817b411b363SPhilipp Reisner { 48181ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 48191ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4820b10d96cbSJohannes Thoma return -1; 4821b411b363SPhilipp Reisner } 4822b411b363SPhilipp Reisner #else 4823b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4824b10d96cbSJohannes Thoma 4825b10d96cbSJohannes Thoma /* Return value: 4826b10d96cbSJohannes Thoma 1 - auth succeeded, 4827b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4828b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4829b10d96cbSJohannes Thoma */ 4830b10d96cbSJohannes Thoma 4831bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4832b411b363SPhilipp Reisner { 48339f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4834b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4835b411b363SPhilipp Reisner struct scatterlist sg; 4836b411b363SPhilipp Reisner char *response = NULL; 4837b411b363SPhilipp Reisner char *right_response = NULL; 4838b411b363SPhilipp Reisner char *peers_ch = NULL; 483944ed167dSPhilipp Reisner unsigned int key_len; 484044ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4841b411b363SPhilipp Reisner unsigned int resp_size; 4842b411b363SPhilipp Reisner struct hash_desc desc; 484377351055SPhilipp Reisner struct packet_info pi; 484444ed167dSPhilipp Reisner struct net_conf *nc; 484569bc7bc3SAndreas Gruenbacher int err, rv; 4846b411b363SPhilipp Reisner 48479f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 48489f5bdc33SAndreas Gruenbacher 484944ed167dSPhilipp Reisner rcu_read_lock(); 4850bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 485144ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 485244ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 485344ed167dSPhilipp Reisner rcu_read_unlock(); 485444ed167dSPhilipp Reisner 4855bde89a9eSAndreas Gruenbacher desc.tfm = connection->cram_hmac_tfm; 4856b411b363SPhilipp Reisner desc.flags = 0; 4857b411b363SPhilipp Reisner 4858bde89a9eSAndreas Gruenbacher rv = crypto_hash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 4859b411b363SPhilipp Reisner if (rv) { 48601ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_setkey() failed with %d\n", rv); 4861b10d96cbSJohannes Thoma rv = -1; 4862b411b363SPhilipp Reisner goto fail; 4863b411b363SPhilipp Reisner } 4864b411b363SPhilipp Reisner 4865b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4866b411b363SPhilipp Reisner 4867bde89a9eSAndreas Gruenbacher sock = &connection->data; 4868bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 48699f5bdc33SAndreas Gruenbacher rv = 0; 48709f5bdc33SAndreas Gruenbacher goto fail; 48719f5bdc33SAndreas Gruenbacher } 4872bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 48739f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4874b411b363SPhilipp Reisner if (!rv) 4875b411b363SPhilipp Reisner goto fail; 4876b411b363SPhilipp Reisner 4877bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 487869bc7bc3SAndreas Gruenbacher if (err) { 4879b411b363SPhilipp Reisner rv = 0; 4880b411b363SPhilipp Reisner goto fail; 4881b411b363SPhilipp Reisner } 4882b411b363SPhilipp Reisner 488377351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 48841ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 488577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4886b411b363SPhilipp Reisner rv = 0; 4887b411b363SPhilipp Reisner goto fail; 4888b411b363SPhilipp Reisner } 4889b411b363SPhilipp Reisner 489077351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 48911ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 4892b10d96cbSJohannes Thoma rv = -1; 4893b411b363SPhilipp Reisner goto fail; 4894b411b363SPhilipp Reisner } 4895b411b363SPhilipp Reisner 489667cca286SPhilipp Reisner if (pi.size < CHALLENGE_LEN) { 489767cca286SPhilipp Reisner drbd_err(connection, "AuthChallenge payload too small.\n"); 489867cca286SPhilipp Reisner rv = -1; 489967cca286SPhilipp Reisner goto fail; 490067cca286SPhilipp Reisner } 490167cca286SPhilipp Reisner 490277351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4903b411b363SPhilipp Reisner if (peers_ch == NULL) { 49041ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 4905b10d96cbSJohannes Thoma rv = -1; 4906b411b363SPhilipp Reisner goto fail; 4907b411b363SPhilipp Reisner } 4908b411b363SPhilipp Reisner 4909bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 4910a5c31904SAndreas Gruenbacher if (err) { 4911b411b363SPhilipp Reisner rv = 0; 4912b411b363SPhilipp Reisner goto fail; 4913b411b363SPhilipp Reisner } 4914b411b363SPhilipp Reisner 491567cca286SPhilipp Reisner if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) { 491667cca286SPhilipp Reisner drbd_err(connection, "Peer presented the same challenge!\n"); 491767cca286SPhilipp Reisner rv = -1; 491867cca286SPhilipp Reisner goto fail; 491967cca286SPhilipp Reisner } 492067cca286SPhilipp Reisner 4921bde89a9eSAndreas Gruenbacher resp_size = crypto_hash_digestsize(connection->cram_hmac_tfm); 4922b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4923b411b363SPhilipp Reisner if (response == NULL) { 49241ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 4925b10d96cbSJohannes Thoma rv = -1; 4926b411b363SPhilipp Reisner goto fail; 4927b411b363SPhilipp Reisner } 4928b411b363SPhilipp Reisner 4929b411b363SPhilipp Reisner sg_init_table(&sg, 1); 493077351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4931b411b363SPhilipp Reisner 4932b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4933b411b363SPhilipp Reisner if (rv) { 49341ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4935b10d96cbSJohannes Thoma rv = -1; 4936b411b363SPhilipp Reisner goto fail; 4937b411b363SPhilipp Reisner } 4938b411b363SPhilipp Reisner 4939bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 49409f5bdc33SAndreas Gruenbacher rv = 0; 49419f5bdc33SAndreas Gruenbacher goto fail; 49429f5bdc33SAndreas Gruenbacher } 4943bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 49449f5bdc33SAndreas Gruenbacher response, resp_size); 4945b411b363SPhilipp Reisner if (!rv) 4946b411b363SPhilipp Reisner goto fail; 4947b411b363SPhilipp Reisner 4948bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 494969bc7bc3SAndreas Gruenbacher if (err) { 4950b411b363SPhilipp Reisner rv = 0; 4951b411b363SPhilipp Reisner goto fail; 4952b411b363SPhilipp Reisner } 4953b411b363SPhilipp Reisner 495477351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 49551ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 495677351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4957b411b363SPhilipp Reisner rv = 0; 4958b411b363SPhilipp Reisner goto fail; 4959b411b363SPhilipp Reisner } 4960b411b363SPhilipp Reisner 496177351055SPhilipp Reisner if (pi.size != resp_size) { 49621ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 4963b411b363SPhilipp Reisner rv = 0; 4964b411b363SPhilipp Reisner goto fail; 4965b411b363SPhilipp Reisner } 4966b411b363SPhilipp Reisner 4967bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 4968a5c31904SAndreas Gruenbacher if (err) { 4969b411b363SPhilipp Reisner rv = 0; 4970b411b363SPhilipp Reisner goto fail; 4971b411b363SPhilipp Reisner } 4972b411b363SPhilipp Reisner 4973b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 49742d1ee87dSJulia Lawall if (right_response == NULL) { 49751ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 4976b10d96cbSJohannes Thoma rv = -1; 4977b411b363SPhilipp Reisner goto fail; 4978b411b363SPhilipp Reisner } 4979b411b363SPhilipp Reisner 4980b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4981b411b363SPhilipp Reisner 4982b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4983b411b363SPhilipp Reisner if (rv) { 49841ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4985b10d96cbSJohannes Thoma rv = -1; 4986b411b363SPhilipp Reisner goto fail; 4987b411b363SPhilipp Reisner } 4988b411b363SPhilipp Reisner 4989b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4990b411b363SPhilipp Reisner 4991b411b363SPhilipp Reisner if (rv) 49921ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 499344ed167dSPhilipp Reisner resp_size); 4994b10d96cbSJohannes Thoma else 4995b10d96cbSJohannes Thoma rv = -1; 4996b411b363SPhilipp Reisner 4997b411b363SPhilipp Reisner fail: 4998b411b363SPhilipp Reisner kfree(peers_ch); 4999b411b363SPhilipp Reisner kfree(response); 5000b411b363SPhilipp Reisner kfree(right_response); 5001b411b363SPhilipp Reisner 5002b411b363SPhilipp Reisner return rv; 5003b411b363SPhilipp Reisner } 5004b411b363SPhilipp Reisner #endif 5005b411b363SPhilipp Reisner 50068fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 5007b411b363SPhilipp Reisner { 5008bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5009b411b363SPhilipp Reisner int h; 5010b411b363SPhilipp Reisner 50111ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 5012b411b363SPhilipp Reisner 5013b411b363SPhilipp Reisner do { 5014bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 5015b411b363SPhilipp Reisner if (h == 0) { 5016bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 501720ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 5018b411b363SPhilipp Reisner } 5019b411b363SPhilipp Reisner if (h == -1) { 50201ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 5021bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5022b411b363SPhilipp Reisner } 5023b411b363SPhilipp Reisner } while (h == 0); 5024b411b363SPhilipp Reisner 502591fd4dadSPhilipp Reisner if (h > 0) 5026bde89a9eSAndreas Gruenbacher drbdd(connection); 5027b411b363SPhilipp Reisner 5028bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 5029b411b363SPhilipp Reisner 50301ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 5031b411b363SPhilipp Reisner return 0; 5032b411b363SPhilipp Reisner } 5033b411b363SPhilipp Reisner 5034b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 5035b411b363SPhilipp Reisner 5036bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5037b411b363SPhilipp Reisner { 5038e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5039b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5040b411b363SPhilipp Reisner 5041b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 5042bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 5043b411b363SPhilipp Reisner } else { 5044bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 50451ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 5046fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5047fc3b10a4SPhilipp Reisner } 5048bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5049e4f78edeSPhilipp Reisner 50502735a594SAndreas Gruenbacher return 0; 5051fc3b10a4SPhilipp Reisner } 5052e4f78edeSPhilipp Reisner 5053bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5054e4f78edeSPhilipp Reisner { 50559f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5056b30ab791SAndreas Gruenbacher struct drbd_device *device; 5057e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5058e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5059e4f78edeSPhilipp Reisner 50609f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 50619f4fe9adSAndreas Gruenbacher if (!peer_device) 50622735a594SAndreas Gruenbacher return -EIO; 50639f4fe9adSAndreas Gruenbacher device = peer_device->device; 50641952e916SAndreas Gruenbacher 5065bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 50660b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 5067bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 50684d0fc3fdSPhilipp Reisner } 50694d0fc3fdSPhilipp Reisner 5070e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 5071b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 5072e4f78edeSPhilipp Reisner } else { 5073b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 5074d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 5075b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5076b411b363SPhilipp Reisner } 5077b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 5078b411b363SPhilipp Reisner 50792735a594SAndreas Gruenbacher return 0; 5080b411b363SPhilipp Reisner } 5081b411b363SPhilipp Reisner 5082bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 5083b411b363SPhilipp Reisner { 5084bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 5085b411b363SPhilipp Reisner 5086b411b363SPhilipp Reisner } 5087b411b363SPhilipp Reisner 5088bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 5089b411b363SPhilipp Reisner { 5090b411b363SPhilipp Reisner /* restore idle timeout */ 5091bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 5092bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 5093bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5094b411b363SPhilipp Reisner 50952735a594SAndreas Gruenbacher return 0; 5096b411b363SPhilipp Reisner } 5097b411b363SPhilipp Reisner 5098bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 5099b411b363SPhilipp Reisner { 51009f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5101b30ab791SAndreas Gruenbacher struct drbd_device *device; 5102e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5103b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5104b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5105b411b363SPhilipp Reisner 51069f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51079f4fe9adSAndreas Gruenbacher if (!peer_device) 51082735a594SAndreas Gruenbacher return -EIO; 51099f4fe9adSAndreas Gruenbacher device = peer_device->device; 51101952e916SAndreas Gruenbacher 51119f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 5112b411b363SPhilipp Reisner 511369a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5114b411b363SPhilipp Reisner 5115b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 5116b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5117b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5118b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 5119b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 5120b30ab791SAndreas Gruenbacher put_ldev(device); 51211d53f09eSLars Ellenberg } 5122b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5123b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5124b411b363SPhilipp Reisner 51252735a594SAndreas Gruenbacher return 0; 5126b411b363SPhilipp Reisner } 5127b411b363SPhilipp Reisner 5128bc9c5c41SAndreas Gruenbacher static int 5129b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5130bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5131bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5132b411b363SPhilipp Reisner { 5133b411b363SPhilipp Reisner struct drbd_request *req; 5134b411b363SPhilipp Reisner struct bio_and_error m; 5135b411b363SPhilipp Reisner 51360500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5137b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5138b411b363SPhilipp Reisner if (unlikely(!req)) { 51390500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 514085997675SAndreas Gruenbacher return -EIO; 5141b411b363SPhilipp Reisner } 5142b411b363SPhilipp Reisner __req_mod(req, what, &m); 51430500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5144b411b363SPhilipp Reisner 5145b411b363SPhilipp Reisner if (m.bio) 5146b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 514785997675SAndreas Gruenbacher return 0; 5148b411b363SPhilipp Reisner } 5149b411b363SPhilipp Reisner 5150bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5151b411b363SPhilipp Reisner { 51529f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5153b30ab791SAndreas Gruenbacher struct drbd_device *device; 5154e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5155b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5156b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5157b411b363SPhilipp Reisner enum drbd_req_event what; 5158b411b363SPhilipp Reisner 51599f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51609f4fe9adSAndreas Gruenbacher if (!peer_device) 51612735a594SAndreas Gruenbacher return -EIO; 51629f4fe9adSAndreas Gruenbacher device = peer_device->device; 51631952e916SAndreas Gruenbacher 516469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5165b411b363SPhilipp Reisner 5166579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5167b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5168b30ab791SAndreas Gruenbacher dec_rs_pending(device); 51692735a594SAndreas Gruenbacher return 0; 5170b411b363SPhilipp Reisner } 5171e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5172b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 51738554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5174b411b363SPhilipp Reisner break; 5175b411b363SPhilipp Reisner case P_WRITE_ACK: 51768554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5177b411b363SPhilipp Reisner break; 5178b411b363SPhilipp Reisner case P_RECV_ACK: 51798554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5180b411b363SPhilipp Reisner break; 5181d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5182d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 51837be8da07SAndreas Gruenbacher break; 51847be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 51857be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5186b411b363SPhilipp Reisner break; 5187b411b363SPhilipp Reisner default: 51882735a594SAndreas Gruenbacher BUG(); 5189b411b363SPhilipp Reisner } 5190b411b363SPhilipp Reisner 5191b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5192b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5193bc9c5c41SAndreas Gruenbacher what, false); 5194b411b363SPhilipp Reisner } 5195b411b363SPhilipp Reisner 5196bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5197b411b363SPhilipp Reisner { 51989f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5199b30ab791SAndreas Gruenbacher struct drbd_device *device; 5200e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5201b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 52022deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 520385997675SAndreas Gruenbacher int err; 5204b411b363SPhilipp Reisner 52059f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52069f4fe9adSAndreas Gruenbacher if (!peer_device) 52072735a594SAndreas Gruenbacher return -EIO; 52089f4fe9adSAndreas Gruenbacher device = peer_device->device; 5209b411b363SPhilipp Reisner 521069a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5211b411b363SPhilipp Reisner 5212579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5213b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5214b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 52152735a594SAndreas Gruenbacher return 0; 5216b411b363SPhilipp Reisner } 52172deb8336SPhilipp Reisner 5218b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5219b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5220303d1448SPhilipp Reisner NEG_ACKED, true); 522185997675SAndreas Gruenbacher if (err) { 52222deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 52232deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5224c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 52252deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 52262deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5227b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 52282deb8336SPhilipp Reisner } 52292735a594SAndreas Gruenbacher return 0; 5230b411b363SPhilipp Reisner } 5231b411b363SPhilipp Reisner 5232bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5233b411b363SPhilipp Reisner { 52349f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5235b30ab791SAndreas Gruenbacher struct drbd_device *device; 5236e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5237b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5238b411b363SPhilipp Reisner 52399f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52409f4fe9adSAndreas Gruenbacher if (!peer_device) 52412735a594SAndreas Gruenbacher return -EIO; 52429f4fe9adSAndreas Gruenbacher device = peer_device->device; 52431952e916SAndreas Gruenbacher 524469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 52457be8da07SAndreas Gruenbacher 5246d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5247b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5248b411b363SPhilipp Reisner 5249b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5250b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 52518554df1cSAndreas Gruenbacher NEG_ACKED, false); 5252b411b363SPhilipp Reisner } 5253b411b363SPhilipp Reisner 5254bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5255b411b363SPhilipp Reisner { 52569f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5257b30ab791SAndreas Gruenbacher struct drbd_device *device; 5258b411b363SPhilipp Reisner sector_t sector; 5259b411b363SPhilipp Reisner int size; 5260e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 52611952e916SAndreas Gruenbacher 52629f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52639f4fe9adSAndreas Gruenbacher if (!peer_device) 52642735a594SAndreas Gruenbacher return -EIO; 52659f4fe9adSAndreas Gruenbacher device = peer_device->device; 5266b411b363SPhilipp Reisner 5267b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5268b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5269b411b363SPhilipp Reisner 527069a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5271b411b363SPhilipp Reisner 5272b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5273b411b363SPhilipp Reisner 5274b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5275b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5276e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5277d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5278b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5279d612d309SPhilipp Reisner case P_RS_CANCEL: 5280d612d309SPhilipp Reisner break; 5281d612d309SPhilipp Reisner default: 52822735a594SAndreas Gruenbacher BUG(); 5283d612d309SPhilipp Reisner } 5284b30ab791SAndreas Gruenbacher put_ldev(device); 5285b411b363SPhilipp Reisner } 5286b411b363SPhilipp Reisner 52872735a594SAndreas Gruenbacher return 0; 5288b411b363SPhilipp Reisner } 5289b411b363SPhilipp Reisner 5290bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5291b411b363SPhilipp Reisner { 5292e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5293c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 52949ed57dcbSLars Ellenberg int vnr; 5295b411b363SPhilipp Reisner 5296bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5297b411b363SPhilipp Reisner 52989ed57dcbSLars Ellenberg rcu_read_lock(); 5299c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5300c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5301c06ece6bSAndreas Gruenbacher 5302b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5303b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5304b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5305b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5306b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5307c4752ef1SPhilipp Reisner } 53089ed57dcbSLars Ellenberg } 53099ed57dcbSLars Ellenberg rcu_read_unlock(); 5310c4752ef1SPhilipp Reisner 53112735a594SAndreas Gruenbacher return 0; 5312b411b363SPhilipp Reisner } 5313b411b363SPhilipp Reisner 5314bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5315b411b363SPhilipp Reisner { 53169f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5317b30ab791SAndreas Gruenbacher struct drbd_device *device; 5318e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 531984b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5320b411b363SPhilipp Reisner sector_t sector; 5321b411b363SPhilipp Reisner int size; 5322b411b363SPhilipp Reisner 53239f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 53249f4fe9adSAndreas Gruenbacher if (!peer_device) 53252735a594SAndreas Gruenbacher return -EIO; 53269f4fe9adSAndreas Gruenbacher device = peer_device->device; 53271952e916SAndreas Gruenbacher 5328b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5329b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5330b411b363SPhilipp Reisner 533169a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5332b411b363SPhilipp Reisner 5333b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5334b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5335b411b363SPhilipp Reisner else 5336b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5337b411b363SPhilipp Reisner 5338b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 53392735a594SAndreas Gruenbacher return 0; 53401d53f09eSLars Ellenberg 5341b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5342b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5343b411b363SPhilipp Reisner 5344b30ab791SAndreas Gruenbacher --device->ov_left; 5345ea5442afSLars Ellenberg 5346ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5347b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5348b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5349ea5442afSLars Ellenberg 5350b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 535184b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 535284b8c06bSAndreas Gruenbacher if (dw) { 535384b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 535484b8c06bSAndreas Gruenbacher dw->device = device; 535584b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5356b411b363SPhilipp Reisner } else { 535784b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5358b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5359b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5360b411b363SPhilipp Reisner } 5361b411b363SPhilipp Reisner } 5362b30ab791SAndreas Gruenbacher put_ldev(device); 53632735a594SAndreas Gruenbacher return 0; 5364b411b363SPhilipp Reisner } 5365b411b363SPhilipp Reisner 5366bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 53670ced55a3SPhilipp Reisner { 53682735a594SAndreas Gruenbacher return 0; 53690ced55a3SPhilipp Reisner } 53700ced55a3SPhilipp Reisner 5371bde89a9eSAndreas Gruenbacher static int connection_finish_peer_reqs(struct drbd_connection *connection) 537232862ec7SPhilipp Reisner { 5373c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5374c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 537532862ec7SPhilipp Reisner 537632862ec7SPhilipp Reisner do { 5377bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 537832862ec7SPhilipp Reisner flush_signals(current); 5379c141ebdaSPhilipp Reisner 5380c141ebdaSPhilipp Reisner rcu_read_lock(); 5381c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5382c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5383b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5384c141ebdaSPhilipp Reisner rcu_read_unlock(); 5385b30ab791SAndreas Gruenbacher if (drbd_finish_peer_reqs(device)) { 538605a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5387c141ebdaSPhilipp Reisner return 1; 5388082a3439SPhilipp Reisner } 538905a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5390c141ebdaSPhilipp Reisner rcu_read_lock(); 5391d3fcb490SPhilipp Reisner } 5392bde89a9eSAndreas Gruenbacher set_bit(SIGNAL_ASENDER, &connection->flags); 5393082a3439SPhilipp Reisner 53940500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5395c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5396c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5397b30ab791SAndreas Gruenbacher not_empty = !list_empty(&device->done_ee); 5398082a3439SPhilipp Reisner if (not_empty) 5399082a3439SPhilipp Reisner break; 5400082a3439SPhilipp Reisner } 54010500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5402c141ebdaSPhilipp Reisner rcu_read_unlock(); 540332862ec7SPhilipp Reisner } while (not_empty); 540432862ec7SPhilipp Reisner 540532862ec7SPhilipp Reisner return 0; 5406b411b363SPhilipp Reisner } 5407b411b363SPhilipp Reisner 5408b411b363SPhilipp Reisner struct asender_cmd { 5409b411b363SPhilipp Reisner size_t pkt_size; 5410bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5411b411b363SPhilipp Reisner }; 5412b411b363SPhilipp Reisner 5413b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 5414e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5415e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5416b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5417b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5418b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5419d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5420b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5421b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5422b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5423b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5424b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5425b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5426b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 542702918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5428d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 54291952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 54301952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5431b411b363SPhilipp Reisner }; 5432b411b363SPhilipp Reisner 5433b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5434b411b363SPhilipp Reisner { 5435bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5436b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 543777351055SPhilipp Reisner struct packet_info pi; 5438257d0af6SPhilipp Reisner int rv; 5439bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5440b411b363SPhilipp Reisner int received = 0; 5441bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 544252b061a4SAndreas Gruenbacher int expect = header_size; 544344ed167dSPhilipp Reisner bool ping_timeout_active = false; 544444ed167dSPhilipp Reisner struct net_conf *nc; 5445bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 54463990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5447b411b363SPhilipp Reisner 54483990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 54493990e04dSPhilipp Reisner if (rv < 0) 54501ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_asender: ERROR set priority, ret=%d\n", rv); 5451b411b363SPhilipp Reisner 5452e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 545380822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 545444ed167dSPhilipp Reisner 545544ed167dSPhilipp Reisner rcu_read_lock(); 5456bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 545744ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5458bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 545944ed167dSPhilipp Reisner ping_int = nc->ping_int; 546044ed167dSPhilipp Reisner rcu_read_unlock(); 546144ed167dSPhilipp Reisner 5462bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5463bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 54641ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5465841ce241SAndreas Gruenbacher goto reconnect; 5466841ce241SAndreas Gruenbacher } 5467bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 546844ed167dSPhilipp Reisner ping_timeout_active = true; 5469b411b363SPhilipp Reisner } 5470b411b363SPhilipp Reisner 547132862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 547232862ec7SPhilipp Reisner much to send */ 5473bb77d34eSAndreas Gruenbacher if (tcp_cork) 5474bde89a9eSAndreas Gruenbacher drbd_tcp_cork(connection->meta.socket); 5475bde89a9eSAndreas Gruenbacher if (connection_finish_peer_reqs(connection)) { 54761ec861ebSAndreas Gruenbacher drbd_err(connection, "connection_finish_peer_reqs() failed\n"); 5477b411b363SPhilipp Reisner goto reconnect; 5478b411b363SPhilipp Reisner } 5479b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5480bb77d34eSAndreas Gruenbacher if (tcp_cork) 5481bde89a9eSAndreas Gruenbacher drbd_tcp_uncork(connection->meta.socket); 5482b411b363SPhilipp Reisner 5483b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5484b411b363SPhilipp Reisner if (signal_pending(current)) 5485b411b363SPhilipp Reisner continue; 5486b411b363SPhilipp Reisner 5487bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5488bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5489b411b363SPhilipp Reisner 5490b411b363SPhilipp Reisner flush_signals(current); 5491b411b363SPhilipp Reisner 5492b411b363SPhilipp Reisner /* Note: 5493b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5494b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5495b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5496b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5497b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5498b411b363SPhilipp Reisner * rv == expected: full header or command 5499b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5500b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5501b411b363SPhilipp Reisner */ 5502b411b363SPhilipp Reisner if (likely(rv > 0)) { 5503b411b363SPhilipp Reisner received += rv; 5504b411b363SPhilipp Reisner buf += rv; 5505b411b363SPhilipp Reisner } else if (rv == 0) { 5506bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5507b66623e3SPhilipp Reisner long t; 5508b66623e3SPhilipp Reisner rcu_read_lock(); 5509bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5510b66623e3SPhilipp Reisner rcu_read_unlock(); 5511b66623e3SPhilipp Reisner 5512bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5513bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5514b66623e3SPhilipp Reisner t); 5515599377acSPhilipp Reisner if (t) 5516599377acSPhilipp Reisner break; 5517599377acSPhilipp Reisner } 55181ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5519b411b363SPhilipp Reisner goto reconnect; 5520b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5521cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5522cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5523bde89a9eSAndreas Gruenbacher if (time_after(connection->last_received, 5524bde89a9eSAndreas Gruenbacher jiffies - connection->meta.socket->sk->sk_rcvtimeo)) 5525cb6518cbSLars Ellenberg continue; 5526f36af18cSLars Ellenberg if (ping_timeout_active) { 55271ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5528b411b363SPhilipp Reisner goto reconnect; 5529b411b363SPhilipp Reisner } 5530bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5531b411b363SPhilipp Reisner continue; 5532b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5533b411b363SPhilipp Reisner continue; 5534b411b363SPhilipp Reisner } else { 55351ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5536b411b363SPhilipp Reisner goto reconnect; 5537b411b363SPhilipp Reisner } 5538b411b363SPhilipp Reisner 5539b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5540bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5541b411b363SPhilipp Reisner goto reconnect; 55427201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 55431952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 55441ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 55452fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5546b411b363SPhilipp Reisner goto disconnect; 5547b411b363SPhilipp Reisner } 5548e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 554952b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 55501ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 555177351055SPhilipp Reisner pi.cmd, pi.size); 5552b411b363SPhilipp Reisner goto reconnect; 5553b411b363SPhilipp Reisner } 5554257d0af6SPhilipp Reisner } 5555b411b363SPhilipp Reisner if (received == expect) { 55562735a594SAndreas Gruenbacher bool err; 5557a4fbda8eSPhilipp Reisner 5558bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 55592735a594SAndreas Gruenbacher if (err) { 55601ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5561b411b363SPhilipp Reisner goto reconnect; 55621952e916SAndreas Gruenbacher } 5563b411b363SPhilipp Reisner 5564bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5565f36af18cSLars Ellenberg 556644ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 556744ed167dSPhilipp Reisner /* restore idle timeout */ 5568bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 556944ed167dSPhilipp Reisner ping_timeout_active = false; 557044ed167dSPhilipp Reisner } 5571b411b363SPhilipp Reisner 5572bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5573b411b363SPhilipp Reisner received = 0; 557452b061a4SAndreas Gruenbacher expect = header_size; 5575b411b363SPhilipp Reisner cmd = NULL; 5576b411b363SPhilipp Reisner } 5577b411b363SPhilipp Reisner } 5578b411b363SPhilipp Reisner 5579b411b363SPhilipp Reisner if (0) { 5580b411b363SPhilipp Reisner reconnect: 5581bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5582bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5583b411b363SPhilipp Reisner } 5584b411b363SPhilipp Reisner if (0) { 5585b411b363SPhilipp Reisner disconnect: 5586bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5587b411b363SPhilipp Reisner } 5588bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5589b411b363SPhilipp Reisner 55901ec861ebSAndreas Gruenbacher drbd_info(connection, "asender terminated\n"); 5591b411b363SPhilipp Reisner 5592b411b363SPhilipp Reisner return 0; 5593b411b363SPhilipp Reisner } 5594