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 50b411b363SPhilipp Reisner #include "drbd_vli.h" 51b411b363SPhilipp Reisner 5277351055SPhilipp Reisner struct packet_info { 5377351055SPhilipp Reisner enum drbd_packet cmd; 54e2857216SAndreas Gruenbacher unsigned int size; 55e2857216SAndreas Gruenbacher unsigned int vnr; 56e658983aSAndreas Gruenbacher void *data; 5777351055SPhilipp Reisner }; 5877351055SPhilipp Reisner 59b411b363SPhilipp Reisner enum finish_epoch { 60b411b363SPhilipp Reisner FE_STILL_LIVE, 61b411b363SPhilipp Reisner FE_DESTROYED, 62b411b363SPhilipp Reisner FE_RECYCLED, 63b411b363SPhilipp Reisner }; 64b411b363SPhilipp Reisner 65bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection); 66bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection); 67b30ab791SAndreas Gruenbacher static int drbd_disconnected(struct drbd_device *device); 68b411b363SPhilipp Reisner 69bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *, struct drbd_epoch *, enum epoch_event); 7099920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner 73b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 74b411b363SPhilipp Reisner 7545bb912bSLars Ellenberg /* 7645bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7745bb912bSLars Ellenberg * page->private being our "next" pointer. 7845bb912bSLars Ellenberg */ 7945bb912bSLars Ellenberg 8045bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8145bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8245bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8345bb912bSLars Ellenberg */ 8445bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8545bb912bSLars Ellenberg { 8645bb912bSLars Ellenberg struct page *page; 8745bb912bSLars Ellenberg struct page *tmp; 8845bb912bSLars Ellenberg 8945bb912bSLars Ellenberg BUG_ON(!n); 9045bb912bSLars Ellenberg BUG_ON(!head); 9145bb912bSLars Ellenberg 9245bb912bSLars Ellenberg page = *head; 9323ce4227SPhilipp Reisner 9423ce4227SPhilipp Reisner if (!page) 9523ce4227SPhilipp Reisner return NULL; 9623ce4227SPhilipp Reisner 9745bb912bSLars Ellenberg while (page) { 9845bb912bSLars Ellenberg tmp = page_chain_next(page); 9945bb912bSLars Ellenberg if (--n == 0) 10045bb912bSLars Ellenberg break; /* found sufficient pages */ 10145bb912bSLars Ellenberg if (tmp == NULL) 10245bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10345bb912bSLars Ellenberg return NULL; 10445bb912bSLars Ellenberg page = tmp; 10545bb912bSLars Ellenberg } 10645bb912bSLars Ellenberg 10745bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10845bb912bSLars Ellenberg set_page_private(page, 0); 10945bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11045bb912bSLars Ellenberg page = *head; 11145bb912bSLars Ellenberg *head = tmp; 11245bb912bSLars Ellenberg return page; 11345bb912bSLars Ellenberg } 11445bb912bSLars Ellenberg 11545bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11645bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11745bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11845bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11945bb912bSLars Ellenberg { 12045bb912bSLars Ellenberg struct page *tmp; 12145bb912bSLars Ellenberg int i = 1; 12245bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12345bb912bSLars Ellenberg ++i, page = tmp; 12445bb912bSLars Ellenberg if (len) 12545bb912bSLars Ellenberg *len = i; 12645bb912bSLars Ellenberg return page; 12745bb912bSLars Ellenberg } 12845bb912bSLars Ellenberg 12945bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13045bb912bSLars Ellenberg { 13145bb912bSLars Ellenberg struct page *tmp; 13245bb912bSLars Ellenberg int i = 0; 13345bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13445bb912bSLars Ellenberg put_page(page); 13545bb912bSLars Ellenberg ++i; 13645bb912bSLars Ellenberg } 13745bb912bSLars Ellenberg return i; 13845bb912bSLars Ellenberg } 13945bb912bSLars Ellenberg 14045bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14145bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14245bb912bSLars Ellenberg { 14345bb912bSLars Ellenberg #if 1 14445bb912bSLars Ellenberg struct page *tmp; 14545bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14645bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14745bb912bSLars Ellenberg #endif 14845bb912bSLars Ellenberg 14945bb912bSLars Ellenberg /* add chain to head */ 15045bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15145bb912bSLars Ellenberg *head = chain_first; 15245bb912bSLars Ellenberg } 15345bb912bSLars Ellenberg 154b30ab791SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_device *device, 15518c2d522SAndreas Gruenbacher unsigned int number) 156b411b363SPhilipp Reisner { 157b411b363SPhilipp Reisner struct page *page = NULL; 15845bb912bSLars Ellenberg struct page *tmp = NULL; 15918c2d522SAndreas Gruenbacher unsigned int i = 0; 160b411b363SPhilipp Reisner 161b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 162b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16345bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 164b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16545bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16645bb912bSLars Ellenberg if (page) 16745bb912bSLars Ellenberg drbd_pp_vacant -= number; 168b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16945bb912bSLars Ellenberg if (page) 17045bb912bSLars Ellenberg return page; 171b411b363SPhilipp Reisner } 17245bb912bSLars Ellenberg 173b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 174b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 175b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17645bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17745bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17845bb912bSLars Ellenberg if (!tmp) 17945bb912bSLars Ellenberg break; 18045bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18145bb912bSLars Ellenberg page = tmp; 18245bb912bSLars Ellenberg } 18345bb912bSLars Ellenberg 18445bb912bSLars Ellenberg if (i == number) 185b411b363SPhilipp Reisner return page; 18645bb912bSLars Ellenberg 18745bb912bSLars Ellenberg /* Not enough pages immediately available this time. 188c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 18945bb912bSLars Ellenberg * function "soon". */ 19045bb912bSLars Ellenberg if (page) { 19145bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19245bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19345bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19445bb912bSLars Ellenberg drbd_pp_vacant += i; 19545bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19645bb912bSLars Ellenberg } 19745bb912bSLars Ellenberg return NULL; 198b411b363SPhilipp Reisner } 199b411b363SPhilipp Reisner 200b30ab791SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_device *device, 201a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 202b411b363SPhilipp Reisner { 203db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 204b411b363SPhilipp Reisner struct list_head *le, *tle; 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 211b30ab791SAndreas Gruenbacher list_for_each_safe(le, tle, &device->net_ee) { 212db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 213045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 214b411b363SPhilipp Reisner break; 215b411b363SPhilipp Reisner list_move(le, to_be_freed); 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner } 218b411b363SPhilipp Reisner 219b30ab791SAndreas Gruenbacher static void drbd_kick_lo_and_reclaim_net(struct drbd_device *device) 220b411b363SPhilipp Reisner { 221b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 222db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 223b411b363SPhilipp Reisner 2240500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 225b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 2260500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 227b411b363SPhilipp Reisner 228db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 229b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 230b411b363SPhilipp Reisner } 231b411b363SPhilipp Reisner 232b411b363SPhilipp Reisner /** 233c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 234b30ab791SAndreas Gruenbacher * @device: DRBD device. 23545bb912bSLars Ellenberg * @number: number of pages requested 23645bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 237b411b363SPhilipp Reisner * 23845bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23945bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 24045bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 24145bb912bSLars Ellenberg * 24245bb912bSLars Ellenberg * Returns a page chain linked via page->private. 243b411b363SPhilipp Reisner */ 244b30ab791SAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_device *device, unsigned int number, 245c37c8ecfSAndreas Gruenbacher bool retry) 246b411b363SPhilipp Reisner { 247b411b363SPhilipp Reisner struct page *page = NULL; 24844ed167dSPhilipp Reisner struct net_conf *nc; 249b411b363SPhilipp Reisner DEFINE_WAIT(wait); 25044ed167dSPhilipp Reisner int mxb; 251b411b363SPhilipp Reisner 25245bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 25345bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25444ed167dSPhilipp Reisner rcu_read_lock(); 255a6b32bc3SAndreas Gruenbacher nc = rcu_dereference(first_peer_device(device)->connection->net_conf); 25644ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 25744ed167dSPhilipp Reisner rcu_read_unlock(); 25844ed167dSPhilipp Reisner 259b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) 260b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 261b411b363SPhilipp Reisner 26245bb912bSLars Ellenberg while (page == NULL) { 263b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 264b411b363SPhilipp Reisner 265b30ab791SAndreas Gruenbacher drbd_kick_lo_and_reclaim_net(device); 266b411b363SPhilipp Reisner 267b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) { 268b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 269b411b363SPhilipp Reisner if (page) 270b411b363SPhilipp Reisner break; 271b411b363SPhilipp Reisner } 272b411b363SPhilipp Reisner 273b411b363SPhilipp Reisner if (!retry) 274b411b363SPhilipp Reisner break; 275b411b363SPhilipp Reisner 276b411b363SPhilipp Reisner if (signal_pending(current)) { 277d0180171SAndreas Gruenbacher drbd_warn(device, "drbd_alloc_pages interrupted!\n"); 278b411b363SPhilipp Reisner break; 279b411b363SPhilipp Reisner } 280b411b363SPhilipp Reisner 281b411b363SPhilipp Reisner schedule(); 282b411b363SPhilipp Reisner } 283b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 284b411b363SPhilipp Reisner 28545bb912bSLars Ellenberg if (page) 286b30ab791SAndreas Gruenbacher atomic_add(number, &device->pp_in_use); 287b411b363SPhilipp Reisner return page; 288b411b363SPhilipp Reisner } 289b411b363SPhilipp Reisner 290c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 2910500813fSAndreas Gruenbacher * Is also used from inside an other spin_lock_irq(&resource->req_lock); 29245bb912bSLars Ellenberg * Either links the page chain back to the global pool, 29345bb912bSLars Ellenberg * or returns all pages to the system. */ 294b30ab791SAndreas Gruenbacher static void drbd_free_pages(struct drbd_device *device, struct page *page, int is_net) 295b411b363SPhilipp Reisner { 296b30ab791SAndreas Gruenbacher atomic_t *a = is_net ? &device->pp_in_use_by_net : &device->pp_in_use; 297b411b363SPhilipp Reisner int i; 298435f0740SLars Ellenberg 299a73ff323SLars Ellenberg if (page == NULL) 300a73ff323SLars Ellenberg return; 301a73ff323SLars Ellenberg 3021816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 30345bb912bSLars Ellenberg i = page_chain_free(page); 30445bb912bSLars Ellenberg else { 30545bb912bSLars Ellenberg struct page *tmp; 30645bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 307b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 30845bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 30945bb912bSLars Ellenberg drbd_pp_vacant += i; 310b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 311b411b363SPhilipp Reisner } 312435f0740SLars Ellenberg i = atomic_sub_return(i, a); 31345bb912bSLars Ellenberg if (i < 0) 314d0180171SAndreas Gruenbacher drbd_warn(device, "ASSERTION FAILED: %s: %d < 0\n", 315435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 316b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 317b411b363SPhilipp Reisner } 318b411b363SPhilipp Reisner 319b411b363SPhilipp Reisner /* 320b411b363SPhilipp Reisner You need to hold the req_lock: 321b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 322b411b363SPhilipp Reisner 323b411b363SPhilipp Reisner You must not have the req_lock: 3243967deb1SAndreas Gruenbacher drbd_free_peer_req() 3250db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3267721f567SAndreas Gruenbacher drbd_free_peer_reqs() 327b411b363SPhilipp Reisner drbd_ee_fix_bhs() 328a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 329b411b363SPhilipp Reisner drbd_clear_done_ee() 330b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 331b411b363SPhilipp Reisner */ 332b411b363SPhilipp Reisner 333f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 334b30ab791SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_device *device, u64 id, sector_t sector, 335f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 336b411b363SPhilipp Reisner { 337db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 338a73ff323SLars Ellenberg struct page *page = NULL; 33945bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 340b411b363SPhilipp Reisner 341b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_AL_EE)) 342b411b363SPhilipp Reisner return NULL; 343b411b363SPhilipp Reisner 344db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 345db830c46SAndreas Gruenbacher if (!peer_req) { 346b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 347d0180171SAndreas Gruenbacher drbd_err(device, "%s: allocation failed\n", __func__); 348b411b363SPhilipp Reisner return NULL; 349b411b363SPhilipp Reisner } 350b411b363SPhilipp Reisner 351a73ff323SLars Ellenberg if (data_size) { 352b30ab791SAndreas Gruenbacher page = drbd_alloc_pages(device, nr_pages, (gfp_mask & __GFP_WAIT)); 35345bb912bSLars Ellenberg if (!page) 35445bb912bSLars Ellenberg goto fail; 355a73ff323SLars Ellenberg } 356b411b363SPhilipp Reisner 357db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 358db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 359db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 360db830c46SAndreas Gruenbacher peer_req->i.local = false; 361db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 362b411b363SPhilipp Reisner 363db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 364b30ab791SAndreas Gruenbacher peer_req->w.device = device; 365db830c46SAndreas Gruenbacher peer_req->pages = page; 366db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 367db830c46SAndreas Gruenbacher peer_req->flags = 0; 3689a8e7753SAndreas Gruenbacher /* 3699a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3709a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3719a8e7753SAndreas Gruenbacher */ 372db830c46SAndreas Gruenbacher peer_req->block_id = id; 373b411b363SPhilipp Reisner 374db830c46SAndreas Gruenbacher return peer_req; 375b411b363SPhilipp Reisner 37645bb912bSLars Ellenberg fail: 377db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 378b411b363SPhilipp Reisner return NULL; 379b411b363SPhilipp Reisner } 380b411b363SPhilipp Reisner 381b30ab791SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_device *device, struct drbd_peer_request *peer_req, 382f6ffca9fSAndreas Gruenbacher int is_net) 383b411b363SPhilipp Reisner { 384db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 385db830c46SAndreas Gruenbacher kfree(peer_req->digest); 386b30ab791SAndreas Gruenbacher drbd_free_pages(device, peer_req->pages, is_net); 3870b0ba1efSAndreas Gruenbacher D_ASSERT(device, atomic_read(&peer_req->pending_bios) == 0); 3880b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 389db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 390b411b363SPhilipp Reisner } 391b411b363SPhilipp Reisner 392b30ab791SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_device *device, struct list_head *list) 393b411b363SPhilipp Reisner { 394b411b363SPhilipp Reisner LIST_HEAD(work_list); 395db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 396b411b363SPhilipp Reisner int count = 0; 397b30ab791SAndreas Gruenbacher int is_net = list == &device->net_ee; 398b411b363SPhilipp Reisner 3990500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 400b411b363SPhilipp Reisner list_splice_init(list, &work_list); 4010500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 402b411b363SPhilipp Reisner 403db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 404b30ab791SAndreas Gruenbacher __drbd_free_peer_req(device, peer_req, is_net); 405b411b363SPhilipp Reisner count++; 406b411b363SPhilipp Reisner } 407b411b363SPhilipp Reisner return count; 408b411b363SPhilipp Reisner } 409b411b363SPhilipp Reisner 410b411b363SPhilipp Reisner /* 411a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 412b411b363SPhilipp Reisner */ 413b30ab791SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_device *device) 414b411b363SPhilipp Reisner { 415b411b363SPhilipp Reisner LIST_HEAD(work_list); 416b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 417db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 418e2b3032bSAndreas Gruenbacher int err = 0; 419b411b363SPhilipp Reisner 4200500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 421b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 422b30ab791SAndreas Gruenbacher list_splice_init(&device->done_ee, &work_list); 4230500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 424b411b363SPhilipp Reisner 425db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 426b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 427b411b363SPhilipp Reisner 428b411b363SPhilipp Reisner /* possible callbacks here: 429d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 430b411b363SPhilipp Reisner * all ignore the last argument. 431b411b363SPhilipp Reisner */ 432db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 433e2b3032bSAndreas Gruenbacher int err2; 434e2b3032bSAndreas Gruenbacher 435b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 436e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 437e2b3032bSAndreas Gruenbacher if (!err) 438e2b3032bSAndreas Gruenbacher err = err2; 439b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 440b411b363SPhilipp Reisner } 441b30ab791SAndreas Gruenbacher wake_up(&device->ee_wait); 442b411b363SPhilipp Reisner 443e2b3032bSAndreas Gruenbacher return err; 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner 446b30ab791SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_device *device, 447d4da1537SAndreas Gruenbacher struct list_head *head) 448b411b363SPhilipp Reisner { 449b411b363SPhilipp Reisner DEFINE_WAIT(wait); 450b411b363SPhilipp Reisner 451b411b363SPhilipp Reisner /* avoids spin_lock/unlock 452b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 453b411b363SPhilipp Reisner while (!list_empty(head)) { 454b30ab791SAndreas Gruenbacher prepare_to_wait(&device->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 4550500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4567eaceaccSJens Axboe io_schedule(); 457b30ab791SAndreas Gruenbacher finish_wait(&device->ee_wait, &wait); 4580500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 459b411b363SPhilipp Reisner } 460b411b363SPhilipp Reisner } 461b411b363SPhilipp Reisner 462b30ab791SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_device *device, 463d4da1537SAndreas Gruenbacher struct list_head *head) 464b411b363SPhilipp Reisner { 4650500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 466b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, head); 4670500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 468b411b363SPhilipp Reisner } 469b411b363SPhilipp Reisner 470dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 471b411b363SPhilipp Reisner { 472b411b363SPhilipp Reisner mm_segment_t oldfs; 473b411b363SPhilipp Reisner struct kvec iov = { 474b411b363SPhilipp Reisner .iov_base = buf, 475b411b363SPhilipp Reisner .iov_len = size, 476b411b363SPhilipp Reisner }; 477b411b363SPhilipp Reisner struct msghdr msg = { 478b411b363SPhilipp Reisner .msg_iovlen = 1, 479b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 480b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 481b411b363SPhilipp Reisner }; 482b411b363SPhilipp Reisner int rv; 483b411b363SPhilipp Reisner 484b411b363SPhilipp Reisner oldfs = get_fs(); 485b411b363SPhilipp Reisner set_fs(KERNEL_DS); 486b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 487b411b363SPhilipp Reisner set_fs(oldfs); 488b411b363SPhilipp Reisner 489b411b363SPhilipp Reisner return rv; 490b411b363SPhilipp Reisner } 491b411b363SPhilipp Reisner 492bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 493b411b363SPhilipp Reisner { 494b411b363SPhilipp Reisner int rv; 495b411b363SPhilipp Reisner 496bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 497b411b363SPhilipp Reisner 498b411b363SPhilipp Reisner if (rv < 0) { 499b411b363SPhilipp Reisner if (rv == -ECONNRESET) 5001ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 501b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 5021ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 503b411b363SPhilipp Reisner } else if (rv == 0) { 504bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 505b66623e3SPhilipp Reisner long t; 506b66623e3SPhilipp Reisner rcu_read_lock(); 507bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 508b66623e3SPhilipp Reisner rcu_read_unlock(); 509b66623e3SPhilipp Reisner 510bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 511b66623e3SPhilipp Reisner 512599377acSPhilipp Reisner if (t) 513599377acSPhilipp Reisner goto out; 514599377acSPhilipp Reisner } 5151ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 516599377acSPhilipp Reisner } 517599377acSPhilipp Reisner 518b411b363SPhilipp Reisner if (rv != size) 519bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 520b411b363SPhilipp Reisner 521599377acSPhilipp Reisner out: 522b411b363SPhilipp Reisner return rv; 523b411b363SPhilipp Reisner } 524b411b363SPhilipp Reisner 525bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 526c6967746SAndreas Gruenbacher { 527c6967746SAndreas Gruenbacher int err; 528c6967746SAndreas Gruenbacher 529bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 530c6967746SAndreas Gruenbacher if (err != size) { 531c6967746SAndreas Gruenbacher if (err >= 0) 532c6967746SAndreas Gruenbacher err = -EIO; 533c6967746SAndreas Gruenbacher } else 534c6967746SAndreas Gruenbacher err = 0; 535c6967746SAndreas Gruenbacher return err; 536c6967746SAndreas Gruenbacher } 537c6967746SAndreas Gruenbacher 538bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 539a5c31904SAndreas Gruenbacher { 540a5c31904SAndreas Gruenbacher int err; 541a5c31904SAndreas Gruenbacher 542bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 543a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5441ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 545a5c31904SAndreas Gruenbacher return err; 546a5c31904SAndreas Gruenbacher } 547a5c31904SAndreas Gruenbacher 5485dbf1673SLars Ellenberg /* quoting tcp(7): 5495dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5505dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5515dbf1673SLars Ellenberg * This is our wrapper to do so. 5525dbf1673SLars Ellenberg */ 5535dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5545dbf1673SLars Ellenberg unsigned int rcv) 5555dbf1673SLars Ellenberg { 5565dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5575dbf1673SLars Ellenberg if (snd) { 5585dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5595dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5605dbf1673SLars Ellenberg } 5615dbf1673SLars Ellenberg if (rcv) { 5625dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5635dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5645dbf1673SLars Ellenberg } 5655dbf1673SLars Ellenberg } 5665dbf1673SLars Ellenberg 567bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 568b411b363SPhilipp Reisner { 569b411b363SPhilipp Reisner const char *what; 570b411b363SPhilipp Reisner struct socket *sock; 571b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 57244ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 57344ed167dSPhilipp Reisner struct net_conf *nc; 57444ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 57569ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 576b411b363SPhilipp Reisner int disconnect_on_error = 1; 577b411b363SPhilipp Reisner 57844ed167dSPhilipp Reisner rcu_read_lock(); 579bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 58044ed167dSPhilipp Reisner if (!nc) { 58144ed167dSPhilipp Reisner rcu_read_unlock(); 582b411b363SPhilipp Reisner return NULL; 58344ed167dSPhilipp Reisner } 58444ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 58544ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 58669ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 587089c075dSAndreas Gruenbacher rcu_read_unlock(); 58844ed167dSPhilipp Reisner 589bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 590bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 59144ed167dSPhilipp Reisner 592bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 59344ed167dSPhilipp Reisner src_in6.sin6_port = 0; 59444ed167dSPhilipp Reisner else 59544ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 59644ed167dSPhilipp Reisner 597bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 598bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 599b411b363SPhilipp Reisner 600b411b363SPhilipp Reisner what = "sock_create_kern"; 60144ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 602b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 603b411b363SPhilipp Reisner if (err < 0) { 604b411b363SPhilipp Reisner sock = NULL; 605b411b363SPhilipp Reisner goto out; 606b411b363SPhilipp Reisner } 607b411b363SPhilipp Reisner 608b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 60969ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 61044ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 611b411b363SPhilipp Reisner 612b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 613b411b363SPhilipp Reisner * for the outgoing connections. 614b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 615b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 616b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 617b411b363SPhilipp Reisner * a free one dynamically. 618b411b363SPhilipp Reisner */ 619b411b363SPhilipp Reisner what = "bind before connect"; 62044ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 621b411b363SPhilipp Reisner if (err < 0) 622b411b363SPhilipp Reisner goto out; 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 625b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 626b411b363SPhilipp Reisner disconnect_on_error = 0; 627b411b363SPhilipp Reisner what = "connect"; 62844ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 629b411b363SPhilipp Reisner 630b411b363SPhilipp Reisner out: 631b411b363SPhilipp Reisner if (err < 0) { 632b411b363SPhilipp Reisner if (sock) { 633b411b363SPhilipp Reisner sock_release(sock); 634b411b363SPhilipp Reisner sock = NULL; 635b411b363SPhilipp Reisner } 636b411b363SPhilipp Reisner switch (-err) { 637b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 638b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 639b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 640b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 641b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 642b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 643b411b363SPhilipp Reisner disconnect_on_error = 0; 644b411b363SPhilipp Reisner break; 645b411b363SPhilipp Reisner default: 6461ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 647b411b363SPhilipp Reisner } 648b411b363SPhilipp Reisner if (disconnect_on_error) 649bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 650b411b363SPhilipp Reisner } 65144ed167dSPhilipp Reisner 652b411b363SPhilipp Reisner return sock; 653b411b363SPhilipp Reisner } 654b411b363SPhilipp Reisner 6557a426fd8SPhilipp Reisner struct accept_wait_data { 656bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6577a426fd8SPhilipp Reisner struct socket *s_listen; 6587a426fd8SPhilipp Reisner struct completion door_bell; 6597a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6607a426fd8SPhilipp Reisner 6617a426fd8SPhilipp Reisner }; 6627a426fd8SPhilipp Reisner 663715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 664b411b363SPhilipp Reisner { 6657a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 666715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6677a426fd8SPhilipp Reisner 668715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 669715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6707a426fd8SPhilipp Reisner complete(&ad->door_bell); 671715306f6SAndreas Gruenbacher state_change(sk); 6727a426fd8SPhilipp Reisner } 6737a426fd8SPhilipp Reisner 674bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 675b411b363SPhilipp Reisner { 6761f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 67744ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 6781f3e509bSPhilipp Reisner struct socket *s_listen; 67944ed167dSPhilipp Reisner struct net_conf *nc; 680b411b363SPhilipp Reisner const char *what; 681b411b363SPhilipp Reisner 68244ed167dSPhilipp Reisner rcu_read_lock(); 683bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 68444ed167dSPhilipp Reisner if (!nc) { 68544ed167dSPhilipp Reisner rcu_read_unlock(); 6867a426fd8SPhilipp Reisner return -EIO; 68744ed167dSPhilipp Reisner } 68844ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 68944ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 69044ed167dSPhilipp Reisner rcu_read_unlock(); 691b411b363SPhilipp Reisner 692bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 693bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 694b411b363SPhilipp Reisner 695b411b363SPhilipp Reisner what = "sock_create_kern"; 69644ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 697b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 698b411b363SPhilipp Reisner if (err) { 699b411b363SPhilipp Reisner s_listen = NULL; 700b411b363SPhilipp Reisner goto out; 701b411b363SPhilipp Reisner } 702b411b363SPhilipp Reisner 7034a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 70444ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 705b411b363SPhilipp Reisner 706b411b363SPhilipp Reisner what = "bind before listen"; 70744ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 708b411b363SPhilipp Reisner if (err < 0) 709b411b363SPhilipp Reisner goto out; 710b411b363SPhilipp Reisner 7117a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7127a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7137a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 714715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7157a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7167a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 717b411b363SPhilipp Reisner 7182820fd39SPhilipp Reisner what = "listen"; 7192820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7202820fd39SPhilipp Reisner if (err < 0) 7212820fd39SPhilipp Reisner goto out; 7222820fd39SPhilipp Reisner 7237a426fd8SPhilipp Reisner return 0; 724b411b363SPhilipp Reisner out: 725b411b363SPhilipp Reisner if (s_listen) 726b411b363SPhilipp Reisner sock_release(s_listen); 727b411b363SPhilipp Reisner if (err < 0) { 728b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7291ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 730bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 731b411b363SPhilipp Reisner } 732b411b363SPhilipp Reisner } 7331f3e509bSPhilipp Reisner 7347a426fd8SPhilipp Reisner return -EIO; 7351f3e509bSPhilipp Reisner } 7361f3e509bSPhilipp Reisner 737715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 738715306f6SAndreas Gruenbacher { 739715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 740715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 741715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 742715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 743715306f6SAndreas Gruenbacher } 744715306f6SAndreas Gruenbacher 745bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7461f3e509bSPhilipp Reisner { 7471f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7481f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7491f3e509bSPhilipp Reisner struct net_conf *nc; 7501f3e509bSPhilipp Reisner 7511f3e509bSPhilipp Reisner rcu_read_lock(); 752bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7531f3e509bSPhilipp Reisner if (!nc) { 7541f3e509bSPhilipp Reisner rcu_read_unlock(); 7551f3e509bSPhilipp Reisner return NULL; 7561f3e509bSPhilipp Reisner } 7571f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7581f3e509bSPhilipp Reisner rcu_read_unlock(); 7591f3e509bSPhilipp Reisner 7601f3e509bSPhilipp Reisner timeo = connect_int * HZ; 76138b682b2SAkinobu Mita /* 28.5% random jitter */ 76238b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7631f3e509bSPhilipp Reisner 7647a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7657a426fd8SPhilipp Reisner if (err <= 0) 7667a426fd8SPhilipp Reisner return NULL; 7671f3e509bSPhilipp Reisner 7687a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 769b411b363SPhilipp Reisner if (err < 0) { 770b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7711ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 772bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 773b411b363SPhilipp Reisner } 774b411b363SPhilipp Reisner } 775b411b363SPhilipp Reisner 776715306f6SAndreas Gruenbacher if (s_estab) 777715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 778b411b363SPhilipp Reisner 779b411b363SPhilipp Reisner return s_estab; 780b411b363SPhilipp Reisner } 781b411b363SPhilipp Reisner 782bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 783b411b363SPhilipp Reisner 784bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 7859f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7869f5bdc33SAndreas Gruenbacher { 787bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 7889f5bdc33SAndreas Gruenbacher return -EIO; 789bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 790b411b363SPhilipp Reisner } 791b411b363SPhilipp Reisner 792bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 793b411b363SPhilipp Reisner { 794bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 7959f5bdc33SAndreas Gruenbacher struct packet_info pi; 7969f5bdc33SAndreas Gruenbacher int err; 797b411b363SPhilipp Reisner 798bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 7999f5bdc33SAndreas Gruenbacher if (err != header_size) { 8009f5bdc33SAndreas Gruenbacher if (err >= 0) 8019f5bdc33SAndreas Gruenbacher err = -EIO; 8029f5bdc33SAndreas Gruenbacher return err; 8039f5bdc33SAndreas Gruenbacher } 804bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8059f5bdc33SAndreas Gruenbacher if (err) 8069f5bdc33SAndreas Gruenbacher return err; 8079f5bdc33SAndreas Gruenbacher return pi.cmd; 808b411b363SPhilipp Reisner } 809b411b363SPhilipp Reisner 810b411b363SPhilipp Reisner /** 811b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 812b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 813b411b363SPhilipp Reisner */ 814dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 815b411b363SPhilipp Reisner { 816b411b363SPhilipp Reisner int rr; 817b411b363SPhilipp Reisner char tb[4]; 818b411b363SPhilipp Reisner 819b411b363SPhilipp Reisner if (!*sock) 82081e84650SAndreas Gruenbacher return false; 821b411b363SPhilipp Reisner 822dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 823b411b363SPhilipp Reisner 824b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 82581e84650SAndreas Gruenbacher return true; 826b411b363SPhilipp Reisner } else { 827b411b363SPhilipp Reisner sock_release(*sock); 828b411b363SPhilipp Reisner *sock = NULL; 82981e84650SAndreas Gruenbacher return false; 830b411b363SPhilipp Reisner } 831b411b363SPhilipp Reisner } 8322325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8332325eb66SPhilipp Reisner in a connection */ 834b30ab791SAndreas Gruenbacher int drbd_connected(struct drbd_device *device) 835907599e0SPhilipp Reisner { 8360829f5edSAndreas Gruenbacher int err; 837907599e0SPhilipp Reisner 838b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 839b30ab791SAndreas Gruenbacher device->peer_seq = 0; 840907599e0SPhilipp Reisner 841a6b32bc3SAndreas Gruenbacher device->state_mutex = first_peer_device(device)->connection->agreed_pro_version < 100 ? 842a6b32bc3SAndreas Gruenbacher &first_peer_device(device)->connection->cstate_mutex : 843b30ab791SAndreas Gruenbacher &device->own_state_mutex; 8448410da8fSPhilipp Reisner 845b30ab791SAndreas Gruenbacher err = drbd_send_sync_param(device); 8460829f5edSAndreas Gruenbacher if (!err) 847b30ab791SAndreas Gruenbacher err = drbd_send_sizes(device, 0, 0); 8480829f5edSAndreas Gruenbacher if (!err) 849b30ab791SAndreas Gruenbacher err = drbd_send_uuids(device); 8500829f5edSAndreas Gruenbacher if (!err) 851b30ab791SAndreas Gruenbacher err = drbd_send_current_state(device); 852b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 853b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 854b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 855b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 8560829f5edSAndreas Gruenbacher return err; 857907599e0SPhilipp Reisner } 858b411b363SPhilipp Reisner 859b411b363SPhilipp Reisner /* 860b411b363SPhilipp Reisner * return values: 861b411b363SPhilipp Reisner * 1 yes, we have a valid connection 862b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 863b411b363SPhilipp Reisner * -1 peer talks different language, 864b411b363SPhilipp Reisner * no point in trying again, please go standalone. 865b411b363SPhilipp Reisner * -2 We do not have a network config... 866b411b363SPhilipp Reisner */ 867bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 868b411b363SPhilipp Reisner { 8697da35862SPhilipp Reisner struct drbd_socket sock, msock; 870c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 87144ed167dSPhilipp Reisner struct net_conf *nc; 87292f14951SPhilipp Reisner int vnr, timeout, h, ok; 87308b165baSPhilipp Reisner bool discard_my_data; 874197296ffSPhilipp Reisner enum drbd_state_rv rv; 8757a426fd8SPhilipp Reisner struct accept_wait_data ad = { 876bde89a9eSAndreas Gruenbacher .connection = connection, 8777a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8787a426fd8SPhilipp Reisner }; 879b411b363SPhilipp Reisner 880bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 881bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 882b411b363SPhilipp Reisner return -2; 883b411b363SPhilipp Reisner 8847da35862SPhilipp Reisner mutex_init(&sock.mutex); 885bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 886bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 8877da35862SPhilipp Reisner sock.socket = NULL; 8887da35862SPhilipp Reisner mutex_init(&msock.mutex); 889bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 890bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 8917da35862SPhilipp Reisner msock.socket = NULL; 8927da35862SPhilipp Reisner 8930916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 894bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 895b411b363SPhilipp Reisner 896bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 8977a426fd8SPhilipp Reisner return 0; 898b411b363SPhilipp Reisner 899b411b363SPhilipp Reisner do { 9002bf89621SAndreas Gruenbacher struct socket *s; 901b411b363SPhilipp Reisner 902bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 903b411b363SPhilipp Reisner if (s) { 9047da35862SPhilipp Reisner if (!sock.socket) { 9057da35862SPhilipp Reisner sock.socket = s; 906bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9077da35862SPhilipp Reisner } else if (!msock.socket) { 908bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9097da35862SPhilipp Reisner msock.socket = s; 910bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 911b411b363SPhilipp Reisner } else { 9121ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 913b411b363SPhilipp Reisner goto out_release_sockets; 914b411b363SPhilipp Reisner } 915b411b363SPhilipp Reisner } 916b411b363SPhilipp Reisner 9177da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9187da35862SPhilipp Reisner rcu_read_lock(); 919bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 9207da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9217da35862SPhilipp Reisner rcu_read_unlock(); 9227da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9237da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9247da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 925b411b363SPhilipp Reisner if (ok) 926b411b363SPhilipp Reisner break; 927b411b363SPhilipp Reisner } 928b411b363SPhilipp Reisner 929b411b363SPhilipp Reisner retry: 930bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 931b411b363SPhilipp Reisner if (s) { 932bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9337da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9347da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 93592f14951SPhilipp Reisner switch (fp) { 936e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9377da35862SPhilipp Reisner if (sock.socket) { 9381ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9397da35862SPhilipp Reisner sock_release(sock.socket); 94080c6eed4SPhilipp Reisner sock.socket = s; 94180c6eed4SPhilipp Reisner goto randomize; 942b411b363SPhilipp Reisner } 9437da35862SPhilipp Reisner sock.socket = s; 944b411b363SPhilipp Reisner break; 945e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 946bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 9477da35862SPhilipp Reisner if (msock.socket) { 9481ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 9497da35862SPhilipp Reisner sock_release(msock.socket); 95080c6eed4SPhilipp Reisner msock.socket = s; 95180c6eed4SPhilipp Reisner goto randomize; 952b411b363SPhilipp Reisner } 9537da35862SPhilipp Reisner msock.socket = s; 954b411b363SPhilipp Reisner break; 955b411b363SPhilipp Reisner default: 9561ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 957b411b363SPhilipp Reisner sock_release(s); 95880c6eed4SPhilipp Reisner randomize: 95938b682b2SAkinobu Mita if (prandom_u32() & 1) 960b411b363SPhilipp Reisner goto retry; 961b411b363SPhilipp Reisner } 962b411b363SPhilipp Reisner } 963b411b363SPhilipp Reisner 964bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 965b411b363SPhilipp Reisner goto out_release_sockets; 966b411b363SPhilipp Reisner if (signal_pending(current)) { 967b411b363SPhilipp Reisner flush_signals(current); 968b411b363SPhilipp Reisner smp_rmb(); 969bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 970b411b363SPhilipp Reisner goto out_release_sockets; 971b411b363SPhilipp Reisner } 972b411b363SPhilipp Reisner 9737da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9747da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 975b666dbf8SPhilipp Reisner } while (!ok); 976b411b363SPhilipp Reisner 9777a426fd8SPhilipp Reisner if (ad.s_listen) 9787a426fd8SPhilipp Reisner sock_release(ad.s_listen); 979b411b363SPhilipp Reisner 98098683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 98198683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 982b411b363SPhilipp Reisner 9837da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9847da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 985b411b363SPhilipp Reisner 9867da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9877da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 988b411b363SPhilipp Reisner 989b411b363SPhilipp Reisner /* NOT YET ... 990bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 9917da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9926038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 993b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 99444ed167dSPhilipp Reisner rcu_read_lock(); 995bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 996b411b363SPhilipp Reisner 9977da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 9987da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 99944ed167dSPhilipp Reisner 10007da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 100144ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 100208b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 100344ed167dSPhilipp Reisner rcu_read_unlock(); 100444ed167dSPhilipp Reisner 10057da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1006b411b363SPhilipp Reisner 1007b411b363SPhilipp Reisner /* we don't want delays. 100825985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10097da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10107da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1011b411b363SPhilipp Reisner 1012bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1013bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1014bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1015b411b363SPhilipp Reisner 1016bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1017b411b363SPhilipp Reisner if (h <= 0) 1018b411b363SPhilipp Reisner return h; 1019b411b363SPhilipp Reisner 1020bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1021b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1022bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1023b10d96cbSJohannes Thoma case -1: 10241ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1025b411b363SPhilipp Reisner return -1; 1026b10d96cbSJohannes Thoma case 0: 10271ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1028b10d96cbSJohannes Thoma return 0; 1029b411b363SPhilipp Reisner } 1030b411b363SPhilipp Reisner } 1031b411b363SPhilipp Reisner 1032bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1033bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1034b411b363SPhilipp Reisner 1035bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10367e2455c1SPhilipp Reisner return -1; 10371e86ac48SPhilipp Reisner 1038bde89a9eSAndreas Gruenbacher set_bit(STATE_SENT, &connection->flags); 1039197296ffSPhilipp Reisner 1040c141ebdaSPhilipp Reisner rcu_read_lock(); 1041c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1042c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1043b30ab791SAndreas Gruenbacher kref_get(&device->kref); 104426ea8f92SAndreas Gruenbacher rcu_read_unlock(); 104526ea8f92SAndreas Gruenbacher 104613c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 104713c76abaSPhilipp Reisner * being promoted to Primary. 104813c76abaSPhilipp Reisner * 104913c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 105013c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 105113c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 105213c76abaSPhilipp Reisner */ 1053b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 1054b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 105513c76abaSPhilipp Reisner 105608b165baSPhilipp Reisner if (discard_my_data) 1057b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 105808b165baSPhilipp Reisner else 1059b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 106008b165baSPhilipp Reisner 1061b30ab791SAndreas Gruenbacher drbd_connected(device); 106205a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1063c141ebdaSPhilipp Reisner rcu_read_lock(); 1064c141ebdaSPhilipp Reisner } 1065c141ebdaSPhilipp Reisner rcu_read_unlock(); 1066c141ebdaSPhilipp Reisner 1067bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1068bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1069bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 10701e86ac48SPhilipp Reisner return 0; 1071a1096a6eSPhilipp Reisner } 10721e86ac48SPhilipp Reisner 1073bde89a9eSAndreas Gruenbacher drbd_thread_start(&connection->asender); 1074b411b363SPhilipp Reisner 10750500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 107608b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 107708b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 107808b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 107908b165baSPhilipp Reisner * just to clear a single value. */ 1080bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 10810500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 108208b165baSPhilipp Reisner 1083d3fcb490SPhilipp Reisner return h; 1084b411b363SPhilipp Reisner 1085b411b363SPhilipp Reisner out_release_sockets: 10867a426fd8SPhilipp Reisner if (ad.s_listen) 10877a426fd8SPhilipp Reisner sock_release(ad.s_listen); 10887da35862SPhilipp Reisner if (sock.socket) 10897da35862SPhilipp Reisner sock_release(sock.socket); 10907da35862SPhilipp Reisner if (msock.socket) 10917da35862SPhilipp Reisner sock_release(msock.socket); 1092b411b363SPhilipp Reisner return -1; 1093b411b363SPhilipp Reisner } 1094b411b363SPhilipp Reisner 1095bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1096b411b363SPhilipp Reisner { 1097bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1098b411b363SPhilipp Reisner 10990c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11000c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11010c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11020c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11031ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11040c8e36d9SAndreas Gruenbacher return -EINVAL; 110502918be2SPhilipp Reisner } 11060c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11070c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11080c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11090c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1110e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1111e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1112e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1113b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1114eefc2f7dSPhilipp Reisner pi->vnr = 0; 1115e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1116e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1117e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1118e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1119e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 112077351055SPhilipp Reisner pi->vnr = 0; 112102918be2SPhilipp Reisner } else { 11221ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1123e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1124bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11258172f3e9SAndreas Gruenbacher return -EINVAL; 1126b411b363SPhilipp Reisner } 1127e658983aSAndreas Gruenbacher pi->data = header + header_size; 11288172f3e9SAndreas Gruenbacher return 0; 1129b411b363SPhilipp Reisner } 1130b411b363SPhilipp Reisner 1131bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1132257d0af6SPhilipp Reisner { 1133bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 113469bc7bc3SAndreas Gruenbacher int err; 1135257d0af6SPhilipp Reisner 1136bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1137a5c31904SAndreas Gruenbacher if (err) 113869bc7bc3SAndreas Gruenbacher return err; 1139257d0af6SPhilipp Reisner 1140bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1141bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1142b411b363SPhilipp Reisner 114369bc7bc3SAndreas Gruenbacher return err; 1144b411b363SPhilipp Reisner } 1145b411b363SPhilipp Reisner 1146bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1147b411b363SPhilipp Reisner { 1148b411b363SPhilipp Reisner int rv; 1149c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 11504b0007c0SPhilipp Reisner int vnr; 1151b411b363SPhilipp Reisner 1152bde89a9eSAndreas Gruenbacher if (connection->write_ordering >= WO_bdev_flush) { 1153615e087fSLars Ellenberg rcu_read_lock(); 1154c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1155c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1156c06ece6bSAndreas Gruenbacher 1157b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1158615e087fSLars Ellenberg continue; 1159b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1160615e087fSLars Ellenberg rcu_read_unlock(); 11614b0007c0SPhilipp Reisner 1162b30ab791SAndreas Gruenbacher rv = blkdev_issue_flush(device->ldev->backing_bdev, 1163615e087fSLars Ellenberg GFP_NOIO, NULL); 1164b411b363SPhilipp Reisner if (rv) { 1165d0180171SAndreas Gruenbacher drbd_info(device, "local disk flush failed with status %d\n", rv); 1166b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1167b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1168b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1169bde89a9eSAndreas Gruenbacher drbd_bump_write_ordering(connection, WO_drain_io); 1170b411b363SPhilipp Reisner } 1171b30ab791SAndreas Gruenbacher put_ldev(device); 117205a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1173615e087fSLars Ellenberg 1174615e087fSLars Ellenberg rcu_read_lock(); 1175615e087fSLars Ellenberg if (rv) 11764b0007c0SPhilipp Reisner break; 1177b411b363SPhilipp Reisner } 1178615e087fSLars Ellenberg rcu_read_unlock(); 1179b411b363SPhilipp Reisner } 1180b411b363SPhilipp Reisner } 1181b411b363SPhilipp Reisner 1182b411b363SPhilipp Reisner /** 1183b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1184b30ab791SAndreas Gruenbacher * @device: DRBD device. 1185b411b363SPhilipp Reisner * @epoch: Epoch object. 1186b411b363SPhilipp Reisner * @ev: Epoch event. 1187b411b363SPhilipp Reisner */ 1188bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1189b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1190b411b363SPhilipp Reisner enum epoch_event ev) 1191b411b363SPhilipp Reisner { 11922451fc3bSPhilipp Reisner int epoch_size; 1193b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1194b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1195b411b363SPhilipp Reisner 1196bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1197b411b363SPhilipp Reisner do { 1198b411b363SPhilipp Reisner next_epoch = NULL; 1199b411b363SPhilipp Reisner 1200b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1201b411b363SPhilipp Reisner 1202b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1203b411b363SPhilipp Reisner case EV_PUT: 1204b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1205b411b363SPhilipp Reisner break; 1206b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1207b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1208b411b363SPhilipp Reisner break; 1209b411b363SPhilipp Reisner case EV_BECAME_LAST: 1210b411b363SPhilipp Reisner /* nothing to do*/ 1211b411b363SPhilipp Reisner break; 1212b411b363SPhilipp Reisner } 1213b411b363SPhilipp Reisner 1214b411b363SPhilipp Reisner if (epoch_size != 0 && 1215b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 121680f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1217b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1218bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1219bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1220bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1221b411b363SPhilipp Reisner } 12229ed57dcbSLars Ellenberg #if 0 12239ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12249ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 122580f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1226bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 12279ed57dcbSLars Ellenberg #endif 1228b411b363SPhilipp Reisner 1229bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1230b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1231b411b363SPhilipp Reisner list_del(&epoch->list); 1232b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1233bde89a9eSAndreas Gruenbacher connection->epochs--; 1234b411b363SPhilipp Reisner kfree(epoch); 1235b411b363SPhilipp Reisner 1236b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1237b411b363SPhilipp Reisner rv = FE_DESTROYED; 1238b411b363SPhilipp Reisner } else { 1239b411b363SPhilipp Reisner epoch->flags = 0; 1240b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1241698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1242b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1243b411b363SPhilipp Reisner rv = FE_RECYCLED; 1244b411b363SPhilipp Reisner } 1245b411b363SPhilipp Reisner } 1246b411b363SPhilipp Reisner 1247b411b363SPhilipp Reisner if (!next_epoch) 1248b411b363SPhilipp Reisner break; 1249b411b363SPhilipp Reisner 1250b411b363SPhilipp Reisner epoch = next_epoch; 1251b411b363SPhilipp Reisner } while (1); 1252b411b363SPhilipp Reisner 1253bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1254b411b363SPhilipp Reisner 1255b411b363SPhilipp Reisner return rv; 1256b411b363SPhilipp Reisner } 1257b411b363SPhilipp Reisner 1258b411b363SPhilipp Reisner /** 1259b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1260bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1261b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1262b411b363SPhilipp Reisner */ 1263bde89a9eSAndreas Gruenbacher void drbd_bump_write_ordering(struct drbd_connection *connection, enum write_ordering_e wo) 1264b411b363SPhilipp Reisner { 1265daeda1ccSPhilipp Reisner struct disk_conf *dc; 1266c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1267b411b363SPhilipp Reisner enum write_ordering_e pwo; 12684b0007c0SPhilipp Reisner int vnr; 1269b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1270b411b363SPhilipp Reisner [WO_none] = "none", 1271b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1272b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1273b411b363SPhilipp Reisner }; 1274b411b363SPhilipp Reisner 1275bde89a9eSAndreas Gruenbacher pwo = connection->write_ordering; 1276b411b363SPhilipp Reisner wo = min(pwo, wo); 1277daeda1ccSPhilipp Reisner rcu_read_lock(); 1278c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1279c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1280c06ece6bSAndreas Gruenbacher 1281b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_ATTACHING)) 12824b0007c0SPhilipp Reisner continue; 1283b30ab791SAndreas Gruenbacher dc = rcu_dereference(device->ldev->disk_conf); 1284daeda1ccSPhilipp Reisner 128566b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1286b411b363SPhilipp Reisner wo = WO_drain_io; 1287d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1288b411b363SPhilipp Reisner wo = WO_none; 1289b30ab791SAndreas Gruenbacher put_ldev(device); 12904b0007c0SPhilipp Reisner } 1291daeda1ccSPhilipp Reisner rcu_read_unlock(); 1292bde89a9eSAndreas Gruenbacher connection->write_ordering = wo; 1293bde89a9eSAndreas Gruenbacher if (pwo != connection->write_ordering || wo == WO_bdev_flush) 12941ec861ebSAndreas Gruenbacher drbd_info(connection, "Method to ensure write ordering: %s\n", write_ordering_str[connection->write_ordering]); 1295b411b363SPhilipp Reisner } 1296b411b363SPhilipp Reisner 1297b411b363SPhilipp Reisner /** 1298fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1299b30ab791SAndreas Gruenbacher * @device: DRBD device. 1300db830c46SAndreas Gruenbacher * @peer_req: peer request 130145bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 130210f6d992SLars Ellenberg * 130310f6d992SLars Ellenberg * May spread the pages to multiple bios, 130410f6d992SLars Ellenberg * depending on bio_add_page restrictions. 130510f6d992SLars Ellenberg * 130610f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 130710f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 130810f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 130910f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 131010f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 131110f6d992SLars Ellenberg * on certain Xen deployments. 131245bb912bSLars Ellenberg */ 131345bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1314b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1315fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 131645bb912bSLars Ellenberg const unsigned rw, const int fault_type) 131745bb912bSLars Ellenberg { 131845bb912bSLars Ellenberg struct bio *bios = NULL; 131945bb912bSLars Ellenberg struct bio *bio; 1320db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1321db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1322db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 132345bb912bSLars Ellenberg unsigned n_bios = 0; 132445bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 132510f6d992SLars Ellenberg int err = -ENOMEM; 132645bb912bSLars Ellenberg 132745bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 132845bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 132945bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 13309476f39dSLars Ellenberg * request in more than one bio. 13319476f39dSLars Ellenberg * 13329476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 13339476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 13349476f39dSLars Ellenberg */ 133545bb912bSLars Ellenberg next_bio: 133645bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 133745bb912bSLars Ellenberg if (!bio) { 1338d0180171SAndreas Gruenbacher drbd_err(device, "submit_ee: Allocation of a bio failed\n"); 133945bb912bSLars Ellenberg goto fail; 134045bb912bSLars Ellenberg } 1341db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 13424f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 1343b30ab791SAndreas Gruenbacher bio->bi_bdev = device->ldev->backing_bdev; 134445bb912bSLars Ellenberg bio->bi_rw = rw; 1345db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1346fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 134745bb912bSLars Ellenberg 134845bb912bSLars Ellenberg bio->bi_next = bios; 134945bb912bSLars Ellenberg bios = bio; 135045bb912bSLars Ellenberg ++n_bios; 135145bb912bSLars Ellenberg 135245bb912bSLars Ellenberg page_chain_for_each(page) { 135345bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 135445bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 135510f6d992SLars Ellenberg /* A single page must always be possible! 135610f6d992SLars Ellenberg * But in case it fails anyways, 135710f6d992SLars Ellenberg * we deal with it, and complain (below). */ 135810f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 1359d0180171SAndreas Gruenbacher drbd_err(device, 136010f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 136110f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 13624f024f37SKent Overstreet len, (uint64_t)bio->bi_iter.bi_sector); 136310f6d992SLars Ellenberg err = -ENOSPC; 136410f6d992SLars Ellenberg goto fail; 136510f6d992SLars Ellenberg } 136645bb912bSLars Ellenberg goto next_bio; 136745bb912bSLars Ellenberg } 136845bb912bSLars Ellenberg ds -= len; 136945bb912bSLars Ellenberg sector += len >> 9; 137045bb912bSLars Ellenberg --nr_pages; 137145bb912bSLars Ellenberg } 13720b0ba1efSAndreas Gruenbacher D_ASSERT(device, page == NULL); 13730b0ba1efSAndreas Gruenbacher D_ASSERT(device, ds == 0); 137445bb912bSLars Ellenberg 1375db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 137645bb912bSLars Ellenberg do { 137745bb912bSLars Ellenberg bio = bios; 137845bb912bSLars Ellenberg bios = bios->bi_next; 137945bb912bSLars Ellenberg bio->bi_next = NULL; 138045bb912bSLars Ellenberg 1381b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 138245bb912bSLars Ellenberg } while (bios); 138345bb912bSLars Ellenberg return 0; 138445bb912bSLars Ellenberg 138545bb912bSLars Ellenberg fail: 138645bb912bSLars Ellenberg while (bios) { 138745bb912bSLars Ellenberg bio = bios; 138845bb912bSLars Ellenberg bios = bios->bi_next; 138945bb912bSLars Ellenberg bio_put(bio); 139045bb912bSLars Ellenberg } 139110f6d992SLars Ellenberg return err; 139245bb912bSLars Ellenberg } 139345bb912bSLars Ellenberg 1394b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1395db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 139653840641SAndreas Gruenbacher { 1397db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 139853840641SAndreas Gruenbacher 1399b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 140053840641SAndreas Gruenbacher drbd_clear_interval(i); 140153840641SAndreas Gruenbacher 14026c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 140353840641SAndreas Gruenbacher if (i->waiting) 1404b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 140553840641SAndreas Gruenbacher } 140653840641SAndreas Gruenbacher 1407bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 140877fede51SPhilipp Reisner { 1409c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 141077fede51SPhilipp Reisner int vnr; 141177fede51SPhilipp Reisner 141277fede51SPhilipp Reisner rcu_read_lock(); 1413c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1414c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1415c06ece6bSAndreas Gruenbacher 1416b30ab791SAndreas Gruenbacher kref_get(&device->kref); 141777fede51SPhilipp Reisner rcu_read_unlock(); 1418b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 141905a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 142077fede51SPhilipp Reisner rcu_read_lock(); 142177fede51SPhilipp Reisner } 142277fede51SPhilipp Reisner rcu_read_unlock(); 142377fede51SPhilipp Reisner } 142477fede51SPhilipp Reisner 14259f4fe9adSAndreas Gruenbacher static struct drbd_peer_device * 14269f4fe9adSAndreas Gruenbacher conn_peer_device(struct drbd_connection *connection, int volume_number) 14279f4fe9adSAndreas Gruenbacher { 14289f4fe9adSAndreas Gruenbacher return idr_find(&connection->peer_devices, volume_number); 14299f4fe9adSAndreas Gruenbacher } 14309f4fe9adSAndreas Gruenbacher 1431bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1432b411b363SPhilipp Reisner { 14332451fc3bSPhilipp Reisner int rv; 1434e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1435b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1436b411b363SPhilipp Reisner 14379ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14389ed57dcbSLars Ellenberg * not a specific (peer)device. 14399ed57dcbSLars Ellenberg */ 1440bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1441bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1442bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1443b411b363SPhilipp Reisner 1444b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1445b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1446b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1447b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1448b411b363SPhilipp Reisner * completed. */ 1449bde89a9eSAndreas Gruenbacher switch (connection->write_ordering) { 1450b411b363SPhilipp Reisner case WO_none: 1451b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 145282bc0194SAndreas Gruenbacher return 0; 1453b411b363SPhilipp Reisner 1454b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1455b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1456b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14572451fc3bSPhilipp Reisner if (epoch) 14582451fc3bSPhilipp Reisner break; 14592451fc3bSPhilipp Reisner else 14601ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 14612451fc3bSPhilipp Reisner /* Fall through */ 14622451fc3bSPhilipp Reisner 14632451fc3bSPhilipp Reisner case WO_bdev_flush: 14642451fc3bSPhilipp Reisner case WO_drain_io: 1465bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1466bde89a9eSAndreas Gruenbacher drbd_flush(connection); 14672451fc3bSPhilipp Reisner 1468bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 14692451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14702451fc3bSPhilipp Reisner if (epoch) 14712451fc3bSPhilipp Reisner break; 1472b411b363SPhilipp Reisner } 1473b411b363SPhilipp Reisner 147482bc0194SAndreas Gruenbacher return 0; 14752451fc3bSPhilipp Reisner default: 14761ec861ebSAndreas Gruenbacher drbd_err(connection, "Strangeness in connection->write_ordering %d\n", connection->write_ordering); 147782bc0194SAndreas Gruenbacher return -EIO; 1478b411b363SPhilipp Reisner } 1479b411b363SPhilipp Reisner 1480b411b363SPhilipp Reisner epoch->flags = 0; 1481b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1482b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1483b411b363SPhilipp Reisner 1484bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1485bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1486bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1487bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1488bde89a9eSAndreas Gruenbacher connection->epochs++; 1489b411b363SPhilipp Reisner } else { 1490b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1491b411b363SPhilipp Reisner kfree(epoch); 1492b411b363SPhilipp Reisner } 1493bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1494b411b363SPhilipp Reisner 149582bc0194SAndreas Gruenbacher return 0; 1496b411b363SPhilipp Reisner } 1497b411b363SPhilipp Reisner 1498b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1499b411b363SPhilipp Reisner * and from receive_Data */ 1500f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1501b30ab791SAndreas Gruenbacher read_in_block(struct drbd_device *device, u64 id, sector_t sector, 1502f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1503b411b363SPhilipp Reisner { 1504b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1505db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1506b411b363SPhilipp Reisner struct page *page; 1507a5c31904SAndreas Gruenbacher int dgs, ds, err; 1508a6b32bc3SAndreas Gruenbacher void *dig_in = first_peer_device(device)->connection->int_dig_in; 1509a6b32bc3SAndreas Gruenbacher void *dig_vv = first_peer_device(device)->connection->int_dig_vv; 15106b4388acSPhilipp Reisner unsigned long *data; 1511b411b363SPhilipp Reisner 151288104ca4SAndreas Gruenbacher dgs = 0; 1513a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->peer_integrity_tfm) { 1514a6b32bc3SAndreas Gruenbacher dgs = crypto_hash_digestsize(first_peer_device(device)->connection->peer_integrity_tfm); 15159f5bdc33SAndreas Gruenbacher /* 15169f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15179f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15189f5bdc33SAndreas Gruenbacher */ 1519a6b32bc3SAndreas Gruenbacher err = drbd_recv_all_warn(first_peer_device(device)->connection, dig_in, dgs); 1520a5c31904SAndreas Gruenbacher if (err) 1521b411b363SPhilipp Reisner return NULL; 1522b411b363SPhilipp Reisner data_size -= dgs; 152388104ca4SAndreas Gruenbacher } 1524b411b363SPhilipp Reisner 1525841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1526841ce241SAndreas Gruenbacher return NULL; 1527841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1528841ce241SAndreas Gruenbacher return NULL; 1529b411b363SPhilipp Reisner 15306666032aSLars Ellenberg /* even though we trust out peer, 15316666032aSLars Ellenberg * we sometimes have to double check. */ 15326666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1533d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1534fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15356666032aSLars Ellenberg (unsigned long long)capacity, 15366666032aSLars Ellenberg (unsigned long long)sector, data_size); 15376666032aSLars Ellenberg return NULL; 15386666032aSLars Ellenberg } 15396666032aSLars Ellenberg 1540b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1541b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1542b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1543b30ab791SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(device, id, sector, data_size, GFP_NOIO); 1544db830c46SAndreas Gruenbacher if (!peer_req) 1545b411b363SPhilipp Reisner return NULL; 154645bb912bSLars Ellenberg 1547a73ff323SLars Ellenberg if (!data_size) 154881a3537aSLars Ellenberg return peer_req; 1549a73ff323SLars Ellenberg 1550b411b363SPhilipp Reisner ds = data_size; 1551db830c46SAndreas Gruenbacher page = peer_req->pages; 155245bb912bSLars Ellenberg page_chain_for_each(page) { 155345bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 15546b4388acSPhilipp Reisner data = kmap(page); 1555a6b32bc3SAndreas Gruenbacher err = drbd_recv_all_warn(first_peer_device(device)->connection, data, len); 1556b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1557d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 15586b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 15596b4388acSPhilipp Reisner } 1560b411b363SPhilipp Reisner kunmap(page); 1561a5c31904SAndreas Gruenbacher if (err) { 1562b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1563b411b363SPhilipp Reisner return NULL; 1564b411b363SPhilipp Reisner } 1565a5c31904SAndreas Gruenbacher ds -= len; 1566b411b363SPhilipp Reisner } 1567b411b363SPhilipp Reisner 1568b411b363SPhilipp Reisner if (dgs) { 156979a3c8d3SAndreas Gruenbacher drbd_csum_ee(first_peer_device(device)->connection->peer_integrity_tfm, peer_req, dig_vv); 1570b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1571d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1572470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1573b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1574b411b363SPhilipp Reisner return NULL; 1575b411b363SPhilipp Reisner } 1576b411b363SPhilipp Reisner } 1577b30ab791SAndreas Gruenbacher device->recv_cnt += data_size>>9; 1578db830c46SAndreas Gruenbacher return peer_req; 1579b411b363SPhilipp Reisner } 1580b411b363SPhilipp Reisner 1581b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1582b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1583b411b363SPhilipp Reisner */ 1584b30ab791SAndreas Gruenbacher static int drbd_drain_block(struct drbd_device *device, int data_size) 1585b411b363SPhilipp Reisner { 1586b411b363SPhilipp Reisner struct page *page; 1587a5c31904SAndreas Gruenbacher int err = 0; 1588b411b363SPhilipp Reisner void *data; 1589b411b363SPhilipp Reisner 1590c3470cdeSLars Ellenberg if (!data_size) 1591fc5be839SAndreas Gruenbacher return 0; 1592c3470cdeSLars Ellenberg 1593b30ab791SAndreas Gruenbacher page = drbd_alloc_pages(device, 1, 1); 1594b411b363SPhilipp Reisner 1595b411b363SPhilipp Reisner data = kmap(page); 1596b411b363SPhilipp Reisner while (data_size) { 1597fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1598fc5be839SAndreas Gruenbacher 1599a6b32bc3SAndreas Gruenbacher err = drbd_recv_all_warn(first_peer_device(device)->connection, data, len); 1600a5c31904SAndreas Gruenbacher if (err) 1601b411b363SPhilipp Reisner break; 1602a5c31904SAndreas Gruenbacher data_size -= len; 1603b411b363SPhilipp Reisner } 1604b411b363SPhilipp Reisner kunmap(page); 1605b30ab791SAndreas Gruenbacher drbd_free_pages(device, page, 0); 1606fc5be839SAndreas Gruenbacher return err; 1607b411b363SPhilipp Reisner } 1608b411b363SPhilipp Reisner 1609b30ab791SAndreas Gruenbacher static int recv_dless_read(struct drbd_device *device, struct drbd_request *req, 1610b411b363SPhilipp Reisner sector_t sector, int data_size) 1611b411b363SPhilipp Reisner { 16127988613bSKent Overstreet struct bio_vec bvec; 16137988613bSKent Overstreet struct bvec_iter iter; 1614b411b363SPhilipp Reisner struct bio *bio; 16157988613bSKent Overstreet int dgs, err, expect; 1616a6b32bc3SAndreas Gruenbacher void *dig_in = first_peer_device(device)->connection->int_dig_in; 1617a6b32bc3SAndreas Gruenbacher void *dig_vv = first_peer_device(device)->connection->int_dig_vv; 1618b411b363SPhilipp Reisner 161988104ca4SAndreas Gruenbacher dgs = 0; 1620a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->peer_integrity_tfm) { 1621a6b32bc3SAndreas Gruenbacher dgs = crypto_hash_digestsize(first_peer_device(device)->connection->peer_integrity_tfm); 1622a6b32bc3SAndreas Gruenbacher err = drbd_recv_all_warn(first_peer_device(device)->connection, dig_in, dgs); 1623a5c31904SAndreas Gruenbacher if (err) 1624a5c31904SAndreas Gruenbacher return err; 1625b411b363SPhilipp Reisner data_size -= dgs; 162688104ca4SAndreas Gruenbacher } 1627b411b363SPhilipp Reisner 1628b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1629b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1630b30ab791SAndreas Gruenbacher device->recv_cnt += data_size>>9; 1631b411b363SPhilipp Reisner 1632b411b363SPhilipp Reisner bio = req->master_bio; 16330b0ba1efSAndreas Gruenbacher D_ASSERT(device, sector == bio->bi_iter.bi_sector); 1634b411b363SPhilipp Reisner 16357988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 16367988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 16377988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 1638a6b32bc3SAndreas Gruenbacher err = drbd_recv_all_warn(first_peer_device(device)->connection, mapped, expect); 16397988613bSKent Overstreet kunmap(bvec.bv_page); 1640a5c31904SAndreas Gruenbacher if (err) 1641a5c31904SAndreas Gruenbacher return err; 1642a5c31904SAndreas Gruenbacher data_size -= expect; 1643b411b363SPhilipp Reisner } 1644b411b363SPhilipp Reisner 1645b411b363SPhilipp Reisner if (dgs) { 164679a3c8d3SAndreas Gruenbacher drbd_csum_bio(first_peer_device(device)->connection->peer_integrity_tfm, bio, dig_vv); 1647b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1648d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED. Broken NICs?\n"); 164928284cefSAndreas Gruenbacher return -EINVAL; 1650b411b363SPhilipp Reisner } 1651b411b363SPhilipp Reisner } 1652b411b363SPhilipp Reisner 16530b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 165428284cefSAndreas Gruenbacher return 0; 1655b411b363SPhilipp Reisner } 1656b411b363SPhilipp Reisner 1657a990be46SAndreas Gruenbacher /* 1658a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1659a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1660a990be46SAndreas Gruenbacher */ 166199920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1662b411b363SPhilipp Reisner { 16638050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16648050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1665b30ab791SAndreas Gruenbacher struct drbd_device *device = w->device; 1666db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 166799920dc5SAndreas Gruenbacher int err; 1668b411b363SPhilipp Reisner 16690b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1670b411b363SPhilipp Reisner 1671db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1672b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1673b30ab791SAndreas Gruenbacher err = drbd_send_ack(device, P_RS_WRITE_ACK, peer_req); 1674b411b363SPhilipp Reisner } else { 1675b411b363SPhilipp Reisner /* Record failure to sync */ 1676b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 1677b411b363SPhilipp Reisner 1678b30ab791SAndreas Gruenbacher err = drbd_send_ack(device, P_NEG_ACK, peer_req); 1679b411b363SPhilipp Reisner } 1680b30ab791SAndreas Gruenbacher dec_unacked(device); 1681b411b363SPhilipp Reisner 168299920dc5SAndreas Gruenbacher return err; 1683b411b363SPhilipp Reisner } 1684b411b363SPhilipp Reisner 1685b30ab791SAndreas Gruenbacher static int recv_resync_read(struct drbd_device *device, sector_t sector, int data_size) __releases(local) 1686b411b363SPhilipp Reisner { 1687db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1688b411b363SPhilipp Reisner 1689b30ab791SAndreas Gruenbacher peer_req = read_in_block(device, ID_SYNCER, sector, data_size); 1690db830c46SAndreas Gruenbacher if (!peer_req) 169145bb912bSLars Ellenberg goto fail; 1692b411b363SPhilipp Reisner 1693b30ab791SAndreas Gruenbacher dec_rs_pending(device); 1694b411b363SPhilipp Reisner 1695b30ab791SAndreas Gruenbacher inc_unacked(device); 1696b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1697b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1698b411b363SPhilipp Reisner 1699db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 170045bb912bSLars Ellenberg 17010500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1702b30ab791SAndreas Gruenbacher list_add(&peer_req->w.list, &device->sync_ee); 17030500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1704b411b363SPhilipp Reisner 1705b30ab791SAndreas Gruenbacher atomic_add(data_size >> 9, &device->rs_sect_ev); 1706b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1707e1c1b0fcSAndreas Gruenbacher return 0; 170845bb912bSLars Ellenberg 170910f6d992SLars Ellenberg /* don't care for the reason here */ 1710d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 17110500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1712db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 17130500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 171422cc37a9SLars Ellenberg 1715b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 171645bb912bSLars Ellenberg fail: 1717b30ab791SAndreas Gruenbacher put_ldev(device); 1718e1c1b0fcSAndreas Gruenbacher return -EIO; 1719b411b363SPhilipp Reisner } 1720b411b363SPhilipp Reisner 1721668eebc6SAndreas Gruenbacher static struct drbd_request * 1722b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 1723bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1724b411b363SPhilipp Reisner { 1725b411b363SPhilipp Reisner struct drbd_request *req; 1726668eebc6SAndreas Gruenbacher 1727bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1728bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17295e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1730668eebc6SAndreas Gruenbacher return req; 1731c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1732d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 1733c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1734c3afd8f5SAndreas Gruenbacher } 1735668eebc6SAndreas Gruenbacher return NULL; 1736668eebc6SAndreas Gruenbacher } 1737668eebc6SAndreas Gruenbacher 1738bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 1739b411b363SPhilipp Reisner { 17409f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1741b30ab791SAndreas Gruenbacher struct drbd_device *device; 1742b411b363SPhilipp Reisner struct drbd_request *req; 1743b411b363SPhilipp Reisner sector_t sector; 174482bc0194SAndreas Gruenbacher int err; 1745e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17464a76b161SAndreas Gruenbacher 17479f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 17489f4fe9adSAndreas Gruenbacher if (!peer_device) 17494a76b161SAndreas Gruenbacher return -EIO; 17509f4fe9adSAndreas Gruenbacher device = peer_device->device; 1751b411b363SPhilipp Reisner 1752b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1753b411b363SPhilipp Reisner 17540500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1755b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 17560500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1757c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 175882bc0194SAndreas Gruenbacher return -EIO; 1759b411b363SPhilipp Reisner 176024c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1761b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1762b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1763b30ab791SAndreas Gruenbacher err = recv_dless_read(device, req, sector, pi->size); 176482bc0194SAndreas Gruenbacher if (!err) 17658554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1766b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1767b411b363SPhilipp Reisner * I don't think we may complete this just yet 1768b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1769b411b363SPhilipp Reisner 177082bc0194SAndreas Gruenbacher return err; 1771b411b363SPhilipp Reisner } 1772b411b363SPhilipp Reisner 1773bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 1774b411b363SPhilipp Reisner { 17759f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1776b30ab791SAndreas Gruenbacher struct drbd_device *device; 1777b411b363SPhilipp Reisner sector_t sector; 177882bc0194SAndreas Gruenbacher int err; 1779e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17804a76b161SAndreas Gruenbacher 17819f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 17829f4fe9adSAndreas Gruenbacher if (!peer_device) 17834a76b161SAndreas Gruenbacher return -EIO; 17849f4fe9adSAndreas Gruenbacher device = peer_device->device; 1785b411b363SPhilipp Reisner 1786b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 17870b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 1788b411b363SPhilipp Reisner 1789b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 1790b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1791b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1792fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1793b30ab791SAndreas Gruenbacher err = recv_resync_read(device, sector, pi->size); 1794b411b363SPhilipp Reisner } else { 1795b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1796d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 1797b411b363SPhilipp Reisner 1798b30ab791SAndreas Gruenbacher err = drbd_drain_block(device, pi->size); 1799b411b363SPhilipp Reisner 1800b30ab791SAndreas Gruenbacher drbd_send_ack_dp(device, P_NEG_ACK, p, pi->size); 1801b411b363SPhilipp Reisner } 1802b411b363SPhilipp Reisner 1803b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 1804778f271dSPhilipp Reisner 180582bc0194SAndreas Gruenbacher return err; 1806b411b363SPhilipp Reisner } 1807b411b363SPhilipp Reisner 1808b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 18097be8da07SAndreas Gruenbacher sector_t sector, int size) 1810b411b363SPhilipp Reisner { 18117be8da07SAndreas Gruenbacher struct drbd_interval *i; 18127be8da07SAndreas Gruenbacher struct drbd_request *req; 1813b411b363SPhilipp Reisner 1814b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 18157be8da07SAndreas Gruenbacher if (!i->local) 18167be8da07SAndreas Gruenbacher continue; 18177be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18187be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18197be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18207be8da07SAndreas Gruenbacher continue; 18212312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18222312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1823d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 18247be8da07SAndreas Gruenbacher } 18257be8da07SAndreas Gruenbacher } 18267be8da07SAndreas Gruenbacher 1827a990be46SAndreas Gruenbacher /* 1828a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1829b411b363SPhilipp Reisner */ 183099920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1831b411b363SPhilipp Reisner { 18328050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18338050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1834b30ab791SAndreas Gruenbacher struct drbd_device *device = w->device; 1835db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 183699920dc5SAndreas Gruenbacher int err = 0, pcmd; 1837b411b363SPhilipp Reisner 1838303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1839db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1840b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 1841b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 1842db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1843b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1844b30ab791SAndreas Gruenbacher err = drbd_send_ack(device, pcmd, peer_req); 1845b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1846b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1847b411b363SPhilipp Reisner } else { 1848b30ab791SAndreas Gruenbacher err = drbd_send_ack(device, P_NEG_ACK, peer_req); 1849b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1850b411b363SPhilipp Reisner * maybe assert this? */ 1851b411b363SPhilipp Reisner } 1852b30ab791SAndreas Gruenbacher dec_unacked(device); 1853b411b363SPhilipp Reisner } 1854b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1855b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1856302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 18570500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 18580b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 1859b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 18607be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 1861b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 18620500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1863bb3bfe96SAndreas Gruenbacher } else 18640b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1865b411b363SPhilipp Reisner 1866a6b32bc3SAndreas Gruenbacher drbd_may_finish_epoch(first_peer_device(device)->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1867b411b363SPhilipp Reisner 186899920dc5SAndreas Gruenbacher return err; 1869b411b363SPhilipp Reisner } 1870b411b363SPhilipp Reisner 18717be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1872b411b363SPhilipp Reisner { 1873b30ab791SAndreas Gruenbacher struct drbd_device *device = w->device; 18748050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18758050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 187699920dc5SAndreas Gruenbacher int err; 1877b411b363SPhilipp Reisner 1878b30ab791SAndreas Gruenbacher err = drbd_send_ack(device, ack, peer_req); 1879b30ab791SAndreas Gruenbacher dec_unacked(device); 1880b411b363SPhilipp Reisner 188199920dc5SAndreas Gruenbacher return err; 1882b411b363SPhilipp Reisner } 1883b411b363SPhilipp Reisner 1884d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 1885b6a370baSPhilipp Reisner { 1886d4dabbe2SLars Ellenberg return e_send_ack(w, P_SUPERSEDED); 18877be8da07SAndreas Gruenbacher } 1888b6a370baSPhilipp Reisner 188999920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18907be8da07SAndreas Gruenbacher { 1891a6b32bc3SAndreas Gruenbacher struct drbd_connection *connection = first_peer_device(w->device)->connection; 18927be8da07SAndreas Gruenbacher 1893bde89a9eSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 1894d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 18957be8da07SAndreas Gruenbacher } 18967be8da07SAndreas Gruenbacher 18973e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18983e394da1SAndreas Gruenbacher { 18993e394da1SAndreas Gruenbacher /* 19003e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 19013e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 19023e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 19033e394da1SAndreas Gruenbacher */ 19043e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 19053e394da1SAndreas Gruenbacher } 19063e394da1SAndreas Gruenbacher 19073e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 19083e394da1SAndreas Gruenbacher { 19093e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 19103e394da1SAndreas Gruenbacher } 19113e394da1SAndreas Gruenbacher 1912b30ab791SAndreas Gruenbacher static void update_peer_seq(struct drbd_device *device, unsigned int peer_seq) 19133e394da1SAndreas Gruenbacher { 19143c13b680SLars Ellenberg unsigned int newest_peer_seq; 19153e394da1SAndreas Gruenbacher 1916a6b32bc3SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &first_peer_device(device)->connection->flags)) { 1917b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 1918b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 1919b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 1920b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 1921b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 19223c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 1923b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 19243e394da1SAndreas Gruenbacher } 19257be8da07SAndreas Gruenbacher } 19263e394da1SAndreas Gruenbacher 1927d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1928d93f6302SLars Ellenberg { 1929d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1930d93f6302SLars Ellenberg } 1931d93f6302SLars Ellenberg 1932d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 1933b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 1934d93f6302SLars Ellenberg { 1935d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1936b6a370baSPhilipp Reisner bool rv = 0; 1937b6a370baSPhilipp Reisner 19380500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1939b30ab791SAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 1940d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1941d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 1942b6a370baSPhilipp Reisner rv = 1; 1943b6a370baSPhilipp Reisner break; 1944b6a370baSPhilipp Reisner } 1945b6a370baSPhilipp Reisner } 19460500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1947b6a370baSPhilipp Reisner 1948b6a370baSPhilipp Reisner return rv; 1949b6a370baSPhilipp Reisner } 1950b6a370baSPhilipp Reisner 1951b411b363SPhilipp Reisner /* Called from receive_Data. 1952b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1953b411b363SPhilipp Reisner * 1954b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1955b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1956b411b363SPhilipp Reisner * been sent. 1957b411b363SPhilipp Reisner * 1958b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1959b411b363SPhilipp Reisner * 1960b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 1961b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1962b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 1963b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1964b411b363SPhilipp Reisner * 1965b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1966b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1967b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1968b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1969b411b363SPhilipp Reisner * 1970b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1971b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 1972b30ab791SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_device *device, const u32 peer_seq) 1973b411b363SPhilipp Reisner { 1974b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1975b411b363SPhilipp Reisner long timeout; 1976b874d231SPhilipp Reisner int ret = 0, tp; 19777be8da07SAndreas Gruenbacher 1978a6b32bc3SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &first_peer_device(device)->connection->flags)) 19797be8da07SAndreas Gruenbacher return 0; 19807be8da07SAndreas Gruenbacher 1981b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 1982b411b363SPhilipp Reisner for (;;) { 1983b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 1984b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 1985b411b363SPhilipp Reisner break; 19867be8da07SAndreas Gruenbacher } 1987b874d231SPhilipp Reisner 1988b411b363SPhilipp Reisner if (signal_pending(current)) { 1989b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1990b411b363SPhilipp Reisner break; 1991b411b363SPhilipp Reisner } 1992b874d231SPhilipp Reisner 1993b874d231SPhilipp Reisner rcu_read_lock(); 1994a6b32bc3SAndreas Gruenbacher tp = rcu_dereference(first_peer_device(device)->connection->net_conf)->two_primaries; 1995b874d231SPhilipp Reisner rcu_read_unlock(); 1996b874d231SPhilipp Reisner 1997b874d231SPhilipp Reisner if (!tp) 1998b874d231SPhilipp Reisner break; 1999b874d231SPhilipp Reisner 2000b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2001b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2002b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 200344ed167dSPhilipp Reisner rcu_read_lock(); 2004a6b32bc3SAndreas Gruenbacher timeout = rcu_dereference(first_peer_device(device)->connection->net_conf)->ping_timeo*HZ/10; 200544ed167dSPhilipp Reisner rcu_read_unlock(); 200671b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2007b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 20087be8da07SAndreas Gruenbacher if (!timeout) { 2009b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2010d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2011b411b363SPhilipp Reisner break; 2012b411b363SPhilipp Reisner } 2013b411b363SPhilipp Reisner } 2014b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2015b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2016b411b363SPhilipp Reisner return ret; 2017b411b363SPhilipp Reisner } 2018b411b363SPhilipp Reisner 2019688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2020688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2021688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2022b30ab791SAndreas Gruenbacher static unsigned long wire_flags_to_bio(struct drbd_device *device, u32 dpf) 202376d2e7ecSPhilipp Reisner { 202476d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 202576d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2026688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 202776d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 202876d2e7ecSPhilipp Reisner } 202976d2e7ecSPhilipp Reisner 2030b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 20317be8da07SAndreas Gruenbacher unsigned int size) 2032b411b363SPhilipp Reisner { 20337be8da07SAndreas Gruenbacher struct drbd_interval *i; 20347be8da07SAndreas Gruenbacher 20357be8da07SAndreas Gruenbacher repeat: 2036b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 20377be8da07SAndreas Gruenbacher struct drbd_request *req; 20387be8da07SAndreas Gruenbacher struct bio_and_error m; 20397be8da07SAndreas Gruenbacher 20407be8da07SAndreas Gruenbacher if (!i->local) 20417be8da07SAndreas Gruenbacher continue; 20427be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 20437be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 20447be8da07SAndreas Gruenbacher continue; 20457be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 20467be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 20470500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 20487be8da07SAndreas Gruenbacher if (m.bio) 2049b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 20500500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 20517be8da07SAndreas Gruenbacher goto repeat; 20527be8da07SAndreas Gruenbacher } 20537be8da07SAndreas Gruenbacher } 20547be8da07SAndreas Gruenbacher 2055b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 20567be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 20577be8da07SAndreas Gruenbacher { 2058a6b32bc3SAndreas Gruenbacher struct drbd_connection *connection = first_peer_device(device)->connection; 2059bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 20607be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 20617be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 20627be8da07SAndreas Gruenbacher struct drbd_interval *i; 20637be8da07SAndreas Gruenbacher bool equal; 20647be8da07SAndreas Gruenbacher int err; 20657be8da07SAndreas Gruenbacher 20667be8da07SAndreas Gruenbacher /* 20677be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 20687be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 20697be8da07SAndreas Gruenbacher */ 2070b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 20717be8da07SAndreas Gruenbacher 20727be8da07SAndreas Gruenbacher repeat: 2073b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 20747be8da07SAndreas Gruenbacher if (i == &peer_req->i) 20757be8da07SAndreas Gruenbacher continue; 20767be8da07SAndreas Gruenbacher 20777be8da07SAndreas Gruenbacher if (!i->local) { 20787be8da07SAndreas Gruenbacher /* 20797be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20807be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20817be8da07SAndreas Gruenbacher * earlier peer request to complete. 20827be8da07SAndreas Gruenbacher */ 2083b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 20847be8da07SAndreas Gruenbacher if (err) 20857be8da07SAndreas Gruenbacher goto out; 20867be8da07SAndreas Gruenbacher goto repeat; 20877be8da07SAndreas Gruenbacher } 20887be8da07SAndreas Gruenbacher 20897be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20907be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20917be8da07SAndreas Gruenbacher /* 20927be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2093d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2094d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2095d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 20967be8da07SAndreas Gruenbacher */ 2097d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 20987be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 20997be8da07SAndreas Gruenbacher 21007be8da07SAndreas Gruenbacher if (!equal) 2101d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21027be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 21037be8da07SAndreas Gruenbacher "assuming %s came first\n", 21047be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21057be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2106d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 21077be8da07SAndreas Gruenbacher 2108b30ab791SAndreas Gruenbacher inc_unacked(device); 2109d4dabbe2SLars Ellenberg peer_req->w.cb = superseded ? e_send_superseded : 21107be8da07SAndreas Gruenbacher e_send_retry_write; 2111b30ab791SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2112a6b32bc3SAndreas Gruenbacher wake_asender(first_peer_device(device)->connection); 21137be8da07SAndreas Gruenbacher 21147be8da07SAndreas Gruenbacher err = -ENOENT; 21157be8da07SAndreas Gruenbacher goto out; 21167be8da07SAndreas Gruenbacher } else { 21177be8da07SAndreas Gruenbacher struct drbd_request *req = 21187be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21197be8da07SAndreas Gruenbacher 21207be8da07SAndreas Gruenbacher if (!equal) 2121d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21227be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21237be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21247be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21257be8da07SAndreas Gruenbacher 21267be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21277be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21287be8da07SAndreas Gruenbacher /* 21297be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2130d4dabbe2SLars Ellenberg * decide if this request has been superseded 2131d4dabbe2SLars Ellenberg * or needs to be retried. 2132d4dabbe2SLars Ellenberg * Requests that have been superseded will 21337be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 21347be8da07SAndreas Gruenbacher * 21357be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 21367be8da07SAndreas Gruenbacher * request to finish locally before submitting 21377be8da07SAndreas Gruenbacher * the conflicting peer request. 21387be8da07SAndreas Gruenbacher */ 2139b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 21407be8da07SAndreas Gruenbacher if (err) { 2141a6b32bc3SAndreas Gruenbacher _conn_request_state(first_peer_device(device)->connection, 21427be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 21437be8da07SAndreas Gruenbacher CS_HARD); 2144b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 21457be8da07SAndreas Gruenbacher goto out; 21467be8da07SAndreas Gruenbacher } 21477be8da07SAndreas Gruenbacher goto repeat; 21487be8da07SAndreas Gruenbacher } 21497be8da07SAndreas Gruenbacher /* 21507be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 21517be8da07SAndreas Gruenbacher * the new peer request has completed. 21527be8da07SAndreas Gruenbacher */ 21537be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 21547be8da07SAndreas Gruenbacher } 21557be8da07SAndreas Gruenbacher } 21567be8da07SAndreas Gruenbacher err = 0; 21577be8da07SAndreas Gruenbacher 21587be8da07SAndreas Gruenbacher out: 21597be8da07SAndreas Gruenbacher if (err) 2160b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 21617be8da07SAndreas Gruenbacher return err; 21627be8da07SAndreas Gruenbacher } 21637be8da07SAndreas Gruenbacher 2164b411b363SPhilipp Reisner /* mirrored write */ 2165bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2166b411b363SPhilipp Reisner { 21679f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2168b30ab791SAndreas Gruenbacher struct drbd_device *device; 2169b411b363SPhilipp Reisner sector_t sector; 2170db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2171e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21727be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2173b411b363SPhilipp Reisner int rw = WRITE; 2174b411b363SPhilipp Reisner u32 dp_flags; 2175302bdeaeSPhilipp Reisner int err, tp; 21767be8da07SAndreas Gruenbacher 21779f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 21789f4fe9adSAndreas Gruenbacher if (!peer_device) 21794a76b161SAndreas Gruenbacher return -EIO; 21809f4fe9adSAndreas Gruenbacher device = peer_device->device; 2181b411b363SPhilipp Reisner 2182b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 218382bc0194SAndreas Gruenbacher int err2; 2184b411b363SPhilipp Reisner 2185b30ab791SAndreas Gruenbacher err = wait_for_and_update_peer_seq(device, peer_seq); 2186b30ab791SAndreas Gruenbacher drbd_send_ack_dp(device, P_NEG_ACK, p, pi->size); 2187bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 2188b30ab791SAndreas Gruenbacher err2 = drbd_drain_block(device, pi->size); 218982bc0194SAndreas Gruenbacher if (!err) 219082bc0194SAndreas Gruenbacher err = err2; 219182bc0194SAndreas Gruenbacher return err; 2192b411b363SPhilipp Reisner } 2193b411b363SPhilipp Reisner 2194fcefa62eSAndreas Gruenbacher /* 2195fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2196fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2197fcefa62eSAndreas Gruenbacher * end of this function. 2198fcefa62eSAndreas Gruenbacher */ 2199b411b363SPhilipp Reisner 2200b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2201b30ab791SAndreas Gruenbacher peer_req = read_in_block(device, p->block_id, sector, pi->size); 2202db830c46SAndreas Gruenbacher if (!peer_req) { 2203b30ab791SAndreas Gruenbacher put_ldev(device); 220482bc0194SAndreas Gruenbacher return -EIO; 2205b411b363SPhilipp Reisner } 2206b411b363SPhilipp Reisner 2207db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2208b411b363SPhilipp Reisner 2209688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2210b30ab791SAndreas Gruenbacher rw |= wire_flags_to_bio(device, dp_flags); 221181a3537aSLars Ellenberg if (peer_req->pages == NULL) { 22120b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 22130b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2214a73ff323SLars Ellenberg } 2215688593c5SLars Ellenberg 2216688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2217db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2218688593c5SLars Ellenberg 2219bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2220bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2221db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2222db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2223bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2224b411b363SPhilipp Reisner 2225302bdeaeSPhilipp Reisner rcu_read_lock(); 22269f4fe9adSAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2227302bdeaeSPhilipp Reisner rcu_read_unlock(); 2228302bdeaeSPhilipp Reisner if (tp) { 2229302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 2230b30ab791SAndreas Gruenbacher err = wait_for_and_update_peer_seq(device, peer_seq); 22317be8da07SAndreas Gruenbacher if (err) 2232b411b363SPhilipp Reisner goto out_interrupted; 22330500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2234b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 22357be8da07SAndreas Gruenbacher if (err) { 22360500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 22377be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2238b30ab791SAndreas Gruenbacher put_ldev(device); 223982bc0194SAndreas Gruenbacher return 0; 2240b411b363SPhilipp Reisner } 2241b411b363SPhilipp Reisner goto out_interrupted; 2242b411b363SPhilipp Reisner } 2243b874d231SPhilipp Reisner } else { 2244b30ab791SAndreas Gruenbacher update_peer_seq(device, peer_seq); 22450500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2246b874d231SPhilipp Reisner } 2247b30ab791SAndreas Gruenbacher list_add(&peer_req->w.list, &device->active_ee); 22480500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2249b411b363SPhilipp Reisner 2250b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2251b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2252b6a370baSPhilipp Reisner 22539f4fe9adSAndreas Gruenbacher if (peer_device->connection->agreed_pro_version < 100) { 225444ed167dSPhilipp Reisner rcu_read_lock(); 22559f4fe9adSAndreas Gruenbacher switch (rcu_dereference(peer_device->connection->net_conf)->wire_protocol) { 2256b411b363SPhilipp Reisner case DRBD_PROT_C: 2257303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2258303d1448SPhilipp Reisner break; 2259303d1448SPhilipp Reisner case DRBD_PROT_B: 2260303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2261303d1448SPhilipp Reisner break; 2262303d1448SPhilipp Reisner } 226344ed167dSPhilipp Reisner rcu_read_unlock(); 2264303d1448SPhilipp Reisner } 2265303d1448SPhilipp Reisner 2266303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2267303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2268b30ab791SAndreas Gruenbacher inc_unacked(device); 2269b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2270b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2271303d1448SPhilipp Reisner } 2272303d1448SPhilipp Reisner 2273303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2274b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2275b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2276b30ab791SAndreas Gruenbacher drbd_send_ack(device, P_RECV_ACK, peer_req); 2277b411b363SPhilipp Reisner } 2278b411b363SPhilipp Reisner 2279b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2280b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2281b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2282db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2283db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2284b30ab791SAndreas Gruenbacher drbd_al_begin_io(device, &peer_req->i, true); 2285b411b363SPhilipp Reisner } 2286b411b363SPhilipp Reisner 2287b30ab791SAndreas Gruenbacher err = drbd_submit_peer_request(device, peer_req, rw, DRBD_FAULT_DT_WR); 228882bc0194SAndreas Gruenbacher if (!err) 228982bc0194SAndreas Gruenbacher return 0; 2290b411b363SPhilipp Reisner 229110f6d992SLars Ellenberg /* don't care for the reason here */ 2292d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 22930500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2294db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2295b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 22960500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2297db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2298b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 229922cc37a9SLars Ellenberg 2300b411b363SPhilipp Reisner out_interrupted: 2301bde89a9eSAndreas Gruenbacher drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT + EV_CLEANUP); 2302b30ab791SAndreas Gruenbacher put_ldev(device); 2303b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 230482bc0194SAndreas Gruenbacher return err; 2305b411b363SPhilipp Reisner } 2306b411b363SPhilipp Reisner 23070f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 23080f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 23090f0601f4SLars Ellenberg * 23100f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 23110f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 23120f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 23130f0601f4SLars Ellenberg * activity, it obviously is "busy". 23140f0601f4SLars Ellenberg * 23150f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 23160f0601f4SLars Ellenberg * to have a short time average so we can react faster. 23170f0601f4SLars Ellenberg */ 2318b30ab791SAndreas Gruenbacher int drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector) 23190f0601f4SLars Ellenberg { 2320b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 23210f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2322e3555d85SPhilipp Reisner struct lc_element *tmp; 23230f0601f4SLars Ellenberg int curr_events; 23240f0601f4SLars Ellenberg int throttle = 0; 2325daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2326daeda1ccSPhilipp Reisner 2327daeda1ccSPhilipp Reisner rcu_read_lock(); 2328b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2329daeda1ccSPhilipp Reisner rcu_read_unlock(); 23300f0601f4SLars Ellenberg 23310f0601f4SLars Ellenberg /* feature disabled? */ 2332daeda1ccSPhilipp Reisner if (c_min_rate == 0) 23330f0601f4SLars Ellenberg return 0; 23340f0601f4SLars Ellenberg 2335b30ab791SAndreas Gruenbacher spin_lock_irq(&device->al_lock); 2336b30ab791SAndreas Gruenbacher tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2337e3555d85SPhilipp Reisner if (tmp) { 2338e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2339e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2340b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->al_lock); 2341e3555d85SPhilipp Reisner return 0; 2342e3555d85SPhilipp Reisner } 2343e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2344e3555d85SPhilipp Reisner } 2345b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->al_lock); 2346e3555d85SPhilipp Reisner 23470f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 23480f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2349b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2350e3555d85SPhilipp Reisner 2351b30ab791SAndreas Gruenbacher if (!device->rs_last_events || curr_events - device->rs_last_events > 64) { 23520f0601f4SLars Ellenberg unsigned long rs_left; 23530f0601f4SLars Ellenberg int i; 23540f0601f4SLars Ellenberg 2355b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 23560f0601f4SLars Ellenberg 23570f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 23580f0601f4SLars Ellenberg * approx. */ 2359b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 23602649f080SLars Ellenberg 2361b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2362b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 23632649f080SLars Ellenberg else 2364b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 23650f0601f4SLars Ellenberg 2366b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 23670f0601f4SLars Ellenberg if (!dt) 23680f0601f4SLars Ellenberg dt++; 2369b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 23700f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 23710f0601f4SLars Ellenberg 2372daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 23730f0601f4SLars Ellenberg throttle = 1; 23740f0601f4SLars Ellenberg } 23750f0601f4SLars Ellenberg return throttle; 23760f0601f4SLars Ellenberg } 23770f0601f4SLars Ellenberg 23780f0601f4SLars Ellenberg 2379bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2380b411b363SPhilipp Reisner { 23819f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2382b30ab791SAndreas Gruenbacher struct drbd_device *device; 2383b411b363SPhilipp Reisner sector_t sector; 23844a76b161SAndreas Gruenbacher sector_t capacity; 2385db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2386b411b363SPhilipp Reisner struct digest_info *di = NULL; 2387b18b37beSPhilipp Reisner int size, verb; 2388b411b363SPhilipp Reisner unsigned int fault_type; 2389e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 23904a76b161SAndreas Gruenbacher 23919f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 23929f4fe9adSAndreas Gruenbacher if (!peer_device) 23934a76b161SAndreas Gruenbacher return -EIO; 23949f4fe9adSAndreas Gruenbacher device = peer_device->device; 2395b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2396b411b363SPhilipp Reisner 2397b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2398b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2399b411b363SPhilipp Reisner 2400c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2401d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2402b411b363SPhilipp Reisner (unsigned long long)sector, size); 240382bc0194SAndreas Gruenbacher return -EINVAL; 2404b411b363SPhilipp Reisner } 2405b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2406d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2407b411b363SPhilipp Reisner (unsigned long long)sector, size); 240882bc0194SAndreas Gruenbacher return -EINVAL; 2409b411b363SPhilipp Reisner } 2410b411b363SPhilipp Reisner 2411b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2412b18b37beSPhilipp Reisner verb = 1; 2413e2857216SAndreas Gruenbacher switch (pi->cmd) { 2414b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2415b30ab791SAndreas Gruenbacher drbd_send_ack_rp(device, P_NEG_DREPLY, p); 2416b18b37beSPhilipp Reisner break; 2417b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2418b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2419b18b37beSPhilipp Reisner case P_OV_REQUEST: 2420b30ab791SAndreas Gruenbacher drbd_send_ack_rp(device, P_NEG_RS_DREPLY , p); 2421b18b37beSPhilipp Reisner break; 2422b18b37beSPhilipp Reisner case P_OV_REPLY: 2423b18b37beSPhilipp Reisner verb = 0; 2424b30ab791SAndreas Gruenbacher dec_rs_pending(device); 2425b30ab791SAndreas Gruenbacher drbd_send_ack_ex(device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2426b18b37beSPhilipp Reisner break; 2427b18b37beSPhilipp Reisner default: 242849ba9b1bSAndreas Gruenbacher BUG(); 2429b18b37beSPhilipp Reisner } 2430b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2431d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2432b411b363SPhilipp Reisner "no local data.\n"); 2433b18b37beSPhilipp Reisner 2434a821cc4aSLars Ellenberg /* drain possibly payload */ 2435b30ab791SAndreas Gruenbacher return drbd_drain_block(device, pi->size); 2436b411b363SPhilipp Reisner } 2437b411b363SPhilipp Reisner 2438b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2439b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2440b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2441b30ab791SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(device, p->block_id, sector, size, GFP_NOIO); 2442db830c46SAndreas Gruenbacher if (!peer_req) { 2443b30ab791SAndreas Gruenbacher put_ldev(device); 244482bc0194SAndreas Gruenbacher return -ENOMEM; 2445b411b363SPhilipp Reisner } 2446b411b363SPhilipp Reisner 2447e2857216SAndreas Gruenbacher switch (pi->cmd) { 2448b411b363SPhilipp Reisner case P_DATA_REQUEST: 2449db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2450b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 245180a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 245280a40e43SLars Ellenberg goto submit; 245380a40e43SLars Ellenberg 2454b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2455db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2456b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 24575f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2458b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2459b411b363SPhilipp Reisner break; 2460b411b363SPhilipp Reisner 2461b411b363SPhilipp Reisner case P_OV_REPLY: 2462b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2463b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2464e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2465b411b363SPhilipp Reisner if (!di) 2466b411b363SPhilipp Reisner goto out_free_e; 2467b411b363SPhilipp Reisner 2468e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2469b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2470b411b363SPhilipp Reisner 2471db830c46SAndreas Gruenbacher peer_req->digest = di; 2472db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2473c36c3cedSLars Ellenberg 24749f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2475b411b363SPhilipp Reisner goto out_free_e; 2476b411b363SPhilipp Reisner 2477e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 24789f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2479db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 24805f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2481b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2482e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 24832649f080SLars Ellenberg /* track progress, we may need to throttle */ 2484b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2485db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2486b30ab791SAndreas Gruenbacher dec_rs_pending(device); 24870f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 24880f0601f4SLars Ellenberg * but accounting still needs to be done. */ 24890f0601f4SLars Ellenberg goto submit_for_resync; 2490b411b363SPhilipp Reisner } 2491b411b363SPhilipp Reisner break; 2492b411b363SPhilipp Reisner 2493b411b363SPhilipp Reisner case P_OV_REQUEST: 2494b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 24959f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2496de228bbaSLars Ellenberg unsigned long now = jiffies; 2497de228bbaSLars Ellenberg int i; 2498b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2499b30ab791SAndreas Gruenbacher device->ov_position = sector; 2500b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2501b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2502de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2503b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2504b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2505de228bbaSLars Ellenberg } 2506d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2507b411b363SPhilipp Reisner (unsigned long long)sector); 2508b411b363SPhilipp Reisner } 2509db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2510b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2511b411b363SPhilipp Reisner break; 2512b411b363SPhilipp Reisner 2513b411b363SPhilipp Reisner default: 251449ba9b1bSAndreas Gruenbacher BUG(); 2515b411b363SPhilipp Reisner } 2516b411b363SPhilipp Reisner 25170f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 25180f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 25190f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 25200f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 25210f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 25220f0601f4SLars Ellenberg * 25230f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 25240f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 25250f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 25260f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 25270f0601f4SLars Ellenberg * a while, anyways. 25280f0601f4SLars Ellenberg */ 2529b411b363SPhilipp Reisner 25300f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 25310f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 25320f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 25330f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 25340f0601f4SLars Ellenberg * 25350f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 25360f0601f4SLars Ellenberg * we would also throttle its application reads. 25370f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 25380f0601f4SLars Ellenberg */ 2539b30ab791SAndreas Gruenbacher if (device->state.peer != R_PRIMARY && drbd_rs_should_slow_down(device, sector)) 2540e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2541b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 254280a40e43SLars Ellenberg goto out_free_e; 2543b411b363SPhilipp Reisner 25440f0601f4SLars Ellenberg submit_for_resync: 2545b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 25460f0601f4SLars Ellenberg 254780a40e43SLars Ellenberg submit: 2548b30ab791SAndreas Gruenbacher inc_unacked(device); 25490500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2550b30ab791SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->read_ee); 25510500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2552b411b363SPhilipp Reisner 2553b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, READ, fault_type) == 0) 255482bc0194SAndreas Gruenbacher return 0; 2555b411b363SPhilipp Reisner 255610f6d992SLars Ellenberg /* don't care for the reason here */ 2557d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 25580500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2559db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 25600500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 256122cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 256222cc37a9SLars Ellenberg 2563b411b363SPhilipp Reisner out_free_e: 2564b30ab791SAndreas Gruenbacher put_ldev(device); 2565b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 256682bc0194SAndreas Gruenbacher return -EIO; 2567b411b363SPhilipp Reisner } 2568b411b363SPhilipp Reisner 2569b30ab791SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_device *device) __must_hold(local) 2570b411b363SPhilipp Reisner { 2571b411b363SPhilipp Reisner int self, peer, rv = -100; 2572b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 257344ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2574b411b363SPhilipp Reisner 2575b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2576b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2577b411b363SPhilipp Reisner 2578b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2579b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2580b411b363SPhilipp Reisner 258144ed167dSPhilipp Reisner rcu_read_lock(); 2582a6b32bc3SAndreas Gruenbacher after_sb_0p = rcu_dereference(first_peer_device(device)->connection->net_conf)->after_sb_0p; 258344ed167dSPhilipp Reisner rcu_read_unlock(); 258444ed167dSPhilipp Reisner switch (after_sb_0p) { 2585b411b363SPhilipp Reisner case ASB_CONSENSUS: 2586b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2587b411b363SPhilipp Reisner case ASB_CALL_HELPER: 258844ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2589d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2590b411b363SPhilipp Reisner break; 2591b411b363SPhilipp Reisner case ASB_DISCONNECT: 2592b411b363SPhilipp Reisner break; 2593b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2594b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2595b411b363SPhilipp Reisner rv = -1; 2596b411b363SPhilipp Reisner break; 2597b411b363SPhilipp Reisner } 2598b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2599b411b363SPhilipp Reisner rv = 1; 2600b411b363SPhilipp Reisner break; 2601b411b363SPhilipp Reisner } 2602b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2603b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2604b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2605b411b363SPhilipp Reisner rv = 1; 2606b411b363SPhilipp Reisner break; 2607b411b363SPhilipp Reisner } 2608b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2609b411b363SPhilipp Reisner rv = -1; 2610b411b363SPhilipp Reisner break; 2611b411b363SPhilipp Reisner } 2612b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2613d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 2614b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2615b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2616b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 2617a6b32bc3SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &first_peer_device(device)->connection->flags) 2618b411b363SPhilipp Reisner ? -1 : 1; 2619b411b363SPhilipp Reisner break; 2620b411b363SPhilipp Reisner } else { 2621b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2622b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2623b411b363SPhilipp Reisner } 262444ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2625b411b363SPhilipp Reisner break; 2626b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2627b411b363SPhilipp Reisner if (ch_self < ch_peer) 2628b411b363SPhilipp Reisner rv = -1; 2629b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2630b411b363SPhilipp Reisner rv = 1; 2631b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2632b411b363SPhilipp Reisner /* Well, then use something else. */ 2633a6b32bc3SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &first_peer_device(device)->connection->flags) 2634b411b363SPhilipp Reisner ? -1 : 1; 2635b411b363SPhilipp Reisner break; 2636b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2637b411b363SPhilipp Reisner rv = -1; 2638b411b363SPhilipp Reisner break; 2639b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2640b411b363SPhilipp Reisner rv = 1; 2641b411b363SPhilipp Reisner } 2642b411b363SPhilipp Reisner 2643b411b363SPhilipp Reisner return rv; 2644b411b363SPhilipp Reisner } 2645b411b363SPhilipp Reisner 2646b30ab791SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_device *device) __must_hold(local) 2647b411b363SPhilipp Reisner { 26486184ea21SAndreas Gruenbacher int hg, rv = -100; 264944ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2650b411b363SPhilipp Reisner 265144ed167dSPhilipp Reisner rcu_read_lock(); 2652a6b32bc3SAndreas Gruenbacher after_sb_1p = rcu_dereference(first_peer_device(device)->connection->net_conf)->after_sb_1p; 265344ed167dSPhilipp Reisner rcu_read_unlock(); 265444ed167dSPhilipp Reisner switch (after_sb_1p) { 2655b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2656b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2657b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2658b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2659b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 266044ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2661d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2662b411b363SPhilipp Reisner break; 2663b411b363SPhilipp Reisner case ASB_DISCONNECT: 2664b411b363SPhilipp Reisner break; 2665b411b363SPhilipp Reisner case ASB_CONSENSUS: 2666b30ab791SAndreas Gruenbacher hg = drbd_asb_recover_0p(device); 2667b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 2668b411b363SPhilipp Reisner rv = hg; 2669b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 2670b411b363SPhilipp Reisner rv = hg; 2671b411b363SPhilipp Reisner break; 2672b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2673b30ab791SAndreas Gruenbacher rv = drbd_asb_recover_0p(device); 2674b411b363SPhilipp Reisner break; 2675b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2676b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 2677b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2678b30ab791SAndreas Gruenbacher hg = drbd_asb_recover_0p(device); 2679b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 2680bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2681bb437946SAndreas Gruenbacher 2682b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2683b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2684b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2685b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2686bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2687b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2688b411b363SPhilipp Reisner } else { 2689d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2690b411b363SPhilipp Reisner rv = hg; 2691b411b363SPhilipp Reisner } 2692b411b363SPhilipp Reisner } else 2693b411b363SPhilipp Reisner rv = hg; 2694b411b363SPhilipp Reisner } 2695b411b363SPhilipp Reisner 2696b411b363SPhilipp Reisner return rv; 2697b411b363SPhilipp Reisner } 2698b411b363SPhilipp Reisner 2699b30ab791SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_device *device) __must_hold(local) 2700b411b363SPhilipp Reisner { 27016184ea21SAndreas Gruenbacher int hg, rv = -100; 270244ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2703b411b363SPhilipp Reisner 270444ed167dSPhilipp Reisner rcu_read_lock(); 2705a6b32bc3SAndreas Gruenbacher after_sb_2p = rcu_dereference(first_peer_device(device)->connection->net_conf)->after_sb_2p; 270644ed167dSPhilipp Reisner rcu_read_unlock(); 270744ed167dSPhilipp Reisner switch (after_sb_2p) { 2708b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2709b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2710b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2711b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2712b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2713b411b363SPhilipp Reisner case ASB_CONSENSUS: 2714b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 271544ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2716d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2717b411b363SPhilipp Reisner break; 2718b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2719b30ab791SAndreas Gruenbacher rv = drbd_asb_recover_0p(device); 2720b411b363SPhilipp Reisner break; 2721b411b363SPhilipp Reisner case ASB_DISCONNECT: 2722b411b363SPhilipp Reisner break; 2723b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2724b30ab791SAndreas Gruenbacher hg = drbd_asb_recover_0p(device); 2725b411b363SPhilipp Reisner if (hg == -1) { 2726bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2727bb437946SAndreas Gruenbacher 2728b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2729b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2730b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2731b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2732bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2733b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2734b411b363SPhilipp Reisner } else { 2735d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2736b411b363SPhilipp Reisner rv = hg; 2737b411b363SPhilipp Reisner } 2738b411b363SPhilipp Reisner } else 2739b411b363SPhilipp Reisner rv = hg; 2740b411b363SPhilipp Reisner } 2741b411b363SPhilipp Reisner 2742b411b363SPhilipp Reisner return rv; 2743b411b363SPhilipp Reisner } 2744b411b363SPhilipp Reisner 2745b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 2746b411b363SPhilipp Reisner u64 bits, u64 flags) 2747b411b363SPhilipp Reisner { 2748b411b363SPhilipp Reisner if (!uuid) { 2749d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 2750b411b363SPhilipp Reisner return; 2751b411b363SPhilipp Reisner } 2752d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2753b411b363SPhilipp Reisner text, 2754b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2755b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2756b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2757b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2758b411b363SPhilipp Reisner (unsigned long long)bits, 2759b411b363SPhilipp Reisner (unsigned long long)flags); 2760b411b363SPhilipp Reisner } 2761b411b363SPhilipp Reisner 2762b411b363SPhilipp Reisner /* 2763b411b363SPhilipp Reisner 100 after split brain try auto recover 2764b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2765b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2766b411b363SPhilipp Reisner 0 no Sync 2767b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2768b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2769b411b363SPhilipp Reisner -100 after split brain, disconnect 2770b411b363SPhilipp Reisner -1000 unrelated data 27714a23f264SPhilipp Reisner -1091 requires proto 91 27724a23f264SPhilipp Reisner -1096 requires proto 96 2773b411b363SPhilipp Reisner */ 2774b30ab791SAndreas Gruenbacher static int drbd_uuid_compare(struct drbd_device *device, int *rule_nr) __must_hold(local) 2775b411b363SPhilipp Reisner { 2776b411b363SPhilipp Reisner u64 self, peer; 2777b411b363SPhilipp Reisner int i, j; 2778b411b363SPhilipp Reisner 2779b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2780b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2781b411b363SPhilipp Reisner 2782b411b363SPhilipp Reisner *rule_nr = 10; 2783b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2784b411b363SPhilipp Reisner return 0; 2785b411b363SPhilipp Reisner 2786b411b363SPhilipp Reisner *rule_nr = 20; 2787b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2788b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2789b411b363SPhilipp Reisner return -2; 2790b411b363SPhilipp Reisner 2791b411b363SPhilipp Reisner *rule_nr = 30; 2792b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2793b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2794b411b363SPhilipp Reisner return 2; 2795b411b363SPhilipp Reisner 2796b411b363SPhilipp Reisner if (self == peer) { 2797b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2798b411b363SPhilipp Reisner 2799b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2800b411b363SPhilipp Reisner 2801a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 28024a23f264SPhilipp Reisner return -1091; 2803b411b363SPhilipp Reisner 2804b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2805b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2806d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2807b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 2808b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 2809b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 2810b411b363SPhilipp Reisner 2811b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 2812b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 2813b411b363SPhilipp Reisner *rule_nr = 34; 2814b411b363SPhilipp Reisner } else { 2815d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 2816b411b363SPhilipp Reisner *rule_nr = 36; 2817b411b363SPhilipp Reisner } 2818b411b363SPhilipp Reisner 2819b411b363SPhilipp Reisner return 1; 2820b411b363SPhilipp Reisner } 2821b411b363SPhilipp Reisner 2822b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 2823b411b363SPhilipp Reisner 2824a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 28254a23f264SPhilipp Reisner return -1091; 2826b411b363SPhilipp Reisner 2827b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 2828b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2829d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2830b411b363SPhilipp Reisner 2831b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 2832b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 2833b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 2834b411b363SPhilipp Reisner 2835b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 2836b411b363SPhilipp Reisner *rule_nr = 35; 2837b411b363SPhilipp Reisner } else { 2838d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 2839b411b363SPhilipp Reisner *rule_nr = 37; 2840b411b363SPhilipp Reisner } 2841b411b363SPhilipp Reisner 2842b411b363SPhilipp Reisner return -1; 2843b411b363SPhilipp Reisner } 2844b411b363SPhilipp Reisner 2845b411b363SPhilipp Reisner /* Common power [off|failure] */ 2846b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 2847b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 2848b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2849b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2850b411b363SPhilipp Reisner *rule_nr = 40; 2851b411b363SPhilipp Reisner 2852b411b363SPhilipp Reisner switch (rct) { 2853b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2854b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2855b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2856b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2857a6b32bc3SAndreas Gruenbacher dc = test_bit(RESOLVE_CONFLICTS, &first_peer_device(device)->connection->flags); 2858b411b363SPhilipp Reisner return dc ? -1 : 1; 2859b411b363SPhilipp Reisner } 2860b411b363SPhilipp Reisner } 2861b411b363SPhilipp Reisner 2862b411b363SPhilipp Reisner *rule_nr = 50; 2863b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 2864b411b363SPhilipp Reisner if (self == peer) 2865b411b363SPhilipp Reisner return -1; 2866b411b363SPhilipp Reisner 2867b411b363SPhilipp Reisner *rule_nr = 51; 2868b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 2869b411b363SPhilipp Reisner if (self == peer) { 2870a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 96 ? 2871b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 2872b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 2873b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 2874b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2875b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2876b411b363SPhilipp Reisner 2877a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 28784a23f264SPhilipp Reisner return -1091; 2879b411b363SPhilipp Reisner 2880b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 2881b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 28824a23f264SPhilipp Reisner 2883d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 2884b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 28854a23f264SPhilipp Reisner 2886b411b363SPhilipp Reisner return -1; 2887b411b363SPhilipp Reisner } 2888b411b363SPhilipp Reisner } 2889b411b363SPhilipp Reisner 2890b411b363SPhilipp Reisner *rule_nr = 60; 2891b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2892b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2893b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 2894b411b363SPhilipp Reisner if (self == peer) 2895b411b363SPhilipp Reisner return -2; 2896b411b363SPhilipp Reisner } 2897b411b363SPhilipp Reisner 2898b411b363SPhilipp Reisner *rule_nr = 70; 2899b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2900b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2901b411b363SPhilipp Reisner if (self == peer) 2902b411b363SPhilipp Reisner return 1; 2903b411b363SPhilipp Reisner 2904b411b363SPhilipp Reisner *rule_nr = 71; 2905b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2906b411b363SPhilipp Reisner if (self == peer) { 2907a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 96 ? 2908b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 2909b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 2910b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2911b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2912b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2913b411b363SPhilipp Reisner 2914a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 29154a23f264SPhilipp Reisner return -1091; 2916b411b363SPhilipp Reisner 2917b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 2918b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 2919b411b363SPhilipp Reisner 2920d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 2921b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 2922b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 2923b411b363SPhilipp Reisner 2924b411b363SPhilipp Reisner return 1; 2925b411b363SPhilipp Reisner } 2926b411b363SPhilipp Reisner } 2927b411b363SPhilipp Reisner 2928b411b363SPhilipp Reisner 2929b411b363SPhilipp Reisner *rule_nr = 80; 2930b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2931b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2932b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 2933b411b363SPhilipp Reisner if (self == peer) 2934b411b363SPhilipp Reisner return 2; 2935b411b363SPhilipp Reisner } 2936b411b363SPhilipp Reisner 2937b411b363SPhilipp Reisner *rule_nr = 90; 2938b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2939b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 2940b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2941b411b363SPhilipp Reisner return 100; 2942b411b363SPhilipp Reisner 2943b411b363SPhilipp Reisner *rule_nr = 100; 2944b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2945b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 2946b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2947b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 2948b411b363SPhilipp Reisner if (self == peer) 2949b411b363SPhilipp Reisner return -100; 2950b411b363SPhilipp Reisner } 2951b411b363SPhilipp Reisner } 2952b411b363SPhilipp Reisner 2953b411b363SPhilipp Reisner return -1000; 2954b411b363SPhilipp Reisner } 2955b411b363SPhilipp Reisner 2956b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2957b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2958b411b363SPhilipp Reisner */ 2959b30ab791SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_device *device, enum drbd_role peer_role, 2960b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2961b411b363SPhilipp Reisner { 2962b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2963b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 296444ed167dSPhilipp Reisner struct net_conf *nc; 29656dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2966b411b363SPhilipp Reisner 2967b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 2968b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2969b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 2970b411b363SPhilipp Reisner 2971d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 29729f2247bbSPhilipp Reisner 2973b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 2974b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 2975b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 2976b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 2977b411b363SPhilipp Reisner 2978b30ab791SAndreas Gruenbacher hg = drbd_uuid_compare(device, &rule_nr); 2979b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 2980b411b363SPhilipp Reisner 2981d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2982b411b363SPhilipp Reisner 2983b411b363SPhilipp Reisner if (hg == -1000) { 2984d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 2985b411b363SPhilipp Reisner return C_MASK; 2986b411b363SPhilipp Reisner } 29874a23f264SPhilipp Reisner if (hg < -1000) { 2988d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2989b411b363SPhilipp Reisner return C_MASK; 2990b411b363SPhilipp Reisner } 2991b411b363SPhilipp Reisner 2992b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2993b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2994b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2995b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2996b411b363SPhilipp Reisner if (f) 2997b411b363SPhilipp Reisner hg = hg*2; 2998d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 2999b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3000b411b363SPhilipp Reisner } 3001b411b363SPhilipp Reisner 30023a11a487SAdam Gandelman if (abs(hg) == 100) 3003b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 30043a11a487SAdam Gandelman 300544ed167dSPhilipp Reisner rcu_read_lock(); 3006a6b32bc3SAndreas Gruenbacher nc = rcu_dereference(first_peer_device(device)->connection->net_conf); 300744ed167dSPhilipp Reisner 300844ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3009b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3010b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3011b411b363SPhilipp Reisner int forced = (hg == -100); 3012b411b363SPhilipp Reisner 3013b411b363SPhilipp Reisner switch (pcount) { 3014b411b363SPhilipp Reisner case 0: 3015b30ab791SAndreas Gruenbacher hg = drbd_asb_recover_0p(device); 3016b411b363SPhilipp Reisner break; 3017b411b363SPhilipp Reisner case 1: 3018b30ab791SAndreas Gruenbacher hg = drbd_asb_recover_1p(device); 3019b411b363SPhilipp Reisner break; 3020b411b363SPhilipp Reisner case 2: 3021b30ab791SAndreas Gruenbacher hg = drbd_asb_recover_2p(device); 3022b411b363SPhilipp Reisner break; 3023b411b363SPhilipp Reisner } 3024b411b363SPhilipp Reisner if (abs(hg) < 100) { 3025d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3026b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3027b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3028b411b363SPhilipp Reisner if (forced) { 3029d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3030b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3031b411b363SPhilipp Reisner hg = hg*2; 3032b411b363SPhilipp Reisner } 3033b411b363SPhilipp Reisner } 3034b411b363SPhilipp Reisner } 3035b411b363SPhilipp Reisner 3036b411b363SPhilipp Reisner if (hg == -100) { 3037b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3038b411b363SPhilipp Reisner hg = -1; 3039b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3040b411b363SPhilipp Reisner hg = 1; 3041b411b363SPhilipp Reisner 3042b411b363SPhilipp Reisner if (abs(hg) < 100) 3043d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3044b411b363SPhilipp Reisner "Sync from %s node\n", 3045b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3046b411b363SPhilipp Reisner } 304744ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 30486dff2902SAndreas Gruenbacher tentative = nc->tentative; 304944ed167dSPhilipp Reisner rcu_read_unlock(); 3050b411b363SPhilipp Reisner 3051b411b363SPhilipp Reisner if (hg == -100) { 3052580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3053580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3054580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3055580b9767SLars Ellenberg * to that disk, in a way... */ 3056d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3057b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3058b411b363SPhilipp Reisner return C_MASK; 3059b411b363SPhilipp Reisner } 3060b411b363SPhilipp Reisner 3061b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3062d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3063b411b363SPhilipp Reisner return C_MASK; 3064b411b363SPhilipp Reisner } 3065b411b363SPhilipp Reisner 3066b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3067b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 306844ed167dSPhilipp Reisner switch (rr_conflict) { 3069b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3070b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3071b411b363SPhilipp Reisner /* fall through */ 3072b411b363SPhilipp Reisner case ASB_DISCONNECT: 3073d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3074b411b363SPhilipp Reisner return C_MASK; 3075b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3076d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3077b411b363SPhilipp Reisner "assumption\n"); 3078b411b363SPhilipp Reisner } 3079b411b363SPhilipp Reisner } 3080b411b363SPhilipp Reisner 3081a6b32bc3SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &first_peer_device(device)->connection->flags)) { 3082cf14c2e9SPhilipp Reisner if (hg == 0) 3083d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3084cf14c2e9SPhilipp Reisner else 3085d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3086cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3087cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3088cf14c2e9SPhilipp Reisner return C_MASK; 3089cf14c2e9SPhilipp Reisner } 3090cf14c2e9SPhilipp Reisner 3091b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3092d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3093b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 309420ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3095b411b363SPhilipp Reisner return C_MASK; 3096b411b363SPhilipp Reisner } 3097b411b363SPhilipp Reisner 3098b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3099b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3100b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3101b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3102b411b363SPhilipp Reisner } else { 3103b411b363SPhilipp Reisner rv = C_CONNECTED; 3104b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3105d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3106b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3107b411b363SPhilipp Reisner } 3108b411b363SPhilipp Reisner } 3109b411b363SPhilipp Reisner 3110b411b363SPhilipp Reisner return rv; 3111b411b363SPhilipp Reisner } 3112b411b363SPhilipp Reisner 3113f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3114b411b363SPhilipp Reisner { 3115b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3116f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3117f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3118b411b363SPhilipp Reisner 3119b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3120f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3121f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3122b411b363SPhilipp Reisner 3123b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3124f179d76dSPhilipp Reisner return peer; 3125b411b363SPhilipp Reisner } 3126b411b363SPhilipp Reisner 3127bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3128b411b363SPhilipp Reisner { 3129e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3130036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3131036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3132036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3133036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3134accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 31357aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3136b411b363SPhilipp Reisner 3137b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3138b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3139b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3140b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3141b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3142cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 31436139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3144cf14c2e9SPhilipp Reisner 3145bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 314686db0618SAndreas Gruenbacher int err; 314786db0618SAndreas Gruenbacher 314888104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 314986db0618SAndreas Gruenbacher return -EIO; 3150bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 315186db0618SAndreas Gruenbacher if (err) 315286db0618SAndreas Gruenbacher return err; 315388104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3154036b17eaSPhilipp Reisner } 315586db0618SAndreas Gruenbacher 31567d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3157bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3158cf14c2e9SPhilipp Reisner 3159cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3160bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3161b411b363SPhilipp Reisner 316244ed167dSPhilipp Reisner rcu_read_lock(); 3163bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 316444ed167dSPhilipp Reisner 3165036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 31661ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 316744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3168b411b363SPhilipp Reisner } 3169b411b363SPhilipp Reisner 3170f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 31711ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 317244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3173b411b363SPhilipp Reisner } 3174b411b363SPhilipp Reisner 3175f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 31761ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 317744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3178b411b363SPhilipp Reisner } 3179b411b363SPhilipp Reisner 3180f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 31811ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 318244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3183b411b363SPhilipp Reisner } 3184b411b363SPhilipp Reisner 31856139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 31861ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 318744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3188b411b363SPhilipp Reisner } 3189b411b363SPhilipp Reisner 319044ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 31911ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 319244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3193b411b363SPhilipp Reisner } 3194b411b363SPhilipp Reisner 3195036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 31961ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3197036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3198036b17eaSPhilipp Reisner } 3199036b17eaSPhilipp Reisner 320086db0618SAndreas Gruenbacher rcu_read_unlock(); 3201fbc12f45SAndreas Gruenbacher } 32027d4c782cSAndreas Gruenbacher 32037d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 32047d4c782cSAndreas Gruenbacher int hash_size; 32057d4c782cSAndreas Gruenbacher 32067d4c782cSAndreas Gruenbacher /* 32077d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 32087d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 32097d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 32107d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 32117d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 32127d4c782cSAndreas Gruenbacher * change. 32137d4c782cSAndreas Gruenbacher */ 32147d4c782cSAndreas Gruenbacher 32157d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 32167d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 32171ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 32187d4c782cSAndreas Gruenbacher integrity_alg); 3219b411b363SPhilipp Reisner goto disconnect; 3220b411b363SPhilipp Reisner } 3221b411b363SPhilipp Reisner 32227d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 32237d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 32247d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 32257d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 32261ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 32277d4c782cSAndreas Gruenbacher goto disconnect; 32287d4c782cSAndreas Gruenbacher } 32297d4c782cSAndreas Gruenbacher } 32307d4c782cSAndreas Gruenbacher 32317d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 32327d4c782cSAndreas Gruenbacher if (!new_net_conf) { 32331ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3234b411b363SPhilipp Reisner goto disconnect; 3235b411b363SPhilipp Reisner } 3236b411b363SPhilipp Reisner 3237bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 32380500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3239bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 32407d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3241b411b363SPhilipp Reisner 32427d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 32437d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 32447d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 32457d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 32467d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3247b411b363SPhilipp Reisner 3248bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 32490500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3250bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3251b411b363SPhilipp Reisner 3252bde89a9eSAndreas Gruenbacher crypto_free_hash(connection->peer_integrity_tfm); 3253bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3254bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3255bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3256bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3257bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3258b411b363SPhilipp Reisner 32597d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 32601ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 32617d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3262b411b363SPhilipp Reisner 32637d4c782cSAndreas Gruenbacher synchronize_rcu(); 32647d4c782cSAndreas Gruenbacher kfree(old_net_conf); 326582bc0194SAndreas Gruenbacher return 0; 3266b411b363SPhilipp Reisner 326744ed167dSPhilipp Reisner disconnect_rcu_unlock: 326844ed167dSPhilipp Reisner rcu_read_unlock(); 3269b411b363SPhilipp Reisner disconnect: 3270b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3271036b17eaSPhilipp Reisner kfree(int_dig_in); 3272036b17eaSPhilipp Reisner kfree(int_dig_vv); 3273bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 327482bc0194SAndreas Gruenbacher return -EIO; 3275b411b363SPhilipp Reisner } 3276b411b363SPhilipp Reisner 3277b411b363SPhilipp Reisner /* helper function 3278b411b363SPhilipp Reisner * input: alg name, feature name 3279b411b363SPhilipp Reisner * return: NULL (alg name was "") 3280b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3281b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3282f63e631aSRashika Kheria static 3283b30ab791SAndreas Gruenbacher struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3284b411b363SPhilipp Reisner const char *alg, const char *name) 3285b411b363SPhilipp Reisner { 3286b411b363SPhilipp Reisner struct crypto_hash *tfm; 3287b411b363SPhilipp Reisner 3288b411b363SPhilipp Reisner if (!alg[0]) 3289b411b363SPhilipp Reisner return NULL; 3290b411b363SPhilipp Reisner 3291b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3292b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3293d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3294b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3295b411b363SPhilipp Reisner return tfm; 3296b411b363SPhilipp Reisner } 3297b411b363SPhilipp Reisner return tfm; 3298b411b363SPhilipp Reisner } 3299b411b363SPhilipp Reisner 3300bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3301b411b363SPhilipp Reisner { 3302bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 33034a76b161SAndreas Gruenbacher int size = pi->size; 33044a76b161SAndreas Gruenbacher 33054a76b161SAndreas Gruenbacher while (size) { 33064a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3307bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 33084a76b161SAndreas Gruenbacher if (s <= 0) { 33094a76b161SAndreas Gruenbacher if (s < 0) 33104a76b161SAndreas Gruenbacher return s; 33114a76b161SAndreas Gruenbacher break; 33124a76b161SAndreas Gruenbacher } 33134a76b161SAndreas Gruenbacher size -= s; 33144a76b161SAndreas Gruenbacher } 33154a76b161SAndreas Gruenbacher if (size) 33164a76b161SAndreas Gruenbacher return -EIO; 33174a76b161SAndreas Gruenbacher return 0; 33184a76b161SAndreas Gruenbacher } 33194a76b161SAndreas Gruenbacher 33204a76b161SAndreas Gruenbacher /* 33214a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 33224a76b161SAndreas Gruenbacher * 33234a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 33244a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 33254a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 33264a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 33274a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 33284a76b161SAndreas Gruenbacher * 33294a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 33304a76b161SAndreas Gruenbacher */ 3331bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 33324a76b161SAndreas Gruenbacher { 33331ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 33342fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3335bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 33364a76b161SAndreas Gruenbacher } 33374a76b161SAndreas Gruenbacher 3338bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 33394a76b161SAndreas Gruenbacher { 33409f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3341b30ab791SAndreas Gruenbacher struct drbd_device *device; 3342e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3343b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3344b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3345b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 33462ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3347813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3348bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3349813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3350778f271dSPhilipp Reisner int fifo_size = 0; 335182bc0194SAndreas Gruenbacher int err; 3352b411b363SPhilipp Reisner 33539f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 33549f4fe9adSAndreas Gruenbacher if (!peer_device) 3355bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 33569f4fe9adSAndreas Gruenbacher device = peer_device->device; 3357b411b363SPhilipp Reisner 3358b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3359b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3360b411b363SPhilipp Reisner + SHARED_SECRET_MAX 33618e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 33628e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3363b411b363SPhilipp Reisner 3364e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3365d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3366e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 336782bc0194SAndreas Gruenbacher return -EIO; 3368b411b363SPhilipp Reisner } 3369b411b363SPhilipp Reisner 3370b411b363SPhilipp Reisner if (apv <= 88) { 3371e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3372e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33738e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3374e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3375e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33760b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 33778e26f9ccSPhilipp Reisner } else { 3378e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3379e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33800b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3381b411b363SPhilipp Reisner } 3382b411b363SPhilipp Reisner 3383b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3384e658983aSAndreas Gruenbacher p = pi->data; 3385b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3386b411b363SPhilipp Reisner 33879f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 338882bc0194SAndreas Gruenbacher if (err) 338982bc0194SAndreas Gruenbacher return err; 3390b411b363SPhilipp Reisner 33910500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 33929f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3393b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3394daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3395daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3396b30ab791SAndreas Gruenbacher put_ldev(device); 33970500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3398d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3399daeda1ccSPhilipp Reisner return -ENOMEM; 3400f399002eSLars Ellenberg } 3401b411b363SPhilipp Reisner 3402b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3403daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3404daeda1ccSPhilipp Reisner 34056394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3406813472ceSPhilipp Reisner } 3407b411b363SPhilipp Reisner 3408b411b363SPhilipp Reisner if (apv >= 88) { 3409b411b363SPhilipp Reisner if (apv == 88) { 34105de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3411d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 34125de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3413b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3414813472ceSPhilipp Reisner err = -EIO; 3415813472ceSPhilipp Reisner goto reconnect; 3416b411b363SPhilipp Reisner } 3417b411b363SPhilipp Reisner 34189f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3419813472ceSPhilipp Reisner if (err) 3420813472ceSPhilipp Reisner goto reconnect; 3421b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3422b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 34230b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3424b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3425b411b363SPhilipp Reisner 3426b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3427b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3428b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 34290b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 34300b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3431b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3432b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3433b411b363SPhilipp Reisner } 3434b411b363SPhilipp Reisner 34352ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3436b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3437d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 34382ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3439b411b363SPhilipp Reisner goto disconnect; 3440b411b363SPhilipp Reisner } 3441b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3442b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3443b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3444b411b363SPhilipp Reisner verify_tfm = NULL; 3445b411b363SPhilipp Reisner goto disconnect; 3446b411b363SPhilipp Reisner } 3447b411b363SPhilipp Reisner } 3448b411b363SPhilipp Reisner 34492ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3450b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3451d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 34522ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3453b411b363SPhilipp Reisner goto disconnect; 3454b411b363SPhilipp Reisner } 3455b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3456b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3457b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3458b411b363SPhilipp Reisner csums_tfm = NULL; 3459b411b363SPhilipp Reisner goto disconnect; 3460b411b363SPhilipp Reisner } 3461b411b363SPhilipp Reisner } 3462b411b363SPhilipp Reisner 3463813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3464daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3465daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3466daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3467daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3468778f271dSPhilipp Reisner 3469daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3470b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3471813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3472813472ceSPhilipp Reisner if (!new_plan) { 3473d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3474b30ab791SAndreas Gruenbacher put_ldev(device); 3475778f271dSPhilipp Reisner goto disconnect; 3476778f271dSPhilipp Reisner } 3477778f271dSPhilipp Reisner } 34788e26f9ccSPhilipp Reisner } 3479b411b363SPhilipp Reisner 348091fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 34812ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 34822ec91e0eSPhilipp Reisner if (!new_net_conf) { 3483d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 348491fd4dadSPhilipp Reisner goto disconnect; 348591fd4dadSPhilipp Reisner } 348691fd4dadSPhilipp Reisner 34872ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 348891fd4dadSPhilipp Reisner 3489b411b363SPhilipp Reisner if (verify_tfm) { 34902ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 34912ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 34929f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->verify_tfm); 34939f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3494d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3495b411b363SPhilipp Reisner } 3496b411b363SPhilipp Reisner if (csums_tfm) { 34972ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 34982ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 34999f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->csums_tfm); 35009f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3501d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3502b411b363SPhilipp Reisner } 3503bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3504778f271dSPhilipp Reisner } 3505b411b363SPhilipp Reisner } 3506b411b363SPhilipp Reisner 3507813472ceSPhilipp Reisner if (new_disk_conf) { 3508b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3509b30ab791SAndreas Gruenbacher put_ldev(device); 3510b411b363SPhilipp Reisner } 3511813472ceSPhilipp Reisner 3512813472ceSPhilipp Reisner if (new_plan) { 3513b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3514b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3515813472ceSPhilipp Reisner } 3516daeda1ccSPhilipp Reisner 35170500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3518daeda1ccSPhilipp Reisner synchronize_rcu(); 3519daeda1ccSPhilipp Reisner if (new_net_conf) 3520daeda1ccSPhilipp Reisner kfree(old_net_conf); 3521daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3522813472ceSPhilipp Reisner kfree(old_plan); 3523daeda1ccSPhilipp Reisner 352482bc0194SAndreas Gruenbacher return 0; 3525b411b363SPhilipp Reisner 3526813472ceSPhilipp Reisner reconnect: 3527813472ceSPhilipp Reisner if (new_disk_conf) { 3528b30ab791SAndreas Gruenbacher put_ldev(device); 3529813472ceSPhilipp Reisner kfree(new_disk_conf); 3530813472ceSPhilipp Reisner } 35310500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3532813472ceSPhilipp Reisner return -EIO; 3533813472ceSPhilipp Reisner 3534b411b363SPhilipp Reisner disconnect: 3535813472ceSPhilipp Reisner kfree(new_plan); 3536813472ceSPhilipp Reisner if (new_disk_conf) { 3537b30ab791SAndreas Gruenbacher put_ldev(device); 3538813472ceSPhilipp Reisner kfree(new_disk_conf); 3539813472ceSPhilipp Reisner } 35400500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3541b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3542b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3543b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3544b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3545b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 35469f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 354782bc0194SAndreas Gruenbacher return -EIO; 3548b411b363SPhilipp Reisner } 3549b411b363SPhilipp Reisner 3550b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3551b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 3552b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3553b411b363SPhilipp Reisner { 3554b411b363SPhilipp Reisner sector_t d; 3555b411b363SPhilipp Reisner if (a == 0 || b == 0) 3556b411b363SPhilipp Reisner return; 3557b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3558b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3559d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 3560b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3561b411b363SPhilipp Reisner } 3562b411b363SPhilipp Reisner 3563bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 3564b411b363SPhilipp Reisner { 35659f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3566b30ab791SAndreas Gruenbacher struct drbd_device *device; 3567e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3568e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 3569b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3570b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3571e89b591cSPhilipp Reisner enum dds_flags ddsf; 3572b411b363SPhilipp Reisner 35739f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 35749f4fe9adSAndreas Gruenbacher if (!peer_device) 3575bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 35769f4fe9adSAndreas Gruenbacher device = peer_device->device; 35774a76b161SAndreas Gruenbacher 3578b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3579b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3580b411b363SPhilipp Reisner 3581b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3582b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3583b30ab791SAndreas Gruenbacher device->p_size = p_size; 3584b411b363SPhilipp Reisner 3585b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3586daeda1ccSPhilipp Reisner rcu_read_lock(); 3587b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 3588daeda1ccSPhilipp Reisner rcu_read_unlock(); 3589daeda1ccSPhilipp Reisner 3590b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 3591b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 3592b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 3593daeda1ccSPhilipp Reisner p_usize, my_usize); 3594b411b363SPhilipp Reisner 3595b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3596b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3597b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 3598daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3599b411b363SPhilipp Reisner 3600b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3601b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3602b30ab791SAndreas Gruenbacher if (drbd_new_dev_size(device, device->ldev, p_usize, 0) < 3603b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) && 3604b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 3605b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 3606d0180171SAndreas Gruenbacher drbd_err(device, "The peer's disk size is too small!\n"); 36079f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 3608b30ab791SAndreas Gruenbacher put_ldev(device); 360982bc0194SAndreas Gruenbacher return -EIO; 3610b411b363SPhilipp Reisner } 3611daeda1ccSPhilipp Reisner 3612daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3613daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3614daeda1ccSPhilipp Reisner 3615daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3616daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3617d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3618b30ab791SAndreas Gruenbacher put_ldev(device); 3619daeda1ccSPhilipp Reisner return -ENOMEM; 3620daeda1ccSPhilipp Reisner } 3621daeda1ccSPhilipp Reisner 36220500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3623b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3624daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3625daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3626daeda1ccSPhilipp Reisner 3627b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 36280500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3629daeda1ccSPhilipp Reisner synchronize_rcu(); 3630daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3631daeda1ccSPhilipp Reisner 3632d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 3633daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3634daeda1ccSPhilipp Reisner } 3635daeda1ccSPhilipp Reisner 3636b30ab791SAndreas Gruenbacher put_ldev(device); 3637b411b363SPhilipp Reisner } 3638b411b363SPhilipp Reisner 3639e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3640b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3641b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 3642b30ab791SAndreas Gruenbacher put_ldev(device); 3643e96c9633SPhilipp Reisner if (dd == DS_ERROR) 364482bc0194SAndreas Gruenbacher return -EIO; 3645b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3646b411b363SPhilipp Reisner } else { 3647b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3648b30ab791SAndreas Gruenbacher drbd_set_my_capacity(device, p_size); 3649b411b363SPhilipp Reisner } 3650b411b363SPhilipp Reisner 3651b30ab791SAndreas Gruenbacher device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 3652b30ab791SAndreas Gruenbacher drbd_reconsider_max_bio_size(device); 365399432fccSPhilipp Reisner 3654b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3655b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 3656b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 3657b411b363SPhilipp Reisner ldsc = 1; 3658b411b363SPhilipp Reisner } 3659b411b363SPhilipp Reisner 3660b30ab791SAndreas Gruenbacher put_ldev(device); 3661b411b363SPhilipp Reisner } 3662b411b363SPhilipp Reisner 3663b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 3664b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3665b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 3666b411b363SPhilipp Reisner /* we have different sizes, probably peer 3667b411b363SPhilipp Reisner * needs to know my new size... */ 3668b30ab791SAndreas Gruenbacher drbd_send_sizes(device, 0, ddsf); 3669b411b363SPhilipp Reisner } 3670b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 3671b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 3672b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 3673b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 3674e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3675d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 3676b411b363SPhilipp Reisner else 3677b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 3678e89b591cSPhilipp Reisner } else 3679b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 3680b411b363SPhilipp Reisner } 3681b411b363SPhilipp Reisner } 3682b411b363SPhilipp Reisner 368382bc0194SAndreas Gruenbacher return 0; 3684b411b363SPhilipp Reisner } 3685b411b363SPhilipp Reisner 3686bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 3687b411b363SPhilipp Reisner { 36889f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3689b30ab791SAndreas Gruenbacher struct drbd_device *device; 3690e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3691b411b363SPhilipp Reisner u64 *p_uuid; 369262b0da3aSLars Ellenberg int i, updated_uuids = 0; 3693b411b363SPhilipp Reisner 36949f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 36959f4fe9adSAndreas Gruenbacher if (!peer_device) 3696bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 36979f4fe9adSAndreas Gruenbacher device = peer_device->device; 36984a76b161SAndreas Gruenbacher 3699b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3700063eacf8SJing Wang if (!p_uuid) { 3701d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 3702063eacf8SJing Wang return false; 3703063eacf8SJing Wang } 3704b411b363SPhilipp Reisner 3705b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3706b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3707b411b363SPhilipp Reisner 3708b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 3709b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 3710b411b363SPhilipp Reisner 3711b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 3712b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 3713b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 3714b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3715d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 3716b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 37179f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 371882bc0194SAndreas Gruenbacher return -EIO; 3719b411b363SPhilipp Reisner } 3720b411b363SPhilipp Reisner 3721b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3722b411b363SPhilipp Reisner int skip_initial_sync = 3723b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 37249f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 3725b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3726b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3727b411b363SPhilipp Reisner if (skip_initial_sync) { 3728d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 3729b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 373020ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 373120ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3732b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 3733b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 3734b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3735b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3736b30ab791SAndreas Gruenbacher drbd_md_sync(device); 373762b0da3aSLars Ellenberg updated_uuids = 1; 3738b411b363SPhilipp Reisner } 3739b30ab791SAndreas Gruenbacher put_ldev(device); 3740b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 3741b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 374218a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 374318a50fa2SPhilipp Reisner for me. */ 3744b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 3745b411b363SPhilipp Reisner } 3746b411b363SPhilipp Reisner 3747b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3748b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3749b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3750b411b363SPhilipp Reisner new disk state... */ 3751b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 3752b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 3753b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 3754b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 375562b0da3aSLars Ellenberg 375662b0da3aSLars Ellenberg if (updated_uuids) 3757b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 3758b411b363SPhilipp Reisner 375982bc0194SAndreas Gruenbacher return 0; 3760b411b363SPhilipp Reisner } 3761b411b363SPhilipp Reisner 3762b411b363SPhilipp Reisner /** 3763b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3764b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3765b411b363SPhilipp Reisner */ 3766b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3767b411b363SPhilipp Reisner { 3768b411b363SPhilipp Reisner union drbd_state ms; 3769b411b363SPhilipp Reisner 3770b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3771369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3772b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3773b411b363SPhilipp Reisner 3774b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3775b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3776b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3777b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3778b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3779b411b363SPhilipp Reisner }; 3780b411b363SPhilipp Reisner 3781b411b363SPhilipp Reisner ms.i = ps.i; 3782b411b363SPhilipp Reisner 3783b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3784b411b363SPhilipp Reisner ms.peer = ps.role; 3785b411b363SPhilipp Reisner ms.role = ps.peer; 3786b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3787b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3788b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3789b411b363SPhilipp Reisner 3790b411b363SPhilipp Reisner return ms; 3791b411b363SPhilipp Reisner } 3792b411b363SPhilipp Reisner 3793bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 3794b411b363SPhilipp Reisner { 37959f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3796b30ab791SAndreas Gruenbacher struct drbd_device *device; 3797e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3798b411b363SPhilipp Reisner union drbd_state mask, val; 3799bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3800b411b363SPhilipp Reisner 38019f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38029f4fe9adSAndreas Gruenbacher if (!peer_device) 38034a76b161SAndreas Gruenbacher return -EIO; 38049f4fe9adSAndreas Gruenbacher device = peer_device->device; 38054a76b161SAndreas Gruenbacher 3806b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3807b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3808b411b363SPhilipp Reisner 38099f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 3810b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 3811b30ab791SAndreas Gruenbacher drbd_send_sr_reply(device, SS_CONCURRENT_ST_CHG); 381282bc0194SAndreas Gruenbacher return 0; 3813b411b363SPhilipp Reisner } 3814b411b363SPhilipp Reisner 3815b411b363SPhilipp Reisner mask = convert_state(mask); 3816b411b363SPhilipp Reisner val = convert_state(val); 3817b411b363SPhilipp Reisner 3818b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 3819b30ab791SAndreas Gruenbacher drbd_send_sr_reply(device, rv); 3820047cd4a6SPhilipp Reisner 3821b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3822b411b363SPhilipp Reisner 382382bc0194SAndreas Gruenbacher return 0; 3824b411b363SPhilipp Reisner } 3825b411b363SPhilipp Reisner 3826bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 3827b411b363SPhilipp Reisner { 3828e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3829dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3830dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3831dfafcc8aSPhilipp Reisner 3832dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3833dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3834dfafcc8aSPhilipp Reisner 3835bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 3836bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 3837bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 383882bc0194SAndreas Gruenbacher return 0; 3839dfafcc8aSPhilipp Reisner } 3840dfafcc8aSPhilipp Reisner 3841dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3842dfafcc8aSPhilipp Reisner val = convert_state(val); 3843dfafcc8aSPhilipp Reisner 3844bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3845bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 3846dfafcc8aSPhilipp Reisner 384782bc0194SAndreas Gruenbacher return 0; 3848dfafcc8aSPhilipp Reisner } 3849dfafcc8aSPhilipp Reisner 3850bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 3851b411b363SPhilipp Reisner { 38529f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3853b30ab791SAndreas Gruenbacher struct drbd_device *device; 3854e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 38554ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3856b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 385765d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3858b411b363SPhilipp Reisner int rv; 3859b411b363SPhilipp Reisner 38609f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38619f4fe9adSAndreas Gruenbacher if (!peer_device) 3862bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 38639f4fe9adSAndreas Gruenbacher device = peer_device->device; 38644a76b161SAndreas Gruenbacher 3865b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3866b411b363SPhilipp Reisner 3867b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3868b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3869b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3870d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3871b411b363SPhilipp Reisner } 3872b411b363SPhilipp Reisner 38730500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 3874b411b363SPhilipp Reisner retry: 3875b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 38760500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 3877b411b363SPhilipp Reisner 3878545752d5SLars Ellenberg /* If some other part of the code (asender thread, timeout) 3879545752d5SLars Ellenberg * already decided to close the connection again, 3880545752d5SLars Ellenberg * we must not "re-establish" it here. */ 3881545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 388258ffa580SLars Ellenberg return -ECONNRESET; 3883545752d5SLars Ellenberg 388440424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 388540424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 388640424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 388740424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 388840424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 388940424e4aSLars Ellenberg */ 389040424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 389140424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 3892e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3893e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3894e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3895e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3896e9ef7bb6SLars Ellenberg * syncing states. 3897e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3898e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3899e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3900e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3901e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3902e9ef7bb6SLars Ellenberg 3903e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3904e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3905e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3906e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3907e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3908b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 3909b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 391082bc0194SAndreas Gruenbacher return 0; 3911e9ef7bb6SLars Ellenberg } 3912e9ef7bb6SLars Ellenberg } 3913e9ef7bb6SLars Ellenberg 391402b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 391502b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 391602b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 3917b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 3918b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 391958ffa580SLars Ellenberg return 0; 392002b91b55SLars Ellenberg } 392102b91b55SLars Ellenberg 3922e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3923e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3924e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3925e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3926e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3927e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3928e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3929e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3930e9ef7bb6SLars Ellenberg 39314ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 39324ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3933b411b363SPhilipp Reisner 393467531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 393567531718SPhilipp Reisner ns.conn = C_BEHIND; 393667531718SPhilipp Reisner 3937b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 3938b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 3939b411b363SPhilipp Reisner int cr; /* consider resync */ 3940b411b363SPhilipp Reisner 3941b411b363SPhilipp Reisner /* if we established a new connection */ 39424ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3943b411b363SPhilipp Reisner /* if we had an established connection 3944b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 39454ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3946b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 39474ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3948b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3949b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3950b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 3951b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3952b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 39534ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3954b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3955b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3956b411b363SPhilipp Reisner 3957b411b363SPhilipp Reisner if (cr) 3958b30ab791SAndreas Gruenbacher ns.conn = drbd_sync_handshake(device, peer_state.role, real_peer_disk); 3959b411b363SPhilipp Reisner 3960b30ab791SAndreas Gruenbacher put_ldev(device); 39614ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 39624ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3963b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 3964b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 3965b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3966d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 3967b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3968580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3969b411b363SPhilipp Reisner } else { 39709f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 397182bc0194SAndreas Gruenbacher return -EIO; 39720b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 39739f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 397482bc0194SAndreas Gruenbacher return -EIO; 3975b411b363SPhilipp Reisner } 3976b411b363SPhilipp Reisner } 3977b411b363SPhilipp Reisner } 3978b411b363SPhilipp Reisner 39790500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 3980b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 3981b411b363SPhilipp Reisner goto retry; 3982b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 3983b411b363SPhilipp Reisner ns.peer = peer_state.role; 3984b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3985b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 39864ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3987b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 39884ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 3989b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3990b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 39918554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3992481c6f50SPhilipp Reisner for temporal network outages! */ 39930500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 3994d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 39959f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 3996b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 3997b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 39989f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 399982bc0194SAndreas Gruenbacher return -EIO; 4000481c6f50SPhilipp Reisner } 4001b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4002b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 40030500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4004b411b363SPhilipp Reisner 4005b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 40069f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 400782bc0194SAndreas Gruenbacher return -EIO; 4008b411b363SPhilipp Reisner } 4009b411b363SPhilipp Reisner 40104ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 40114ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4012b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4013b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4014b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4015b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 4016b30ab791SAndreas Gruenbacher drbd_send_uuids(device); 4017b30ab791SAndreas Gruenbacher drbd_send_current_state(device); 4018b411b363SPhilipp Reisner } 4019b411b363SPhilipp Reisner } 4020b411b363SPhilipp Reisner 4021b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4022b411b363SPhilipp Reisner 4023b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4024b411b363SPhilipp Reisner 402582bc0194SAndreas Gruenbacher return 0; 4026b411b363SPhilipp Reisner } 4027b411b363SPhilipp Reisner 4028bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4029b411b363SPhilipp Reisner { 40309f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4031b30ab791SAndreas Gruenbacher struct drbd_device *device; 4032e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 40334a76b161SAndreas Gruenbacher 40349f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 40359f4fe9adSAndreas Gruenbacher if (!peer_device) 40364a76b161SAndreas Gruenbacher return -EIO; 40379f4fe9adSAndreas Gruenbacher device = peer_device->device; 4038b411b363SPhilipp Reisner 4039b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4040b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4041b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4042b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4043b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4044b411b363SPhilipp Reisner 40450b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4046b411b363SPhilipp Reisner 4047b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4048b411b363SPhilipp Reisner _not_ be rotated into the history */ 4049b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4050b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4051b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4052b411b363SPhilipp Reisner 4053b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4054b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4055b411b363SPhilipp Reisner 4056b30ab791SAndreas Gruenbacher put_ldev(device); 4057b411b363SPhilipp Reisner } else 4058d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4059b411b363SPhilipp Reisner 406082bc0194SAndreas Gruenbacher return 0; 4061b411b363SPhilipp Reisner } 4062b411b363SPhilipp Reisner 40632c46407dSAndreas Gruenbacher /** 40642c46407dSAndreas Gruenbacher * receive_bitmap_plain 40652c46407dSAndreas Gruenbacher * 40662c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40672c46407dSAndreas Gruenbacher * code upon failure. 40682c46407dSAndreas Gruenbacher */ 40692c46407dSAndreas Gruenbacher static int 4070b30ab791SAndreas Gruenbacher receive_bitmap_plain(struct drbd_device *device, unsigned int size, 4071e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4072b411b363SPhilipp Reisner { 407350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 4074a6b32bc3SAndreas Gruenbacher drbd_header_size(first_peer_device(device)->connection); 4075e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 407650d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4077e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 40782c46407dSAndreas Gruenbacher int err; 4079b411b363SPhilipp Reisner 408050d0b1adSAndreas Gruenbacher if (want != size) { 4081d0180171SAndreas Gruenbacher drbd_err(device, "%s:want (%u) != size (%u)\n", __func__, want, size); 40822c46407dSAndreas Gruenbacher return -EIO; 4083b411b363SPhilipp Reisner } 4084b411b363SPhilipp Reisner if (want == 0) 40852c46407dSAndreas Gruenbacher return 0; 4086a6b32bc3SAndreas Gruenbacher err = drbd_recv_all(first_peer_device(device)->connection, p, want); 408782bc0194SAndreas Gruenbacher if (err) 40882c46407dSAndreas Gruenbacher return err; 4089b411b363SPhilipp Reisner 4090b30ab791SAndreas Gruenbacher drbd_bm_merge_lel(device, c->word_offset, num_words, p); 4091b411b363SPhilipp Reisner 4092b411b363SPhilipp Reisner c->word_offset += num_words; 4093b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4094b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4095b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4096b411b363SPhilipp Reisner 40972c46407dSAndreas Gruenbacher return 1; 4098b411b363SPhilipp Reisner } 4099b411b363SPhilipp Reisner 4100a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4101a02d1240SAndreas Gruenbacher { 4102a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4103a02d1240SAndreas Gruenbacher } 4104a02d1240SAndreas Gruenbacher 4105a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4106a02d1240SAndreas Gruenbacher { 4107a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4108a02d1240SAndreas Gruenbacher } 4109a02d1240SAndreas Gruenbacher 4110a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4111a02d1240SAndreas Gruenbacher { 4112a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4113a02d1240SAndreas Gruenbacher } 4114a02d1240SAndreas Gruenbacher 41152c46407dSAndreas Gruenbacher /** 41162c46407dSAndreas Gruenbacher * recv_bm_rle_bits 41172c46407dSAndreas Gruenbacher * 41182c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41192c46407dSAndreas Gruenbacher * code upon failure. 41202c46407dSAndreas Gruenbacher */ 41212c46407dSAndreas Gruenbacher static int 4122b30ab791SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_device *device, 4123b411b363SPhilipp Reisner struct p_compressed_bm *p, 4124c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4125c6d25cfeSPhilipp Reisner unsigned int len) 4126b411b363SPhilipp Reisner { 4127b411b363SPhilipp Reisner struct bitstream bs; 4128b411b363SPhilipp Reisner u64 look_ahead; 4129b411b363SPhilipp Reisner u64 rl; 4130b411b363SPhilipp Reisner u64 tmp; 4131b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4132b411b363SPhilipp Reisner unsigned long e; 4133a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4134b411b363SPhilipp Reisner int have; 4135b411b363SPhilipp Reisner int bits; 4136b411b363SPhilipp Reisner 4137a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4138b411b363SPhilipp Reisner 4139b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4140b411b363SPhilipp Reisner if (bits < 0) 41412c46407dSAndreas Gruenbacher return -EIO; 4142b411b363SPhilipp Reisner 4143b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4144b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4145b411b363SPhilipp Reisner if (bits <= 0) 41462c46407dSAndreas Gruenbacher return -EIO; 4147b411b363SPhilipp Reisner 4148b411b363SPhilipp Reisner if (toggle) { 4149b411b363SPhilipp Reisner e = s + rl -1; 4150b411b363SPhilipp Reisner if (e >= c->bm_bits) { 4151d0180171SAndreas Gruenbacher drbd_err(device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 41522c46407dSAndreas Gruenbacher return -EIO; 4153b411b363SPhilipp Reisner } 4154b30ab791SAndreas Gruenbacher _drbd_bm_set_bits(device, s, e); 4155b411b363SPhilipp Reisner } 4156b411b363SPhilipp Reisner 4157b411b363SPhilipp Reisner if (have < bits) { 4158d0180171SAndreas Gruenbacher drbd_err(device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4159b411b363SPhilipp Reisner have, bits, look_ahead, 4160b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4161b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 41622c46407dSAndreas Gruenbacher return -EIO; 4163b411b363SPhilipp Reisner } 4164d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4165d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4166b411b363SPhilipp Reisner look_ahead >>= bits; 4167d2da5b0cSLars Ellenberg else 4168d2da5b0cSLars Ellenberg look_ahead = 0; 4169b411b363SPhilipp Reisner have -= bits; 4170b411b363SPhilipp Reisner 4171b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4172b411b363SPhilipp Reisner if (bits < 0) 41732c46407dSAndreas Gruenbacher return -EIO; 4174b411b363SPhilipp Reisner look_ahead |= tmp << have; 4175b411b363SPhilipp Reisner have += bits; 4176b411b363SPhilipp Reisner } 4177b411b363SPhilipp Reisner 4178b411b363SPhilipp Reisner c->bit_offset = s; 4179b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4180b411b363SPhilipp Reisner 41812c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4182b411b363SPhilipp Reisner } 4183b411b363SPhilipp Reisner 41842c46407dSAndreas Gruenbacher /** 41852c46407dSAndreas Gruenbacher * decode_bitmap_c 41862c46407dSAndreas Gruenbacher * 41872c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41882c46407dSAndreas Gruenbacher * code upon failure. 41892c46407dSAndreas Gruenbacher */ 41902c46407dSAndreas Gruenbacher static int 4191b30ab791SAndreas Gruenbacher decode_bitmap_c(struct drbd_device *device, 4192b411b363SPhilipp Reisner struct p_compressed_bm *p, 4193c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4194c6d25cfeSPhilipp Reisner unsigned int len) 4195b411b363SPhilipp Reisner { 4196a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4197b30ab791SAndreas Gruenbacher return recv_bm_rle_bits(device, p, c, len - sizeof(*p)); 4198b411b363SPhilipp Reisner 4199b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4200b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4201b411b363SPhilipp Reisner * during all our tests. */ 4202b411b363SPhilipp Reisner 4203d0180171SAndreas Gruenbacher drbd_err(device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 4204a6b32bc3SAndreas Gruenbacher conn_request_state(first_peer_device(device)->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 42052c46407dSAndreas Gruenbacher return -EIO; 4206b411b363SPhilipp Reisner } 4207b411b363SPhilipp Reisner 4208b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4209b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4210b411b363SPhilipp Reisner { 4211b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4212a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 421350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 421450d0b1adSAndreas Gruenbacher unsigned int plain = 421550d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 421650d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 421750d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 421850d0b1adSAndreas Gruenbacher unsigned int r; 4219b411b363SPhilipp Reisner 4220b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4221b411b363SPhilipp Reisner if (total == 0) 4222b411b363SPhilipp Reisner return; 4223b411b363SPhilipp Reisner 4224b411b363SPhilipp Reisner /* don't report if not compressed */ 4225b411b363SPhilipp Reisner if (total >= plain) 4226b411b363SPhilipp Reisner return; 4227b411b363SPhilipp Reisner 4228b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4229b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4230b411b363SPhilipp Reisner : (1000 * total / plain); 4231b411b363SPhilipp Reisner 4232b411b363SPhilipp Reisner if (r > 1000) 4233b411b363SPhilipp Reisner r = 1000; 4234b411b363SPhilipp Reisner 4235b411b363SPhilipp Reisner r = 1000 - r; 4236d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4237b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4238b411b363SPhilipp Reisner direction, 4239b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4240b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4241b411b363SPhilipp Reisner total, r/10, r % 10); 4242b411b363SPhilipp Reisner } 4243b411b363SPhilipp Reisner 4244b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4245b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4246b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4247b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4248b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4249b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4250b411b363SPhilipp Reisner 4251b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4252bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4253b411b363SPhilipp Reisner { 42549f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4255b30ab791SAndreas Gruenbacher struct drbd_device *device; 4256b411b363SPhilipp Reisner struct bm_xfer_ctx c; 42572c46407dSAndreas Gruenbacher int err; 42584a76b161SAndreas Gruenbacher 42599f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42609f4fe9adSAndreas Gruenbacher if (!peer_device) 42614a76b161SAndreas Gruenbacher return -EIO; 42629f4fe9adSAndreas Gruenbacher device = peer_device->device; 4263b411b363SPhilipp Reisner 4264b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 426520ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 426620ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4267b411b363SPhilipp Reisner 4268b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4269b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4270b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4271b411b363SPhilipp Reisner }; 4272b411b363SPhilipp Reisner 42732c46407dSAndreas Gruenbacher for(;;) { 4274e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4275b30ab791SAndreas Gruenbacher err = receive_bitmap_plain(device, pi->size, pi->data, &c); 4276e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4277b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4278b411b363SPhilipp Reisner * and the feature is enabled! */ 4279e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4280b411b363SPhilipp Reisner 4281bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4282d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 428382bc0194SAndreas Gruenbacher err = -EIO; 4284b411b363SPhilipp Reisner goto out; 4285b411b363SPhilipp Reisner } 4286e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4287d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 428882bc0194SAndreas Gruenbacher err = -EIO; 428978fcbdaeSAndreas Gruenbacher goto out; 4290b411b363SPhilipp Reisner } 42919f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4292e658983aSAndreas Gruenbacher if (err) 4293e658983aSAndreas Gruenbacher goto out; 4294b30ab791SAndreas Gruenbacher err = decode_bitmap_c(device, p, &c, pi->size); 4295b411b363SPhilipp Reisner } else { 4296d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 429782bc0194SAndreas Gruenbacher err = -EIO; 4298b411b363SPhilipp Reisner goto out; 4299b411b363SPhilipp Reisner } 4300b411b363SPhilipp Reisner 4301e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4302bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4303b411b363SPhilipp Reisner 43042c46407dSAndreas Gruenbacher if (err <= 0) { 43052c46407dSAndreas Gruenbacher if (err < 0) 43062c46407dSAndreas Gruenbacher goto out; 4307b411b363SPhilipp Reisner break; 43082c46407dSAndreas Gruenbacher } 43099f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 431082bc0194SAndreas Gruenbacher if (err) 4311b411b363SPhilipp Reisner goto out; 43122c46407dSAndreas Gruenbacher } 4313b411b363SPhilipp Reisner 4314b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4315b411b363SPhilipp Reisner 4316b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4317de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4318de1f8e4aSAndreas Gruenbacher 4319b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 432082bc0194SAndreas Gruenbacher if (err) 4321b411b363SPhilipp Reisner goto out; 4322b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4323b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 43240b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4325b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4326b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4327b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4328d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4329b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4330b411b363SPhilipp Reisner } 433182bc0194SAndreas Gruenbacher err = 0; 4332b411b363SPhilipp Reisner 4333b411b363SPhilipp Reisner out: 4334b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4335b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4336b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 433782bc0194SAndreas Gruenbacher return err; 4338b411b363SPhilipp Reisner } 4339b411b363SPhilipp Reisner 4340bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4341b411b363SPhilipp Reisner { 43421ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4343e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4344b411b363SPhilipp Reisner 4345bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4346b411b363SPhilipp Reisner } 4347b411b363SPhilipp Reisner 4348bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4349b411b363SPhilipp Reisner { 4350b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4351b411b363SPhilipp Reisner * with the data requests being unplugged */ 4352bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4353b411b363SPhilipp Reisner 435482bc0194SAndreas Gruenbacher return 0; 4355b411b363SPhilipp Reisner } 4356b411b363SPhilipp Reisner 4357bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 435873a01a18SPhilipp Reisner { 43599f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4360b30ab791SAndreas Gruenbacher struct drbd_device *device; 4361e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 43624a76b161SAndreas Gruenbacher 43639f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 43649f4fe9adSAndreas Gruenbacher if (!peer_device) 43654a76b161SAndreas Gruenbacher return -EIO; 43669f4fe9adSAndreas Gruenbacher device = peer_device->device; 436773a01a18SPhilipp Reisner 4368b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4369f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4370f735e363SLars Ellenberg case C_WF_BITMAP_T: 4371f735e363SLars Ellenberg case C_BEHIND: 4372f735e363SLars Ellenberg break; 4373f735e363SLars Ellenberg default: 4374d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4375b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4376f735e363SLars Ellenberg } 4377f735e363SLars Ellenberg 4378b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 437973a01a18SPhilipp Reisner 438082bc0194SAndreas Gruenbacher return 0; 438173a01a18SPhilipp Reisner } 438273a01a18SPhilipp Reisner 438302918be2SPhilipp Reisner struct data_cmd { 438402918be2SPhilipp Reisner int expect_payload; 438502918be2SPhilipp Reisner size_t pkt_size; 4386bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4387b411b363SPhilipp Reisner }; 4388b411b363SPhilipp Reisner 438902918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 439002918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 439102918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 439202918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 439302918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4394e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4395e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4396e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 439702918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 439802918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4399e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4400e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 440102918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 440202918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 440302918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 440402918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 440502918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 440602918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 440702918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 440802918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 440902918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 441002918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 441173a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 44124a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4413036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 441402918be2SPhilipp Reisner }; 441502918be2SPhilipp Reisner 4416bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4417b411b363SPhilipp Reisner { 441877351055SPhilipp Reisner struct packet_info pi; 441902918be2SPhilipp Reisner size_t shs; /* sub header size */ 442082bc0194SAndreas Gruenbacher int err; 4421b411b363SPhilipp Reisner 4422bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 4423deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4424deebe195SAndreas Gruenbacher 4425bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4426bde89a9eSAndreas Gruenbacher if (drbd_recv_header(connection, &pi)) 442702918be2SPhilipp Reisner goto err_out; 442802918be2SPhilipp Reisner 4429deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 44304a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 44311ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 44322fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 443302918be2SPhilipp Reisner goto err_out; 44340b33a916SLars Ellenberg } 4435b411b363SPhilipp Reisner 4436e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4437e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 44381ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 44392fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4440c13f7e1aSLars Ellenberg goto err_out; 4441c13f7e1aSLars Ellenberg } 4442c13f7e1aSLars Ellenberg 4443c13f7e1aSLars Ellenberg if (shs) { 4444bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 4445a5c31904SAndreas Gruenbacher if (err) 444602918be2SPhilipp Reisner goto err_out; 4447e2857216SAndreas Gruenbacher pi.size -= shs; 4448b411b363SPhilipp Reisner } 444902918be2SPhilipp Reisner 4450bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 44514a76b161SAndreas Gruenbacher if (err) { 44521ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 44539f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 445402918be2SPhilipp Reisner goto err_out; 445502918be2SPhilipp Reisner } 445602918be2SPhilipp Reisner } 445782bc0194SAndreas Gruenbacher return; 445802918be2SPhilipp Reisner 445902918be2SPhilipp Reisner err_out: 4460bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4461b411b363SPhilipp Reisner } 4462b411b363SPhilipp Reisner 4463bde89a9eSAndreas Gruenbacher void conn_flush_workqueue(struct drbd_connection *connection) 4464b411b363SPhilipp Reisner { 4465b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4466b411b363SPhilipp Reisner 4467b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 4468bde89a9eSAndreas Gruenbacher barr.w.connection = connection; 4469b411b363SPhilipp Reisner init_completion(&barr.done); 4470bde89a9eSAndreas Gruenbacher drbd_queue_work(&connection->sender_work, &barr.w); 4471b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4472b411b363SPhilipp Reisner } 4473b411b363SPhilipp Reisner 4474bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 4475f70b3511SPhilipp Reisner { 4476c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4477bbeb641cSPhilipp Reisner enum drbd_conns oc; 4478376694a0SPhilipp Reisner int vnr; 4479f70b3511SPhilipp Reisner 4480bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 4481b411b363SPhilipp Reisner return; 4482b411b363SPhilipp Reisner 4483545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4484545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4485545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4486545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4487545752d5SLars Ellenberg */ 4488bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4489545752d5SLars Ellenberg 4490b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4491bde89a9eSAndreas Gruenbacher drbd_thread_stop(&connection->asender); 4492bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 4493360cc740SPhilipp Reisner 4494c141ebdaSPhilipp Reisner rcu_read_lock(); 4495c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 4496c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4497b30ab791SAndreas Gruenbacher kref_get(&device->kref); 4498c141ebdaSPhilipp Reisner rcu_read_unlock(); 4499b30ab791SAndreas Gruenbacher drbd_disconnected(device); 4500c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 4501c141ebdaSPhilipp Reisner rcu_read_lock(); 4502c141ebdaSPhilipp Reisner } 4503c141ebdaSPhilipp Reisner rcu_read_unlock(); 4504c141ebdaSPhilipp Reisner 4505bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 45061ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 450712038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4508bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 4509bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 451012038a3aSPhilipp Reisner 45111ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 4512360cc740SPhilipp Reisner 4513bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 4514bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 4515cb703454SPhilipp Reisner 45160500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 4517bde89a9eSAndreas Gruenbacher oc = connection->cstate; 4518bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4519bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4520bbeb641cSPhilipp Reisner 45210500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 4522360cc740SPhilipp Reisner 4523f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4524bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4525360cc740SPhilipp Reisner } 4526360cc740SPhilipp Reisner 4527b30ab791SAndreas Gruenbacher static int drbd_disconnected(struct drbd_device *device) 4528360cc740SPhilipp Reisner { 4529360cc740SPhilipp Reisner unsigned int i; 4530b411b363SPhilipp Reisner 453185719573SPhilipp Reisner /* wait for current activity to cease. */ 45320500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4533b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 4534b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 4535b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 45360500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4537b411b363SPhilipp Reisner 4538b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4539b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4540b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4541b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4542b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4543b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4544b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4545b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4546b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4547b411b363SPhilipp Reisner * on the fly. */ 4548b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4549b30ab791SAndreas Gruenbacher device->rs_total = 0; 4550b30ab791SAndreas Gruenbacher device->rs_failed = 0; 4551b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 4552b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 4553b411b363SPhilipp Reisner 4554b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 4555b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 4556b411b363SPhilipp Reisner 4557b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4558b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4559b411b363SPhilipp Reisner * to be "canceled" */ 4560b30ab791SAndreas Gruenbacher drbd_flush_workqueue(device); 4561b411b363SPhilipp Reisner 4562b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 4563b411b363SPhilipp Reisner 4564d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4565d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4566d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4567b30ab791SAndreas Gruenbacher drbd_flush_workqueue(device); 4568d10b4ea3SPhilipp Reisner 456908332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 457008332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 4571b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4572b411b363SPhilipp Reisner 4573b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4574b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 4575b411b363SPhilipp Reisner 4576b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 4577a6b32bc3SAndreas Gruenbacher tl_clear(first_peer_device(device)->connection); 4578b411b363SPhilipp Reisner 4579b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4580b411b363SPhilipp Reisner 458120ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 458220ceb2b2SLars Ellenberg * if any. */ 4583b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, !test_bit(BITMAP_IO, &device->flags)); 458420ceb2b2SLars Ellenberg 4585b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4586b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4587b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4588b411b363SPhilipp Reisner * 4589b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4590b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4591b411b363SPhilipp Reisner */ 4592b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 4593b411b363SPhilipp Reisner if (i) 4594d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 4595b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 4596435f0740SLars Ellenberg if (i) 4597d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 4598b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 4599b411b363SPhilipp Reisner if (i) 4600d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 4601b411b363SPhilipp Reisner 46020b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 46030b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 46040b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 46050b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 4606b411b363SPhilipp Reisner 4607360cc740SPhilipp Reisner return 0; 4608b411b363SPhilipp Reisner } 4609b411b363SPhilipp Reisner 4610b411b363SPhilipp Reisner /* 4611b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4612b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4613b411b363SPhilipp Reisner * 4614b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4615b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4616b411b363SPhilipp Reisner * 4617b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4618b411b363SPhilipp Reisner */ 4619bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 4620b411b363SPhilipp Reisner { 46219f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 46229f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4623b411b363SPhilipp Reisner 4624bde89a9eSAndreas Gruenbacher sock = &connection->data; 4625bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 46269f5bdc33SAndreas Gruenbacher if (!p) 4627e8d17b01SAndreas Gruenbacher return -EIO; 4628b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4629b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4630b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 4631bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4632b411b363SPhilipp Reisner } 4633b411b363SPhilipp Reisner 4634b411b363SPhilipp Reisner /* 4635b411b363SPhilipp Reisner * return values: 4636b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4637b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4638b411b363SPhilipp Reisner * -1 peer talks different language, 4639b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4640b411b363SPhilipp Reisner */ 4641bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 4642b411b363SPhilipp Reisner { 4643bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 4644e658983aSAndreas Gruenbacher struct p_connection_features *p; 4645e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 464677351055SPhilipp Reisner struct packet_info pi; 4647a5c31904SAndreas Gruenbacher int err; 4648b411b363SPhilipp Reisner 4649bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 4650e8d17b01SAndreas Gruenbacher if (err) 4651b411b363SPhilipp Reisner return 0; 4652b411b363SPhilipp Reisner 4653bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 465469bc7bc3SAndreas Gruenbacher if (err) 4655b411b363SPhilipp Reisner return 0; 4656b411b363SPhilipp Reisner 46576038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 46581ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 465977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4660b411b363SPhilipp Reisner return -1; 4661b411b363SPhilipp Reisner } 4662b411b363SPhilipp Reisner 466377351055SPhilipp Reisner if (pi.size != expect) { 46641ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 466577351055SPhilipp Reisner expect, pi.size); 4666b411b363SPhilipp Reisner return -1; 4667b411b363SPhilipp Reisner } 4668b411b363SPhilipp Reisner 4669e658983aSAndreas Gruenbacher p = pi.data; 4670bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 4671a5c31904SAndreas Gruenbacher if (err) 4672b411b363SPhilipp Reisner return 0; 4673b411b363SPhilipp Reisner 4674b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4675b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4676b411b363SPhilipp Reisner if (p->protocol_max == 0) 4677b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4678b411b363SPhilipp Reisner 4679b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4680b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4681b411b363SPhilipp Reisner goto incompat; 4682b411b363SPhilipp Reisner 4683bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4684b411b363SPhilipp Reisner 46851ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 4686bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 4687b411b363SPhilipp Reisner 4688b411b363SPhilipp Reisner return 1; 4689b411b363SPhilipp Reisner 4690b411b363SPhilipp Reisner incompat: 46911ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 4692b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4693b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4694b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4695b411b363SPhilipp Reisner return -1; 4696b411b363SPhilipp Reisner } 4697b411b363SPhilipp Reisner 4698b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4699bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4700b411b363SPhilipp Reisner { 47011ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 47021ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4703b10d96cbSJohannes Thoma return -1; 4704b411b363SPhilipp Reisner } 4705b411b363SPhilipp Reisner #else 4706b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4707b10d96cbSJohannes Thoma 4708b10d96cbSJohannes Thoma /* Return value: 4709b10d96cbSJohannes Thoma 1 - auth succeeded, 4710b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4711b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4712b10d96cbSJohannes Thoma */ 4713b10d96cbSJohannes Thoma 4714bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4715b411b363SPhilipp Reisner { 47169f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4717b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4718b411b363SPhilipp Reisner struct scatterlist sg; 4719b411b363SPhilipp Reisner char *response = NULL; 4720b411b363SPhilipp Reisner char *right_response = NULL; 4721b411b363SPhilipp Reisner char *peers_ch = NULL; 472244ed167dSPhilipp Reisner unsigned int key_len; 472344ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4724b411b363SPhilipp Reisner unsigned int resp_size; 4725b411b363SPhilipp Reisner struct hash_desc desc; 472677351055SPhilipp Reisner struct packet_info pi; 472744ed167dSPhilipp Reisner struct net_conf *nc; 472869bc7bc3SAndreas Gruenbacher int err, rv; 4729b411b363SPhilipp Reisner 47309f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 47319f5bdc33SAndreas Gruenbacher 473244ed167dSPhilipp Reisner rcu_read_lock(); 4733bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 473444ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 473544ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 473644ed167dSPhilipp Reisner rcu_read_unlock(); 473744ed167dSPhilipp Reisner 4738bde89a9eSAndreas Gruenbacher desc.tfm = connection->cram_hmac_tfm; 4739b411b363SPhilipp Reisner desc.flags = 0; 4740b411b363SPhilipp Reisner 4741bde89a9eSAndreas Gruenbacher rv = crypto_hash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 4742b411b363SPhilipp Reisner if (rv) { 47431ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_setkey() failed with %d\n", rv); 4744b10d96cbSJohannes Thoma rv = -1; 4745b411b363SPhilipp Reisner goto fail; 4746b411b363SPhilipp Reisner } 4747b411b363SPhilipp Reisner 4748b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4749b411b363SPhilipp Reisner 4750bde89a9eSAndreas Gruenbacher sock = &connection->data; 4751bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 47529f5bdc33SAndreas Gruenbacher rv = 0; 47539f5bdc33SAndreas Gruenbacher goto fail; 47549f5bdc33SAndreas Gruenbacher } 4755bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 47569f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4757b411b363SPhilipp Reisner if (!rv) 4758b411b363SPhilipp Reisner goto fail; 4759b411b363SPhilipp Reisner 4760bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 476169bc7bc3SAndreas Gruenbacher if (err) { 4762b411b363SPhilipp Reisner rv = 0; 4763b411b363SPhilipp Reisner goto fail; 4764b411b363SPhilipp Reisner } 4765b411b363SPhilipp Reisner 476677351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 47671ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 476877351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4769b411b363SPhilipp Reisner rv = 0; 4770b411b363SPhilipp Reisner goto fail; 4771b411b363SPhilipp Reisner } 4772b411b363SPhilipp Reisner 477377351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 47741ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 4775b10d96cbSJohannes Thoma rv = -1; 4776b411b363SPhilipp Reisner goto fail; 4777b411b363SPhilipp Reisner } 4778b411b363SPhilipp Reisner 477977351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4780b411b363SPhilipp Reisner if (peers_ch == NULL) { 47811ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 4782b10d96cbSJohannes Thoma rv = -1; 4783b411b363SPhilipp Reisner goto fail; 4784b411b363SPhilipp Reisner } 4785b411b363SPhilipp Reisner 4786bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 4787a5c31904SAndreas Gruenbacher if (err) { 4788b411b363SPhilipp Reisner rv = 0; 4789b411b363SPhilipp Reisner goto fail; 4790b411b363SPhilipp Reisner } 4791b411b363SPhilipp Reisner 4792bde89a9eSAndreas Gruenbacher resp_size = crypto_hash_digestsize(connection->cram_hmac_tfm); 4793b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4794b411b363SPhilipp Reisner if (response == NULL) { 47951ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 4796b10d96cbSJohannes Thoma rv = -1; 4797b411b363SPhilipp Reisner goto fail; 4798b411b363SPhilipp Reisner } 4799b411b363SPhilipp Reisner 4800b411b363SPhilipp Reisner sg_init_table(&sg, 1); 480177351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4802b411b363SPhilipp Reisner 4803b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4804b411b363SPhilipp Reisner if (rv) { 48051ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4806b10d96cbSJohannes Thoma rv = -1; 4807b411b363SPhilipp Reisner goto fail; 4808b411b363SPhilipp Reisner } 4809b411b363SPhilipp Reisner 4810bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 48119f5bdc33SAndreas Gruenbacher rv = 0; 48129f5bdc33SAndreas Gruenbacher goto fail; 48139f5bdc33SAndreas Gruenbacher } 4814bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 48159f5bdc33SAndreas Gruenbacher response, resp_size); 4816b411b363SPhilipp Reisner if (!rv) 4817b411b363SPhilipp Reisner goto fail; 4818b411b363SPhilipp Reisner 4819bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 482069bc7bc3SAndreas Gruenbacher if (err) { 4821b411b363SPhilipp Reisner rv = 0; 4822b411b363SPhilipp Reisner goto fail; 4823b411b363SPhilipp Reisner } 4824b411b363SPhilipp Reisner 482577351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 48261ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 482777351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4828b411b363SPhilipp Reisner rv = 0; 4829b411b363SPhilipp Reisner goto fail; 4830b411b363SPhilipp Reisner } 4831b411b363SPhilipp Reisner 483277351055SPhilipp Reisner if (pi.size != resp_size) { 48331ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 4834b411b363SPhilipp Reisner rv = 0; 4835b411b363SPhilipp Reisner goto fail; 4836b411b363SPhilipp Reisner } 4837b411b363SPhilipp Reisner 4838bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 4839a5c31904SAndreas Gruenbacher if (err) { 4840b411b363SPhilipp Reisner rv = 0; 4841b411b363SPhilipp Reisner goto fail; 4842b411b363SPhilipp Reisner } 4843b411b363SPhilipp Reisner 4844b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 48452d1ee87dSJulia Lawall if (right_response == NULL) { 48461ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 4847b10d96cbSJohannes Thoma rv = -1; 4848b411b363SPhilipp Reisner goto fail; 4849b411b363SPhilipp Reisner } 4850b411b363SPhilipp Reisner 4851b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4852b411b363SPhilipp Reisner 4853b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4854b411b363SPhilipp Reisner if (rv) { 48551ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4856b10d96cbSJohannes Thoma rv = -1; 4857b411b363SPhilipp Reisner goto fail; 4858b411b363SPhilipp Reisner } 4859b411b363SPhilipp Reisner 4860b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4861b411b363SPhilipp Reisner 4862b411b363SPhilipp Reisner if (rv) 48631ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 486444ed167dSPhilipp Reisner resp_size); 4865b10d96cbSJohannes Thoma else 4866b10d96cbSJohannes Thoma rv = -1; 4867b411b363SPhilipp Reisner 4868b411b363SPhilipp Reisner fail: 4869b411b363SPhilipp Reisner kfree(peers_ch); 4870b411b363SPhilipp Reisner kfree(response); 4871b411b363SPhilipp Reisner kfree(right_response); 4872b411b363SPhilipp Reisner 4873b411b363SPhilipp Reisner return rv; 4874b411b363SPhilipp Reisner } 4875b411b363SPhilipp Reisner #endif 4876b411b363SPhilipp Reisner 48778fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 4878b411b363SPhilipp Reisner { 4879bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 4880b411b363SPhilipp Reisner int h; 4881b411b363SPhilipp Reisner 48821ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 4883b411b363SPhilipp Reisner 4884b411b363SPhilipp Reisner do { 4885bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 4886b411b363SPhilipp Reisner if (h == 0) { 4887bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 488820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4889b411b363SPhilipp Reisner } 4890b411b363SPhilipp Reisner if (h == -1) { 48911ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 4892bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 4893b411b363SPhilipp Reisner } 4894b411b363SPhilipp Reisner } while (h == 0); 4895b411b363SPhilipp Reisner 489691fd4dadSPhilipp Reisner if (h > 0) 4897bde89a9eSAndreas Gruenbacher drbdd(connection); 4898b411b363SPhilipp Reisner 4899bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 4900b411b363SPhilipp Reisner 49011ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 4902b411b363SPhilipp Reisner return 0; 4903b411b363SPhilipp Reisner } 4904b411b363SPhilipp Reisner 4905b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4906b411b363SPhilipp Reisner 4907bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 4908b411b363SPhilipp Reisner { 4909e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4910b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4911b411b363SPhilipp Reisner 4912b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4913bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 4914b411b363SPhilipp Reisner } else { 4915bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 49161ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 4917fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4918fc3b10a4SPhilipp Reisner } 4919bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 4920e4f78edeSPhilipp Reisner 49212735a594SAndreas Gruenbacher return 0; 4922fc3b10a4SPhilipp Reisner } 4923e4f78edeSPhilipp Reisner 4924bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 4925e4f78edeSPhilipp Reisner { 49269f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4927b30ab791SAndreas Gruenbacher struct drbd_device *device; 4928e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4929e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4930e4f78edeSPhilipp Reisner 49319f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 49329f4fe9adSAndreas Gruenbacher if (!peer_device) 49332735a594SAndreas Gruenbacher return -EIO; 49349f4fe9adSAndreas Gruenbacher device = peer_device->device; 49351952e916SAndreas Gruenbacher 4936bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 49370b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 4938bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 49394d0fc3fdSPhilipp Reisner } 49404d0fc3fdSPhilipp Reisner 4941e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4942b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 4943e4f78edeSPhilipp Reisner } else { 4944b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 4945d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 4946b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4947b411b363SPhilipp Reisner } 4948b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 4949b411b363SPhilipp Reisner 49502735a594SAndreas Gruenbacher return 0; 4951b411b363SPhilipp Reisner } 4952b411b363SPhilipp Reisner 4953bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 4954b411b363SPhilipp Reisner { 4955bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 4956b411b363SPhilipp Reisner 4957b411b363SPhilipp Reisner } 4958b411b363SPhilipp Reisner 4959bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 4960b411b363SPhilipp Reisner { 4961b411b363SPhilipp Reisner /* restore idle timeout */ 4962bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 4963bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 4964bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 4965b411b363SPhilipp Reisner 49662735a594SAndreas Gruenbacher return 0; 4967b411b363SPhilipp Reisner } 4968b411b363SPhilipp Reisner 4969bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 4970b411b363SPhilipp Reisner { 49719f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4972b30ab791SAndreas Gruenbacher struct drbd_device *device; 4973e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4974b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4975b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4976b411b363SPhilipp Reisner 49779f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 49789f4fe9adSAndreas Gruenbacher if (!peer_device) 49792735a594SAndreas Gruenbacher return -EIO; 49809f4fe9adSAndreas Gruenbacher device = peer_device->device; 49811952e916SAndreas Gruenbacher 49829f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 4983b411b363SPhilipp Reisner 4984b30ab791SAndreas Gruenbacher update_peer_seq(device, be32_to_cpu(p->seq_num)); 4985b411b363SPhilipp Reisner 4986b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4987b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 4988b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 4989b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4990b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 4991b30ab791SAndreas Gruenbacher put_ldev(device); 49921d53f09eSLars Ellenberg } 4993b30ab791SAndreas Gruenbacher dec_rs_pending(device); 4994b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 4995b411b363SPhilipp Reisner 49962735a594SAndreas Gruenbacher return 0; 4997b411b363SPhilipp Reisner } 4998b411b363SPhilipp Reisner 4999bc9c5c41SAndreas Gruenbacher static int 5000b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5001bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5002bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5003b411b363SPhilipp Reisner { 5004b411b363SPhilipp Reisner struct drbd_request *req; 5005b411b363SPhilipp Reisner struct bio_and_error m; 5006b411b363SPhilipp Reisner 50070500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5008b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5009b411b363SPhilipp Reisner if (unlikely(!req)) { 50100500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 501185997675SAndreas Gruenbacher return -EIO; 5012b411b363SPhilipp Reisner } 5013b411b363SPhilipp Reisner __req_mod(req, what, &m); 50140500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5015b411b363SPhilipp Reisner 5016b411b363SPhilipp Reisner if (m.bio) 5017b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 501885997675SAndreas Gruenbacher return 0; 5019b411b363SPhilipp Reisner } 5020b411b363SPhilipp Reisner 5021bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5022b411b363SPhilipp Reisner { 50239f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5024b30ab791SAndreas Gruenbacher struct drbd_device *device; 5025e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5026b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5027b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5028b411b363SPhilipp Reisner enum drbd_req_event what; 5029b411b363SPhilipp Reisner 50309f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 50319f4fe9adSAndreas Gruenbacher if (!peer_device) 50322735a594SAndreas Gruenbacher return -EIO; 50339f4fe9adSAndreas Gruenbacher device = peer_device->device; 50341952e916SAndreas Gruenbacher 5035b30ab791SAndreas Gruenbacher update_peer_seq(device, be32_to_cpu(p->seq_num)); 5036b411b363SPhilipp Reisner 5037579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5038b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5039b30ab791SAndreas Gruenbacher dec_rs_pending(device); 50402735a594SAndreas Gruenbacher return 0; 5041b411b363SPhilipp Reisner } 5042e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5043b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 50448554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5045b411b363SPhilipp Reisner break; 5046b411b363SPhilipp Reisner case P_WRITE_ACK: 50478554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5048b411b363SPhilipp Reisner break; 5049b411b363SPhilipp Reisner case P_RECV_ACK: 50508554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5051b411b363SPhilipp Reisner break; 5052d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5053d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 50547be8da07SAndreas Gruenbacher break; 50557be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 50567be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5057b411b363SPhilipp Reisner break; 5058b411b363SPhilipp Reisner default: 50592735a594SAndreas Gruenbacher BUG(); 5060b411b363SPhilipp Reisner } 5061b411b363SPhilipp Reisner 5062b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5063b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5064bc9c5c41SAndreas Gruenbacher what, false); 5065b411b363SPhilipp Reisner } 5066b411b363SPhilipp Reisner 5067bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5068b411b363SPhilipp Reisner { 50699f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5070b30ab791SAndreas Gruenbacher struct drbd_device *device; 5071e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5072b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 50732deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 507485997675SAndreas Gruenbacher int err; 5075b411b363SPhilipp Reisner 50769f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 50779f4fe9adSAndreas Gruenbacher if (!peer_device) 50782735a594SAndreas Gruenbacher return -EIO; 50799f4fe9adSAndreas Gruenbacher device = peer_device->device; 5080b411b363SPhilipp Reisner 5081b30ab791SAndreas Gruenbacher update_peer_seq(device, be32_to_cpu(p->seq_num)); 5082b411b363SPhilipp Reisner 5083579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5084b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5085b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 50862735a594SAndreas Gruenbacher return 0; 5087b411b363SPhilipp Reisner } 50882deb8336SPhilipp Reisner 5089b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5090b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5091303d1448SPhilipp Reisner NEG_ACKED, true); 509285997675SAndreas Gruenbacher if (err) { 50932deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 50942deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5095c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 50962deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 50972deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5098b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 50992deb8336SPhilipp Reisner } 51002735a594SAndreas Gruenbacher return 0; 5101b411b363SPhilipp Reisner } 5102b411b363SPhilipp Reisner 5103bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5104b411b363SPhilipp Reisner { 51059f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5106b30ab791SAndreas Gruenbacher struct drbd_device *device; 5107e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5108b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5109b411b363SPhilipp Reisner 51109f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51119f4fe9adSAndreas Gruenbacher if (!peer_device) 51122735a594SAndreas Gruenbacher return -EIO; 51139f4fe9adSAndreas Gruenbacher device = peer_device->device; 51141952e916SAndreas Gruenbacher 5115b30ab791SAndreas Gruenbacher update_peer_seq(device, be32_to_cpu(p->seq_num)); 51167be8da07SAndreas Gruenbacher 5117d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5118b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5119b411b363SPhilipp Reisner 5120b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5121b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 51228554df1cSAndreas Gruenbacher NEG_ACKED, false); 5123b411b363SPhilipp Reisner } 5124b411b363SPhilipp Reisner 5125bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5126b411b363SPhilipp Reisner { 51279f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5128b30ab791SAndreas Gruenbacher struct drbd_device *device; 5129b411b363SPhilipp Reisner sector_t sector; 5130b411b363SPhilipp Reisner int size; 5131e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 51321952e916SAndreas Gruenbacher 51339f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51349f4fe9adSAndreas Gruenbacher if (!peer_device) 51352735a594SAndreas Gruenbacher return -EIO; 51369f4fe9adSAndreas Gruenbacher device = peer_device->device; 5137b411b363SPhilipp Reisner 5138b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5139b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5140b411b363SPhilipp Reisner 5141b30ab791SAndreas Gruenbacher update_peer_seq(device, be32_to_cpu(p->seq_num)); 5142b411b363SPhilipp Reisner 5143b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5144b411b363SPhilipp Reisner 5145b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5146b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5147e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5148d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5149b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5150d612d309SPhilipp Reisner case P_RS_CANCEL: 5151d612d309SPhilipp Reisner break; 5152d612d309SPhilipp Reisner default: 51532735a594SAndreas Gruenbacher BUG(); 5154d612d309SPhilipp Reisner } 5155b30ab791SAndreas Gruenbacher put_ldev(device); 5156b411b363SPhilipp Reisner } 5157b411b363SPhilipp Reisner 51582735a594SAndreas Gruenbacher return 0; 5159b411b363SPhilipp Reisner } 5160b411b363SPhilipp Reisner 5161bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5162b411b363SPhilipp Reisner { 5163e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5164c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 51659ed57dcbSLars Ellenberg int vnr; 5166b411b363SPhilipp Reisner 5167bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5168b411b363SPhilipp Reisner 51699ed57dcbSLars Ellenberg rcu_read_lock(); 5170c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5171c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5172c06ece6bSAndreas Gruenbacher 5173b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5174b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5175b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5176b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5177b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5178c4752ef1SPhilipp Reisner } 51799ed57dcbSLars Ellenberg } 51809ed57dcbSLars Ellenberg rcu_read_unlock(); 5181c4752ef1SPhilipp Reisner 51822735a594SAndreas Gruenbacher return 0; 5183b411b363SPhilipp Reisner } 5184b411b363SPhilipp Reisner 5185bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5186b411b363SPhilipp Reisner { 51879f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5188b30ab791SAndreas Gruenbacher struct drbd_device *device; 5189e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5190b411b363SPhilipp Reisner struct drbd_work *w; 5191b411b363SPhilipp Reisner sector_t sector; 5192b411b363SPhilipp Reisner int size; 5193b411b363SPhilipp Reisner 51949f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51959f4fe9adSAndreas Gruenbacher if (!peer_device) 51962735a594SAndreas Gruenbacher return -EIO; 51979f4fe9adSAndreas Gruenbacher device = peer_device->device; 51981952e916SAndreas Gruenbacher 5199b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5200b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5201b411b363SPhilipp Reisner 5202b30ab791SAndreas Gruenbacher update_peer_seq(device, be32_to_cpu(p->seq_num)); 5203b411b363SPhilipp Reisner 5204b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5205b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5206b411b363SPhilipp Reisner else 5207b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5208b411b363SPhilipp Reisner 5209b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 52102735a594SAndreas Gruenbacher return 0; 52111d53f09eSLars Ellenberg 5212b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5213b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5214b411b363SPhilipp Reisner 5215b30ab791SAndreas Gruenbacher --device->ov_left; 5216ea5442afSLars Ellenberg 5217ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5218b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5219b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5220ea5442afSLars Ellenberg 5221b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 5222b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5223b411b363SPhilipp Reisner if (w) { 5224b411b363SPhilipp Reisner w->cb = w_ov_finished; 5225b30ab791SAndreas Gruenbacher w->device = device; 52269f4fe9adSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, w); 5227b411b363SPhilipp Reisner } else { 5228d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc(w) failed."); 5229b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5230b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5231b411b363SPhilipp Reisner } 5232b411b363SPhilipp Reisner } 5233b30ab791SAndreas Gruenbacher put_ldev(device); 52342735a594SAndreas Gruenbacher return 0; 5235b411b363SPhilipp Reisner } 5236b411b363SPhilipp Reisner 5237bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 52380ced55a3SPhilipp Reisner { 52392735a594SAndreas Gruenbacher return 0; 52400ced55a3SPhilipp Reisner } 52410ced55a3SPhilipp Reisner 5242bde89a9eSAndreas Gruenbacher static int connection_finish_peer_reqs(struct drbd_connection *connection) 524332862ec7SPhilipp Reisner { 5244c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5245c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 524632862ec7SPhilipp Reisner 524732862ec7SPhilipp Reisner do { 5248bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 524932862ec7SPhilipp Reisner flush_signals(current); 5250c141ebdaSPhilipp Reisner 5251c141ebdaSPhilipp Reisner rcu_read_lock(); 5252c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5253c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5254b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5255c141ebdaSPhilipp Reisner rcu_read_unlock(); 5256b30ab791SAndreas Gruenbacher if (drbd_finish_peer_reqs(device)) { 525705a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5258c141ebdaSPhilipp Reisner return 1; 5259082a3439SPhilipp Reisner } 526005a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5261c141ebdaSPhilipp Reisner rcu_read_lock(); 5262d3fcb490SPhilipp Reisner } 5263bde89a9eSAndreas Gruenbacher set_bit(SIGNAL_ASENDER, &connection->flags); 5264082a3439SPhilipp Reisner 52650500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5266c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5267c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5268b30ab791SAndreas Gruenbacher not_empty = !list_empty(&device->done_ee); 5269082a3439SPhilipp Reisner if (not_empty) 5270082a3439SPhilipp Reisner break; 5271082a3439SPhilipp Reisner } 52720500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5273c141ebdaSPhilipp Reisner rcu_read_unlock(); 527432862ec7SPhilipp Reisner } while (not_empty); 527532862ec7SPhilipp Reisner 527632862ec7SPhilipp Reisner return 0; 5277b411b363SPhilipp Reisner } 5278b411b363SPhilipp Reisner 5279b411b363SPhilipp Reisner struct asender_cmd { 5280b411b363SPhilipp Reisner size_t pkt_size; 5281bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5282b411b363SPhilipp Reisner }; 5283b411b363SPhilipp Reisner 5284b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 5285e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5286e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5287b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5288b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5289b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5290d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5291b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5292b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5293b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5294b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5295b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5296b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5297b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 529802918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5299d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 53001952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 53011952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5302b411b363SPhilipp Reisner }; 5303b411b363SPhilipp Reisner 5304b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5305b411b363SPhilipp Reisner { 5306bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5307b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 530877351055SPhilipp Reisner struct packet_info pi; 5309257d0af6SPhilipp Reisner int rv; 5310bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5311b411b363SPhilipp Reisner int received = 0; 5312bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 531352b061a4SAndreas Gruenbacher int expect = header_size; 531444ed167dSPhilipp Reisner bool ping_timeout_active = false; 531544ed167dSPhilipp Reisner struct net_conf *nc; 5316bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 53173990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5318b411b363SPhilipp Reisner 53193990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 53203990e04dSPhilipp Reisner if (rv < 0) 53211ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_asender: ERROR set priority, ret=%d\n", rv); 5322b411b363SPhilipp Reisner 5323e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 532480822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 532544ed167dSPhilipp Reisner 532644ed167dSPhilipp Reisner rcu_read_lock(); 5327bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 532844ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5329bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 533044ed167dSPhilipp Reisner ping_int = nc->ping_int; 533144ed167dSPhilipp Reisner rcu_read_unlock(); 533244ed167dSPhilipp Reisner 5333bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5334bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 53351ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5336841ce241SAndreas Gruenbacher goto reconnect; 5337841ce241SAndreas Gruenbacher } 5338bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 533944ed167dSPhilipp Reisner ping_timeout_active = true; 5340b411b363SPhilipp Reisner } 5341b411b363SPhilipp Reisner 534232862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 534332862ec7SPhilipp Reisner much to send */ 5344bb77d34eSAndreas Gruenbacher if (tcp_cork) 5345bde89a9eSAndreas Gruenbacher drbd_tcp_cork(connection->meta.socket); 5346bde89a9eSAndreas Gruenbacher if (connection_finish_peer_reqs(connection)) { 53471ec861ebSAndreas Gruenbacher drbd_err(connection, "connection_finish_peer_reqs() failed\n"); 5348b411b363SPhilipp Reisner goto reconnect; 5349b411b363SPhilipp Reisner } 5350b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5351bb77d34eSAndreas Gruenbacher if (tcp_cork) 5352bde89a9eSAndreas Gruenbacher drbd_tcp_uncork(connection->meta.socket); 5353b411b363SPhilipp Reisner 5354b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5355b411b363SPhilipp Reisner if (signal_pending(current)) 5356b411b363SPhilipp Reisner continue; 5357b411b363SPhilipp Reisner 5358bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5359bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5360b411b363SPhilipp Reisner 5361b411b363SPhilipp Reisner flush_signals(current); 5362b411b363SPhilipp Reisner 5363b411b363SPhilipp Reisner /* Note: 5364b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5365b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5366b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5367b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5368b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5369b411b363SPhilipp Reisner * rv == expected: full header or command 5370b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5371b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5372b411b363SPhilipp Reisner */ 5373b411b363SPhilipp Reisner if (likely(rv > 0)) { 5374b411b363SPhilipp Reisner received += rv; 5375b411b363SPhilipp Reisner buf += rv; 5376b411b363SPhilipp Reisner } else if (rv == 0) { 5377bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5378b66623e3SPhilipp Reisner long t; 5379b66623e3SPhilipp Reisner rcu_read_lock(); 5380bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5381b66623e3SPhilipp Reisner rcu_read_unlock(); 5382b66623e3SPhilipp Reisner 5383bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5384bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5385b66623e3SPhilipp Reisner t); 5386599377acSPhilipp Reisner if (t) 5387599377acSPhilipp Reisner break; 5388599377acSPhilipp Reisner } 53891ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5390b411b363SPhilipp Reisner goto reconnect; 5391b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5392cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5393cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5394bde89a9eSAndreas Gruenbacher if (time_after(connection->last_received, 5395bde89a9eSAndreas Gruenbacher jiffies - connection->meta.socket->sk->sk_rcvtimeo)) 5396cb6518cbSLars Ellenberg continue; 5397f36af18cSLars Ellenberg if (ping_timeout_active) { 53981ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5399b411b363SPhilipp Reisner goto reconnect; 5400b411b363SPhilipp Reisner } 5401bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5402b411b363SPhilipp Reisner continue; 5403b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5404b411b363SPhilipp Reisner continue; 5405b411b363SPhilipp Reisner } else { 54061ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5407b411b363SPhilipp Reisner goto reconnect; 5408b411b363SPhilipp Reisner } 5409b411b363SPhilipp Reisner 5410b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5411bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5412b411b363SPhilipp Reisner goto reconnect; 54137201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 54141952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 54151ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 54162fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5417b411b363SPhilipp Reisner goto disconnect; 5418b411b363SPhilipp Reisner } 5419e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 542052b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 54211ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 542277351055SPhilipp Reisner pi.cmd, pi.size); 5423b411b363SPhilipp Reisner goto reconnect; 5424b411b363SPhilipp Reisner } 5425257d0af6SPhilipp Reisner } 5426b411b363SPhilipp Reisner if (received == expect) { 54272735a594SAndreas Gruenbacher bool err; 5428a4fbda8eSPhilipp Reisner 5429bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 54302735a594SAndreas Gruenbacher if (err) { 54311ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5432b411b363SPhilipp Reisner goto reconnect; 54331952e916SAndreas Gruenbacher } 5434b411b363SPhilipp Reisner 5435bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5436f36af18cSLars Ellenberg 543744ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 543844ed167dSPhilipp Reisner /* restore idle timeout */ 5439bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 544044ed167dSPhilipp Reisner ping_timeout_active = false; 544144ed167dSPhilipp Reisner } 5442b411b363SPhilipp Reisner 5443bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5444b411b363SPhilipp Reisner received = 0; 544552b061a4SAndreas Gruenbacher expect = header_size; 5446b411b363SPhilipp Reisner cmd = NULL; 5447b411b363SPhilipp Reisner } 5448b411b363SPhilipp Reisner } 5449b411b363SPhilipp Reisner 5450b411b363SPhilipp Reisner if (0) { 5451b411b363SPhilipp Reisner reconnect: 5452bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5453bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5454b411b363SPhilipp Reisner } 5455b411b363SPhilipp Reisner if (0) { 5456b411b363SPhilipp Reisner disconnect: 5457bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5458b411b363SPhilipp Reisner } 5459bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5460b411b363SPhilipp Reisner 54611ec861ebSAndreas Gruenbacher drbd_info(connection, "asender terminated\n"); 5462b411b363SPhilipp Reisner 5463b411b363SPhilipp Reisner return 0; 5464b411b363SPhilipp Reisner } 5465