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; 7949f5bdc33SAndreas Gruenbacher int err; 795b411b363SPhilipp Reisner 796bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 7979f5bdc33SAndreas Gruenbacher if (err != header_size) { 7989f5bdc33SAndreas Gruenbacher if (err >= 0) 7999f5bdc33SAndreas Gruenbacher err = -EIO; 8009f5bdc33SAndreas Gruenbacher return err; 8019f5bdc33SAndreas Gruenbacher } 802bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8039f5bdc33SAndreas Gruenbacher if (err) 8049f5bdc33SAndreas Gruenbacher return err; 8059f5bdc33SAndreas Gruenbacher return pi.cmd; 806b411b363SPhilipp Reisner } 807b411b363SPhilipp Reisner 808b411b363SPhilipp Reisner /** 809b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 810b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 811b411b363SPhilipp Reisner */ 812dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 813b411b363SPhilipp Reisner { 814b411b363SPhilipp Reisner int rr; 815b411b363SPhilipp Reisner char tb[4]; 816b411b363SPhilipp Reisner 817b411b363SPhilipp Reisner if (!*sock) 81881e84650SAndreas Gruenbacher return false; 819b411b363SPhilipp Reisner 820dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 821b411b363SPhilipp Reisner 822b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 82381e84650SAndreas Gruenbacher return true; 824b411b363SPhilipp Reisner } else { 825b411b363SPhilipp Reisner sock_release(*sock); 826b411b363SPhilipp Reisner *sock = NULL; 82781e84650SAndreas Gruenbacher return false; 828b411b363SPhilipp Reisner } 829b411b363SPhilipp Reisner } 8302325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8312325eb66SPhilipp Reisner in a connection */ 83269a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 833907599e0SPhilipp Reisner { 83469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 8350829f5edSAndreas Gruenbacher int err; 836907599e0SPhilipp Reisner 837b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 838b30ab791SAndreas Gruenbacher device->peer_seq = 0; 839907599e0SPhilipp Reisner 84069a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 84169a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 842b30ab791SAndreas Gruenbacher &device->own_state_mutex; 8438410da8fSPhilipp Reisner 84469a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 8450829f5edSAndreas Gruenbacher if (!err) 84669a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 8470829f5edSAndreas Gruenbacher if (!err) 84869a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 8490829f5edSAndreas Gruenbacher if (!err) 85069a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 851b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 852b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 853b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 854b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 8550829f5edSAndreas Gruenbacher return err; 856907599e0SPhilipp Reisner } 857b411b363SPhilipp Reisner 858b411b363SPhilipp Reisner /* 859b411b363SPhilipp Reisner * return values: 860b411b363SPhilipp Reisner * 1 yes, we have a valid connection 861b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 862b411b363SPhilipp Reisner * -1 peer talks different language, 863b411b363SPhilipp Reisner * no point in trying again, please go standalone. 864b411b363SPhilipp Reisner * -2 We do not have a network config... 865b411b363SPhilipp Reisner */ 866bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 867b411b363SPhilipp Reisner { 8687da35862SPhilipp Reisner struct drbd_socket sock, msock; 869c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 87044ed167dSPhilipp Reisner struct net_conf *nc; 87192f14951SPhilipp Reisner int vnr, timeout, h, ok; 87208b165baSPhilipp Reisner bool discard_my_data; 873197296ffSPhilipp Reisner enum drbd_state_rv rv; 8747a426fd8SPhilipp Reisner struct accept_wait_data ad = { 875bde89a9eSAndreas Gruenbacher .connection = connection, 8767a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8777a426fd8SPhilipp Reisner }; 878b411b363SPhilipp Reisner 879bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 880bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 881b411b363SPhilipp Reisner return -2; 882b411b363SPhilipp Reisner 8837da35862SPhilipp Reisner mutex_init(&sock.mutex); 884bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 885bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 8867da35862SPhilipp Reisner sock.socket = NULL; 8877da35862SPhilipp Reisner mutex_init(&msock.mutex); 888bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 889bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 8907da35862SPhilipp Reisner msock.socket = NULL; 8917da35862SPhilipp Reisner 8920916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 893bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 894b411b363SPhilipp Reisner 895bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 8967a426fd8SPhilipp Reisner return 0; 897b411b363SPhilipp Reisner 898b411b363SPhilipp Reisner do { 8992bf89621SAndreas Gruenbacher struct socket *s; 900b411b363SPhilipp Reisner 901bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 902b411b363SPhilipp Reisner if (s) { 9037da35862SPhilipp Reisner if (!sock.socket) { 9047da35862SPhilipp Reisner sock.socket = s; 905bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9067da35862SPhilipp Reisner } else if (!msock.socket) { 907bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9087da35862SPhilipp Reisner msock.socket = s; 909bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 910b411b363SPhilipp Reisner } else { 9111ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 912b411b363SPhilipp Reisner goto out_release_sockets; 913b411b363SPhilipp Reisner } 914b411b363SPhilipp Reisner } 915b411b363SPhilipp Reisner 9167da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9177da35862SPhilipp Reisner rcu_read_lock(); 918bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 9197da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9207da35862SPhilipp Reisner rcu_read_unlock(); 9217da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9227da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9237da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 924b411b363SPhilipp Reisner if (ok) 925b411b363SPhilipp Reisner break; 926b411b363SPhilipp Reisner } 927b411b363SPhilipp Reisner 928b411b363SPhilipp Reisner retry: 929bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 930b411b363SPhilipp Reisner if (s) { 931bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9327da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9337da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 93492f14951SPhilipp Reisner switch (fp) { 935e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9367da35862SPhilipp Reisner if (sock.socket) { 9371ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9387da35862SPhilipp Reisner sock_release(sock.socket); 93980c6eed4SPhilipp Reisner sock.socket = s; 94080c6eed4SPhilipp Reisner goto randomize; 941b411b363SPhilipp Reisner } 9427da35862SPhilipp Reisner sock.socket = s; 943b411b363SPhilipp Reisner break; 944e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 945bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 9467da35862SPhilipp Reisner if (msock.socket) { 9471ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 9487da35862SPhilipp Reisner sock_release(msock.socket); 94980c6eed4SPhilipp Reisner msock.socket = s; 95080c6eed4SPhilipp Reisner goto randomize; 951b411b363SPhilipp Reisner } 9527da35862SPhilipp Reisner msock.socket = s; 953b411b363SPhilipp Reisner break; 954b411b363SPhilipp Reisner default: 9551ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 956b411b363SPhilipp Reisner sock_release(s); 95780c6eed4SPhilipp Reisner randomize: 95838b682b2SAkinobu Mita if (prandom_u32() & 1) 959b411b363SPhilipp Reisner goto retry; 960b411b363SPhilipp Reisner } 961b411b363SPhilipp Reisner } 962b411b363SPhilipp Reisner 963bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 964b411b363SPhilipp Reisner goto out_release_sockets; 965b411b363SPhilipp Reisner if (signal_pending(current)) { 966b411b363SPhilipp Reisner flush_signals(current); 967b411b363SPhilipp Reisner smp_rmb(); 968bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 969b411b363SPhilipp Reisner goto out_release_sockets; 970b411b363SPhilipp Reisner } 971b411b363SPhilipp Reisner 9727da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9737da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 974b666dbf8SPhilipp Reisner } while (!ok); 975b411b363SPhilipp Reisner 9767a426fd8SPhilipp Reisner if (ad.s_listen) 9777a426fd8SPhilipp Reisner sock_release(ad.s_listen); 978b411b363SPhilipp Reisner 97998683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 98098683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 981b411b363SPhilipp Reisner 9827da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9837da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 984b411b363SPhilipp Reisner 9857da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9867da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 987b411b363SPhilipp Reisner 988b411b363SPhilipp Reisner /* NOT YET ... 989bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 9907da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9916038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 992b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 99344ed167dSPhilipp Reisner rcu_read_lock(); 994bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 995b411b363SPhilipp Reisner 9967da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 9977da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 99844ed167dSPhilipp Reisner 9997da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 100044ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 100108b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 100244ed167dSPhilipp Reisner rcu_read_unlock(); 100344ed167dSPhilipp Reisner 10047da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1005b411b363SPhilipp Reisner 1006b411b363SPhilipp Reisner /* we don't want delays. 100725985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10087da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10097da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1010b411b363SPhilipp Reisner 1011bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1012bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1013bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1014b411b363SPhilipp Reisner 1015bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1016b411b363SPhilipp Reisner if (h <= 0) 1017b411b363SPhilipp Reisner return h; 1018b411b363SPhilipp Reisner 1019bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1020b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1021bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1022b10d96cbSJohannes Thoma case -1: 10231ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1024b411b363SPhilipp Reisner return -1; 1025b10d96cbSJohannes Thoma case 0: 10261ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1027b10d96cbSJohannes Thoma return 0; 1028b411b363SPhilipp Reisner } 1029b411b363SPhilipp Reisner } 1030b411b363SPhilipp Reisner 1031bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1032bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1033b411b363SPhilipp Reisner 1034bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10357e2455c1SPhilipp Reisner return -1; 10361e86ac48SPhilipp Reisner 103713c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 103813c76abaSPhilipp Reisner * being promoted to Primary. 103913c76abaSPhilipp Reisner * 104013c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 104113c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 104213c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 104313c76abaSPhilipp Reisner */ 104431007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 104531007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 104631007745SPhilipp Reisner 104731007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 104831007745SPhilipp Reisner 104931007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 105031007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 105131007745SPhilipp Reisner 105231007745SPhilipp Reisner rcu_read_lock(); 105331007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 105431007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 105531007745SPhilipp Reisner kref_get(&device->kref); 105631007745SPhilipp Reisner rcu_read_unlock(); 105713c76abaSPhilipp Reisner 105808b165baSPhilipp Reisner if (discard_my_data) 1059b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 106008b165baSPhilipp Reisner else 1061b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 106208b165baSPhilipp Reisner 106369a22773SAndreas Gruenbacher drbd_connected(peer_device); 106405a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1065c141ebdaSPhilipp Reisner rcu_read_lock(); 1066c141ebdaSPhilipp Reisner } 1067c141ebdaSPhilipp Reisner rcu_read_unlock(); 1068c141ebdaSPhilipp Reisner 1069bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1070bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1071bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 10721e86ac48SPhilipp Reisner return 0; 1073a1096a6eSPhilipp Reisner } 10741e86ac48SPhilipp Reisner 1075bde89a9eSAndreas Gruenbacher drbd_thread_start(&connection->asender); 1076b411b363SPhilipp Reisner 10770500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 107808b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 107908b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 108008b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 108108b165baSPhilipp Reisner * just to clear a single value. */ 1082bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 10830500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 108408b165baSPhilipp Reisner 1085d3fcb490SPhilipp Reisner return h; 1086b411b363SPhilipp Reisner 1087b411b363SPhilipp Reisner out_release_sockets: 10887a426fd8SPhilipp Reisner if (ad.s_listen) 10897a426fd8SPhilipp Reisner sock_release(ad.s_listen); 10907da35862SPhilipp Reisner if (sock.socket) 10917da35862SPhilipp Reisner sock_release(sock.socket); 10927da35862SPhilipp Reisner if (msock.socket) 10937da35862SPhilipp Reisner sock_release(msock.socket); 1094b411b363SPhilipp Reisner return -1; 1095b411b363SPhilipp Reisner } 1096b411b363SPhilipp Reisner 1097bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1098b411b363SPhilipp Reisner { 1099bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1100b411b363SPhilipp Reisner 11010c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11020c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11030c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11040c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11051ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11060c8e36d9SAndreas Gruenbacher return -EINVAL; 110702918be2SPhilipp Reisner } 11080c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11090c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11100c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11110c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1112e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1113e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1114e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1115b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1116eefc2f7dSPhilipp Reisner pi->vnr = 0; 1117e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1118e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1119e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1120e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1121e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 112277351055SPhilipp Reisner pi->vnr = 0; 112302918be2SPhilipp Reisner } else { 11241ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1125e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1126bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11278172f3e9SAndreas Gruenbacher return -EINVAL; 1128b411b363SPhilipp Reisner } 1129e658983aSAndreas Gruenbacher pi->data = header + header_size; 11308172f3e9SAndreas Gruenbacher return 0; 1131b411b363SPhilipp Reisner } 1132b411b363SPhilipp Reisner 1133bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1134257d0af6SPhilipp Reisner { 1135bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 113669bc7bc3SAndreas Gruenbacher int err; 1137257d0af6SPhilipp Reisner 1138bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1139a5c31904SAndreas Gruenbacher if (err) 114069bc7bc3SAndreas Gruenbacher return err; 1141257d0af6SPhilipp Reisner 1142bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1143bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1144b411b363SPhilipp Reisner 114569bc7bc3SAndreas Gruenbacher return err; 1146b411b363SPhilipp Reisner } 1147b411b363SPhilipp Reisner 1148bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1149b411b363SPhilipp Reisner { 1150b411b363SPhilipp Reisner int rv; 1151c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 11524b0007c0SPhilipp Reisner int vnr; 1153b411b363SPhilipp Reisner 1154e9526580SPhilipp Reisner if (connection->resource->write_ordering >= WO_bdev_flush) { 1155615e087fSLars Ellenberg rcu_read_lock(); 1156c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1157c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1158c06ece6bSAndreas Gruenbacher 1159b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1160615e087fSLars Ellenberg continue; 1161b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1162615e087fSLars Ellenberg rcu_read_unlock(); 11634b0007c0SPhilipp Reisner 1164b30ab791SAndreas Gruenbacher rv = blkdev_issue_flush(device->ldev->backing_bdev, 1165615e087fSLars Ellenberg GFP_NOIO, NULL); 1166b411b363SPhilipp Reisner if (rv) { 1167d0180171SAndreas Gruenbacher drbd_info(device, "local disk flush failed with status %d\n", rv); 1168b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1169b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1170b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11718fe39aacSPhilipp Reisner drbd_bump_write_ordering(connection->resource, NULL, WO_drain_io); 1172b411b363SPhilipp Reisner } 1173b30ab791SAndreas Gruenbacher put_ldev(device); 117405a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1175615e087fSLars Ellenberg 1176615e087fSLars Ellenberg rcu_read_lock(); 1177615e087fSLars Ellenberg if (rv) 11784b0007c0SPhilipp Reisner break; 1179b411b363SPhilipp Reisner } 1180615e087fSLars Ellenberg rcu_read_unlock(); 1181b411b363SPhilipp Reisner } 1182b411b363SPhilipp Reisner } 1183b411b363SPhilipp Reisner 1184b411b363SPhilipp Reisner /** 1185b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1186b30ab791SAndreas Gruenbacher * @device: DRBD device. 1187b411b363SPhilipp Reisner * @epoch: Epoch object. 1188b411b363SPhilipp Reisner * @ev: Epoch event. 1189b411b363SPhilipp Reisner */ 1190bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1191b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1192b411b363SPhilipp Reisner enum epoch_event ev) 1193b411b363SPhilipp Reisner { 11942451fc3bSPhilipp Reisner int epoch_size; 1195b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1196b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1197b411b363SPhilipp Reisner 1198bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1199b411b363SPhilipp Reisner do { 1200b411b363SPhilipp Reisner next_epoch = NULL; 1201b411b363SPhilipp Reisner 1202b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1203b411b363SPhilipp Reisner 1204b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1205b411b363SPhilipp Reisner case EV_PUT: 1206b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1207b411b363SPhilipp Reisner break; 1208b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1209b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1210b411b363SPhilipp Reisner break; 1211b411b363SPhilipp Reisner case EV_BECAME_LAST: 1212b411b363SPhilipp Reisner /* nothing to do*/ 1213b411b363SPhilipp Reisner break; 1214b411b363SPhilipp Reisner } 1215b411b363SPhilipp Reisner 1216b411b363SPhilipp Reisner if (epoch_size != 0 && 1217b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 121880f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1219b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1220bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1221bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1222bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1223b411b363SPhilipp Reisner } 12249ed57dcbSLars Ellenberg #if 0 12259ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12269ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 122780f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1228bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 12299ed57dcbSLars Ellenberg #endif 1230b411b363SPhilipp Reisner 1231bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1232b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1233b411b363SPhilipp Reisner list_del(&epoch->list); 1234b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1235bde89a9eSAndreas Gruenbacher connection->epochs--; 1236b411b363SPhilipp Reisner kfree(epoch); 1237b411b363SPhilipp Reisner 1238b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1239b411b363SPhilipp Reisner rv = FE_DESTROYED; 1240b411b363SPhilipp Reisner } else { 1241b411b363SPhilipp Reisner epoch->flags = 0; 1242b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1243698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1244b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1245b411b363SPhilipp Reisner rv = FE_RECYCLED; 1246b411b363SPhilipp Reisner } 1247b411b363SPhilipp Reisner } 1248b411b363SPhilipp Reisner 1249b411b363SPhilipp Reisner if (!next_epoch) 1250b411b363SPhilipp Reisner break; 1251b411b363SPhilipp Reisner 1252b411b363SPhilipp Reisner epoch = next_epoch; 1253b411b363SPhilipp Reisner } while (1); 1254b411b363SPhilipp Reisner 1255bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1256b411b363SPhilipp Reisner 1257b411b363SPhilipp Reisner return rv; 1258b411b363SPhilipp Reisner } 1259b411b363SPhilipp Reisner 12608fe39aacSPhilipp Reisner static enum write_ordering_e 12618fe39aacSPhilipp Reisner max_allowed_wo(struct drbd_backing_dev *bdev, enum write_ordering_e wo) 12628fe39aacSPhilipp Reisner { 12638fe39aacSPhilipp Reisner struct disk_conf *dc; 12648fe39aacSPhilipp Reisner 12658fe39aacSPhilipp Reisner dc = rcu_dereference(bdev->disk_conf); 12668fe39aacSPhilipp Reisner 12678fe39aacSPhilipp Reisner if (wo == WO_bdev_flush && !dc->disk_flushes) 12688fe39aacSPhilipp Reisner wo = WO_drain_io; 12698fe39aacSPhilipp Reisner if (wo == WO_drain_io && !dc->disk_drain) 12708fe39aacSPhilipp Reisner wo = WO_none; 12718fe39aacSPhilipp Reisner 12728fe39aacSPhilipp Reisner return wo; 12738fe39aacSPhilipp Reisner } 12748fe39aacSPhilipp Reisner 1275b411b363SPhilipp Reisner /** 1276b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1277bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1278b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1279b411b363SPhilipp Reisner */ 12808fe39aacSPhilipp Reisner void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, 12818fe39aacSPhilipp Reisner enum write_ordering_e wo) 1282b411b363SPhilipp Reisner { 1283e9526580SPhilipp Reisner struct drbd_device *device; 1284b411b363SPhilipp Reisner enum write_ordering_e pwo; 12854b0007c0SPhilipp Reisner int vnr; 1286b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1287b411b363SPhilipp Reisner [WO_none] = "none", 1288b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1289b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1290b411b363SPhilipp Reisner }; 1291b411b363SPhilipp Reisner 1292e9526580SPhilipp Reisner pwo = resource->write_ordering; 129370df7092SLars Ellenberg if (wo != WO_bdev_flush) 1294b411b363SPhilipp Reisner wo = min(pwo, wo); 1295daeda1ccSPhilipp Reisner rcu_read_lock(); 1296e9526580SPhilipp Reisner idr_for_each_entry(&resource->devices, device, vnr) { 12978fe39aacSPhilipp Reisner if (get_ldev(device)) { 12988fe39aacSPhilipp Reisner wo = max_allowed_wo(device->ldev, wo); 12998fe39aacSPhilipp Reisner if (device->ldev == bdev) 13008fe39aacSPhilipp Reisner bdev = NULL; 1301b30ab791SAndreas Gruenbacher put_ldev(device); 13024b0007c0SPhilipp Reisner } 13038fe39aacSPhilipp Reisner } 13048fe39aacSPhilipp Reisner 13058fe39aacSPhilipp Reisner if (bdev) 13068fe39aacSPhilipp Reisner wo = max_allowed_wo(bdev, wo); 13078fe39aacSPhilipp Reisner 130870df7092SLars Ellenberg rcu_read_unlock(); 130970df7092SLars Ellenberg 1310e9526580SPhilipp Reisner resource->write_ordering = wo; 1311e9526580SPhilipp Reisner if (pwo != resource->write_ordering || wo == WO_bdev_flush) 1312e9526580SPhilipp Reisner drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]); 1313b411b363SPhilipp Reisner } 1314b411b363SPhilipp Reisner 1315b411b363SPhilipp Reisner /** 1316fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1317b30ab791SAndreas Gruenbacher * @device: DRBD device. 1318db830c46SAndreas Gruenbacher * @peer_req: peer request 131945bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 132010f6d992SLars Ellenberg * 132110f6d992SLars Ellenberg * May spread the pages to multiple bios, 132210f6d992SLars Ellenberg * depending on bio_add_page restrictions. 132310f6d992SLars Ellenberg * 132410f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 132510f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 132610f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 132710f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 132810f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 132910f6d992SLars Ellenberg * on certain Xen deployments. 133045bb912bSLars Ellenberg */ 133145bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1332b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1333fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 133445bb912bSLars Ellenberg const unsigned rw, const int fault_type) 133545bb912bSLars Ellenberg { 133645bb912bSLars Ellenberg struct bio *bios = NULL; 133745bb912bSLars Ellenberg struct bio *bio; 1338db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1339db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1340db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 134145bb912bSLars Ellenberg unsigned n_bios = 0; 134245bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 134310f6d992SLars Ellenberg int err = -ENOMEM; 134445bb912bSLars Ellenberg 1345a0fb3c47SLars Ellenberg if (peer_req->flags & EE_IS_TRIM_USE_ZEROOUT) { 1346a0fb3c47SLars Ellenberg /* wait for all pending IO completions, before we start 1347a0fb3c47SLars Ellenberg * zeroing things out. */ 1348a0fb3c47SLars Ellenberg conn_wait_active_ee_empty(first_peer_device(device)->connection); 1349a0fb3c47SLars Ellenberg if (blkdev_issue_zeroout(device->ldev->backing_bdev, 1350a0fb3c47SLars Ellenberg sector, ds >> 9, GFP_NOIO)) 1351a0fb3c47SLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 1352a0fb3c47SLars Ellenberg drbd_endio_write_sec_final(peer_req); 1353a0fb3c47SLars Ellenberg return 0; 1354a0fb3c47SLars Ellenberg } 1355a0fb3c47SLars Ellenberg 135654ed4ed8SLars Ellenberg /* Discards don't have any payload. 135754ed4ed8SLars Ellenberg * But the scsi layer still expects a bio_vec it can use internally, 135854ed4ed8SLars Ellenberg * see sd_setup_discard_cmnd() and blk_add_request_payload(). */ 1359a0fb3c47SLars Ellenberg if (peer_req->flags & EE_IS_TRIM) 136054ed4ed8SLars Ellenberg nr_pages = 1; 1361a0fb3c47SLars Ellenberg 136245bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 136345bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 136445bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 13659476f39dSLars Ellenberg * request in more than one bio. 13669476f39dSLars Ellenberg * 13679476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 13689476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 13699476f39dSLars Ellenberg */ 137045bb912bSLars Ellenberg next_bio: 137145bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 137245bb912bSLars Ellenberg if (!bio) { 1373a0fb3c47SLars Ellenberg drbd_err(device, "submit_ee: Allocation of a bio failed (nr_pages=%u)\n", nr_pages); 137445bb912bSLars Ellenberg goto fail; 137545bb912bSLars Ellenberg } 1376db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 13774f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 1378b30ab791SAndreas Gruenbacher bio->bi_bdev = device->ldev->backing_bdev; 137945bb912bSLars Ellenberg bio->bi_rw = rw; 1380db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1381fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 138245bb912bSLars Ellenberg 138345bb912bSLars Ellenberg bio->bi_next = bios; 138445bb912bSLars Ellenberg bios = bio; 138545bb912bSLars Ellenberg ++n_bios; 138645bb912bSLars Ellenberg 1387a0fb3c47SLars Ellenberg if (rw & REQ_DISCARD) { 1388a0fb3c47SLars Ellenberg bio->bi_iter.bi_size = ds; 1389a0fb3c47SLars Ellenberg goto submit; 1390a0fb3c47SLars Ellenberg } 1391a0fb3c47SLars Ellenberg 139245bb912bSLars Ellenberg page_chain_for_each(page) { 139345bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 139445bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 139510f6d992SLars Ellenberg /* A single page must always be possible! 139610f6d992SLars Ellenberg * But in case it fails anyways, 139710f6d992SLars Ellenberg * we deal with it, and complain (below). */ 139810f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 1399d0180171SAndreas Gruenbacher drbd_err(device, 140010f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 140110f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 14024f024f37SKent Overstreet len, (uint64_t)bio->bi_iter.bi_sector); 140310f6d992SLars Ellenberg err = -ENOSPC; 140410f6d992SLars Ellenberg goto fail; 140510f6d992SLars Ellenberg } 140645bb912bSLars Ellenberg goto next_bio; 140745bb912bSLars Ellenberg } 140845bb912bSLars Ellenberg ds -= len; 140945bb912bSLars Ellenberg sector += len >> 9; 141045bb912bSLars Ellenberg --nr_pages; 141145bb912bSLars Ellenberg } 14120b0ba1efSAndreas Gruenbacher D_ASSERT(device, ds == 0); 1413a0fb3c47SLars Ellenberg submit: 1414a0fb3c47SLars Ellenberg D_ASSERT(device, page == NULL); 141545bb912bSLars Ellenberg 1416db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 141745bb912bSLars Ellenberg do { 141845bb912bSLars Ellenberg bio = bios; 141945bb912bSLars Ellenberg bios = bios->bi_next; 142045bb912bSLars Ellenberg bio->bi_next = NULL; 142145bb912bSLars Ellenberg 1422b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 142345bb912bSLars Ellenberg } while (bios); 142445bb912bSLars Ellenberg return 0; 142545bb912bSLars Ellenberg 142645bb912bSLars Ellenberg fail: 142745bb912bSLars Ellenberg while (bios) { 142845bb912bSLars Ellenberg bio = bios; 142945bb912bSLars Ellenberg bios = bios->bi_next; 143045bb912bSLars Ellenberg bio_put(bio); 143145bb912bSLars Ellenberg } 143210f6d992SLars Ellenberg return err; 143345bb912bSLars Ellenberg } 143445bb912bSLars Ellenberg 1435b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1436db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 143753840641SAndreas Gruenbacher { 1438db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 143953840641SAndreas Gruenbacher 1440b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 144153840641SAndreas Gruenbacher drbd_clear_interval(i); 144253840641SAndreas Gruenbacher 14436c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 144453840641SAndreas Gruenbacher if (i->waiting) 1445b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 144653840641SAndreas Gruenbacher } 144753840641SAndreas Gruenbacher 1448bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 144977fede51SPhilipp Reisner { 1450c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 145177fede51SPhilipp Reisner int vnr; 145277fede51SPhilipp Reisner 145377fede51SPhilipp Reisner rcu_read_lock(); 1454c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1455c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1456c06ece6bSAndreas Gruenbacher 1457b30ab791SAndreas Gruenbacher kref_get(&device->kref); 145877fede51SPhilipp Reisner rcu_read_unlock(); 1459b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 146005a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 146177fede51SPhilipp Reisner rcu_read_lock(); 146277fede51SPhilipp Reisner } 146377fede51SPhilipp Reisner rcu_read_unlock(); 146477fede51SPhilipp Reisner } 146577fede51SPhilipp Reisner 14669f4fe9adSAndreas Gruenbacher static struct drbd_peer_device * 14679f4fe9adSAndreas Gruenbacher conn_peer_device(struct drbd_connection *connection, int volume_number) 14689f4fe9adSAndreas Gruenbacher { 14699f4fe9adSAndreas Gruenbacher return idr_find(&connection->peer_devices, volume_number); 14709f4fe9adSAndreas Gruenbacher } 14719f4fe9adSAndreas Gruenbacher 1472bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1473b411b363SPhilipp Reisner { 14742451fc3bSPhilipp Reisner int rv; 1475e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1476b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1477b411b363SPhilipp Reisner 14789ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14799ed57dcbSLars Ellenberg * not a specific (peer)device. 14809ed57dcbSLars Ellenberg */ 1481bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1482bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1483bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1484b411b363SPhilipp Reisner 1485b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1486b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1487b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1488b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1489b411b363SPhilipp Reisner * completed. */ 1490e9526580SPhilipp Reisner switch (connection->resource->write_ordering) { 1491b411b363SPhilipp Reisner case WO_none: 1492b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 149382bc0194SAndreas Gruenbacher return 0; 1494b411b363SPhilipp Reisner 1495b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1496b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1497b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14982451fc3bSPhilipp Reisner if (epoch) 14992451fc3bSPhilipp Reisner break; 15002451fc3bSPhilipp Reisner else 15011ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 15022451fc3bSPhilipp Reisner /* Fall through */ 15032451fc3bSPhilipp Reisner 15042451fc3bSPhilipp Reisner case WO_bdev_flush: 15052451fc3bSPhilipp Reisner case WO_drain_io: 1506bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1507bde89a9eSAndreas Gruenbacher drbd_flush(connection); 15082451fc3bSPhilipp Reisner 1509bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 15102451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 15112451fc3bSPhilipp Reisner if (epoch) 15122451fc3bSPhilipp Reisner break; 1513b411b363SPhilipp Reisner } 1514b411b363SPhilipp Reisner 151582bc0194SAndreas Gruenbacher return 0; 15162451fc3bSPhilipp Reisner default: 1517e9526580SPhilipp Reisner drbd_err(connection, "Strangeness in connection->write_ordering %d\n", 1518e9526580SPhilipp Reisner connection->resource->write_ordering); 151982bc0194SAndreas Gruenbacher return -EIO; 1520b411b363SPhilipp Reisner } 1521b411b363SPhilipp Reisner 1522b411b363SPhilipp Reisner epoch->flags = 0; 1523b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1524b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1525b411b363SPhilipp Reisner 1526bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1527bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1528bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1529bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1530bde89a9eSAndreas Gruenbacher connection->epochs++; 1531b411b363SPhilipp Reisner } else { 1532b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1533b411b363SPhilipp Reisner kfree(epoch); 1534b411b363SPhilipp Reisner } 1535bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1536b411b363SPhilipp Reisner 153782bc0194SAndreas Gruenbacher return 0; 1538b411b363SPhilipp Reisner } 1539b411b363SPhilipp Reisner 1540b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1541b411b363SPhilipp Reisner * and from receive_Data */ 1542f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 154369a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1544a0fb3c47SLars Ellenberg struct packet_info *pi) __must_hold(local) 1545b411b363SPhilipp Reisner { 154669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1547b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1548db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1549b411b363SPhilipp Reisner struct page *page; 1550a5c31904SAndreas Gruenbacher int dgs, ds, err; 1551a0fb3c47SLars Ellenberg int data_size = pi->size; 155269a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 155369a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 15546b4388acSPhilipp Reisner unsigned long *data; 1555a0fb3c47SLars Ellenberg struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; 1556b411b363SPhilipp Reisner 155788104ca4SAndreas Gruenbacher dgs = 0; 1558a0fb3c47SLars Ellenberg if (!trim && peer_device->connection->peer_integrity_tfm) { 155969a22773SAndreas Gruenbacher dgs = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 15609f5bdc33SAndreas Gruenbacher /* 15619f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15629f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15639f5bdc33SAndreas Gruenbacher */ 156469a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, dgs); 1565a5c31904SAndreas Gruenbacher if (err) 1566b411b363SPhilipp Reisner return NULL; 1567b411b363SPhilipp Reisner data_size -= dgs; 156888104ca4SAndreas Gruenbacher } 1569b411b363SPhilipp Reisner 1570a0fb3c47SLars Ellenberg if (trim) { 1571a0fb3c47SLars Ellenberg D_ASSERT(peer_device, data_size == 0); 1572a0fb3c47SLars Ellenberg data_size = be32_to_cpu(trim->size); 1573a0fb3c47SLars Ellenberg } 1574a0fb3c47SLars Ellenberg 1575841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1576841ce241SAndreas Gruenbacher return NULL; 1577a0fb3c47SLars Ellenberg /* prepare for larger trim requests. */ 1578a0fb3c47SLars Ellenberg if (!trim && !expect(data_size <= DRBD_MAX_BIO_SIZE)) 1579841ce241SAndreas Gruenbacher return NULL; 1580b411b363SPhilipp Reisner 15816666032aSLars Ellenberg /* even though we trust out peer, 15826666032aSLars Ellenberg * we sometimes have to double check. */ 15836666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1584d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1585fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15866666032aSLars Ellenberg (unsigned long long)capacity, 15876666032aSLars Ellenberg (unsigned long long)sector, data_size); 15886666032aSLars Ellenberg return NULL; 15896666032aSLars Ellenberg } 15906666032aSLars Ellenberg 1591b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1592b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1593b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1594a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, id, sector, data_size, trim == NULL, GFP_NOIO); 1595db830c46SAndreas Gruenbacher if (!peer_req) 1596b411b363SPhilipp Reisner return NULL; 159745bb912bSLars Ellenberg 1598a0fb3c47SLars Ellenberg if (trim) 159981a3537aSLars Ellenberg return peer_req; 1600a73ff323SLars Ellenberg 1601b411b363SPhilipp Reisner ds = data_size; 1602db830c46SAndreas Gruenbacher page = peer_req->pages; 160345bb912bSLars Ellenberg page_chain_for_each(page) { 160445bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 16056b4388acSPhilipp Reisner data = kmap(page); 160669a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1607b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1608d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 16096b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 16106b4388acSPhilipp Reisner } 1611b411b363SPhilipp Reisner kunmap(page); 1612a5c31904SAndreas Gruenbacher if (err) { 1613b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1614b411b363SPhilipp Reisner return NULL; 1615b411b363SPhilipp Reisner } 1616a5c31904SAndreas Gruenbacher ds -= len; 1617b411b363SPhilipp Reisner } 1618b411b363SPhilipp Reisner 1619b411b363SPhilipp Reisner if (dgs) { 162069a22773SAndreas Gruenbacher drbd_csum_ee(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv); 1621b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1622d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1623470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1624b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1625b411b363SPhilipp Reisner return NULL; 1626b411b363SPhilipp Reisner } 1627b411b363SPhilipp Reisner } 1628b30ab791SAndreas Gruenbacher device->recv_cnt += data_size>>9; 1629db830c46SAndreas Gruenbacher return peer_req; 1630b411b363SPhilipp Reisner } 1631b411b363SPhilipp Reisner 1632b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1633b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1634b411b363SPhilipp Reisner */ 163569a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1636b411b363SPhilipp Reisner { 1637b411b363SPhilipp Reisner struct page *page; 1638a5c31904SAndreas Gruenbacher int err = 0; 1639b411b363SPhilipp Reisner void *data; 1640b411b363SPhilipp Reisner 1641c3470cdeSLars Ellenberg if (!data_size) 1642fc5be839SAndreas Gruenbacher return 0; 1643c3470cdeSLars Ellenberg 164469a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1645b411b363SPhilipp Reisner 1646b411b363SPhilipp Reisner data = kmap(page); 1647b411b363SPhilipp Reisner while (data_size) { 1648fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1649fc5be839SAndreas Gruenbacher 165069a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1651a5c31904SAndreas Gruenbacher if (err) 1652b411b363SPhilipp Reisner break; 1653a5c31904SAndreas Gruenbacher data_size -= len; 1654b411b363SPhilipp Reisner } 1655b411b363SPhilipp Reisner kunmap(page); 165669a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1657fc5be839SAndreas Gruenbacher return err; 1658b411b363SPhilipp Reisner } 1659b411b363SPhilipp Reisner 166069a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1661b411b363SPhilipp Reisner sector_t sector, int data_size) 1662b411b363SPhilipp Reisner { 16637988613bSKent Overstreet struct bio_vec bvec; 16647988613bSKent Overstreet struct bvec_iter iter; 1665b411b363SPhilipp Reisner struct bio *bio; 16667988613bSKent Overstreet int dgs, err, expect; 166769a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 166869a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1669b411b363SPhilipp Reisner 167088104ca4SAndreas Gruenbacher dgs = 0; 167169a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 167269a22773SAndreas Gruenbacher dgs = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 167369a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, dgs); 1674a5c31904SAndreas Gruenbacher if (err) 1675a5c31904SAndreas Gruenbacher return err; 1676b411b363SPhilipp Reisner data_size -= dgs; 167788104ca4SAndreas Gruenbacher } 1678b411b363SPhilipp Reisner 1679b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1680b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 168169a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1682b411b363SPhilipp Reisner 1683b411b363SPhilipp Reisner bio = req->master_bio; 168469a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1685b411b363SPhilipp Reisner 16867988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 16877988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 16887988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 168969a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 16907988613bSKent Overstreet kunmap(bvec.bv_page); 1691a5c31904SAndreas Gruenbacher if (err) 1692a5c31904SAndreas Gruenbacher return err; 1693a5c31904SAndreas Gruenbacher data_size -= expect; 1694b411b363SPhilipp Reisner } 1695b411b363SPhilipp Reisner 1696b411b363SPhilipp Reisner if (dgs) { 169769a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 1698b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 169969a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 170028284cefSAndreas Gruenbacher return -EINVAL; 1701b411b363SPhilipp Reisner } 1702b411b363SPhilipp Reisner } 1703b411b363SPhilipp Reisner 170469a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 170528284cefSAndreas Gruenbacher return 0; 1706b411b363SPhilipp Reisner } 1707b411b363SPhilipp Reisner 1708a990be46SAndreas Gruenbacher /* 1709a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1710a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1711a990be46SAndreas Gruenbacher */ 171299920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1713b411b363SPhilipp Reisner { 17148050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1715a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1716a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1717a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1718db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 171999920dc5SAndreas Gruenbacher int err; 1720b411b363SPhilipp Reisner 17210b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1722b411b363SPhilipp Reisner 1723db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1724b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1725a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 1726b411b363SPhilipp Reisner } else { 1727b411b363SPhilipp Reisner /* Record failure to sync */ 1728b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 1729b411b363SPhilipp Reisner 1730a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1731b411b363SPhilipp Reisner } 1732b30ab791SAndreas Gruenbacher dec_unacked(device); 1733b411b363SPhilipp Reisner 173499920dc5SAndreas Gruenbacher return err; 1735b411b363SPhilipp Reisner } 1736b411b363SPhilipp Reisner 173769a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 1738a0fb3c47SLars Ellenberg struct packet_info *pi) __releases(local) 1739b411b363SPhilipp Reisner { 174069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1741db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1742b411b363SPhilipp Reisner 1743a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi); 1744db830c46SAndreas Gruenbacher if (!peer_req) 174545bb912bSLars Ellenberg goto fail; 1746b411b363SPhilipp Reisner 1747b30ab791SAndreas Gruenbacher dec_rs_pending(device); 1748b411b363SPhilipp Reisner 1749b30ab791SAndreas Gruenbacher inc_unacked(device); 1750b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1751b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1752b411b363SPhilipp Reisner 1753a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 175445bb912bSLars Ellenberg 17550500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1756a8cd15baSAndreas Gruenbacher list_add(&peer_req->w.list, &device->sync_ee); 17570500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1758b411b363SPhilipp Reisner 1759a0fb3c47SLars Ellenberg atomic_add(pi->size >> 9, &device->rs_sect_ev); 1760b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1761e1c1b0fcSAndreas Gruenbacher return 0; 176245bb912bSLars Ellenberg 176310f6d992SLars Ellenberg /* don't care for the reason here */ 1764d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 17650500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1766a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 17670500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 176822cc37a9SLars Ellenberg 1769b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 177045bb912bSLars Ellenberg fail: 1771b30ab791SAndreas Gruenbacher put_ldev(device); 1772e1c1b0fcSAndreas Gruenbacher return -EIO; 1773b411b363SPhilipp Reisner } 1774b411b363SPhilipp Reisner 1775668eebc6SAndreas Gruenbacher static struct drbd_request * 1776b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 1777bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1778b411b363SPhilipp Reisner { 1779b411b363SPhilipp Reisner struct drbd_request *req; 1780668eebc6SAndreas Gruenbacher 1781bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1782bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17835e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1784668eebc6SAndreas Gruenbacher return req; 1785c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1786d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 1787c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1788c3afd8f5SAndreas Gruenbacher } 1789668eebc6SAndreas Gruenbacher return NULL; 1790668eebc6SAndreas Gruenbacher } 1791668eebc6SAndreas Gruenbacher 1792bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 1793b411b363SPhilipp Reisner { 17949f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1795b30ab791SAndreas Gruenbacher struct drbd_device *device; 1796b411b363SPhilipp Reisner struct drbd_request *req; 1797b411b363SPhilipp Reisner sector_t sector; 179882bc0194SAndreas Gruenbacher int err; 1799e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 18004a76b161SAndreas Gruenbacher 18019f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 18029f4fe9adSAndreas Gruenbacher if (!peer_device) 18034a76b161SAndreas Gruenbacher return -EIO; 18049f4fe9adSAndreas Gruenbacher device = peer_device->device; 1805b411b363SPhilipp Reisner 1806b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1807b411b363SPhilipp Reisner 18080500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1809b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 18100500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1811c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 181282bc0194SAndreas Gruenbacher return -EIO; 1813b411b363SPhilipp Reisner 181424c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1815b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1816b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 181769a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 181882bc0194SAndreas Gruenbacher if (!err) 18198554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1820b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1821b411b363SPhilipp Reisner * I don't think we may complete this just yet 1822b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1823b411b363SPhilipp Reisner 182482bc0194SAndreas Gruenbacher return err; 1825b411b363SPhilipp Reisner } 1826b411b363SPhilipp Reisner 1827bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 1828b411b363SPhilipp Reisner { 18299f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1830b30ab791SAndreas Gruenbacher struct drbd_device *device; 1831b411b363SPhilipp Reisner sector_t sector; 183282bc0194SAndreas Gruenbacher int err; 1833e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 18344a76b161SAndreas Gruenbacher 18359f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 18369f4fe9adSAndreas Gruenbacher if (!peer_device) 18374a76b161SAndreas Gruenbacher return -EIO; 18389f4fe9adSAndreas Gruenbacher device = peer_device->device; 1839b411b363SPhilipp Reisner 1840b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 18410b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 1842b411b363SPhilipp Reisner 1843b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 1844b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1845b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1846fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1847a0fb3c47SLars Ellenberg err = recv_resync_read(peer_device, sector, pi); 1848b411b363SPhilipp Reisner } else { 1849b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1850d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 1851b411b363SPhilipp Reisner 185269a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 1853b411b363SPhilipp Reisner 185469a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 1855b411b363SPhilipp Reisner } 1856b411b363SPhilipp Reisner 1857b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 1858778f271dSPhilipp Reisner 185982bc0194SAndreas Gruenbacher return err; 1860b411b363SPhilipp Reisner } 1861b411b363SPhilipp Reisner 1862b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 18637be8da07SAndreas Gruenbacher sector_t sector, int size) 1864b411b363SPhilipp Reisner { 18657be8da07SAndreas Gruenbacher struct drbd_interval *i; 18667be8da07SAndreas Gruenbacher struct drbd_request *req; 1867b411b363SPhilipp Reisner 1868b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 18697be8da07SAndreas Gruenbacher if (!i->local) 18707be8da07SAndreas Gruenbacher continue; 18717be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18727be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18737be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18747be8da07SAndreas Gruenbacher continue; 18752312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18762312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1877d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 18787be8da07SAndreas Gruenbacher } 18797be8da07SAndreas Gruenbacher } 18807be8da07SAndreas Gruenbacher 1881a990be46SAndreas Gruenbacher /* 1882a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1883b411b363SPhilipp Reisner */ 188499920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1885b411b363SPhilipp Reisner { 18868050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1887a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1888a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1889a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1890db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 189199920dc5SAndreas Gruenbacher int err = 0, pcmd; 1892b411b363SPhilipp Reisner 1893303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1894db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1895b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 1896b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 1897db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1898b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1899a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 1900b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1901b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1902b411b363SPhilipp Reisner } else { 1903a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1904b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1905b411b363SPhilipp Reisner * maybe assert this? */ 1906b411b363SPhilipp Reisner } 1907b30ab791SAndreas Gruenbacher dec_unacked(device); 1908b411b363SPhilipp Reisner } 1909b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1910b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1911302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 19120500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 19130b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 1914b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 19157be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 1916b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 19170500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1918bb3bfe96SAndreas Gruenbacher } else 19190b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1920b411b363SPhilipp Reisner 1921a6b32bc3SAndreas Gruenbacher drbd_may_finish_epoch(first_peer_device(device)->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1922b411b363SPhilipp Reisner 192399920dc5SAndreas Gruenbacher return err; 1924b411b363SPhilipp Reisner } 1925b411b363SPhilipp Reisner 1926a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1927b411b363SPhilipp Reisner { 19288050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1929a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1930a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 193199920dc5SAndreas Gruenbacher int err; 1932b411b363SPhilipp Reisner 1933a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 1934a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 1935b411b363SPhilipp Reisner 193699920dc5SAndreas Gruenbacher return err; 1937b411b363SPhilipp Reisner } 1938b411b363SPhilipp Reisner 1939d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 1940b6a370baSPhilipp Reisner { 1941a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 19427be8da07SAndreas Gruenbacher } 1943b6a370baSPhilipp Reisner 194499920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 19457be8da07SAndreas Gruenbacher { 1946a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 1947a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1948a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 19497be8da07SAndreas Gruenbacher 1950a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 1951d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 19527be8da07SAndreas Gruenbacher } 19537be8da07SAndreas Gruenbacher 19543e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 19553e394da1SAndreas Gruenbacher { 19563e394da1SAndreas Gruenbacher /* 19573e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 19583e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 19593e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 19603e394da1SAndreas Gruenbacher */ 19613e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 19623e394da1SAndreas Gruenbacher } 19633e394da1SAndreas Gruenbacher 19643e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 19653e394da1SAndreas Gruenbacher { 19663e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 19673e394da1SAndreas Gruenbacher } 19683e394da1SAndreas Gruenbacher 196969a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 19703e394da1SAndreas Gruenbacher { 197169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 19723c13b680SLars Ellenberg unsigned int newest_peer_seq; 19733e394da1SAndreas Gruenbacher 197469a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 1975b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 1976b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 1977b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 1978b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 1979b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 19803c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 1981b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 19823e394da1SAndreas Gruenbacher } 19837be8da07SAndreas Gruenbacher } 19843e394da1SAndreas Gruenbacher 1985d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1986d93f6302SLars Ellenberg { 1987d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1988d93f6302SLars Ellenberg } 1989d93f6302SLars Ellenberg 1990d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 1991b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 1992d93f6302SLars Ellenberg { 1993d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1994b6a370baSPhilipp Reisner bool rv = 0; 1995b6a370baSPhilipp Reisner 19960500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1997a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 1998d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1999d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 2000b6a370baSPhilipp Reisner rv = 1; 2001b6a370baSPhilipp Reisner break; 2002b6a370baSPhilipp Reisner } 2003b6a370baSPhilipp Reisner } 20040500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2005b6a370baSPhilipp Reisner 2006b6a370baSPhilipp Reisner return rv; 2007b6a370baSPhilipp Reisner } 2008b6a370baSPhilipp Reisner 2009b411b363SPhilipp Reisner /* Called from receive_Data. 2010b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 2011b411b363SPhilipp Reisner * 2012b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 2013b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 2014b411b363SPhilipp Reisner * been sent. 2015b411b363SPhilipp Reisner * 2016b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 2017b411b363SPhilipp Reisner * 2018b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 2019b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 2020b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 2021b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 2022b411b363SPhilipp Reisner * 2023b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 2024b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 2025b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 2026b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 2027b411b363SPhilipp Reisner * 2028b411b363SPhilipp Reisner * returns 0 if we may process the packet, 2029b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 203069a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 2031b411b363SPhilipp Reisner { 203269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2033b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2034b411b363SPhilipp Reisner long timeout; 2035b874d231SPhilipp Reisner int ret = 0, tp; 20367be8da07SAndreas Gruenbacher 203769a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 20387be8da07SAndreas Gruenbacher return 0; 20397be8da07SAndreas Gruenbacher 2040b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2041b411b363SPhilipp Reisner for (;;) { 2042b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 2043b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 2044b411b363SPhilipp Reisner break; 20457be8da07SAndreas Gruenbacher } 2046b874d231SPhilipp Reisner 2047b411b363SPhilipp Reisner if (signal_pending(current)) { 2048b411b363SPhilipp Reisner ret = -ERESTARTSYS; 2049b411b363SPhilipp Reisner break; 2050b411b363SPhilipp Reisner } 2051b874d231SPhilipp Reisner 2052b874d231SPhilipp Reisner rcu_read_lock(); 2053a6b32bc3SAndreas Gruenbacher tp = rcu_dereference(first_peer_device(device)->connection->net_conf)->two_primaries; 2054b874d231SPhilipp Reisner rcu_read_unlock(); 2055b874d231SPhilipp Reisner 2056b874d231SPhilipp Reisner if (!tp) 2057b874d231SPhilipp Reisner break; 2058b874d231SPhilipp Reisner 2059b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2060b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2061b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 206244ed167dSPhilipp Reisner rcu_read_lock(); 206369a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 206444ed167dSPhilipp Reisner rcu_read_unlock(); 206571b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2066b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 20677be8da07SAndreas Gruenbacher if (!timeout) { 2068b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2069d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2070b411b363SPhilipp Reisner break; 2071b411b363SPhilipp Reisner } 2072b411b363SPhilipp Reisner } 2073b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2074b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2075b411b363SPhilipp Reisner return ret; 2076b411b363SPhilipp Reisner } 2077b411b363SPhilipp Reisner 2078688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2079688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2080688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 208181f0ffd2SAndreas Gruenbacher static unsigned long wire_flags_to_bio(u32 dpf) 208276d2e7ecSPhilipp Reisner { 208376d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 208476d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2085688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 208676d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 208776d2e7ecSPhilipp Reisner } 208876d2e7ecSPhilipp Reisner 2089b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 20907be8da07SAndreas Gruenbacher unsigned int size) 2091b411b363SPhilipp Reisner { 20927be8da07SAndreas Gruenbacher struct drbd_interval *i; 20937be8da07SAndreas Gruenbacher 20947be8da07SAndreas Gruenbacher repeat: 2095b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 20967be8da07SAndreas Gruenbacher struct drbd_request *req; 20977be8da07SAndreas Gruenbacher struct bio_and_error m; 20987be8da07SAndreas Gruenbacher 20997be8da07SAndreas Gruenbacher if (!i->local) 21007be8da07SAndreas Gruenbacher continue; 21017be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 21027be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 21037be8da07SAndreas Gruenbacher continue; 21047be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 21057be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 21060500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 21077be8da07SAndreas Gruenbacher if (m.bio) 2108b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 21090500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 21107be8da07SAndreas Gruenbacher goto repeat; 21117be8da07SAndreas Gruenbacher } 21127be8da07SAndreas Gruenbacher } 21137be8da07SAndreas Gruenbacher 2114b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 21157be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 21167be8da07SAndreas Gruenbacher { 2117e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2118bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 21197be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 21207be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 21217be8da07SAndreas Gruenbacher struct drbd_interval *i; 21227be8da07SAndreas Gruenbacher bool equal; 21237be8da07SAndreas Gruenbacher int err; 21247be8da07SAndreas Gruenbacher 21257be8da07SAndreas Gruenbacher /* 21267be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 21277be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 21287be8da07SAndreas Gruenbacher */ 2129b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 21307be8da07SAndreas Gruenbacher 21317be8da07SAndreas Gruenbacher repeat: 2132b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21337be8da07SAndreas Gruenbacher if (i == &peer_req->i) 21347be8da07SAndreas Gruenbacher continue; 21357be8da07SAndreas Gruenbacher 21367be8da07SAndreas Gruenbacher if (!i->local) { 21377be8da07SAndreas Gruenbacher /* 21387be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 21397be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 21407be8da07SAndreas Gruenbacher * earlier peer request to complete. 21417be8da07SAndreas Gruenbacher */ 2142b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 21437be8da07SAndreas Gruenbacher if (err) 21447be8da07SAndreas Gruenbacher goto out; 21457be8da07SAndreas Gruenbacher goto repeat; 21467be8da07SAndreas Gruenbacher } 21477be8da07SAndreas Gruenbacher 21487be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 21497be8da07SAndreas Gruenbacher if (resolve_conflicts) { 21507be8da07SAndreas Gruenbacher /* 21517be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2152d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2153d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2154d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 21557be8da07SAndreas Gruenbacher */ 2156d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 21577be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 21587be8da07SAndreas Gruenbacher 21597be8da07SAndreas Gruenbacher if (!equal) 2160d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21617be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 21627be8da07SAndreas Gruenbacher "assuming %s came first\n", 21637be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21647be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2165d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 21667be8da07SAndreas Gruenbacher 2167b30ab791SAndreas Gruenbacher inc_unacked(device); 2168a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 21697be8da07SAndreas Gruenbacher e_send_retry_write; 2170a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2171e33b32deSAndreas Gruenbacher wake_asender(connection); 21727be8da07SAndreas Gruenbacher 21737be8da07SAndreas Gruenbacher err = -ENOENT; 21747be8da07SAndreas Gruenbacher goto out; 21757be8da07SAndreas Gruenbacher } else { 21767be8da07SAndreas Gruenbacher struct drbd_request *req = 21777be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21787be8da07SAndreas Gruenbacher 21797be8da07SAndreas Gruenbacher if (!equal) 2180d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21817be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21827be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21837be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21847be8da07SAndreas Gruenbacher 21857be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21867be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21877be8da07SAndreas Gruenbacher /* 21887be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2189d4dabbe2SLars Ellenberg * decide if this request has been superseded 2190d4dabbe2SLars Ellenberg * or needs to be retried. 2191d4dabbe2SLars Ellenberg * Requests that have been superseded will 21927be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 21937be8da07SAndreas Gruenbacher * 21947be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 21957be8da07SAndreas Gruenbacher * request to finish locally before submitting 21967be8da07SAndreas Gruenbacher * the conflicting peer request. 21977be8da07SAndreas Gruenbacher */ 2198b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 21997be8da07SAndreas Gruenbacher if (err) { 2200e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2201b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 22027be8da07SAndreas Gruenbacher goto out; 22037be8da07SAndreas Gruenbacher } 22047be8da07SAndreas Gruenbacher goto repeat; 22057be8da07SAndreas Gruenbacher } 22067be8da07SAndreas Gruenbacher /* 22077be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 22087be8da07SAndreas Gruenbacher * the new peer request has completed. 22097be8da07SAndreas Gruenbacher */ 22107be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 22117be8da07SAndreas Gruenbacher } 22127be8da07SAndreas Gruenbacher } 22137be8da07SAndreas Gruenbacher err = 0; 22147be8da07SAndreas Gruenbacher 22157be8da07SAndreas Gruenbacher out: 22167be8da07SAndreas Gruenbacher if (err) 2217b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 22187be8da07SAndreas Gruenbacher return err; 22197be8da07SAndreas Gruenbacher } 22207be8da07SAndreas Gruenbacher 2221b411b363SPhilipp Reisner /* mirrored write */ 2222bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2223b411b363SPhilipp Reisner { 22249f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2225b30ab791SAndreas Gruenbacher struct drbd_device *device; 2226b411b363SPhilipp Reisner sector_t sector; 2227db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2228e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 22297be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2230b411b363SPhilipp Reisner int rw = WRITE; 2231b411b363SPhilipp Reisner u32 dp_flags; 2232302bdeaeSPhilipp Reisner int err, tp; 22337be8da07SAndreas Gruenbacher 22349f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 22359f4fe9adSAndreas Gruenbacher if (!peer_device) 22364a76b161SAndreas Gruenbacher return -EIO; 22379f4fe9adSAndreas Gruenbacher device = peer_device->device; 2238b411b363SPhilipp Reisner 2239b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 224082bc0194SAndreas Gruenbacher int err2; 2241b411b363SPhilipp Reisner 224269a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 224369a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2244bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 224569a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 224682bc0194SAndreas Gruenbacher if (!err) 224782bc0194SAndreas Gruenbacher err = err2; 224882bc0194SAndreas Gruenbacher return err; 2249b411b363SPhilipp Reisner } 2250b411b363SPhilipp Reisner 2251fcefa62eSAndreas Gruenbacher /* 2252fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2253fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2254fcefa62eSAndreas Gruenbacher * end of this function. 2255fcefa62eSAndreas Gruenbacher */ 2256b411b363SPhilipp Reisner 2257b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2258a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, p->block_id, sector, pi); 2259db830c46SAndreas Gruenbacher if (!peer_req) { 2260b30ab791SAndreas Gruenbacher put_ldev(device); 226182bc0194SAndreas Gruenbacher return -EIO; 2262b411b363SPhilipp Reisner } 2263b411b363SPhilipp Reisner 2264a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 2265b411b363SPhilipp Reisner 2266688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 226781f0ffd2SAndreas Gruenbacher rw |= wire_flags_to_bio(dp_flags); 2268a0fb3c47SLars Ellenberg if (pi->cmd == P_TRIM) { 2269a0fb3c47SLars Ellenberg struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); 2270a0fb3c47SLars Ellenberg peer_req->flags |= EE_IS_TRIM; 2271a0fb3c47SLars Ellenberg if (!blk_queue_discard(q)) 2272a0fb3c47SLars Ellenberg peer_req->flags |= EE_IS_TRIM_USE_ZEROOUT; 2273a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->i.size > 0); 2274a0fb3c47SLars Ellenberg D_ASSERT(peer_device, rw & REQ_DISCARD); 2275a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->pages == NULL); 2276a0fb3c47SLars Ellenberg } else if (peer_req->pages == NULL) { 22770b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 22780b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2279a73ff323SLars Ellenberg } 2280688593c5SLars Ellenberg 2281688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2282db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2283688593c5SLars Ellenberg 2284bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2285bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2286db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2287db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2288bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2289b411b363SPhilipp Reisner 2290302bdeaeSPhilipp Reisner rcu_read_lock(); 22919f4fe9adSAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2292302bdeaeSPhilipp Reisner rcu_read_unlock(); 2293302bdeaeSPhilipp Reisner if (tp) { 2294302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 229569a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 22967be8da07SAndreas Gruenbacher if (err) 2297b411b363SPhilipp Reisner goto out_interrupted; 22980500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2299b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 23007be8da07SAndreas Gruenbacher if (err) { 23010500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 23027be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2303b30ab791SAndreas Gruenbacher put_ldev(device); 230482bc0194SAndreas Gruenbacher return 0; 2305b411b363SPhilipp Reisner } 2306b411b363SPhilipp Reisner goto out_interrupted; 2307b411b363SPhilipp Reisner } 2308b874d231SPhilipp Reisner } else { 230969a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 23100500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2311b874d231SPhilipp Reisner } 2312a0fb3c47SLars Ellenberg /* if we use the zeroout fallback code, we process synchronously 2313a0fb3c47SLars Ellenberg * and we wait for all pending requests, respectively wait for 2314a0fb3c47SLars Ellenberg * active_ee to become empty in drbd_submit_peer_request(); 2315a0fb3c47SLars Ellenberg * better not add ourselves here. */ 2316a0fb3c47SLars Ellenberg if ((peer_req->flags & EE_IS_TRIM_USE_ZEROOUT) == 0) 2317a8cd15baSAndreas Gruenbacher list_add(&peer_req->w.list, &device->active_ee); 23180500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2319b411b363SPhilipp Reisner 2320b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2321b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2322b6a370baSPhilipp Reisner 23239f4fe9adSAndreas Gruenbacher if (peer_device->connection->agreed_pro_version < 100) { 232444ed167dSPhilipp Reisner rcu_read_lock(); 23259f4fe9adSAndreas Gruenbacher switch (rcu_dereference(peer_device->connection->net_conf)->wire_protocol) { 2326b411b363SPhilipp Reisner case DRBD_PROT_C: 2327303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2328303d1448SPhilipp Reisner break; 2329303d1448SPhilipp Reisner case DRBD_PROT_B: 2330303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2331303d1448SPhilipp Reisner break; 2332303d1448SPhilipp Reisner } 233344ed167dSPhilipp Reisner rcu_read_unlock(); 2334303d1448SPhilipp Reisner } 2335303d1448SPhilipp Reisner 2336303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2337303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2338b30ab791SAndreas Gruenbacher inc_unacked(device); 2339b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2340b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2341303d1448SPhilipp Reisner } 2342303d1448SPhilipp Reisner 2343303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2344b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2345b411b363SPhilipp Reisner * sends on the msock, but anyways */ 234669a22773SAndreas Gruenbacher drbd_send_ack(first_peer_device(device), P_RECV_ACK, peer_req); 2347b411b363SPhilipp Reisner } 2348b411b363SPhilipp Reisner 2349b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2350b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2351b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2352db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2353db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 23544dd726f0SLars Ellenberg drbd_al_begin_io(device, &peer_req->i); 2355b411b363SPhilipp Reisner } 2356b411b363SPhilipp Reisner 2357b30ab791SAndreas Gruenbacher err = drbd_submit_peer_request(device, peer_req, rw, DRBD_FAULT_DT_WR); 235882bc0194SAndreas Gruenbacher if (!err) 235982bc0194SAndreas Gruenbacher return 0; 2360b411b363SPhilipp Reisner 236110f6d992SLars Ellenberg /* don't care for the reason here */ 2362d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 23630500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2364a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2365b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 23660500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2367db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2368b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 236922cc37a9SLars Ellenberg 2370b411b363SPhilipp Reisner out_interrupted: 2371bde89a9eSAndreas Gruenbacher drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT + EV_CLEANUP); 2372b30ab791SAndreas Gruenbacher put_ldev(device); 2373b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 237482bc0194SAndreas Gruenbacher return err; 2375b411b363SPhilipp Reisner } 2376b411b363SPhilipp Reisner 23770f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 23780f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 23790f0601f4SLars Ellenberg * 23800f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 23810f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 23820f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 23830f0601f4SLars Ellenberg * activity, it obviously is "busy". 23840f0601f4SLars Ellenberg * 23850f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 23860f0601f4SLars Ellenberg * to have a short time average so we can react faster. 23870f0601f4SLars Ellenberg */ 2388e8299874SLars Ellenberg bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector) 2389e8299874SLars Ellenberg { 2390e8299874SLars Ellenberg struct lc_element *tmp; 2391e8299874SLars Ellenberg bool throttle = true; 2392e8299874SLars Ellenberg 2393e8299874SLars Ellenberg if (!drbd_rs_c_min_rate_throttle(device)) 2394e8299874SLars Ellenberg return false; 2395e8299874SLars Ellenberg 2396e8299874SLars Ellenberg spin_lock_irq(&device->al_lock); 2397e8299874SLars Ellenberg tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2398e8299874SLars Ellenberg if (tmp) { 2399e8299874SLars Ellenberg struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2400e8299874SLars Ellenberg if (test_bit(BME_PRIORITY, &bm_ext->flags)) 2401e8299874SLars Ellenberg throttle = false; 2402e8299874SLars Ellenberg /* Do not slow down if app IO is already waiting for this extent */ 2403e8299874SLars Ellenberg } 2404e8299874SLars Ellenberg spin_unlock_irq(&device->al_lock); 2405e8299874SLars Ellenberg 2406e8299874SLars Ellenberg return throttle; 2407e8299874SLars Ellenberg } 2408e8299874SLars Ellenberg 2409e8299874SLars Ellenberg bool drbd_rs_c_min_rate_throttle(struct drbd_device *device) 24100f0601f4SLars Ellenberg { 2411b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 24120f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2413daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2414e8299874SLars Ellenberg int curr_events; 2415daeda1ccSPhilipp Reisner 2416daeda1ccSPhilipp Reisner rcu_read_lock(); 2417b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2418daeda1ccSPhilipp Reisner rcu_read_unlock(); 24190f0601f4SLars Ellenberg 24200f0601f4SLars Ellenberg /* feature disabled? */ 2421daeda1ccSPhilipp Reisner if (c_min_rate == 0) 2422e8299874SLars Ellenberg return false; 2423e3555d85SPhilipp Reisner 24240f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 24250f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2426b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2427b30ab791SAndreas Gruenbacher if (!device->rs_last_events || curr_events - device->rs_last_events > 64) { 24280f0601f4SLars Ellenberg unsigned long rs_left; 24290f0601f4SLars Ellenberg int i; 24300f0601f4SLars Ellenberg 2431b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 24320f0601f4SLars Ellenberg 24330f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 24340f0601f4SLars Ellenberg * approx. */ 2435b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 24362649f080SLars Ellenberg 2437b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2438b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 24392649f080SLars Ellenberg else 2440b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 24410f0601f4SLars Ellenberg 2442b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 24430f0601f4SLars Ellenberg if (!dt) 24440f0601f4SLars Ellenberg dt++; 2445b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 24460f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 24470f0601f4SLars Ellenberg 2448daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 2449e8299874SLars Ellenberg return true; 24500f0601f4SLars Ellenberg } 2451e8299874SLars Ellenberg return false; 24520f0601f4SLars Ellenberg } 24530f0601f4SLars Ellenberg 2454bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2455b411b363SPhilipp Reisner { 24569f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2457b30ab791SAndreas Gruenbacher struct drbd_device *device; 2458b411b363SPhilipp Reisner sector_t sector; 24594a76b161SAndreas Gruenbacher sector_t capacity; 2460db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2461b411b363SPhilipp Reisner struct digest_info *di = NULL; 2462b18b37beSPhilipp Reisner int size, verb; 2463b411b363SPhilipp Reisner unsigned int fault_type; 2464e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 24654a76b161SAndreas Gruenbacher 24669f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 24679f4fe9adSAndreas Gruenbacher if (!peer_device) 24684a76b161SAndreas Gruenbacher return -EIO; 24699f4fe9adSAndreas Gruenbacher device = peer_device->device; 2470b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2471b411b363SPhilipp Reisner 2472b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2473b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2474b411b363SPhilipp Reisner 2475c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2476d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2477b411b363SPhilipp Reisner (unsigned long long)sector, size); 247882bc0194SAndreas Gruenbacher return -EINVAL; 2479b411b363SPhilipp Reisner } 2480b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2481d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2482b411b363SPhilipp Reisner (unsigned long long)sector, size); 248382bc0194SAndreas Gruenbacher return -EINVAL; 2484b411b363SPhilipp Reisner } 2485b411b363SPhilipp Reisner 2486b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2487b18b37beSPhilipp Reisner verb = 1; 2488e2857216SAndreas Gruenbacher switch (pi->cmd) { 2489b18b37beSPhilipp Reisner case P_DATA_REQUEST: 249069a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2491b18b37beSPhilipp Reisner break; 2492b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2493b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2494b18b37beSPhilipp Reisner case P_OV_REQUEST: 249569a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2496b18b37beSPhilipp Reisner break; 2497b18b37beSPhilipp Reisner case P_OV_REPLY: 2498b18b37beSPhilipp Reisner verb = 0; 2499b30ab791SAndreas Gruenbacher dec_rs_pending(device); 250069a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2501b18b37beSPhilipp Reisner break; 2502b18b37beSPhilipp Reisner default: 250349ba9b1bSAndreas Gruenbacher BUG(); 2504b18b37beSPhilipp Reisner } 2505b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2506d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2507b411b363SPhilipp Reisner "no local data.\n"); 2508b18b37beSPhilipp Reisner 2509a821cc4aSLars Ellenberg /* drain possibly payload */ 251069a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2511b411b363SPhilipp Reisner } 2512b411b363SPhilipp Reisner 2513b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2514b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2515b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2516a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, 2517a0fb3c47SLars Ellenberg true /* has real payload */, GFP_NOIO); 2518db830c46SAndreas Gruenbacher if (!peer_req) { 2519b30ab791SAndreas Gruenbacher put_ldev(device); 252082bc0194SAndreas Gruenbacher return -ENOMEM; 2521b411b363SPhilipp Reisner } 2522b411b363SPhilipp Reisner 2523e2857216SAndreas Gruenbacher switch (pi->cmd) { 2524b411b363SPhilipp Reisner case P_DATA_REQUEST: 2525a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2526b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 252780a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 252880a40e43SLars Ellenberg goto submit; 252980a40e43SLars Ellenberg 2530b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2531a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2532b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 25335f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2534b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2535b411b363SPhilipp Reisner break; 2536b411b363SPhilipp Reisner 2537b411b363SPhilipp Reisner case P_OV_REPLY: 2538b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2539b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2540e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2541b411b363SPhilipp Reisner if (!di) 2542b411b363SPhilipp Reisner goto out_free_e; 2543b411b363SPhilipp Reisner 2544e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2545b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2546b411b363SPhilipp Reisner 2547db830c46SAndreas Gruenbacher peer_req->digest = di; 2548db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2549c36c3cedSLars Ellenberg 25509f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2551b411b363SPhilipp Reisner goto out_free_e; 2552b411b363SPhilipp Reisner 2553e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 25549f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2555a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 25565f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2557b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2558aaaba345SLars Ellenberg /* remember to report stats in drbd_resync_finished */ 2559aaaba345SLars Ellenberg device->use_csums = true; 2560e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 25612649f080SLars Ellenberg /* track progress, we may need to throttle */ 2562b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2563a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2564b30ab791SAndreas Gruenbacher dec_rs_pending(device); 25650f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 25660f0601f4SLars Ellenberg * but accounting still needs to be done. */ 25670f0601f4SLars Ellenberg goto submit_for_resync; 2568b411b363SPhilipp Reisner } 2569b411b363SPhilipp Reisner break; 2570b411b363SPhilipp Reisner 2571b411b363SPhilipp Reisner case P_OV_REQUEST: 2572b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 25739f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2574de228bbaSLars Ellenberg unsigned long now = jiffies; 2575de228bbaSLars Ellenberg int i; 2576b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2577b30ab791SAndreas Gruenbacher device->ov_position = sector; 2578b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2579b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2580de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2581b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2582b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2583de228bbaSLars Ellenberg } 2584d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2585b411b363SPhilipp Reisner (unsigned long long)sector); 2586b411b363SPhilipp Reisner } 2587a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2588b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2589b411b363SPhilipp Reisner break; 2590b411b363SPhilipp Reisner 2591b411b363SPhilipp Reisner default: 259249ba9b1bSAndreas Gruenbacher BUG(); 2593b411b363SPhilipp Reisner } 2594b411b363SPhilipp Reisner 25950f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 25960f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 25970f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 25980f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 25990f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 26000f0601f4SLars Ellenberg * 26010f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 26020f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 26030f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 26040f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 26050f0601f4SLars Ellenberg * a while, anyways. 26060f0601f4SLars Ellenberg */ 2607b411b363SPhilipp Reisner 26080f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 26090f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 26100f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 26110f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 26120f0601f4SLars Ellenberg * 26130f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 26140f0601f4SLars Ellenberg * we would also throttle its application reads. 26150f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 26160f0601f4SLars Ellenberg */ 2617b30ab791SAndreas Gruenbacher if (device->state.peer != R_PRIMARY && drbd_rs_should_slow_down(device, sector)) 2618e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2619b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 262080a40e43SLars Ellenberg goto out_free_e; 2621b411b363SPhilipp Reisner 26220f0601f4SLars Ellenberg submit_for_resync: 2623b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 26240f0601f4SLars Ellenberg 262580a40e43SLars Ellenberg submit: 2626b30ab791SAndreas Gruenbacher inc_unacked(device); 26270500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2628a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->read_ee); 26290500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2630b411b363SPhilipp Reisner 2631b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, READ, fault_type) == 0) 263282bc0194SAndreas Gruenbacher return 0; 2633b411b363SPhilipp Reisner 263410f6d992SLars Ellenberg /* don't care for the reason here */ 2635d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 26360500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2637a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 26380500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 263922cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 264022cc37a9SLars Ellenberg 2641b411b363SPhilipp Reisner out_free_e: 2642b30ab791SAndreas Gruenbacher put_ldev(device); 2643b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 264482bc0194SAndreas Gruenbacher return -EIO; 2645b411b363SPhilipp Reisner } 2646b411b363SPhilipp Reisner 264769a22773SAndreas Gruenbacher /** 264869a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 264969a22773SAndreas Gruenbacher */ 265069a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2651b411b363SPhilipp Reisner { 265269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2653b411b363SPhilipp Reisner int self, peer, rv = -100; 2654b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 265544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2656b411b363SPhilipp Reisner 2657b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2658b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2659b411b363SPhilipp Reisner 2660b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2661b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2662b411b363SPhilipp Reisner 266344ed167dSPhilipp Reisner rcu_read_lock(); 266469a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 266544ed167dSPhilipp Reisner rcu_read_unlock(); 266644ed167dSPhilipp Reisner switch (after_sb_0p) { 2667b411b363SPhilipp Reisner case ASB_CONSENSUS: 2668b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2669b411b363SPhilipp Reisner case ASB_CALL_HELPER: 267044ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2671d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2672b411b363SPhilipp Reisner break; 2673b411b363SPhilipp Reisner case ASB_DISCONNECT: 2674b411b363SPhilipp Reisner break; 2675b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2676b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2677b411b363SPhilipp Reisner rv = -1; 2678b411b363SPhilipp Reisner break; 2679b411b363SPhilipp Reisner } 2680b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2681b411b363SPhilipp Reisner rv = 1; 2682b411b363SPhilipp Reisner break; 2683b411b363SPhilipp Reisner } 2684b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2685b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_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... */ 2695d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 2696b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2697b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2698b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 269969a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2700b411b363SPhilipp Reisner ? -1 : 1; 2701b411b363SPhilipp Reisner break; 2702b411b363SPhilipp Reisner } else { 2703b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2704b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2705b411b363SPhilipp Reisner } 270644ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2707b411b363SPhilipp Reisner break; 2708b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2709b411b363SPhilipp Reisner if (ch_self < ch_peer) 2710b411b363SPhilipp Reisner rv = -1; 2711b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2712b411b363SPhilipp Reisner rv = 1; 2713b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2714b411b363SPhilipp Reisner /* Well, then use something else. */ 271569a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2716b411b363SPhilipp Reisner ? -1 : 1; 2717b411b363SPhilipp Reisner break; 2718b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2719b411b363SPhilipp Reisner rv = -1; 2720b411b363SPhilipp Reisner break; 2721b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2722b411b363SPhilipp Reisner rv = 1; 2723b411b363SPhilipp Reisner } 2724b411b363SPhilipp Reisner 2725b411b363SPhilipp Reisner return rv; 2726b411b363SPhilipp Reisner } 2727b411b363SPhilipp Reisner 272869a22773SAndreas Gruenbacher /** 272969a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 273069a22773SAndreas Gruenbacher */ 273169a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 2732b411b363SPhilipp Reisner { 273369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 27346184ea21SAndreas Gruenbacher int hg, rv = -100; 273544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2736b411b363SPhilipp Reisner 273744ed167dSPhilipp Reisner rcu_read_lock(); 273869a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 273944ed167dSPhilipp Reisner rcu_read_unlock(); 274044ed167dSPhilipp Reisner switch (after_sb_1p) { 2741b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2742b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2743b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2744b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2745b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 274644ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2747d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2748b411b363SPhilipp Reisner break; 2749b411b363SPhilipp Reisner case ASB_DISCONNECT: 2750b411b363SPhilipp Reisner break; 2751b411b363SPhilipp Reisner case ASB_CONSENSUS: 275269a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2753b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 2754b411b363SPhilipp Reisner rv = hg; 2755b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 2756b411b363SPhilipp Reisner rv = hg; 2757b411b363SPhilipp Reisner break; 2758b411b363SPhilipp Reisner case ASB_VIOLENTLY: 275969a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2760b411b363SPhilipp Reisner break; 2761b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2762b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 2763b411b363SPhilipp Reisner case ASB_CALL_HELPER: 276469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2765b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 2766bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2767bb437946SAndreas Gruenbacher 2768b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2769b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2770b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2771b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2772bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2773b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2774b411b363SPhilipp Reisner } else { 2775d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2776b411b363SPhilipp Reisner rv = hg; 2777b411b363SPhilipp Reisner } 2778b411b363SPhilipp Reisner } else 2779b411b363SPhilipp Reisner rv = hg; 2780b411b363SPhilipp Reisner } 2781b411b363SPhilipp Reisner 2782b411b363SPhilipp Reisner return rv; 2783b411b363SPhilipp Reisner } 2784b411b363SPhilipp Reisner 278569a22773SAndreas Gruenbacher /** 278669a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 278769a22773SAndreas Gruenbacher */ 278869a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 2789b411b363SPhilipp Reisner { 279069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 27916184ea21SAndreas Gruenbacher int hg, rv = -100; 279244ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2793b411b363SPhilipp Reisner 279444ed167dSPhilipp Reisner rcu_read_lock(); 279569a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 279644ed167dSPhilipp Reisner rcu_read_unlock(); 279744ed167dSPhilipp Reisner switch (after_sb_2p) { 2798b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2799b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2800b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2801b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2802b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2803b411b363SPhilipp Reisner case ASB_CONSENSUS: 2804b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 280544ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2806d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2807b411b363SPhilipp Reisner break; 2808b411b363SPhilipp Reisner case ASB_VIOLENTLY: 280969a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2810b411b363SPhilipp Reisner break; 2811b411b363SPhilipp Reisner case ASB_DISCONNECT: 2812b411b363SPhilipp Reisner break; 2813b411b363SPhilipp Reisner case ASB_CALL_HELPER: 281469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2815b411b363SPhilipp Reisner if (hg == -1) { 2816bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2817bb437946SAndreas Gruenbacher 2818b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2819b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2820b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2821b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2822bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2823b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2824b411b363SPhilipp Reisner } else { 2825d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2826b411b363SPhilipp Reisner rv = hg; 2827b411b363SPhilipp Reisner } 2828b411b363SPhilipp Reisner } else 2829b411b363SPhilipp Reisner rv = hg; 2830b411b363SPhilipp Reisner } 2831b411b363SPhilipp Reisner 2832b411b363SPhilipp Reisner return rv; 2833b411b363SPhilipp Reisner } 2834b411b363SPhilipp Reisner 2835b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 2836b411b363SPhilipp Reisner u64 bits, u64 flags) 2837b411b363SPhilipp Reisner { 2838b411b363SPhilipp Reisner if (!uuid) { 2839d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 2840b411b363SPhilipp Reisner return; 2841b411b363SPhilipp Reisner } 2842d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2843b411b363SPhilipp Reisner text, 2844b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2845b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2846b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2847b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2848b411b363SPhilipp Reisner (unsigned long long)bits, 2849b411b363SPhilipp Reisner (unsigned long long)flags); 2850b411b363SPhilipp Reisner } 2851b411b363SPhilipp Reisner 2852b411b363SPhilipp Reisner /* 2853b411b363SPhilipp Reisner 100 after split brain try auto recover 2854b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2855b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2856b411b363SPhilipp Reisner 0 no Sync 2857b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2858b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2859b411b363SPhilipp Reisner -100 after split brain, disconnect 2860b411b363SPhilipp Reisner -1000 unrelated data 28614a23f264SPhilipp Reisner -1091 requires proto 91 28624a23f264SPhilipp Reisner -1096 requires proto 96 2863b411b363SPhilipp Reisner */ 286444a4d551SLars Ellenberg static int drbd_uuid_compare(struct drbd_device *const device, int *rule_nr) __must_hold(local) 2865b411b363SPhilipp Reisner { 286644a4d551SLars Ellenberg struct drbd_peer_device *const peer_device = first_peer_device(device); 286744a4d551SLars Ellenberg struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; 2868b411b363SPhilipp Reisner u64 self, peer; 2869b411b363SPhilipp Reisner int i, j; 2870b411b363SPhilipp Reisner 2871b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2872b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2873b411b363SPhilipp Reisner 2874b411b363SPhilipp Reisner *rule_nr = 10; 2875b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2876b411b363SPhilipp Reisner return 0; 2877b411b363SPhilipp Reisner 2878b411b363SPhilipp Reisner *rule_nr = 20; 2879b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2880b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2881b411b363SPhilipp Reisner return -2; 2882b411b363SPhilipp Reisner 2883b411b363SPhilipp Reisner *rule_nr = 30; 2884b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2885b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2886b411b363SPhilipp Reisner return 2; 2887b411b363SPhilipp Reisner 2888b411b363SPhilipp Reisner if (self == peer) { 2889b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2890b411b363SPhilipp Reisner 2891b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2892b411b363SPhilipp Reisner 289344a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 28944a23f264SPhilipp Reisner return -1091; 2895b411b363SPhilipp Reisner 2896b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2897b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2898d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2899b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 2900b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 2901b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 2902b411b363SPhilipp Reisner 2903b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 2904b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 2905b411b363SPhilipp Reisner *rule_nr = 34; 2906b411b363SPhilipp Reisner } else { 2907d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 2908b411b363SPhilipp Reisner *rule_nr = 36; 2909b411b363SPhilipp Reisner } 2910b411b363SPhilipp Reisner 2911b411b363SPhilipp Reisner return 1; 2912b411b363SPhilipp Reisner } 2913b411b363SPhilipp Reisner 2914b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 2915b411b363SPhilipp Reisner 291644a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 29174a23f264SPhilipp Reisner return -1091; 2918b411b363SPhilipp Reisner 2919b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 2920b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2921d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2922b411b363SPhilipp Reisner 2923b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 2924b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 2925b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 2926b411b363SPhilipp Reisner 2927b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 2928b411b363SPhilipp Reisner *rule_nr = 35; 2929b411b363SPhilipp Reisner } else { 2930d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 2931b411b363SPhilipp Reisner *rule_nr = 37; 2932b411b363SPhilipp Reisner } 2933b411b363SPhilipp Reisner 2934b411b363SPhilipp Reisner return -1; 2935b411b363SPhilipp Reisner } 2936b411b363SPhilipp Reisner 2937b411b363SPhilipp Reisner /* Common power [off|failure] */ 2938b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 2939b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 2940b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2941b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2942b411b363SPhilipp Reisner *rule_nr = 40; 2943b411b363SPhilipp Reisner 2944b411b363SPhilipp Reisner switch (rct) { 2945b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2946b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2947b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2948b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 294944a4d551SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); 2950b411b363SPhilipp Reisner return dc ? -1 : 1; 2951b411b363SPhilipp Reisner } 2952b411b363SPhilipp Reisner } 2953b411b363SPhilipp Reisner 2954b411b363SPhilipp Reisner *rule_nr = 50; 2955b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 2956b411b363SPhilipp Reisner if (self == peer) 2957b411b363SPhilipp Reisner return -1; 2958b411b363SPhilipp Reisner 2959b411b363SPhilipp Reisner *rule_nr = 51; 2960b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 2961b411b363SPhilipp Reisner if (self == peer) { 296244a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 2963b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 2964b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 2965b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 2966b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2967b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2968b411b363SPhilipp Reisner 296944a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 29704a23f264SPhilipp Reisner return -1091; 2971b411b363SPhilipp Reisner 2972b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 2973b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 29744a23f264SPhilipp Reisner 2975d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 2976b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 29774a23f264SPhilipp Reisner 2978b411b363SPhilipp Reisner return -1; 2979b411b363SPhilipp Reisner } 2980b411b363SPhilipp Reisner } 2981b411b363SPhilipp Reisner 2982b411b363SPhilipp Reisner *rule_nr = 60; 2983b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2984b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2985b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 2986b411b363SPhilipp Reisner if (self == peer) 2987b411b363SPhilipp Reisner return -2; 2988b411b363SPhilipp Reisner } 2989b411b363SPhilipp Reisner 2990b411b363SPhilipp Reisner *rule_nr = 70; 2991b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2992b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2993b411b363SPhilipp Reisner if (self == peer) 2994b411b363SPhilipp Reisner return 1; 2995b411b363SPhilipp Reisner 2996b411b363SPhilipp Reisner *rule_nr = 71; 2997b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2998b411b363SPhilipp Reisner if (self == peer) { 299944a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3000b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 3001b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 3002b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 3003b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3004b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 3005b411b363SPhilipp Reisner 300644a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 30074a23f264SPhilipp Reisner return -1091; 3008b411b363SPhilipp Reisner 3009b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 3010b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 3011b411b363SPhilipp Reisner 3012d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 3013b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3014b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3015b411b363SPhilipp Reisner 3016b411b363SPhilipp Reisner return 1; 3017b411b363SPhilipp Reisner } 3018b411b363SPhilipp Reisner } 3019b411b363SPhilipp Reisner 3020b411b363SPhilipp Reisner 3021b411b363SPhilipp Reisner *rule_nr = 80; 3022b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3023b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3024b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3025b411b363SPhilipp Reisner if (self == peer) 3026b411b363SPhilipp Reisner return 2; 3027b411b363SPhilipp Reisner } 3028b411b363SPhilipp Reisner 3029b411b363SPhilipp Reisner *rule_nr = 90; 3030b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3031b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3032b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 3033b411b363SPhilipp Reisner return 100; 3034b411b363SPhilipp Reisner 3035b411b363SPhilipp Reisner *rule_nr = 100; 3036b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3037b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3038b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 3039b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 3040b411b363SPhilipp Reisner if (self == peer) 3041b411b363SPhilipp Reisner return -100; 3042b411b363SPhilipp Reisner } 3043b411b363SPhilipp Reisner } 3044b411b363SPhilipp Reisner 3045b411b363SPhilipp Reisner return -1000; 3046b411b363SPhilipp Reisner } 3047b411b363SPhilipp Reisner 3048b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 3049b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 3050b411b363SPhilipp Reisner */ 305169a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 305269a22773SAndreas Gruenbacher enum drbd_role peer_role, 3053b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 3054b411b363SPhilipp Reisner { 305569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 3056b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 3057b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 305844ed167dSPhilipp Reisner struct net_conf *nc; 30596dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 3060b411b363SPhilipp Reisner 3061b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 3062b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 3063b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 3064b411b363SPhilipp Reisner 3065d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 30669f2247bbSPhilipp Reisner 3067b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 3068b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 3069b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 3070b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3071b411b363SPhilipp Reisner 3072b30ab791SAndreas Gruenbacher hg = drbd_uuid_compare(device, &rule_nr); 3073b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 3074b411b363SPhilipp Reisner 3075d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 3076b411b363SPhilipp Reisner 3077b411b363SPhilipp Reisner if (hg == -1000) { 3078d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3079b411b363SPhilipp Reisner return C_MASK; 3080b411b363SPhilipp Reisner } 30814a23f264SPhilipp Reisner if (hg < -1000) { 3082d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3083b411b363SPhilipp Reisner return C_MASK; 3084b411b363SPhilipp Reisner } 3085b411b363SPhilipp Reisner 3086b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3087b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3088b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3089b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3090b411b363SPhilipp Reisner if (f) 3091b411b363SPhilipp Reisner hg = hg*2; 3092d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3093b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3094b411b363SPhilipp Reisner } 3095b411b363SPhilipp Reisner 30963a11a487SAdam Gandelman if (abs(hg) == 100) 3097b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 30983a11a487SAdam Gandelman 309944ed167dSPhilipp Reisner rcu_read_lock(); 310069a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 310144ed167dSPhilipp Reisner 310244ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3103b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3104b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3105b411b363SPhilipp Reisner int forced = (hg == -100); 3106b411b363SPhilipp Reisner 3107b411b363SPhilipp Reisner switch (pcount) { 3108b411b363SPhilipp Reisner case 0: 310969a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3110b411b363SPhilipp Reisner break; 3111b411b363SPhilipp Reisner case 1: 311269a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3113b411b363SPhilipp Reisner break; 3114b411b363SPhilipp Reisner case 2: 311569a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3116b411b363SPhilipp Reisner break; 3117b411b363SPhilipp Reisner } 3118b411b363SPhilipp Reisner if (abs(hg) < 100) { 3119d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3120b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3121b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3122b411b363SPhilipp Reisner if (forced) { 3123d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3124b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3125b411b363SPhilipp Reisner hg = hg*2; 3126b411b363SPhilipp Reisner } 3127b411b363SPhilipp Reisner } 3128b411b363SPhilipp Reisner } 3129b411b363SPhilipp Reisner 3130b411b363SPhilipp Reisner if (hg == -100) { 3131b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3132b411b363SPhilipp Reisner hg = -1; 3133b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3134b411b363SPhilipp Reisner hg = 1; 3135b411b363SPhilipp Reisner 3136b411b363SPhilipp Reisner if (abs(hg) < 100) 3137d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3138b411b363SPhilipp Reisner "Sync from %s node\n", 3139b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3140b411b363SPhilipp Reisner } 314144ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 31426dff2902SAndreas Gruenbacher tentative = nc->tentative; 314344ed167dSPhilipp Reisner rcu_read_unlock(); 3144b411b363SPhilipp Reisner 3145b411b363SPhilipp Reisner if (hg == -100) { 3146580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3147580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3148580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3149580b9767SLars Ellenberg * to that disk, in a way... */ 3150d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3151b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3152b411b363SPhilipp Reisner return C_MASK; 3153b411b363SPhilipp Reisner } 3154b411b363SPhilipp Reisner 3155b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3156d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3157b411b363SPhilipp Reisner return C_MASK; 3158b411b363SPhilipp Reisner } 3159b411b363SPhilipp Reisner 3160b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3161b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 316244ed167dSPhilipp Reisner switch (rr_conflict) { 3163b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3164b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3165b411b363SPhilipp Reisner /* fall through */ 3166b411b363SPhilipp Reisner case ASB_DISCONNECT: 3167d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3168b411b363SPhilipp Reisner return C_MASK; 3169b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3170d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3171b411b363SPhilipp Reisner "assumption\n"); 3172b411b363SPhilipp Reisner } 3173b411b363SPhilipp Reisner } 3174b411b363SPhilipp Reisner 317569a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3176cf14c2e9SPhilipp Reisner if (hg == 0) 3177d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3178cf14c2e9SPhilipp Reisner else 3179d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3180cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3181cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3182cf14c2e9SPhilipp Reisner return C_MASK; 3183cf14c2e9SPhilipp Reisner } 3184cf14c2e9SPhilipp Reisner 3185b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3186d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3187b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 318820ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3189b411b363SPhilipp Reisner return C_MASK; 3190b411b363SPhilipp Reisner } 3191b411b363SPhilipp Reisner 3192b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3193b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3194b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3195b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3196b411b363SPhilipp Reisner } else { 3197b411b363SPhilipp Reisner rv = C_CONNECTED; 3198b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3199d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3200b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3201b411b363SPhilipp Reisner } 3202b411b363SPhilipp Reisner } 3203b411b363SPhilipp Reisner 3204b411b363SPhilipp Reisner return rv; 3205b411b363SPhilipp Reisner } 3206b411b363SPhilipp Reisner 3207f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3208b411b363SPhilipp Reisner { 3209b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3210f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3211f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3212b411b363SPhilipp Reisner 3213b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3214f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3215f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3216b411b363SPhilipp Reisner 3217b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3218f179d76dSPhilipp Reisner return peer; 3219b411b363SPhilipp Reisner } 3220b411b363SPhilipp Reisner 3221bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3222b411b363SPhilipp Reisner { 3223e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3224036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3225036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3226036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3227036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3228accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 32297aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3230b411b363SPhilipp Reisner 3231b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3232b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3233b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3234b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3235b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3236cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 32376139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3238cf14c2e9SPhilipp Reisner 3239bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 324086db0618SAndreas Gruenbacher int err; 324186db0618SAndreas Gruenbacher 324288104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 324386db0618SAndreas Gruenbacher return -EIO; 3244bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 324586db0618SAndreas Gruenbacher if (err) 324686db0618SAndreas Gruenbacher return err; 324788104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3248036b17eaSPhilipp Reisner } 324986db0618SAndreas Gruenbacher 32507d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3251bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3252cf14c2e9SPhilipp Reisner 3253cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3254bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3255b411b363SPhilipp Reisner 325644ed167dSPhilipp Reisner rcu_read_lock(); 3257bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 325844ed167dSPhilipp Reisner 3259036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 32601ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 326144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3262b411b363SPhilipp Reisner } 3263b411b363SPhilipp Reisner 3264f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 32651ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 326644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3267b411b363SPhilipp Reisner } 3268b411b363SPhilipp Reisner 3269f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 32701ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 327144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3272b411b363SPhilipp Reisner } 3273b411b363SPhilipp Reisner 3274f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 32751ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 327644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3277b411b363SPhilipp Reisner } 3278b411b363SPhilipp Reisner 32796139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 32801ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 328144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3282b411b363SPhilipp Reisner } 3283b411b363SPhilipp Reisner 328444ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 32851ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 328644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3287b411b363SPhilipp Reisner } 3288b411b363SPhilipp Reisner 3289036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 32901ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3291036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3292036b17eaSPhilipp Reisner } 3293036b17eaSPhilipp Reisner 329486db0618SAndreas Gruenbacher rcu_read_unlock(); 3295fbc12f45SAndreas Gruenbacher } 32967d4c782cSAndreas Gruenbacher 32977d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 32987d4c782cSAndreas Gruenbacher int hash_size; 32997d4c782cSAndreas Gruenbacher 33007d4c782cSAndreas Gruenbacher /* 33017d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 33027d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 33037d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 33047d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 33057d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 33067d4c782cSAndreas Gruenbacher * change. 33077d4c782cSAndreas Gruenbacher */ 33087d4c782cSAndreas Gruenbacher 33097d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 33107d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 33111ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 33127d4c782cSAndreas Gruenbacher integrity_alg); 3313b411b363SPhilipp Reisner goto disconnect; 3314b411b363SPhilipp Reisner } 3315b411b363SPhilipp Reisner 33167d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 33177d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 33187d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 33197d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 33201ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 33217d4c782cSAndreas Gruenbacher goto disconnect; 33227d4c782cSAndreas Gruenbacher } 33237d4c782cSAndreas Gruenbacher } 33247d4c782cSAndreas Gruenbacher 33257d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 33267d4c782cSAndreas Gruenbacher if (!new_net_conf) { 33271ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3328b411b363SPhilipp Reisner goto disconnect; 3329b411b363SPhilipp Reisner } 3330b411b363SPhilipp Reisner 3331bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 33320500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3333bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 33347d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3335b411b363SPhilipp Reisner 33367d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 33377d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 33387d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 33397d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 33407d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3341b411b363SPhilipp Reisner 3342bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 33430500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3344bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3345b411b363SPhilipp Reisner 3346bde89a9eSAndreas Gruenbacher crypto_free_hash(connection->peer_integrity_tfm); 3347bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3348bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3349bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3350bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3351bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3352b411b363SPhilipp Reisner 33537d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 33541ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 33557d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3356b411b363SPhilipp Reisner 33577d4c782cSAndreas Gruenbacher synchronize_rcu(); 33587d4c782cSAndreas Gruenbacher kfree(old_net_conf); 335982bc0194SAndreas Gruenbacher return 0; 3360b411b363SPhilipp Reisner 336144ed167dSPhilipp Reisner disconnect_rcu_unlock: 336244ed167dSPhilipp Reisner rcu_read_unlock(); 3363b411b363SPhilipp Reisner disconnect: 3364b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3365036b17eaSPhilipp Reisner kfree(int_dig_in); 3366036b17eaSPhilipp Reisner kfree(int_dig_vv); 3367bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 336882bc0194SAndreas Gruenbacher return -EIO; 3369b411b363SPhilipp Reisner } 3370b411b363SPhilipp Reisner 3371b411b363SPhilipp Reisner /* helper function 3372b411b363SPhilipp Reisner * input: alg name, feature name 3373b411b363SPhilipp Reisner * return: NULL (alg name was "") 3374b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3375b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 33768ce953aaSLars Ellenberg static struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3377b411b363SPhilipp Reisner const char *alg, const char *name) 3378b411b363SPhilipp Reisner { 3379b411b363SPhilipp Reisner struct crypto_hash *tfm; 3380b411b363SPhilipp Reisner 3381b411b363SPhilipp Reisner if (!alg[0]) 3382b411b363SPhilipp Reisner return NULL; 3383b411b363SPhilipp Reisner 3384b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3385b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3386d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3387b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3388b411b363SPhilipp Reisner return tfm; 3389b411b363SPhilipp Reisner } 3390b411b363SPhilipp Reisner return tfm; 3391b411b363SPhilipp Reisner } 3392b411b363SPhilipp Reisner 3393bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3394b411b363SPhilipp Reisner { 3395bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 33964a76b161SAndreas Gruenbacher int size = pi->size; 33974a76b161SAndreas Gruenbacher 33984a76b161SAndreas Gruenbacher while (size) { 33994a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3400bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 34014a76b161SAndreas Gruenbacher if (s <= 0) { 34024a76b161SAndreas Gruenbacher if (s < 0) 34034a76b161SAndreas Gruenbacher return s; 34044a76b161SAndreas Gruenbacher break; 34054a76b161SAndreas Gruenbacher } 34064a76b161SAndreas Gruenbacher size -= s; 34074a76b161SAndreas Gruenbacher } 34084a76b161SAndreas Gruenbacher if (size) 34094a76b161SAndreas Gruenbacher return -EIO; 34104a76b161SAndreas Gruenbacher return 0; 34114a76b161SAndreas Gruenbacher } 34124a76b161SAndreas Gruenbacher 34134a76b161SAndreas Gruenbacher /* 34144a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 34154a76b161SAndreas Gruenbacher * 34164a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 34174a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 34184a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 34194a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 34204a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 34214a76b161SAndreas Gruenbacher * 34224a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 34234a76b161SAndreas Gruenbacher */ 3424bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 34254a76b161SAndreas Gruenbacher { 34261ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 34272fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3428bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 34294a76b161SAndreas Gruenbacher } 34304a76b161SAndreas Gruenbacher 3431bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 34324a76b161SAndreas Gruenbacher { 34339f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3434b30ab791SAndreas Gruenbacher struct drbd_device *device; 3435e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3436b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3437b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3438b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 34392ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3440813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3441bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3442813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3443778f271dSPhilipp Reisner int fifo_size = 0; 344482bc0194SAndreas Gruenbacher int err; 3445b411b363SPhilipp Reisner 34469f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 34479f4fe9adSAndreas Gruenbacher if (!peer_device) 3448bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 34499f4fe9adSAndreas Gruenbacher device = peer_device->device; 3450b411b363SPhilipp Reisner 3451b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3452b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3453b411b363SPhilipp Reisner + SHARED_SECRET_MAX 34548e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 34558e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3456b411b363SPhilipp Reisner 3457e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3458d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3459e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 346082bc0194SAndreas Gruenbacher return -EIO; 3461b411b363SPhilipp Reisner } 3462b411b363SPhilipp Reisner 3463b411b363SPhilipp Reisner if (apv <= 88) { 3464e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3465e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 34668e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3467e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3468e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 34690b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 34708e26f9ccSPhilipp Reisner } else { 3471e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3472e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 34730b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3474b411b363SPhilipp Reisner } 3475b411b363SPhilipp Reisner 3476b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3477e658983aSAndreas Gruenbacher p = pi->data; 3478b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3479b411b363SPhilipp Reisner 34809f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 348182bc0194SAndreas Gruenbacher if (err) 348282bc0194SAndreas Gruenbacher return err; 3483b411b363SPhilipp Reisner 34840500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 34859f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3486b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3487daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3488daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3489b30ab791SAndreas Gruenbacher put_ldev(device); 34900500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3491d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3492daeda1ccSPhilipp Reisner return -ENOMEM; 3493f399002eSLars Ellenberg } 3494b411b363SPhilipp Reisner 3495b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3496daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3497daeda1ccSPhilipp Reisner 34986394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3499813472ceSPhilipp Reisner } 3500b411b363SPhilipp Reisner 3501b411b363SPhilipp Reisner if (apv >= 88) { 3502b411b363SPhilipp Reisner if (apv == 88) { 35035de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3504d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 35055de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3506b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3507813472ceSPhilipp Reisner err = -EIO; 3508813472ceSPhilipp Reisner goto reconnect; 3509b411b363SPhilipp Reisner } 3510b411b363SPhilipp Reisner 35119f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3512813472ceSPhilipp Reisner if (err) 3513813472ceSPhilipp Reisner goto reconnect; 3514b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3515b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 35160b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3517b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3518b411b363SPhilipp Reisner 3519b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3520b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3521b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 35220b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 35230b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3524b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3525b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3526b411b363SPhilipp Reisner } 3527b411b363SPhilipp Reisner 35282ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3529b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3530d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 35312ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3532b411b363SPhilipp Reisner goto disconnect; 3533b411b363SPhilipp Reisner } 3534b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3535b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3536b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3537b411b363SPhilipp Reisner verify_tfm = NULL; 3538b411b363SPhilipp Reisner goto disconnect; 3539b411b363SPhilipp Reisner } 3540b411b363SPhilipp Reisner } 3541b411b363SPhilipp Reisner 35422ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3543b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3544d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 35452ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3546b411b363SPhilipp Reisner goto disconnect; 3547b411b363SPhilipp Reisner } 3548b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3549b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3550b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3551b411b363SPhilipp Reisner csums_tfm = NULL; 3552b411b363SPhilipp Reisner goto disconnect; 3553b411b363SPhilipp Reisner } 3554b411b363SPhilipp Reisner } 3555b411b363SPhilipp Reisner 3556813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3557daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3558daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3559daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3560daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3561778f271dSPhilipp Reisner 3562daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3563b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3564813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3565813472ceSPhilipp Reisner if (!new_plan) { 3566d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3567b30ab791SAndreas Gruenbacher put_ldev(device); 3568778f271dSPhilipp Reisner goto disconnect; 3569778f271dSPhilipp Reisner } 3570778f271dSPhilipp Reisner } 35718e26f9ccSPhilipp Reisner } 3572b411b363SPhilipp Reisner 357391fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 35742ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 35752ec91e0eSPhilipp Reisner if (!new_net_conf) { 3576d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 357791fd4dadSPhilipp Reisner goto disconnect; 357891fd4dadSPhilipp Reisner } 357991fd4dadSPhilipp Reisner 35802ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 358191fd4dadSPhilipp Reisner 3582b411b363SPhilipp Reisner if (verify_tfm) { 35832ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 35842ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 35859f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->verify_tfm); 35869f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3587d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3588b411b363SPhilipp Reisner } 3589b411b363SPhilipp Reisner if (csums_tfm) { 35902ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 35912ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 35929f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->csums_tfm); 35939f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3594d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3595b411b363SPhilipp Reisner } 3596bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3597778f271dSPhilipp Reisner } 3598b411b363SPhilipp Reisner } 3599b411b363SPhilipp Reisner 3600813472ceSPhilipp Reisner if (new_disk_conf) { 3601b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3602b30ab791SAndreas Gruenbacher put_ldev(device); 3603b411b363SPhilipp Reisner } 3604813472ceSPhilipp Reisner 3605813472ceSPhilipp Reisner if (new_plan) { 3606b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3607b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3608813472ceSPhilipp Reisner } 3609daeda1ccSPhilipp Reisner 36100500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3611daeda1ccSPhilipp Reisner synchronize_rcu(); 3612daeda1ccSPhilipp Reisner if (new_net_conf) 3613daeda1ccSPhilipp Reisner kfree(old_net_conf); 3614daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3615813472ceSPhilipp Reisner kfree(old_plan); 3616daeda1ccSPhilipp Reisner 361782bc0194SAndreas Gruenbacher return 0; 3618b411b363SPhilipp Reisner 3619813472ceSPhilipp Reisner reconnect: 3620813472ceSPhilipp Reisner if (new_disk_conf) { 3621b30ab791SAndreas Gruenbacher put_ldev(device); 3622813472ceSPhilipp Reisner kfree(new_disk_conf); 3623813472ceSPhilipp Reisner } 36240500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3625813472ceSPhilipp Reisner return -EIO; 3626813472ceSPhilipp Reisner 3627b411b363SPhilipp Reisner disconnect: 3628813472ceSPhilipp Reisner kfree(new_plan); 3629813472ceSPhilipp Reisner if (new_disk_conf) { 3630b30ab791SAndreas Gruenbacher put_ldev(device); 3631813472ceSPhilipp Reisner kfree(new_disk_conf); 3632813472ceSPhilipp Reisner } 36330500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3634b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3635b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3636b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3637b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3638b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 36399f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 364082bc0194SAndreas Gruenbacher return -EIO; 3641b411b363SPhilipp Reisner } 3642b411b363SPhilipp Reisner 3643b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3644b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 3645b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3646b411b363SPhilipp Reisner { 3647b411b363SPhilipp Reisner sector_t d; 3648b411b363SPhilipp Reisner if (a == 0 || b == 0) 3649b411b363SPhilipp Reisner return; 3650b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3651b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3652d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 3653b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3654b411b363SPhilipp Reisner } 3655b411b363SPhilipp Reisner 3656bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 3657b411b363SPhilipp Reisner { 36589f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3659b30ab791SAndreas Gruenbacher struct drbd_device *device; 3660e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3661e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 36626a8d68b1SLars Ellenberg sector_t p_size, p_usize, p_csize, my_usize; 3663b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3664e89b591cSPhilipp Reisner enum dds_flags ddsf; 3665b411b363SPhilipp Reisner 36669f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 36679f4fe9adSAndreas Gruenbacher if (!peer_device) 3668bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 36699f4fe9adSAndreas Gruenbacher device = peer_device->device; 36704a76b161SAndreas Gruenbacher 3671b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3672b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 36736a8d68b1SLars Ellenberg p_csize = be64_to_cpu(p->c_size); 3674b411b363SPhilipp Reisner 3675b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3676b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3677b30ab791SAndreas Gruenbacher device->p_size = p_size; 3678b411b363SPhilipp Reisner 3679b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3680daeda1ccSPhilipp Reisner rcu_read_lock(); 3681b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 3682daeda1ccSPhilipp Reisner rcu_read_unlock(); 3683daeda1ccSPhilipp Reisner 3684b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 3685b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 3686b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 3687daeda1ccSPhilipp Reisner p_usize, my_usize); 3688b411b363SPhilipp Reisner 3689b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3690b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3691b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 3692daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3693b411b363SPhilipp Reisner 3694b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3695b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3696b30ab791SAndreas Gruenbacher if (drbd_new_dev_size(device, device->ldev, p_usize, 0) < 3697b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) && 3698b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 3699b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 3700d0180171SAndreas Gruenbacher drbd_err(device, "The peer's disk size is too small!\n"); 37019f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 3702b30ab791SAndreas Gruenbacher put_ldev(device); 370382bc0194SAndreas Gruenbacher return -EIO; 3704b411b363SPhilipp Reisner } 3705daeda1ccSPhilipp Reisner 3706daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3707daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3708daeda1ccSPhilipp Reisner 3709daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3710daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3711d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3712b30ab791SAndreas Gruenbacher put_ldev(device); 3713daeda1ccSPhilipp Reisner return -ENOMEM; 3714daeda1ccSPhilipp Reisner } 3715daeda1ccSPhilipp Reisner 37160500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3717b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3718daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3719daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3720daeda1ccSPhilipp Reisner 3721b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 37220500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3723daeda1ccSPhilipp Reisner synchronize_rcu(); 3724daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3725daeda1ccSPhilipp Reisner 3726d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 3727daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3728daeda1ccSPhilipp Reisner } 3729daeda1ccSPhilipp Reisner 3730b30ab791SAndreas Gruenbacher put_ldev(device); 3731b411b363SPhilipp Reisner } 3732b411b363SPhilipp Reisner 373320c68fdeSLars Ellenberg device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 373420c68fdeSLars Ellenberg /* Leave drbd_reconsider_max_bio_size() before drbd_determine_dev_size(). 373520c68fdeSLars Ellenberg In case we cleared the QUEUE_FLAG_DISCARD from our queue in 373620c68fdeSLars Ellenberg drbd_reconsider_max_bio_size(), we can be sure that after 373720c68fdeSLars Ellenberg drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */ 373820c68fdeSLars Ellenberg 3739e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3740b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 37418fe39aacSPhilipp Reisner drbd_reconsider_max_bio_size(device, device->ldev); 3742b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 3743b30ab791SAndreas Gruenbacher put_ldev(device); 3744e96c9633SPhilipp Reisner if (dd == DS_ERROR) 374582bc0194SAndreas Gruenbacher return -EIO; 3746b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3747b411b363SPhilipp Reisner } else { 37486a8d68b1SLars Ellenberg /* 37496a8d68b1SLars Ellenberg * I am diskless, need to accept the peer's *current* size. 37506a8d68b1SLars Ellenberg * I must NOT accept the peers backing disk size, 37516a8d68b1SLars Ellenberg * it may have been larger than mine all along... 37526a8d68b1SLars Ellenberg * 37536a8d68b1SLars Ellenberg * At this point, the peer knows more about my disk, or at 37546a8d68b1SLars Ellenberg * least about what we last agreed upon, than myself. 37556a8d68b1SLars Ellenberg * So if his c_size is less than his d_size, the most likely 37566a8d68b1SLars Ellenberg * reason is that *my* d_size was smaller last time we checked. 37576a8d68b1SLars Ellenberg * 37586a8d68b1SLars Ellenberg * However, if he sends a zero current size, 37596a8d68b1SLars Ellenberg * take his (user-capped or) backing disk size anyways. 37606a8d68b1SLars Ellenberg */ 37618fe39aacSPhilipp Reisner drbd_reconsider_max_bio_size(device, NULL); 37626a8d68b1SLars Ellenberg drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); 3763b411b363SPhilipp Reisner } 3764b411b363SPhilipp Reisner 3765b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3766b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 3767b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 3768b411b363SPhilipp Reisner ldsc = 1; 3769b411b363SPhilipp Reisner } 3770b411b363SPhilipp Reisner 3771b30ab791SAndreas Gruenbacher put_ldev(device); 3772b411b363SPhilipp Reisner } 3773b411b363SPhilipp Reisner 3774b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 3775b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3776b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 3777b411b363SPhilipp Reisner /* we have different sizes, probably peer 3778b411b363SPhilipp Reisner * needs to know my new size... */ 377969a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 3780b411b363SPhilipp Reisner } 3781b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 3782b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 3783b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 3784b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 3785e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3786d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 3787b411b363SPhilipp Reisner else 3788b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 3789e89b591cSPhilipp Reisner } else 3790b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 3791b411b363SPhilipp Reisner } 3792b411b363SPhilipp Reisner } 3793b411b363SPhilipp Reisner 379482bc0194SAndreas Gruenbacher return 0; 3795b411b363SPhilipp Reisner } 3796b411b363SPhilipp Reisner 3797bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 3798b411b363SPhilipp Reisner { 37999f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3800b30ab791SAndreas Gruenbacher struct drbd_device *device; 3801e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3802b411b363SPhilipp Reisner u64 *p_uuid; 380362b0da3aSLars Ellenberg int i, updated_uuids = 0; 3804b411b363SPhilipp Reisner 38059f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38069f4fe9adSAndreas Gruenbacher if (!peer_device) 3807bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 38089f4fe9adSAndreas Gruenbacher device = peer_device->device; 38094a76b161SAndreas Gruenbacher 3810b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3811063eacf8SJing Wang if (!p_uuid) { 3812d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 3813063eacf8SJing Wang return false; 3814063eacf8SJing Wang } 3815b411b363SPhilipp Reisner 3816b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3817b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3818b411b363SPhilipp Reisner 3819b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 3820b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 3821b411b363SPhilipp Reisner 3822b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 3823b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 3824b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 3825b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3826d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 3827b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 38289f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 382982bc0194SAndreas Gruenbacher return -EIO; 3830b411b363SPhilipp Reisner } 3831b411b363SPhilipp Reisner 3832b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3833b411b363SPhilipp Reisner int skip_initial_sync = 3834b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 38359f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 3836b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3837b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3838b411b363SPhilipp Reisner if (skip_initial_sync) { 3839d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 3840b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 384120ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 384220ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3843b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 3844b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 3845b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3846b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3847b30ab791SAndreas Gruenbacher drbd_md_sync(device); 384862b0da3aSLars Ellenberg updated_uuids = 1; 3849b411b363SPhilipp Reisner } 3850b30ab791SAndreas Gruenbacher put_ldev(device); 3851b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 3852b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 385318a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 385418a50fa2SPhilipp Reisner for me. */ 3855b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 3856b411b363SPhilipp Reisner } 3857b411b363SPhilipp Reisner 3858b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3859b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3860b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3861b411b363SPhilipp Reisner new disk state... */ 3862b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 3863b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 3864b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 3865b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 386662b0da3aSLars Ellenberg 386762b0da3aSLars Ellenberg if (updated_uuids) 3868b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 3869b411b363SPhilipp Reisner 387082bc0194SAndreas Gruenbacher return 0; 3871b411b363SPhilipp Reisner } 3872b411b363SPhilipp Reisner 3873b411b363SPhilipp Reisner /** 3874b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3875b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3876b411b363SPhilipp Reisner */ 3877b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3878b411b363SPhilipp Reisner { 3879b411b363SPhilipp Reisner union drbd_state ms; 3880b411b363SPhilipp Reisner 3881b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3882369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3883b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3884b411b363SPhilipp Reisner 3885b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3886b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3887b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3888b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3889b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3890b411b363SPhilipp Reisner }; 3891b411b363SPhilipp Reisner 3892b411b363SPhilipp Reisner ms.i = ps.i; 3893b411b363SPhilipp Reisner 3894b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3895b411b363SPhilipp Reisner ms.peer = ps.role; 3896b411b363SPhilipp Reisner ms.role = ps.peer; 3897b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3898b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3899b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3900b411b363SPhilipp Reisner 3901b411b363SPhilipp Reisner return ms; 3902b411b363SPhilipp Reisner } 3903b411b363SPhilipp Reisner 3904bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 3905b411b363SPhilipp Reisner { 39069f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3907b30ab791SAndreas Gruenbacher struct drbd_device *device; 3908e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3909b411b363SPhilipp Reisner union drbd_state mask, val; 3910bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3911b411b363SPhilipp Reisner 39129f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 39139f4fe9adSAndreas Gruenbacher if (!peer_device) 39144a76b161SAndreas Gruenbacher return -EIO; 39159f4fe9adSAndreas Gruenbacher device = peer_device->device; 39164a76b161SAndreas Gruenbacher 3917b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3918b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3919b411b363SPhilipp Reisner 39209f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 3921b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 392269a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 392382bc0194SAndreas Gruenbacher return 0; 3924b411b363SPhilipp Reisner } 3925b411b363SPhilipp Reisner 3926b411b363SPhilipp Reisner mask = convert_state(mask); 3927b411b363SPhilipp Reisner val = convert_state(val); 3928b411b363SPhilipp Reisner 3929b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 393069a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 3931047cd4a6SPhilipp Reisner 3932b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3933b411b363SPhilipp Reisner 393482bc0194SAndreas Gruenbacher return 0; 3935b411b363SPhilipp Reisner } 3936b411b363SPhilipp Reisner 3937bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 3938b411b363SPhilipp Reisner { 3939e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3940dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3941dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3942dfafcc8aSPhilipp Reisner 3943dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3944dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3945dfafcc8aSPhilipp Reisner 3946bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 3947bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 3948bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 394982bc0194SAndreas Gruenbacher return 0; 3950dfafcc8aSPhilipp Reisner } 3951dfafcc8aSPhilipp Reisner 3952dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3953dfafcc8aSPhilipp Reisner val = convert_state(val); 3954dfafcc8aSPhilipp Reisner 3955bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3956bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 3957dfafcc8aSPhilipp Reisner 395882bc0194SAndreas Gruenbacher return 0; 3959dfafcc8aSPhilipp Reisner } 3960dfafcc8aSPhilipp Reisner 3961bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 3962b411b363SPhilipp Reisner { 39639f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3964b30ab791SAndreas Gruenbacher struct drbd_device *device; 3965e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 39664ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3967b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 396865d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3969b411b363SPhilipp Reisner int rv; 3970b411b363SPhilipp Reisner 39719f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 39729f4fe9adSAndreas Gruenbacher if (!peer_device) 3973bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 39749f4fe9adSAndreas Gruenbacher device = peer_device->device; 39754a76b161SAndreas Gruenbacher 3976b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3977b411b363SPhilipp Reisner 3978b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3979b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3980b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3981d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3982b411b363SPhilipp Reisner } 3983b411b363SPhilipp Reisner 39840500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 3985b411b363SPhilipp Reisner retry: 3986b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 39870500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 3988b411b363SPhilipp Reisner 3989545752d5SLars Ellenberg /* If some other part of the code (asender thread, timeout) 3990545752d5SLars Ellenberg * already decided to close the connection again, 3991545752d5SLars Ellenberg * we must not "re-establish" it here. */ 3992545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 399358ffa580SLars Ellenberg return -ECONNRESET; 3994545752d5SLars Ellenberg 399540424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 399640424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 399740424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 399840424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 399940424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 400040424e4aSLars Ellenberg */ 400140424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 400240424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 4003e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 4004e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 4005e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 4006e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 4007e9ef7bb6SLars Ellenberg * syncing states. 4008e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 4009e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 4010e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 4011e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 4012e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 4013e9ef7bb6SLars Ellenberg 4014e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 4015e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 4016e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 4017e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 4018e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 4019b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 4020b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 402182bc0194SAndreas Gruenbacher return 0; 4022e9ef7bb6SLars Ellenberg } 4023e9ef7bb6SLars Ellenberg } 4024e9ef7bb6SLars Ellenberg 402502b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 402602b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 402702b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 4028b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 4029b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 403058ffa580SLars Ellenberg return 0; 403102b91b55SLars Ellenberg } 403202b91b55SLars Ellenberg 4033e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 4034e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 4035e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 4036e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 4037e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 4038e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 4039e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 4040e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 4041e9ef7bb6SLars Ellenberg 40424ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 40434ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4044b411b363SPhilipp Reisner 404567531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 404667531718SPhilipp Reisner ns.conn = C_BEHIND; 404767531718SPhilipp Reisner 4048b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 4049b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 4050b411b363SPhilipp Reisner int cr; /* consider resync */ 4051b411b363SPhilipp Reisner 4052b411b363SPhilipp Reisner /* if we established a new connection */ 40534ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 4054b411b363SPhilipp Reisner /* if we had an established connection 4055b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 40564ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4057b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 40584ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 4059b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 4060b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 4061b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 4062b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 4063b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 40644ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4065b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 4066b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 4067b411b363SPhilipp Reisner 4068b411b363SPhilipp Reisner if (cr) 406969a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 4070b411b363SPhilipp Reisner 4071b30ab791SAndreas Gruenbacher put_ldev(device); 40724ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 40734ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4074b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 4075b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 4076b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 4077d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 4078b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 4079580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 4080b411b363SPhilipp Reisner } else { 40819f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 408282bc0194SAndreas Gruenbacher return -EIO; 40830b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 40849f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 408582bc0194SAndreas Gruenbacher return -EIO; 4086b411b363SPhilipp Reisner } 4087b411b363SPhilipp Reisner } 4088b411b363SPhilipp Reisner } 4089b411b363SPhilipp Reisner 40900500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4091b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 4092b411b363SPhilipp Reisner goto retry; 4093b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 4094b411b363SPhilipp Reisner ns.peer = peer_state.role; 4095b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4096b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 40974ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4098b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 40994ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4100b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4101b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 41028554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4103481c6f50SPhilipp Reisner for temporal network outages! */ 41040500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4105d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 41069f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4107b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4108b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 41099f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 411082bc0194SAndreas Gruenbacher return -EIO; 4111481c6f50SPhilipp Reisner } 4112b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4113b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 41140500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4115b411b363SPhilipp Reisner 4116b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 41179f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 411882bc0194SAndreas Gruenbacher return -EIO; 4119b411b363SPhilipp Reisner } 4120b411b363SPhilipp Reisner 41214ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 41224ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4123b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4124b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4125b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4126b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 412769a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 412869a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4129b411b363SPhilipp Reisner } 4130b411b363SPhilipp Reisner } 4131b411b363SPhilipp Reisner 4132b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4133b411b363SPhilipp Reisner 4134b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4135b411b363SPhilipp Reisner 413682bc0194SAndreas Gruenbacher return 0; 4137b411b363SPhilipp Reisner } 4138b411b363SPhilipp Reisner 4139bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4140b411b363SPhilipp Reisner { 41419f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4142b30ab791SAndreas Gruenbacher struct drbd_device *device; 4143e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 41444a76b161SAndreas Gruenbacher 41459f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 41469f4fe9adSAndreas Gruenbacher if (!peer_device) 41474a76b161SAndreas Gruenbacher return -EIO; 41489f4fe9adSAndreas Gruenbacher device = peer_device->device; 4149b411b363SPhilipp Reisner 4150b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4151b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4152b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4153b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4154b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4155b411b363SPhilipp Reisner 41560b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4157b411b363SPhilipp Reisner 4158b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4159b411b363SPhilipp Reisner _not_ be rotated into the history */ 4160b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4161b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4162b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4163b411b363SPhilipp Reisner 4164b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4165b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4166b411b363SPhilipp Reisner 4167b30ab791SAndreas Gruenbacher put_ldev(device); 4168b411b363SPhilipp Reisner } else 4169d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4170b411b363SPhilipp Reisner 417182bc0194SAndreas Gruenbacher return 0; 4172b411b363SPhilipp Reisner } 4173b411b363SPhilipp Reisner 41742c46407dSAndreas Gruenbacher /** 41752c46407dSAndreas Gruenbacher * receive_bitmap_plain 41762c46407dSAndreas Gruenbacher * 41772c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41782c46407dSAndreas Gruenbacher * code upon failure. 41792c46407dSAndreas Gruenbacher */ 41802c46407dSAndreas Gruenbacher static int 418169a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4182e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4183b411b363SPhilipp Reisner { 418450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 418569a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4186e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 418750d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4188e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 41892c46407dSAndreas Gruenbacher int err; 4190b411b363SPhilipp Reisner 419150d0b1adSAndreas Gruenbacher if (want != size) { 419269a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 41932c46407dSAndreas Gruenbacher return -EIO; 4194b411b363SPhilipp Reisner } 4195b411b363SPhilipp Reisner if (want == 0) 41962c46407dSAndreas Gruenbacher return 0; 419769a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 419882bc0194SAndreas Gruenbacher if (err) 41992c46407dSAndreas Gruenbacher return err; 4200b411b363SPhilipp Reisner 420169a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4202b411b363SPhilipp Reisner 4203b411b363SPhilipp Reisner c->word_offset += num_words; 4204b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4205b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4206b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4207b411b363SPhilipp Reisner 42082c46407dSAndreas Gruenbacher return 1; 4209b411b363SPhilipp Reisner } 4210b411b363SPhilipp Reisner 4211a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4212a02d1240SAndreas Gruenbacher { 4213a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4214a02d1240SAndreas Gruenbacher } 4215a02d1240SAndreas Gruenbacher 4216a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4217a02d1240SAndreas Gruenbacher { 4218a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4219a02d1240SAndreas Gruenbacher } 4220a02d1240SAndreas Gruenbacher 4221a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4222a02d1240SAndreas Gruenbacher { 4223a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4224a02d1240SAndreas Gruenbacher } 4225a02d1240SAndreas Gruenbacher 42262c46407dSAndreas Gruenbacher /** 42272c46407dSAndreas Gruenbacher * recv_bm_rle_bits 42282c46407dSAndreas Gruenbacher * 42292c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 42302c46407dSAndreas Gruenbacher * code upon failure. 42312c46407dSAndreas Gruenbacher */ 42322c46407dSAndreas Gruenbacher static int 423369a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4234b411b363SPhilipp Reisner struct p_compressed_bm *p, 4235c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4236c6d25cfeSPhilipp Reisner unsigned int len) 4237b411b363SPhilipp Reisner { 4238b411b363SPhilipp Reisner struct bitstream bs; 4239b411b363SPhilipp Reisner u64 look_ahead; 4240b411b363SPhilipp Reisner u64 rl; 4241b411b363SPhilipp Reisner u64 tmp; 4242b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4243b411b363SPhilipp Reisner unsigned long e; 4244a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4245b411b363SPhilipp Reisner int have; 4246b411b363SPhilipp Reisner int bits; 4247b411b363SPhilipp Reisner 4248a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4249b411b363SPhilipp Reisner 4250b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4251b411b363SPhilipp Reisner if (bits < 0) 42522c46407dSAndreas Gruenbacher return -EIO; 4253b411b363SPhilipp Reisner 4254b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4255b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4256b411b363SPhilipp Reisner if (bits <= 0) 42572c46407dSAndreas Gruenbacher return -EIO; 4258b411b363SPhilipp Reisner 4259b411b363SPhilipp Reisner if (toggle) { 4260b411b363SPhilipp Reisner e = s + rl -1; 4261b411b363SPhilipp Reisner if (e >= c->bm_bits) { 426269a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 42632c46407dSAndreas Gruenbacher return -EIO; 4264b411b363SPhilipp Reisner } 426569a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4266b411b363SPhilipp Reisner } 4267b411b363SPhilipp Reisner 4268b411b363SPhilipp Reisner if (have < bits) { 426969a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4270b411b363SPhilipp Reisner have, bits, look_ahead, 4271b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4272b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 42732c46407dSAndreas Gruenbacher return -EIO; 4274b411b363SPhilipp Reisner } 4275d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4276d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4277b411b363SPhilipp Reisner look_ahead >>= bits; 4278d2da5b0cSLars Ellenberg else 4279d2da5b0cSLars Ellenberg look_ahead = 0; 4280b411b363SPhilipp Reisner have -= bits; 4281b411b363SPhilipp Reisner 4282b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4283b411b363SPhilipp Reisner if (bits < 0) 42842c46407dSAndreas Gruenbacher return -EIO; 4285b411b363SPhilipp Reisner look_ahead |= tmp << have; 4286b411b363SPhilipp Reisner have += bits; 4287b411b363SPhilipp Reisner } 4288b411b363SPhilipp Reisner 4289b411b363SPhilipp Reisner c->bit_offset = s; 4290b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4291b411b363SPhilipp Reisner 42922c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4293b411b363SPhilipp Reisner } 4294b411b363SPhilipp Reisner 42952c46407dSAndreas Gruenbacher /** 42962c46407dSAndreas Gruenbacher * decode_bitmap_c 42972c46407dSAndreas Gruenbacher * 42982c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 42992c46407dSAndreas Gruenbacher * code upon failure. 43002c46407dSAndreas Gruenbacher */ 43012c46407dSAndreas Gruenbacher static int 430269a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4303b411b363SPhilipp Reisner struct p_compressed_bm *p, 4304c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4305c6d25cfeSPhilipp Reisner unsigned int len) 4306b411b363SPhilipp Reisner { 4307a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 430869a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4309b411b363SPhilipp Reisner 4310b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4311b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4312b411b363SPhilipp Reisner * during all our tests. */ 4313b411b363SPhilipp Reisner 431469a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 431569a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 43162c46407dSAndreas Gruenbacher return -EIO; 4317b411b363SPhilipp Reisner } 4318b411b363SPhilipp Reisner 4319b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4320b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4321b411b363SPhilipp Reisner { 4322b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4323a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 432450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 432550d0b1adSAndreas Gruenbacher unsigned int plain = 432650d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 432750d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 432850d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 432950d0b1adSAndreas Gruenbacher unsigned int r; 4330b411b363SPhilipp Reisner 4331b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4332b411b363SPhilipp Reisner if (total == 0) 4333b411b363SPhilipp Reisner return; 4334b411b363SPhilipp Reisner 4335b411b363SPhilipp Reisner /* don't report if not compressed */ 4336b411b363SPhilipp Reisner if (total >= plain) 4337b411b363SPhilipp Reisner return; 4338b411b363SPhilipp Reisner 4339b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4340b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4341b411b363SPhilipp Reisner : (1000 * total / plain); 4342b411b363SPhilipp Reisner 4343b411b363SPhilipp Reisner if (r > 1000) 4344b411b363SPhilipp Reisner r = 1000; 4345b411b363SPhilipp Reisner 4346b411b363SPhilipp Reisner r = 1000 - r; 4347d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4348b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4349b411b363SPhilipp Reisner direction, 4350b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4351b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4352b411b363SPhilipp Reisner total, r/10, r % 10); 4353b411b363SPhilipp Reisner } 4354b411b363SPhilipp Reisner 4355b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4356b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4357b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4358b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4359b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4360b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4361b411b363SPhilipp Reisner 4362b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4363bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4364b411b363SPhilipp Reisner { 43659f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4366b30ab791SAndreas Gruenbacher struct drbd_device *device; 4367b411b363SPhilipp Reisner struct bm_xfer_ctx c; 43682c46407dSAndreas Gruenbacher int err; 43694a76b161SAndreas Gruenbacher 43709f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 43719f4fe9adSAndreas Gruenbacher if (!peer_device) 43724a76b161SAndreas Gruenbacher return -EIO; 43739f4fe9adSAndreas Gruenbacher device = peer_device->device; 4374b411b363SPhilipp Reisner 4375b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 437620ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 437720ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4378b411b363SPhilipp Reisner 4379b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4380b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4381b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4382b411b363SPhilipp Reisner }; 4383b411b363SPhilipp Reisner 43842c46407dSAndreas Gruenbacher for(;;) { 4385e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 438669a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4387e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4388b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4389b411b363SPhilipp Reisner * and the feature is enabled! */ 4390e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4391b411b363SPhilipp Reisner 4392bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4393d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 439482bc0194SAndreas Gruenbacher err = -EIO; 4395b411b363SPhilipp Reisner goto out; 4396b411b363SPhilipp Reisner } 4397e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4398d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 439982bc0194SAndreas Gruenbacher err = -EIO; 440078fcbdaeSAndreas Gruenbacher goto out; 4401b411b363SPhilipp Reisner } 44029f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4403e658983aSAndreas Gruenbacher if (err) 4404e658983aSAndreas Gruenbacher goto out; 440569a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4406b411b363SPhilipp Reisner } else { 4407d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 440882bc0194SAndreas Gruenbacher err = -EIO; 4409b411b363SPhilipp Reisner goto out; 4410b411b363SPhilipp Reisner } 4411b411b363SPhilipp Reisner 4412e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4413bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4414b411b363SPhilipp Reisner 44152c46407dSAndreas Gruenbacher if (err <= 0) { 44162c46407dSAndreas Gruenbacher if (err < 0) 44172c46407dSAndreas Gruenbacher goto out; 4418b411b363SPhilipp Reisner break; 44192c46407dSAndreas Gruenbacher } 44209f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 442182bc0194SAndreas Gruenbacher if (err) 4422b411b363SPhilipp Reisner goto out; 44232c46407dSAndreas Gruenbacher } 4424b411b363SPhilipp Reisner 4425b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4426b411b363SPhilipp Reisner 4427b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4428de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4429de1f8e4aSAndreas Gruenbacher 4430b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 443182bc0194SAndreas Gruenbacher if (err) 4432b411b363SPhilipp Reisner goto out; 4433b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4434b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 44350b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4436b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4437b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4438b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4439d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4440b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4441b411b363SPhilipp Reisner } 444282bc0194SAndreas Gruenbacher err = 0; 4443b411b363SPhilipp Reisner 4444b411b363SPhilipp Reisner out: 4445b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4446b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4447b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 444882bc0194SAndreas Gruenbacher return err; 4449b411b363SPhilipp Reisner } 4450b411b363SPhilipp Reisner 4451bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4452b411b363SPhilipp Reisner { 44531ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4454e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4455b411b363SPhilipp Reisner 4456bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4457b411b363SPhilipp Reisner } 4458b411b363SPhilipp Reisner 4459bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4460b411b363SPhilipp Reisner { 4461b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4462b411b363SPhilipp Reisner * with the data requests being unplugged */ 4463bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4464b411b363SPhilipp Reisner 446582bc0194SAndreas Gruenbacher return 0; 4466b411b363SPhilipp Reisner } 4467b411b363SPhilipp Reisner 4468bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 446973a01a18SPhilipp Reisner { 44709f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4471b30ab791SAndreas Gruenbacher struct drbd_device *device; 4472e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 44734a76b161SAndreas Gruenbacher 44749f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 44759f4fe9adSAndreas Gruenbacher if (!peer_device) 44764a76b161SAndreas Gruenbacher return -EIO; 44779f4fe9adSAndreas Gruenbacher device = peer_device->device; 447873a01a18SPhilipp Reisner 4479b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4480f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4481f735e363SLars Ellenberg case C_WF_BITMAP_T: 4482f735e363SLars Ellenberg case C_BEHIND: 4483f735e363SLars Ellenberg break; 4484f735e363SLars Ellenberg default: 4485d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4486b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4487f735e363SLars Ellenberg } 4488f735e363SLars Ellenberg 4489b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 449073a01a18SPhilipp Reisner 449182bc0194SAndreas Gruenbacher return 0; 449273a01a18SPhilipp Reisner } 449373a01a18SPhilipp Reisner 449402918be2SPhilipp Reisner struct data_cmd { 449502918be2SPhilipp Reisner int expect_payload; 449602918be2SPhilipp Reisner size_t pkt_size; 4497bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4498b411b363SPhilipp Reisner }; 4499b411b363SPhilipp Reisner 450002918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 450102918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 450202918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 450302918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 450402918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4505e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4506e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4507e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 450802918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 450902918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4510e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4511e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 451202918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 451302918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 451402918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 451502918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 451602918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 451702918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 451802918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 451902918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 452002918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 452102918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 452273a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 45234a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4524036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 4525a0fb3c47SLars Ellenberg [P_TRIM] = { 0, sizeof(struct p_trim), receive_Data }, 452602918be2SPhilipp Reisner }; 452702918be2SPhilipp Reisner 4528bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4529b411b363SPhilipp Reisner { 453077351055SPhilipp Reisner struct packet_info pi; 453102918be2SPhilipp Reisner size_t shs; /* sub header size */ 453282bc0194SAndreas Gruenbacher int err; 4533b411b363SPhilipp Reisner 4534bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 4535deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4536deebe195SAndreas Gruenbacher 4537bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4538bde89a9eSAndreas Gruenbacher if (drbd_recv_header(connection, &pi)) 453902918be2SPhilipp Reisner goto err_out; 454002918be2SPhilipp Reisner 4541deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 45424a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 45431ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 45442fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 454502918be2SPhilipp Reisner goto err_out; 45460b33a916SLars Ellenberg } 4547b411b363SPhilipp Reisner 4548e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4549e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 45501ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 45512fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4552c13f7e1aSLars Ellenberg goto err_out; 4553c13f7e1aSLars Ellenberg } 4554c13f7e1aSLars Ellenberg 4555c13f7e1aSLars Ellenberg if (shs) { 4556bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 4557a5c31904SAndreas Gruenbacher if (err) 455802918be2SPhilipp Reisner goto err_out; 4559e2857216SAndreas Gruenbacher pi.size -= shs; 4560b411b363SPhilipp Reisner } 456102918be2SPhilipp Reisner 4562bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 45634a76b161SAndreas Gruenbacher if (err) { 45641ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 45659f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 456602918be2SPhilipp Reisner goto err_out; 456702918be2SPhilipp Reisner } 456802918be2SPhilipp Reisner } 456982bc0194SAndreas Gruenbacher return; 457002918be2SPhilipp Reisner 457102918be2SPhilipp Reisner err_out: 4572bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4573b411b363SPhilipp Reisner } 4574b411b363SPhilipp Reisner 4575bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 4576f70b3511SPhilipp Reisner { 4577c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4578bbeb641cSPhilipp Reisner enum drbd_conns oc; 4579376694a0SPhilipp Reisner int vnr; 4580f70b3511SPhilipp Reisner 4581bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 4582b411b363SPhilipp Reisner return; 4583b411b363SPhilipp Reisner 4584545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4585545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4586545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4587545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4588545752d5SLars Ellenberg */ 4589bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4590545752d5SLars Ellenberg 4591b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4592bde89a9eSAndreas Gruenbacher drbd_thread_stop(&connection->asender); 4593bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 4594360cc740SPhilipp Reisner 4595c141ebdaSPhilipp Reisner rcu_read_lock(); 4596c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 4597c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4598b30ab791SAndreas Gruenbacher kref_get(&device->kref); 4599c141ebdaSPhilipp Reisner rcu_read_unlock(); 460069a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 4601c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 4602c141ebdaSPhilipp Reisner rcu_read_lock(); 4603c141ebdaSPhilipp Reisner } 4604c141ebdaSPhilipp Reisner rcu_read_unlock(); 4605c141ebdaSPhilipp Reisner 4606bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 46071ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 460812038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4609bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 4610bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 461112038a3aSPhilipp Reisner 46121ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 4613360cc740SPhilipp Reisner 4614bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 4615bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 4616cb703454SPhilipp Reisner 46170500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 4618bde89a9eSAndreas Gruenbacher oc = connection->cstate; 4619bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4620bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4621bbeb641cSPhilipp Reisner 46220500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 4623360cc740SPhilipp Reisner 4624f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4625bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4626360cc740SPhilipp Reisner } 4627360cc740SPhilipp Reisner 462869a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 4629360cc740SPhilipp Reisner { 463069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4631360cc740SPhilipp Reisner unsigned int i; 4632b411b363SPhilipp Reisner 463385719573SPhilipp Reisner /* wait for current activity to cease. */ 46340500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4635b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 4636b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 4637b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 46380500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4639b411b363SPhilipp Reisner 4640b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4641b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4642b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4643b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4644b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4645b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4646b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4647b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4648b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4649b411b363SPhilipp Reisner * on the fly. */ 4650b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4651b30ab791SAndreas Gruenbacher device->rs_total = 0; 4652b30ab791SAndreas Gruenbacher device->rs_failed = 0; 4653b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 4654b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 4655b411b363SPhilipp Reisner 4656b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 4657b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 4658b411b363SPhilipp Reisner 4659b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4660b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4661b411b363SPhilipp Reisner * to be "canceled" */ 4662b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4663b411b363SPhilipp Reisner 4664b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 4665b411b363SPhilipp Reisner 4666d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4667d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4668d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4669b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4670d10b4ea3SPhilipp Reisner 467108332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 467208332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 4673b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4674b411b363SPhilipp Reisner 4675b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4676b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 4677b411b363SPhilipp Reisner 4678b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 467969a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 4680b411b363SPhilipp Reisner 4681b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4682b411b363SPhilipp Reisner 468320ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 468420ceb2b2SLars Ellenberg * if any. */ 4685b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, !test_bit(BITMAP_IO, &device->flags)); 468620ceb2b2SLars Ellenberg 4687b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4688b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4689b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4690b411b363SPhilipp Reisner * 4691b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4692b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4693b411b363SPhilipp Reisner */ 4694b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 4695b411b363SPhilipp Reisner if (i) 4696d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 4697b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 4698435f0740SLars Ellenberg if (i) 4699d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 4700b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 4701b411b363SPhilipp Reisner if (i) 4702d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 4703b411b363SPhilipp Reisner 47040b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 47050b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 47060b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 47070b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 4708b411b363SPhilipp Reisner 4709360cc740SPhilipp Reisner return 0; 4710b411b363SPhilipp Reisner } 4711b411b363SPhilipp Reisner 4712b411b363SPhilipp Reisner /* 4713b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4714b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4715b411b363SPhilipp Reisner * 4716b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4717b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4718b411b363SPhilipp Reisner * 4719b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4720b411b363SPhilipp Reisner */ 4721bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 4722b411b363SPhilipp Reisner { 47239f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 47249f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4725b411b363SPhilipp Reisner 4726bde89a9eSAndreas Gruenbacher sock = &connection->data; 4727bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 47289f5bdc33SAndreas Gruenbacher if (!p) 4729e8d17b01SAndreas Gruenbacher return -EIO; 4730b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4731b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4732b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 473320c68fdeSLars Ellenberg p->feature_flags = cpu_to_be32(PRO_FEATURES); 4734bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4735b411b363SPhilipp Reisner } 4736b411b363SPhilipp Reisner 4737b411b363SPhilipp Reisner /* 4738b411b363SPhilipp Reisner * return values: 4739b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4740b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4741b411b363SPhilipp Reisner * -1 peer talks different language, 4742b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4743b411b363SPhilipp Reisner */ 4744bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 4745b411b363SPhilipp Reisner { 4746bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 4747e658983aSAndreas Gruenbacher struct p_connection_features *p; 4748e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 474977351055SPhilipp Reisner struct packet_info pi; 4750a5c31904SAndreas Gruenbacher int err; 4751b411b363SPhilipp Reisner 4752bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 4753e8d17b01SAndreas Gruenbacher if (err) 4754b411b363SPhilipp Reisner return 0; 4755b411b363SPhilipp Reisner 4756bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 475769bc7bc3SAndreas Gruenbacher if (err) 4758b411b363SPhilipp Reisner return 0; 4759b411b363SPhilipp Reisner 47606038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 47611ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 476277351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4763b411b363SPhilipp Reisner return -1; 4764b411b363SPhilipp Reisner } 4765b411b363SPhilipp Reisner 476677351055SPhilipp Reisner if (pi.size != expect) { 47671ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 476877351055SPhilipp Reisner expect, pi.size); 4769b411b363SPhilipp Reisner return -1; 4770b411b363SPhilipp Reisner } 4771b411b363SPhilipp Reisner 4772e658983aSAndreas Gruenbacher p = pi.data; 4773bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 4774a5c31904SAndreas Gruenbacher if (err) 4775b411b363SPhilipp Reisner return 0; 4776b411b363SPhilipp Reisner 4777b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4778b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4779b411b363SPhilipp Reisner if (p->protocol_max == 0) 4780b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4781b411b363SPhilipp Reisner 4782b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4783b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4784b411b363SPhilipp Reisner goto incompat; 4785b411b363SPhilipp Reisner 4786bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 478720c68fdeSLars Ellenberg connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); 4788b411b363SPhilipp Reisner 47891ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 4790bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 4791b411b363SPhilipp Reisner 479220c68fdeSLars Ellenberg drbd_info(connection, "Agreed to%ssupport TRIM on protocol level\n", 479320c68fdeSLars Ellenberg connection->agreed_features & FF_TRIM ? " " : " not "); 479420c68fdeSLars Ellenberg 4795b411b363SPhilipp Reisner return 1; 4796b411b363SPhilipp Reisner 4797b411b363SPhilipp Reisner incompat: 47981ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 4799b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4800b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4801b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4802b411b363SPhilipp Reisner return -1; 4803b411b363SPhilipp Reisner } 4804b411b363SPhilipp Reisner 4805b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4806bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4807b411b363SPhilipp Reisner { 48081ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 48091ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4810b10d96cbSJohannes Thoma return -1; 4811b411b363SPhilipp Reisner } 4812b411b363SPhilipp Reisner #else 4813b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4814b10d96cbSJohannes Thoma 4815b10d96cbSJohannes Thoma /* Return value: 4816b10d96cbSJohannes Thoma 1 - auth succeeded, 4817b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4818b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4819b10d96cbSJohannes Thoma */ 4820b10d96cbSJohannes Thoma 4821bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4822b411b363SPhilipp Reisner { 48239f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4824b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4825b411b363SPhilipp Reisner struct scatterlist sg; 4826b411b363SPhilipp Reisner char *response = NULL; 4827b411b363SPhilipp Reisner char *right_response = NULL; 4828b411b363SPhilipp Reisner char *peers_ch = NULL; 482944ed167dSPhilipp Reisner unsigned int key_len; 483044ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4831b411b363SPhilipp Reisner unsigned int resp_size; 4832b411b363SPhilipp Reisner struct hash_desc desc; 483377351055SPhilipp Reisner struct packet_info pi; 483444ed167dSPhilipp Reisner struct net_conf *nc; 483569bc7bc3SAndreas Gruenbacher int err, rv; 4836b411b363SPhilipp Reisner 48379f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 48389f5bdc33SAndreas Gruenbacher 483944ed167dSPhilipp Reisner rcu_read_lock(); 4840bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 484144ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 484244ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 484344ed167dSPhilipp Reisner rcu_read_unlock(); 484444ed167dSPhilipp Reisner 4845bde89a9eSAndreas Gruenbacher desc.tfm = connection->cram_hmac_tfm; 4846b411b363SPhilipp Reisner desc.flags = 0; 4847b411b363SPhilipp Reisner 4848bde89a9eSAndreas Gruenbacher rv = crypto_hash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 4849b411b363SPhilipp Reisner if (rv) { 48501ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_setkey() failed with %d\n", rv); 4851b10d96cbSJohannes Thoma rv = -1; 4852b411b363SPhilipp Reisner goto fail; 4853b411b363SPhilipp Reisner } 4854b411b363SPhilipp Reisner 4855b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4856b411b363SPhilipp Reisner 4857bde89a9eSAndreas Gruenbacher sock = &connection->data; 4858bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 48599f5bdc33SAndreas Gruenbacher rv = 0; 48609f5bdc33SAndreas Gruenbacher goto fail; 48619f5bdc33SAndreas Gruenbacher } 4862bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 48639f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4864b411b363SPhilipp Reisner if (!rv) 4865b411b363SPhilipp Reisner goto fail; 4866b411b363SPhilipp Reisner 4867bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 486869bc7bc3SAndreas Gruenbacher if (err) { 4869b411b363SPhilipp Reisner rv = 0; 4870b411b363SPhilipp Reisner goto fail; 4871b411b363SPhilipp Reisner } 4872b411b363SPhilipp Reisner 487377351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 48741ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 487577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4876b411b363SPhilipp Reisner rv = 0; 4877b411b363SPhilipp Reisner goto fail; 4878b411b363SPhilipp Reisner } 4879b411b363SPhilipp Reisner 488077351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 48811ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 4882b10d96cbSJohannes Thoma rv = -1; 4883b411b363SPhilipp Reisner goto fail; 4884b411b363SPhilipp Reisner } 4885b411b363SPhilipp Reisner 488667cca286SPhilipp Reisner if (pi.size < CHALLENGE_LEN) { 488767cca286SPhilipp Reisner drbd_err(connection, "AuthChallenge payload too small.\n"); 488867cca286SPhilipp Reisner rv = -1; 488967cca286SPhilipp Reisner goto fail; 489067cca286SPhilipp Reisner } 489167cca286SPhilipp Reisner 489277351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4893b411b363SPhilipp Reisner if (peers_ch == NULL) { 48941ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 4895b10d96cbSJohannes Thoma rv = -1; 4896b411b363SPhilipp Reisner goto fail; 4897b411b363SPhilipp Reisner } 4898b411b363SPhilipp Reisner 4899bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 4900a5c31904SAndreas Gruenbacher if (err) { 4901b411b363SPhilipp Reisner rv = 0; 4902b411b363SPhilipp Reisner goto fail; 4903b411b363SPhilipp Reisner } 4904b411b363SPhilipp Reisner 490567cca286SPhilipp Reisner if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) { 490667cca286SPhilipp Reisner drbd_err(connection, "Peer presented the same challenge!\n"); 490767cca286SPhilipp Reisner rv = -1; 490867cca286SPhilipp Reisner goto fail; 490967cca286SPhilipp Reisner } 491067cca286SPhilipp Reisner 4911bde89a9eSAndreas Gruenbacher resp_size = crypto_hash_digestsize(connection->cram_hmac_tfm); 4912b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4913b411b363SPhilipp Reisner if (response == NULL) { 49141ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 4915b10d96cbSJohannes Thoma rv = -1; 4916b411b363SPhilipp Reisner goto fail; 4917b411b363SPhilipp Reisner } 4918b411b363SPhilipp Reisner 4919b411b363SPhilipp Reisner sg_init_table(&sg, 1); 492077351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4921b411b363SPhilipp Reisner 4922b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4923b411b363SPhilipp Reisner if (rv) { 49241ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4925b10d96cbSJohannes Thoma rv = -1; 4926b411b363SPhilipp Reisner goto fail; 4927b411b363SPhilipp Reisner } 4928b411b363SPhilipp Reisner 4929bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 49309f5bdc33SAndreas Gruenbacher rv = 0; 49319f5bdc33SAndreas Gruenbacher goto fail; 49329f5bdc33SAndreas Gruenbacher } 4933bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 49349f5bdc33SAndreas Gruenbacher response, resp_size); 4935b411b363SPhilipp Reisner if (!rv) 4936b411b363SPhilipp Reisner goto fail; 4937b411b363SPhilipp Reisner 4938bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 493969bc7bc3SAndreas Gruenbacher if (err) { 4940b411b363SPhilipp Reisner rv = 0; 4941b411b363SPhilipp Reisner goto fail; 4942b411b363SPhilipp Reisner } 4943b411b363SPhilipp Reisner 494477351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 49451ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 494677351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4947b411b363SPhilipp Reisner rv = 0; 4948b411b363SPhilipp Reisner goto fail; 4949b411b363SPhilipp Reisner } 4950b411b363SPhilipp Reisner 495177351055SPhilipp Reisner if (pi.size != resp_size) { 49521ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 4953b411b363SPhilipp Reisner rv = 0; 4954b411b363SPhilipp Reisner goto fail; 4955b411b363SPhilipp Reisner } 4956b411b363SPhilipp Reisner 4957bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 4958a5c31904SAndreas Gruenbacher if (err) { 4959b411b363SPhilipp Reisner rv = 0; 4960b411b363SPhilipp Reisner goto fail; 4961b411b363SPhilipp Reisner } 4962b411b363SPhilipp Reisner 4963b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 49642d1ee87dSJulia Lawall if (right_response == NULL) { 49651ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 4966b10d96cbSJohannes Thoma rv = -1; 4967b411b363SPhilipp Reisner goto fail; 4968b411b363SPhilipp Reisner } 4969b411b363SPhilipp Reisner 4970b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4971b411b363SPhilipp Reisner 4972b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4973b411b363SPhilipp Reisner if (rv) { 49741ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4975b10d96cbSJohannes Thoma rv = -1; 4976b411b363SPhilipp Reisner goto fail; 4977b411b363SPhilipp Reisner } 4978b411b363SPhilipp Reisner 4979b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4980b411b363SPhilipp Reisner 4981b411b363SPhilipp Reisner if (rv) 49821ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 498344ed167dSPhilipp Reisner resp_size); 4984b10d96cbSJohannes Thoma else 4985b10d96cbSJohannes Thoma rv = -1; 4986b411b363SPhilipp Reisner 4987b411b363SPhilipp Reisner fail: 4988b411b363SPhilipp Reisner kfree(peers_ch); 4989b411b363SPhilipp Reisner kfree(response); 4990b411b363SPhilipp Reisner kfree(right_response); 4991b411b363SPhilipp Reisner 4992b411b363SPhilipp Reisner return rv; 4993b411b363SPhilipp Reisner } 4994b411b363SPhilipp Reisner #endif 4995b411b363SPhilipp Reisner 49968fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 4997b411b363SPhilipp Reisner { 4998bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 4999b411b363SPhilipp Reisner int h; 5000b411b363SPhilipp Reisner 50011ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 5002b411b363SPhilipp Reisner 5003b411b363SPhilipp Reisner do { 5004bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 5005b411b363SPhilipp Reisner if (h == 0) { 5006bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 500720ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 5008b411b363SPhilipp Reisner } 5009b411b363SPhilipp Reisner if (h == -1) { 50101ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 5011bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5012b411b363SPhilipp Reisner } 5013b411b363SPhilipp Reisner } while (h == 0); 5014b411b363SPhilipp Reisner 501591fd4dadSPhilipp Reisner if (h > 0) 5016bde89a9eSAndreas Gruenbacher drbdd(connection); 5017b411b363SPhilipp Reisner 5018bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 5019b411b363SPhilipp Reisner 50201ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 5021b411b363SPhilipp Reisner return 0; 5022b411b363SPhilipp Reisner } 5023b411b363SPhilipp Reisner 5024b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 5025b411b363SPhilipp Reisner 5026bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5027b411b363SPhilipp Reisner { 5028e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5029b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5030b411b363SPhilipp Reisner 5031b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 5032bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 5033b411b363SPhilipp Reisner } else { 5034bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 50351ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 5036fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5037fc3b10a4SPhilipp Reisner } 5038bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5039e4f78edeSPhilipp Reisner 50402735a594SAndreas Gruenbacher return 0; 5041fc3b10a4SPhilipp Reisner } 5042e4f78edeSPhilipp Reisner 5043bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5044e4f78edeSPhilipp Reisner { 50459f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5046b30ab791SAndreas Gruenbacher struct drbd_device *device; 5047e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5048e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5049e4f78edeSPhilipp Reisner 50509f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 50519f4fe9adSAndreas Gruenbacher if (!peer_device) 50522735a594SAndreas Gruenbacher return -EIO; 50539f4fe9adSAndreas Gruenbacher device = peer_device->device; 50541952e916SAndreas Gruenbacher 5055bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 50560b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 5057bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 50584d0fc3fdSPhilipp Reisner } 50594d0fc3fdSPhilipp Reisner 5060e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 5061b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 5062e4f78edeSPhilipp Reisner } else { 5063b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 5064d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 5065b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5066b411b363SPhilipp Reisner } 5067b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 5068b411b363SPhilipp Reisner 50692735a594SAndreas Gruenbacher return 0; 5070b411b363SPhilipp Reisner } 5071b411b363SPhilipp Reisner 5072bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 5073b411b363SPhilipp Reisner { 5074bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 5075b411b363SPhilipp Reisner 5076b411b363SPhilipp Reisner } 5077b411b363SPhilipp Reisner 5078bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 5079b411b363SPhilipp Reisner { 5080b411b363SPhilipp Reisner /* restore idle timeout */ 5081bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 5082bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 5083bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5084b411b363SPhilipp Reisner 50852735a594SAndreas Gruenbacher return 0; 5086b411b363SPhilipp Reisner } 5087b411b363SPhilipp Reisner 5088bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 5089b411b363SPhilipp Reisner { 50909f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5091b30ab791SAndreas Gruenbacher struct drbd_device *device; 5092e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5093b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5094b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5095b411b363SPhilipp Reisner 50969f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 50979f4fe9adSAndreas Gruenbacher if (!peer_device) 50982735a594SAndreas Gruenbacher return -EIO; 50999f4fe9adSAndreas Gruenbacher device = peer_device->device; 51001952e916SAndreas Gruenbacher 51019f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 5102b411b363SPhilipp Reisner 510369a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5104b411b363SPhilipp Reisner 5105b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 5106b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5107b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5108b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 5109b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 5110b30ab791SAndreas Gruenbacher put_ldev(device); 51111d53f09eSLars Ellenberg } 5112b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5113b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5114b411b363SPhilipp Reisner 51152735a594SAndreas Gruenbacher return 0; 5116b411b363SPhilipp Reisner } 5117b411b363SPhilipp Reisner 5118bc9c5c41SAndreas Gruenbacher static int 5119b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5120bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5121bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5122b411b363SPhilipp Reisner { 5123b411b363SPhilipp Reisner struct drbd_request *req; 5124b411b363SPhilipp Reisner struct bio_and_error m; 5125b411b363SPhilipp Reisner 51260500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5127b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5128b411b363SPhilipp Reisner if (unlikely(!req)) { 51290500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 513085997675SAndreas Gruenbacher return -EIO; 5131b411b363SPhilipp Reisner } 5132b411b363SPhilipp Reisner __req_mod(req, what, &m); 51330500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5134b411b363SPhilipp Reisner 5135b411b363SPhilipp Reisner if (m.bio) 5136b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 513785997675SAndreas Gruenbacher return 0; 5138b411b363SPhilipp Reisner } 5139b411b363SPhilipp Reisner 5140bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5141b411b363SPhilipp Reisner { 51429f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5143b30ab791SAndreas Gruenbacher struct drbd_device *device; 5144e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5145b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5146b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5147b411b363SPhilipp Reisner enum drbd_req_event what; 5148b411b363SPhilipp Reisner 51499f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51509f4fe9adSAndreas Gruenbacher if (!peer_device) 51512735a594SAndreas Gruenbacher return -EIO; 51529f4fe9adSAndreas Gruenbacher device = peer_device->device; 51531952e916SAndreas Gruenbacher 515469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5155b411b363SPhilipp Reisner 5156579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5157b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5158b30ab791SAndreas Gruenbacher dec_rs_pending(device); 51592735a594SAndreas Gruenbacher return 0; 5160b411b363SPhilipp Reisner } 5161e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5162b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 51638554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5164b411b363SPhilipp Reisner break; 5165b411b363SPhilipp Reisner case P_WRITE_ACK: 51668554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5167b411b363SPhilipp Reisner break; 5168b411b363SPhilipp Reisner case P_RECV_ACK: 51698554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5170b411b363SPhilipp Reisner break; 5171d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5172d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 51737be8da07SAndreas Gruenbacher break; 51747be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 51757be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5176b411b363SPhilipp Reisner break; 5177b411b363SPhilipp Reisner default: 51782735a594SAndreas Gruenbacher BUG(); 5179b411b363SPhilipp Reisner } 5180b411b363SPhilipp Reisner 5181b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5182b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5183bc9c5c41SAndreas Gruenbacher what, false); 5184b411b363SPhilipp Reisner } 5185b411b363SPhilipp Reisner 5186bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5187b411b363SPhilipp Reisner { 51889f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5189b30ab791SAndreas Gruenbacher struct drbd_device *device; 5190e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5191b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 51922deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 519385997675SAndreas Gruenbacher int err; 5194b411b363SPhilipp Reisner 51959f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51969f4fe9adSAndreas Gruenbacher if (!peer_device) 51972735a594SAndreas Gruenbacher return -EIO; 51989f4fe9adSAndreas Gruenbacher device = peer_device->device; 5199b411b363SPhilipp Reisner 520069a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5201b411b363SPhilipp Reisner 5202579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5203b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5204b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 52052735a594SAndreas Gruenbacher return 0; 5206b411b363SPhilipp Reisner } 52072deb8336SPhilipp Reisner 5208b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5209b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5210303d1448SPhilipp Reisner NEG_ACKED, true); 521185997675SAndreas Gruenbacher if (err) { 52122deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 52132deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5214c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 52152deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 52162deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5217b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 52182deb8336SPhilipp Reisner } 52192735a594SAndreas Gruenbacher return 0; 5220b411b363SPhilipp Reisner } 5221b411b363SPhilipp Reisner 5222bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5223b411b363SPhilipp Reisner { 52249f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5225b30ab791SAndreas Gruenbacher struct drbd_device *device; 5226e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5227b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5228b411b363SPhilipp Reisner 52299f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52309f4fe9adSAndreas Gruenbacher if (!peer_device) 52312735a594SAndreas Gruenbacher return -EIO; 52329f4fe9adSAndreas Gruenbacher device = peer_device->device; 52331952e916SAndreas Gruenbacher 523469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 52357be8da07SAndreas Gruenbacher 5236d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5237b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5238b411b363SPhilipp Reisner 5239b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5240b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 52418554df1cSAndreas Gruenbacher NEG_ACKED, false); 5242b411b363SPhilipp Reisner } 5243b411b363SPhilipp Reisner 5244bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5245b411b363SPhilipp Reisner { 52469f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5247b30ab791SAndreas Gruenbacher struct drbd_device *device; 5248b411b363SPhilipp Reisner sector_t sector; 5249b411b363SPhilipp Reisner int size; 5250e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 52511952e916SAndreas Gruenbacher 52529f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52539f4fe9adSAndreas Gruenbacher if (!peer_device) 52542735a594SAndreas Gruenbacher return -EIO; 52559f4fe9adSAndreas Gruenbacher device = peer_device->device; 5256b411b363SPhilipp Reisner 5257b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5258b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5259b411b363SPhilipp Reisner 526069a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5261b411b363SPhilipp Reisner 5262b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5263b411b363SPhilipp Reisner 5264b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5265b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5266e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5267d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5268b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5269d612d309SPhilipp Reisner case P_RS_CANCEL: 5270d612d309SPhilipp Reisner break; 5271d612d309SPhilipp Reisner default: 52722735a594SAndreas Gruenbacher BUG(); 5273d612d309SPhilipp Reisner } 5274b30ab791SAndreas Gruenbacher put_ldev(device); 5275b411b363SPhilipp Reisner } 5276b411b363SPhilipp Reisner 52772735a594SAndreas Gruenbacher return 0; 5278b411b363SPhilipp Reisner } 5279b411b363SPhilipp Reisner 5280bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5281b411b363SPhilipp Reisner { 5282e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5283c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 52849ed57dcbSLars Ellenberg int vnr; 5285b411b363SPhilipp Reisner 5286bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5287b411b363SPhilipp Reisner 52889ed57dcbSLars Ellenberg rcu_read_lock(); 5289c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5290c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5291c06ece6bSAndreas Gruenbacher 5292b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5293b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5294b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5295b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5296b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5297c4752ef1SPhilipp Reisner } 52989ed57dcbSLars Ellenberg } 52999ed57dcbSLars Ellenberg rcu_read_unlock(); 5300c4752ef1SPhilipp Reisner 53012735a594SAndreas Gruenbacher return 0; 5302b411b363SPhilipp Reisner } 5303b411b363SPhilipp Reisner 5304bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5305b411b363SPhilipp Reisner { 53069f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5307b30ab791SAndreas Gruenbacher struct drbd_device *device; 5308e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 530984b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5310b411b363SPhilipp Reisner sector_t sector; 5311b411b363SPhilipp Reisner int size; 5312b411b363SPhilipp Reisner 53139f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 53149f4fe9adSAndreas Gruenbacher if (!peer_device) 53152735a594SAndreas Gruenbacher return -EIO; 53169f4fe9adSAndreas Gruenbacher device = peer_device->device; 53171952e916SAndreas Gruenbacher 5318b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5319b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5320b411b363SPhilipp Reisner 532169a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5322b411b363SPhilipp Reisner 5323b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5324b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5325b411b363SPhilipp Reisner else 5326b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5327b411b363SPhilipp Reisner 5328b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 53292735a594SAndreas Gruenbacher return 0; 53301d53f09eSLars Ellenberg 5331b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5332b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5333b411b363SPhilipp Reisner 5334b30ab791SAndreas Gruenbacher --device->ov_left; 5335ea5442afSLars Ellenberg 5336ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5337b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5338b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5339ea5442afSLars Ellenberg 5340b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 534184b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 534284b8c06bSAndreas Gruenbacher if (dw) { 534384b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 534484b8c06bSAndreas Gruenbacher dw->device = device; 534584b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5346b411b363SPhilipp Reisner } else { 534784b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5348b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5349b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5350b411b363SPhilipp Reisner } 5351b411b363SPhilipp Reisner } 5352b30ab791SAndreas Gruenbacher put_ldev(device); 53532735a594SAndreas Gruenbacher return 0; 5354b411b363SPhilipp Reisner } 5355b411b363SPhilipp Reisner 5356bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 53570ced55a3SPhilipp Reisner { 53582735a594SAndreas Gruenbacher return 0; 53590ced55a3SPhilipp Reisner } 53600ced55a3SPhilipp Reisner 5361bde89a9eSAndreas Gruenbacher static int connection_finish_peer_reqs(struct drbd_connection *connection) 536232862ec7SPhilipp Reisner { 5363c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5364c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 536532862ec7SPhilipp Reisner 536632862ec7SPhilipp Reisner do { 5367bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 536832862ec7SPhilipp Reisner flush_signals(current); 5369c141ebdaSPhilipp Reisner 5370c141ebdaSPhilipp Reisner rcu_read_lock(); 5371c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5372c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5373b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5374c141ebdaSPhilipp Reisner rcu_read_unlock(); 5375b30ab791SAndreas Gruenbacher if (drbd_finish_peer_reqs(device)) { 537605a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5377c141ebdaSPhilipp Reisner return 1; 5378082a3439SPhilipp Reisner } 537905a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5380c141ebdaSPhilipp Reisner rcu_read_lock(); 5381d3fcb490SPhilipp Reisner } 5382bde89a9eSAndreas Gruenbacher set_bit(SIGNAL_ASENDER, &connection->flags); 5383082a3439SPhilipp Reisner 53840500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5385c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5386c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5387b30ab791SAndreas Gruenbacher not_empty = !list_empty(&device->done_ee); 5388082a3439SPhilipp Reisner if (not_empty) 5389082a3439SPhilipp Reisner break; 5390082a3439SPhilipp Reisner } 53910500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5392c141ebdaSPhilipp Reisner rcu_read_unlock(); 539332862ec7SPhilipp Reisner } while (not_empty); 539432862ec7SPhilipp Reisner 539532862ec7SPhilipp Reisner return 0; 5396b411b363SPhilipp Reisner } 5397b411b363SPhilipp Reisner 5398b411b363SPhilipp Reisner struct asender_cmd { 5399b411b363SPhilipp Reisner size_t pkt_size; 5400bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5401b411b363SPhilipp Reisner }; 5402b411b363SPhilipp Reisner 5403b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 5404e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5405e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5406b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5407b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5408b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5409d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5410b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5411b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5412b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5413b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5414b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5415b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5416b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 541702918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5418d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 54191952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 54201952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5421b411b363SPhilipp Reisner }; 5422b411b363SPhilipp Reisner 5423b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5424b411b363SPhilipp Reisner { 5425bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5426b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 542777351055SPhilipp Reisner struct packet_info pi; 5428257d0af6SPhilipp Reisner int rv; 5429bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5430b411b363SPhilipp Reisner int received = 0; 5431bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 543252b061a4SAndreas Gruenbacher int expect = header_size; 543344ed167dSPhilipp Reisner bool ping_timeout_active = false; 543444ed167dSPhilipp Reisner struct net_conf *nc; 5435bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 54363990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5437b411b363SPhilipp Reisner 54383990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 54393990e04dSPhilipp Reisner if (rv < 0) 54401ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_asender: ERROR set priority, ret=%d\n", rv); 5441b411b363SPhilipp Reisner 5442e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 544380822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 544444ed167dSPhilipp Reisner 544544ed167dSPhilipp Reisner rcu_read_lock(); 5446bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 544744ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5448bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 544944ed167dSPhilipp Reisner ping_int = nc->ping_int; 545044ed167dSPhilipp Reisner rcu_read_unlock(); 545144ed167dSPhilipp Reisner 5452bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5453bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 54541ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5455841ce241SAndreas Gruenbacher goto reconnect; 5456841ce241SAndreas Gruenbacher } 5457bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 545844ed167dSPhilipp Reisner ping_timeout_active = true; 5459b411b363SPhilipp Reisner } 5460b411b363SPhilipp Reisner 546132862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 546232862ec7SPhilipp Reisner much to send */ 5463bb77d34eSAndreas Gruenbacher if (tcp_cork) 5464bde89a9eSAndreas Gruenbacher drbd_tcp_cork(connection->meta.socket); 5465bde89a9eSAndreas Gruenbacher if (connection_finish_peer_reqs(connection)) { 54661ec861ebSAndreas Gruenbacher drbd_err(connection, "connection_finish_peer_reqs() failed\n"); 5467b411b363SPhilipp Reisner goto reconnect; 5468b411b363SPhilipp Reisner } 5469b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5470bb77d34eSAndreas Gruenbacher if (tcp_cork) 5471bde89a9eSAndreas Gruenbacher drbd_tcp_uncork(connection->meta.socket); 5472b411b363SPhilipp Reisner 5473b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5474b411b363SPhilipp Reisner if (signal_pending(current)) 5475b411b363SPhilipp Reisner continue; 5476b411b363SPhilipp Reisner 5477bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5478bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5479b411b363SPhilipp Reisner 5480b411b363SPhilipp Reisner flush_signals(current); 5481b411b363SPhilipp Reisner 5482b411b363SPhilipp Reisner /* Note: 5483b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5484b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5485b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5486b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5487b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5488b411b363SPhilipp Reisner * rv == expected: full header or command 5489b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5490b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5491b411b363SPhilipp Reisner */ 5492b411b363SPhilipp Reisner if (likely(rv > 0)) { 5493b411b363SPhilipp Reisner received += rv; 5494b411b363SPhilipp Reisner buf += rv; 5495b411b363SPhilipp Reisner } else if (rv == 0) { 5496bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5497b66623e3SPhilipp Reisner long t; 5498b66623e3SPhilipp Reisner rcu_read_lock(); 5499bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5500b66623e3SPhilipp Reisner rcu_read_unlock(); 5501b66623e3SPhilipp Reisner 5502bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5503bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5504b66623e3SPhilipp Reisner t); 5505599377acSPhilipp Reisner if (t) 5506599377acSPhilipp Reisner break; 5507599377acSPhilipp Reisner } 55081ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5509b411b363SPhilipp Reisner goto reconnect; 5510b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5511cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5512cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5513bde89a9eSAndreas Gruenbacher if (time_after(connection->last_received, 5514bde89a9eSAndreas Gruenbacher jiffies - connection->meta.socket->sk->sk_rcvtimeo)) 5515cb6518cbSLars Ellenberg continue; 5516f36af18cSLars Ellenberg if (ping_timeout_active) { 55171ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5518b411b363SPhilipp Reisner goto reconnect; 5519b411b363SPhilipp Reisner } 5520bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5521b411b363SPhilipp Reisner continue; 5522b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5523b411b363SPhilipp Reisner continue; 5524b411b363SPhilipp Reisner } else { 55251ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5526b411b363SPhilipp Reisner goto reconnect; 5527b411b363SPhilipp Reisner } 5528b411b363SPhilipp Reisner 5529b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5530bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5531b411b363SPhilipp Reisner goto reconnect; 55327201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 55331952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 55341ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 55352fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5536b411b363SPhilipp Reisner goto disconnect; 5537b411b363SPhilipp Reisner } 5538e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 553952b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 55401ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 554177351055SPhilipp Reisner pi.cmd, pi.size); 5542b411b363SPhilipp Reisner goto reconnect; 5543b411b363SPhilipp Reisner } 5544257d0af6SPhilipp Reisner } 5545b411b363SPhilipp Reisner if (received == expect) { 55462735a594SAndreas Gruenbacher bool err; 5547a4fbda8eSPhilipp Reisner 5548bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 55492735a594SAndreas Gruenbacher if (err) { 55501ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5551b411b363SPhilipp Reisner goto reconnect; 55521952e916SAndreas Gruenbacher } 5553b411b363SPhilipp Reisner 5554bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5555f36af18cSLars Ellenberg 555644ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 555744ed167dSPhilipp Reisner /* restore idle timeout */ 5558bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 555944ed167dSPhilipp Reisner ping_timeout_active = false; 556044ed167dSPhilipp Reisner } 5561b411b363SPhilipp Reisner 5562bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5563b411b363SPhilipp Reisner received = 0; 556452b061a4SAndreas Gruenbacher expect = header_size; 5565b411b363SPhilipp Reisner cmd = NULL; 5566b411b363SPhilipp Reisner } 5567b411b363SPhilipp Reisner } 5568b411b363SPhilipp Reisner 5569b411b363SPhilipp Reisner if (0) { 5570b411b363SPhilipp Reisner reconnect: 5571bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5572bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5573b411b363SPhilipp Reisner } 5574b411b363SPhilipp Reisner if (0) { 5575b411b363SPhilipp Reisner disconnect: 5576bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5577b411b363SPhilipp Reisner } 5578bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5579b411b363SPhilipp Reisner 55801ec861ebSAndreas Gruenbacher drbd_info(connection, "asender terminated\n"); 5581b411b363SPhilipp Reisner 5582b411b363SPhilipp Reisner return 0; 5583b411b363SPhilipp Reisner } 5584