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); 6769a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_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 { 203a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req, *tmp; 204b411b363SPhilipp Reisner 205b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 206b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 207b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 208b411b363SPhilipp Reisner stop to examine the list... */ 209b411b363SPhilipp Reisner 210a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, tmp, &device->net_ee, w.list) { 211045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 212b411b363SPhilipp Reisner break; 213a8cd15baSAndreas Gruenbacher list_move(&peer_req->w.list, to_be_freed); 214b411b363SPhilipp Reisner } 215b411b363SPhilipp Reisner } 216b411b363SPhilipp Reisner 217b30ab791SAndreas Gruenbacher static void drbd_kick_lo_and_reclaim_net(struct drbd_device *device) 218b411b363SPhilipp Reisner { 219b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 220db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 221b411b363SPhilipp Reisner 2220500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 223b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 2240500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 225b411b363SPhilipp Reisner 226a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 227b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 228b411b363SPhilipp Reisner } 229b411b363SPhilipp Reisner 230b411b363SPhilipp Reisner /** 231c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 232b30ab791SAndreas Gruenbacher * @device: DRBD device. 23345bb912bSLars Ellenberg * @number: number of pages requested 23445bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 235b411b363SPhilipp Reisner * 23645bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23745bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23845bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 23945bb912bSLars Ellenberg * 24045bb912bSLars Ellenberg * Returns a page chain linked via page->private. 241b411b363SPhilipp Reisner */ 24269a22773SAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_peer_device *peer_device, unsigned int number, 243c37c8ecfSAndreas Gruenbacher bool retry) 244b411b363SPhilipp Reisner { 24569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 246b411b363SPhilipp Reisner struct page *page = NULL; 24744ed167dSPhilipp Reisner struct net_conf *nc; 248b411b363SPhilipp Reisner DEFINE_WAIT(wait); 24944ed167dSPhilipp Reisner int mxb; 250b411b363SPhilipp Reisner 25145bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 25245bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25344ed167dSPhilipp Reisner rcu_read_lock(); 25469a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 25544ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 25644ed167dSPhilipp Reisner rcu_read_unlock(); 25744ed167dSPhilipp Reisner 258b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) 259b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 260b411b363SPhilipp Reisner 26145bb912bSLars Ellenberg while (page == NULL) { 262b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 263b411b363SPhilipp Reisner 264b30ab791SAndreas Gruenbacher drbd_kick_lo_and_reclaim_net(device); 265b411b363SPhilipp Reisner 266b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) { 267b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 268b411b363SPhilipp Reisner if (page) 269b411b363SPhilipp Reisner break; 270b411b363SPhilipp Reisner } 271b411b363SPhilipp Reisner 272b411b363SPhilipp Reisner if (!retry) 273b411b363SPhilipp Reisner break; 274b411b363SPhilipp Reisner 275b411b363SPhilipp Reisner if (signal_pending(current)) { 276d0180171SAndreas Gruenbacher drbd_warn(device, "drbd_alloc_pages interrupted!\n"); 277b411b363SPhilipp Reisner break; 278b411b363SPhilipp Reisner } 279b411b363SPhilipp Reisner 280b411b363SPhilipp Reisner schedule(); 281b411b363SPhilipp Reisner } 282b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 283b411b363SPhilipp Reisner 28445bb912bSLars Ellenberg if (page) 285b30ab791SAndreas Gruenbacher atomic_add(number, &device->pp_in_use); 286b411b363SPhilipp Reisner return page; 287b411b363SPhilipp Reisner } 288b411b363SPhilipp Reisner 289c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 2900500813fSAndreas Gruenbacher * Is also used from inside an other spin_lock_irq(&resource->req_lock); 29145bb912bSLars Ellenberg * Either links the page chain back to the global pool, 29245bb912bSLars Ellenberg * or returns all pages to the system. */ 293b30ab791SAndreas Gruenbacher static void drbd_free_pages(struct drbd_device *device, struct page *page, int is_net) 294b411b363SPhilipp Reisner { 295b30ab791SAndreas Gruenbacher atomic_t *a = is_net ? &device->pp_in_use_by_net : &device->pp_in_use; 296b411b363SPhilipp Reisner int i; 297435f0740SLars Ellenberg 298a73ff323SLars Ellenberg if (page == NULL) 299a73ff323SLars Ellenberg return; 300a73ff323SLars Ellenberg 3011816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 30245bb912bSLars Ellenberg i = page_chain_free(page); 30345bb912bSLars Ellenberg else { 30445bb912bSLars Ellenberg struct page *tmp; 30545bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 306b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 30745bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 30845bb912bSLars Ellenberg drbd_pp_vacant += i; 309b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 310b411b363SPhilipp Reisner } 311435f0740SLars Ellenberg i = atomic_sub_return(i, a); 31245bb912bSLars Ellenberg if (i < 0) 313d0180171SAndreas Gruenbacher drbd_warn(device, "ASSERTION FAILED: %s: %d < 0\n", 314435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 315b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 316b411b363SPhilipp Reisner } 317b411b363SPhilipp Reisner 318b411b363SPhilipp Reisner /* 319b411b363SPhilipp Reisner You need to hold the req_lock: 320b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 321b411b363SPhilipp Reisner 322b411b363SPhilipp Reisner You must not have the req_lock: 3233967deb1SAndreas Gruenbacher drbd_free_peer_req() 3240db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3257721f567SAndreas Gruenbacher drbd_free_peer_reqs() 326b411b363SPhilipp Reisner drbd_ee_fix_bhs() 327a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 328b411b363SPhilipp Reisner drbd_clear_done_ee() 329b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 330b411b363SPhilipp Reisner */ 331b411b363SPhilipp Reisner 332f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 33369a22773SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 334f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 335b411b363SPhilipp Reisner { 33669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 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) { 35269a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_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; 364a8cd15baSAndreas Gruenbacher peer_req->peer_device = peer_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 403a8cd15baSAndreas 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 425a8cd15baSAndreas 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 */ 432a8cd15baSAndreas 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 */ 436a8cd15baSAndreas 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 struct kvec iov = { 473b411b363SPhilipp Reisner .iov_base = buf, 474b411b363SPhilipp Reisner .iov_len = size, 475b411b363SPhilipp Reisner }; 476b411b363SPhilipp Reisner struct msghdr msg = { 477b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 478b411b363SPhilipp Reisner }; 479f730c848SAl Viro return kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); 480b411b363SPhilipp Reisner } 481b411b363SPhilipp Reisner 482bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 483b411b363SPhilipp Reisner { 484b411b363SPhilipp Reisner int rv; 485b411b363SPhilipp Reisner 486bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 487b411b363SPhilipp Reisner 488b411b363SPhilipp Reisner if (rv < 0) { 489b411b363SPhilipp Reisner if (rv == -ECONNRESET) 4901ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 491b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 4921ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 493b411b363SPhilipp Reisner } else if (rv == 0) { 494bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 495b66623e3SPhilipp Reisner long t; 496b66623e3SPhilipp Reisner rcu_read_lock(); 497bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 498b66623e3SPhilipp Reisner rcu_read_unlock(); 499b66623e3SPhilipp Reisner 500bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 501b66623e3SPhilipp Reisner 502599377acSPhilipp Reisner if (t) 503599377acSPhilipp Reisner goto out; 504599377acSPhilipp Reisner } 5051ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 506599377acSPhilipp Reisner } 507599377acSPhilipp Reisner 508b411b363SPhilipp Reisner if (rv != size) 509bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 510b411b363SPhilipp Reisner 511599377acSPhilipp Reisner out: 512b411b363SPhilipp Reisner return rv; 513b411b363SPhilipp Reisner } 514b411b363SPhilipp Reisner 515bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 516c6967746SAndreas Gruenbacher { 517c6967746SAndreas Gruenbacher int err; 518c6967746SAndreas Gruenbacher 519bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 520c6967746SAndreas Gruenbacher if (err != size) { 521c6967746SAndreas Gruenbacher if (err >= 0) 522c6967746SAndreas Gruenbacher err = -EIO; 523c6967746SAndreas Gruenbacher } else 524c6967746SAndreas Gruenbacher err = 0; 525c6967746SAndreas Gruenbacher return err; 526c6967746SAndreas Gruenbacher } 527c6967746SAndreas Gruenbacher 528bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 529a5c31904SAndreas Gruenbacher { 530a5c31904SAndreas Gruenbacher int err; 531a5c31904SAndreas Gruenbacher 532bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 533a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5341ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 535a5c31904SAndreas Gruenbacher return err; 536a5c31904SAndreas Gruenbacher } 537a5c31904SAndreas Gruenbacher 5385dbf1673SLars Ellenberg /* quoting tcp(7): 5395dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5405dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5415dbf1673SLars Ellenberg * This is our wrapper to do so. 5425dbf1673SLars Ellenberg */ 5435dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5445dbf1673SLars Ellenberg unsigned int rcv) 5455dbf1673SLars Ellenberg { 5465dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5475dbf1673SLars Ellenberg if (snd) { 5485dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5495dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5505dbf1673SLars Ellenberg } 5515dbf1673SLars Ellenberg if (rcv) { 5525dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5535dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5545dbf1673SLars Ellenberg } 5555dbf1673SLars Ellenberg } 5565dbf1673SLars Ellenberg 557bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 558b411b363SPhilipp Reisner { 559b411b363SPhilipp Reisner const char *what; 560b411b363SPhilipp Reisner struct socket *sock; 561b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 56244ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 56344ed167dSPhilipp Reisner struct net_conf *nc; 56444ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 56569ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 566b411b363SPhilipp Reisner int disconnect_on_error = 1; 567b411b363SPhilipp Reisner 56844ed167dSPhilipp Reisner rcu_read_lock(); 569bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 57044ed167dSPhilipp Reisner if (!nc) { 57144ed167dSPhilipp Reisner rcu_read_unlock(); 572b411b363SPhilipp Reisner return NULL; 57344ed167dSPhilipp Reisner } 57444ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 57544ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 57669ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 577089c075dSAndreas Gruenbacher rcu_read_unlock(); 57844ed167dSPhilipp Reisner 579bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 580bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 58144ed167dSPhilipp Reisner 582bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 58344ed167dSPhilipp Reisner src_in6.sin6_port = 0; 58444ed167dSPhilipp Reisner else 58544ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 58644ed167dSPhilipp Reisner 587bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 588bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 589b411b363SPhilipp Reisner 590b411b363SPhilipp Reisner what = "sock_create_kern"; 59144ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 592b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 593b411b363SPhilipp Reisner if (err < 0) { 594b411b363SPhilipp Reisner sock = NULL; 595b411b363SPhilipp Reisner goto out; 596b411b363SPhilipp Reisner } 597b411b363SPhilipp Reisner 598b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 59969ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 60044ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 601b411b363SPhilipp Reisner 602b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 603b411b363SPhilipp Reisner * for the outgoing connections. 604b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 605b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 606b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 607b411b363SPhilipp Reisner * a free one dynamically. 608b411b363SPhilipp Reisner */ 609b411b363SPhilipp Reisner what = "bind before connect"; 61044ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 611b411b363SPhilipp Reisner if (err < 0) 612b411b363SPhilipp Reisner goto out; 613b411b363SPhilipp Reisner 614b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 615b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 616b411b363SPhilipp Reisner disconnect_on_error = 0; 617b411b363SPhilipp Reisner what = "connect"; 61844ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 619b411b363SPhilipp Reisner 620b411b363SPhilipp Reisner out: 621b411b363SPhilipp Reisner if (err < 0) { 622b411b363SPhilipp Reisner if (sock) { 623b411b363SPhilipp Reisner sock_release(sock); 624b411b363SPhilipp Reisner sock = NULL; 625b411b363SPhilipp Reisner } 626b411b363SPhilipp Reisner switch (-err) { 627b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 628b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 629b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 630b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 631b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 632b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 633b411b363SPhilipp Reisner disconnect_on_error = 0; 634b411b363SPhilipp Reisner break; 635b411b363SPhilipp Reisner default: 6361ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 637b411b363SPhilipp Reisner } 638b411b363SPhilipp Reisner if (disconnect_on_error) 639bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 640b411b363SPhilipp Reisner } 64144ed167dSPhilipp Reisner 642b411b363SPhilipp Reisner return sock; 643b411b363SPhilipp Reisner } 644b411b363SPhilipp Reisner 6457a426fd8SPhilipp Reisner struct accept_wait_data { 646bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6477a426fd8SPhilipp Reisner struct socket *s_listen; 6487a426fd8SPhilipp Reisner struct completion door_bell; 6497a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6507a426fd8SPhilipp Reisner 6517a426fd8SPhilipp Reisner }; 6527a426fd8SPhilipp Reisner 653715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 654b411b363SPhilipp Reisner { 6557a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 656715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6577a426fd8SPhilipp Reisner 658715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 659715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6607a426fd8SPhilipp Reisner complete(&ad->door_bell); 661715306f6SAndreas Gruenbacher state_change(sk); 6627a426fd8SPhilipp Reisner } 6637a426fd8SPhilipp Reisner 664bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 665b411b363SPhilipp Reisner { 6661f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 66744ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 6681f3e509bSPhilipp Reisner struct socket *s_listen; 66944ed167dSPhilipp Reisner struct net_conf *nc; 670b411b363SPhilipp Reisner const char *what; 671b411b363SPhilipp Reisner 67244ed167dSPhilipp Reisner rcu_read_lock(); 673bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 67444ed167dSPhilipp Reisner if (!nc) { 67544ed167dSPhilipp Reisner rcu_read_unlock(); 6767a426fd8SPhilipp Reisner return -EIO; 67744ed167dSPhilipp Reisner } 67844ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 67944ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 68044ed167dSPhilipp Reisner rcu_read_unlock(); 681b411b363SPhilipp Reisner 682bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 683bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 684b411b363SPhilipp Reisner 685b411b363SPhilipp Reisner what = "sock_create_kern"; 68644ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 687b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 688b411b363SPhilipp Reisner if (err) { 689b411b363SPhilipp Reisner s_listen = NULL; 690b411b363SPhilipp Reisner goto out; 691b411b363SPhilipp Reisner } 692b411b363SPhilipp Reisner 6934a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 69444ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 695b411b363SPhilipp Reisner 696b411b363SPhilipp Reisner what = "bind before listen"; 69744ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 698b411b363SPhilipp Reisner if (err < 0) 699b411b363SPhilipp Reisner goto out; 700b411b363SPhilipp Reisner 7017a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7027a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7037a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 704715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7057a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7067a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 707b411b363SPhilipp Reisner 7082820fd39SPhilipp Reisner what = "listen"; 7092820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7102820fd39SPhilipp Reisner if (err < 0) 7112820fd39SPhilipp Reisner goto out; 7122820fd39SPhilipp Reisner 7137a426fd8SPhilipp Reisner return 0; 714b411b363SPhilipp Reisner out: 715b411b363SPhilipp Reisner if (s_listen) 716b411b363SPhilipp Reisner sock_release(s_listen); 717b411b363SPhilipp Reisner if (err < 0) { 718b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7191ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 720bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 721b411b363SPhilipp Reisner } 722b411b363SPhilipp Reisner } 7231f3e509bSPhilipp Reisner 7247a426fd8SPhilipp Reisner return -EIO; 7251f3e509bSPhilipp Reisner } 7261f3e509bSPhilipp Reisner 727715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 728715306f6SAndreas Gruenbacher { 729715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 730715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 731715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 732715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 733715306f6SAndreas Gruenbacher } 734715306f6SAndreas Gruenbacher 735bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7361f3e509bSPhilipp Reisner { 7371f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7381f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7391f3e509bSPhilipp Reisner struct net_conf *nc; 7401f3e509bSPhilipp Reisner 7411f3e509bSPhilipp Reisner rcu_read_lock(); 742bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7431f3e509bSPhilipp Reisner if (!nc) { 7441f3e509bSPhilipp Reisner rcu_read_unlock(); 7451f3e509bSPhilipp Reisner return NULL; 7461f3e509bSPhilipp Reisner } 7471f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7481f3e509bSPhilipp Reisner rcu_read_unlock(); 7491f3e509bSPhilipp Reisner 7501f3e509bSPhilipp Reisner timeo = connect_int * HZ; 75138b682b2SAkinobu Mita /* 28.5% random jitter */ 75238b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7531f3e509bSPhilipp Reisner 7547a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7557a426fd8SPhilipp Reisner if (err <= 0) 7567a426fd8SPhilipp Reisner return NULL; 7571f3e509bSPhilipp Reisner 7587a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 759b411b363SPhilipp Reisner if (err < 0) { 760b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7611ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 762bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 763b411b363SPhilipp Reisner } 764b411b363SPhilipp Reisner } 765b411b363SPhilipp Reisner 766715306f6SAndreas Gruenbacher if (s_estab) 767715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 768b411b363SPhilipp Reisner 769b411b363SPhilipp Reisner return s_estab; 770b411b363SPhilipp Reisner } 771b411b363SPhilipp Reisner 772bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 773b411b363SPhilipp Reisner 774bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 7759f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7769f5bdc33SAndreas Gruenbacher { 777bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 7789f5bdc33SAndreas Gruenbacher return -EIO; 779bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 780b411b363SPhilipp Reisner } 781b411b363SPhilipp Reisner 782bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 783b411b363SPhilipp Reisner { 784bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 7859f5bdc33SAndreas Gruenbacher struct packet_info pi; 7869f5bdc33SAndreas Gruenbacher int err; 787b411b363SPhilipp Reisner 788bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 7899f5bdc33SAndreas Gruenbacher if (err != header_size) { 7909f5bdc33SAndreas Gruenbacher if (err >= 0) 7919f5bdc33SAndreas Gruenbacher err = -EIO; 7929f5bdc33SAndreas Gruenbacher return err; 7939f5bdc33SAndreas Gruenbacher } 794bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 7959f5bdc33SAndreas Gruenbacher if (err) 7969f5bdc33SAndreas Gruenbacher return err; 7979f5bdc33SAndreas Gruenbacher return pi.cmd; 798b411b363SPhilipp Reisner } 799b411b363SPhilipp Reisner 800b411b363SPhilipp Reisner /** 801b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 802b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 803b411b363SPhilipp Reisner */ 804dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 805b411b363SPhilipp Reisner { 806b411b363SPhilipp Reisner int rr; 807b411b363SPhilipp Reisner char tb[4]; 808b411b363SPhilipp Reisner 809b411b363SPhilipp Reisner if (!*sock) 81081e84650SAndreas Gruenbacher return false; 811b411b363SPhilipp Reisner 812dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 813b411b363SPhilipp Reisner 814b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 81581e84650SAndreas Gruenbacher return true; 816b411b363SPhilipp Reisner } else { 817b411b363SPhilipp Reisner sock_release(*sock); 818b411b363SPhilipp Reisner *sock = NULL; 81981e84650SAndreas Gruenbacher return false; 820b411b363SPhilipp Reisner } 821b411b363SPhilipp Reisner } 8222325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8232325eb66SPhilipp Reisner in a connection */ 82469a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 825907599e0SPhilipp Reisner { 82669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 8270829f5edSAndreas Gruenbacher int err; 828907599e0SPhilipp Reisner 829b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 830b30ab791SAndreas Gruenbacher device->peer_seq = 0; 831907599e0SPhilipp Reisner 83269a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 83369a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 834b30ab791SAndreas Gruenbacher &device->own_state_mutex; 8358410da8fSPhilipp Reisner 83669a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 8370829f5edSAndreas Gruenbacher if (!err) 83869a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 8390829f5edSAndreas Gruenbacher if (!err) 84069a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 8410829f5edSAndreas Gruenbacher if (!err) 84269a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 843b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 844b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 845b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 846b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 8470829f5edSAndreas Gruenbacher return err; 848907599e0SPhilipp Reisner } 849b411b363SPhilipp Reisner 850b411b363SPhilipp Reisner /* 851b411b363SPhilipp Reisner * return values: 852b411b363SPhilipp Reisner * 1 yes, we have a valid connection 853b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 854b411b363SPhilipp Reisner * -1 peer talks different language, 855b411b363SPhilipp Reisner * no point in trying again, please go standalone. 856b411b363SPhilipp Reisner * -2 We do not have a network config... 857b411b363SPhilipp Reisner */ 858bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 859b411b363SPhilipp Reisner { 8607da35862SPhilipp Reisner struct drbd_socket sock, msock; 861c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 86244ed167dSPhilipp Reisner struct net_conf *nc; 86392f14951SPhilipp Reisner int vnr, timeout, h, ok; 86408b165baSPhilipp Reisner bool discard_my_data; 865197296ffSPhilipp Reisner enum drbd_state_rv rv; 8667a426fd8SPhilipp Reisner struct accept_wait_data ad = { 867bde89a9eSAndreas Gruenbacher .connection = connection, 8687a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 8697a426fd8SPhilipp Reisner }; 870b411b363SPhilipp Reisner 871bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 872bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 873b411b363SPhilipp Reisner return -2; 874b411b363SPhilipp Reisner 8757da35862SPhilipp Reisner mutex_init(&sock.mutex); 876bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 877bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 8787da35862SPhilipp Reisner sock.socket = NULL; 8797da35862SPhilipp Reisner mutex_init(&msock.mutex); 880bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 881bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 8827da35862SPhilipp Reisner msock.socket = NULL; 8837da35862SPhilipp Reisner 8840916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 885bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 886b411b363SPhilipp Reisner 887bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 8887a426fd8SPhilipp Reisner return 0; 889b411b363SPhilipp Reisner 890b411b363SPhilipp Reisner do { 8912bf89621SAndreas Gruenbacher struct socket *s; 892b411b363SPhilipp Reisner 893bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 894b411b363SPhilipp Reisner if (s) { 8957da35862SPhilipp Reisner if (!sock.socket) { 8967da35862SPhilipp Reisner sock.socket = s; 897bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 8987da35862SPhilipp Reisner } else if (!msock.socket) { 899bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9007da35862SPhilipp Reisner msock.socket = s; 901bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 902b411b363SPhilipp Reisner } else { 9031ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 904b411b363SPhilipp Reisner goto out_release_sockets; 905b411b363SPhilipp Reisner } 906b411b363SPhilipp Reisner } 907b411b363SPhilipp Reisner 9087da35862SPhilipp Reisner if (sock.socket && msock.socket) { 9097da35862SPhilipp Reisner rcu_read_lock(); 910bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 9117da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 9127da35862SPhilipp Reisner rcu_read_unlock(); 9137da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9147da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9157da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 916b411b363SPhilipp Reisner if (ok) 917b411b363SPhilipp Reisner break; 918b411b363SPhilipp Reisner } 919b411b363SPhilipp Reisner 920b411b363SPhilipp Reisner retry: 921bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 922b411b363SPhilipp Reisner if (s) { 923bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9247da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9257da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 92692f14951SPhilipp Reisner switch (fp) { 927e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9287da35862SPhilipp Reisner if (sock.socket) { 9291ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9307da35862SPhilipp Reisner sock_release(sock.socket); 93180c6eed4SPhilipp Reisner sock.socket = s; 93280c6eed4SPhilipp Reisner goto randomize; 933b411b363SPhilipp Reisner } 9347da35862SPhilipp Reisner sock.socket = s; 935b411b363SPhilipp Reisner break; 936e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 937bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 9387da35862SPhilipp Reisner if (msock.socket) { 9391ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 9407da35862SPhilipp Reisner sock_release(msock.socket); 94180c6eed4SPhilipp Reisner msock.socket = s; 94280c6eed4SPhilipp Reisner goto randomize; 943b411b363SPhilipp Reisner } 9447da35862SPhilipp Reisner msock.socket = s; 945b411b363SPhilipp Reisner break; 946b411b363SPhilipp Reisner default: 9471ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 948b411b363SPhilipp Reisner sock_release(s); 94980c6eed4SPhilipp Reisner randomize: 95038b682b2SAkinobu Mita if (prandom_u32() & 1) 951b411b363SPhilipp Reisner goto retry; 952b411b363SPhilipp Reisner } 953b411b363SPhilipp Reisner } 954b411b363SPhilipp Reisner 955bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 956b411b363SPhilipp Reisner goto out_release_sockets; 957b411b363SPhilipp Reisner if (signal_pending(current)) { 958b411b363SPhilipp Reisner flush_signals(current); 959b411b363SPhilipp Reisner smp_rmb(); 960bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 961b411b363SPhilipp Reisner goto out_release_sockets; 962b411b363SPhilipp Reisner } 963b411b363SPhilipp Reisner 9647da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9657da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 966b666dbf8SPhilipp Reisner } while (!ok); 967b411b363SPhilipp Reisner 9687a426fd8SPhilipp Reisner if (ad.s_listen) 9697a426fd8SPhilipp Reisner sock_release(ad.s_listen); 970b411b363SPhilipp Reisner 97198683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 97298683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 973b411b363SPhilipp Reisner 9747da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9757da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 976b411b363SPhilipp Reisner 9777da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9787da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 979b411b363SPhilipp Reisner 980b411b363SPhilipp Reisner /* NOT YET ... 981bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 9827da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9836038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 984b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 98544ed167dSPhilipp Reisner rcu_read_lock(); 986bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 987b411b363SPhilipp Reisner 9887da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 9897da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 99044ed167dSPhilipp Reisner 9917da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 99244ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 99308b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 99444ed167dSPhilipp Reisner rcu_read_unlock(); 99544ed167dSPhilipp Reisner 9967da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 997b411b363SPhilipp Reisner 998b411b363SPhilipp Reisner /* we don't want delays. 99925985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10007da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10017da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1002b411b363SPhilipp Reisner 1003bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1004bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1005bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1006b411b363SPhilipp Reisner 1007bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1008b411b363SPhilipp Reisner if (h <= 0) 1009b411b363SPhilipp Reisner return h; 1010b411b363SPhilipp Reisner 1011bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1012b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1013bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1014b10d96cbSJohannes Thoma case -1: 10151ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1016b411b363SPhilipp Reisner return -1; 1017b10d96cbSJohannes Thoma case 0: 10181ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1019b10d96cbSJohannes Thoma return 0; 1020b411b363SPhilipp Reisner } 1021b411b363SPhilipp Reisner } 1022b411b363SPhilipp Reisner 1023bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1024bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1025b411b363SPhilipp Reisner 1026bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10277e2455c1SPhilipp Reisner return -1; 10281e86ac48SPhilipp Reisner 102913c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 103013c76abaSPhilipp Reisner * being promoted to Primary. 103113c76abaSPhilipp Reisner * 103213c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 103313c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 103413c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 103513c76abaSPhilipp Reisner */ 103631007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 103731007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 103831007745SPhilipp Reisner 103931007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 104031007745SPhilipp Reisner 104131007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 104231007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 104331007745SPhilipp Reisner 104431007745SPhilipp Reisner rcu_read_lock(); 104531007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 104631007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 104731007745SPhilipp Reisner kref_get(&device->kref); 104831007745SPhilipp Reisner rcu_read_unlock(); 104913c76abaSPhilipp Reisner 105008b165baSPhilipp Reisner if (discard_my_data) 1051b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 105208b165baSPhilipp Reisner else 1053b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 105408b165baSPhilipp Reisner 105569a22773SAndreas Gruenbacher drbd_connected(peer_device); 105605a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1057c141ebdaSPhilipp Reisner rcu_read_lock(); 1058c141ebdaSPhilipp Reisner } 1059c141ebdaSPhilipp Reisner rcu_read_unlock(); 1060c141ebdaSPhilipp Reisner 1061bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1062bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1063bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 10641e86ac48SPhilipp Reisner return 0; 1065a1096a6eSPhilipp Reisner } 10661e86ac48SPhilipp Reisner 1067bde89a9eSAndreas Gruenbacher drbd_thread_start(&connection->asender); 1068b411b363SPhilipp Reisner 10690500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 107008b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 107108b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 107208b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 107308b165baSPhilipp Reisner * just to clear a single value. */ 1074bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 10750500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 107608b165baSPhilipp Reisner 1077d3fcb490SPhilipp Reisner return h; 1078b411b363SPhilipp Reisner 1079b411b363SPhilipp Reisner out_release_sockets: 10807a426fd8SPhilipp Reisner if (ad.s_listen) 10817a426fd8SPhilipp Reisner sock_release(ad.s_listen); 10827da35862SPhilipp Reisner if (sock.socket) 10837da35862SPhilipp Reisner sock_release(sock.socket); 10847da35862SPhilipp Reisner if (msock.socket) 10857da35862SPhilipp Reisner sock_release(msock.socket); 1086b411b363SPhilipp Reisner return -1; 1087b411b363SPhilipp Reisner } 1088b411b363SPhilipp Reisner 1089bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1090b411b363SPhilipp Reisner { 1091bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1092b411b363SPhilipp Reisner 10930c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10940c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 10950c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 10960c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 10971ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 10980c8e36d9SAndreas Gruenbacher return -EINVAL; 109902918be2SPhilipp Reisner } 11000c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11010c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11020c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11030c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1104e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1105e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1106e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1107b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1108eefc2f7dSPhilipp Reisner pi->vnr = 0; 1109e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1110e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1111e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1112e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1113e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 111477351055SPhilipp Reisner pi->vnr = 0; 111502918be2SPhilipp Reisner } else { 11161ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1117e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1118bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11198172f3e9SAndreas Gruenbacher return -EINVAL; 1120b411b363SPhilipp Reisner } 1121e658983aSAndreas Gruenbacher pi->data = header + header_size; 11228172f3e9SAndreas Gruenbacher return 0; 1123b411b363SPhilipp Reisner } 1124b411b363SPhilipp Reisner 1125bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1126257d0af6SPhilipp Reisner { 1127bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 112869bc7bc3SAndreas Gruenbacher int err; 1129257d0af6SPhilipp Reisner 1130bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1131a5c31904SAndreas Gruenbacher if (err) 113269bc7bc3SAndreas Gruenbacher return err; 1133257d0af6SPhilipp Reisner 1134bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1135bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1136b411b363SPhilipp Reisner 113769bc7bc3SAndreas Gruenbacher return err; 1138b411b363SPhilipp Reisner } 1139b411b363SPhilipp Reisner 1140bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1141b411b363SPhilipp Reisner { 1142b411b363SPhilipp Reisner int rv; 1143c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 11444b0007c0SPhilipp Reisner int vnr; 1145b411b363SPhilipp Reisner 1146bde89a9eSAndreas Gruenbacher if (connection->write_ordering >= WO_bdev_flush) { 1147615e087fSLars Ellenberg rcu_read_lock(); 1148c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1149c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1150c06ece6bSAndreas Gruenbacher 1151b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1152615e087fSLars Ellenberg continue; 1153b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1154615e087fSLars Ellenberg rcu_read_unlock(); 11554b0007c0SPhilipp Reisner 1156b30ab791SAndreas Gruenbacher rv = blkdev_issue_flush(device->ldev->backing_bdev, 1157615e087fSLars Ellenberg GFP_NOIO, NULL); 1158b411b363SPhilipp Reisner if (rv) { 1159d0180171SAndreas Gruenbacher drbd_info(device, "local disk flush failed with status %d\n", rv); 1160b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1161b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1162b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1163bde89a9eSAndreas Gruenbacher drbd_bump_write_ordering(connection, WO_drain_io); 1164b411b363SPhilipp Reisner } 1165b30ab791SAndreas Gruenbacher put_ldev(device); 116605a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1167615e087fSLars Ellenberg 1168615e087fSLars Ellenberg rcu_read_lock(); 1169615e087fSLars Ellenberg if (rv) 11704b0007c0SPhilipp Reisner break; 1171b411b363SPhilipp Reisner } 1172615e087fSLars Ellenberg rcu_read_unlock(); 1173b411b363SPhilipp Reisner } 1174b411b363SPhilipp Reisner } 1175b411b363SPhilipp Reisner 1176b411b363SPhilipp Reisner /** 1177b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1178b30ab791SAndreas Gruenbacher * @device: DRBD device. 1179b411b363SPhilipp Reisner * @epoch: Epoch object. 1180b411b363SPhilipp Reisner * @ev: Epoch event. 1181b411b363SPhilipp Reisner */ 1182bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1183b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1184b411b363SPhilipp Reisner enum epoch_event ev) 1185b411b363SPhilipp Reisner { 11862451fc3bSPhilipp Reisner int epoch_size; 1187b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1188b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1189b411b363SPhilipp Reisner 1190bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1191b411b363SPhilipp Reisner do { 1192b411b363SPhilipp Reisner next_epoch = NULL; 1193b411b363SPhilipp Reisner 1194b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1195b411b363SPhilipp Reisner 1196b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1197b411b363SPhilipp Reisner case EV_PUT: 1198b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1199b411b363SPhilipp Reisner break; 1200b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1201b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1202b411b363SPhilipp Reisner break; 1203b411b363SPhilipp Reisner case EV_BECAME_LAST: 1204b411b363SPhilipp Reisner /* nothing to do*/ 1205b411b363SPhilipp Reisner break; 1206b411b363SPhilipp Reisner } 1207b411b363SPhilipp Reisner 1208b411b363SPhilipp Reisner if (epoch_size != 0 && 1209b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 121080f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1211b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1212bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1213bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1214bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1215b411b363SPhilipp Reisner } 12169ed57dcbSLars Ellenberg #if 0 12179ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 12189ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 121980f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1220bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 12219ed57dcbSLars Ellenberg #endif 1222b411b363SPhilipp Reisner 1223bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1224b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1225b411b363SPhilipp Reisner list_del(&epoch->list); 1226b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1227bde89a9eSAndreas Gruenbacher connection->epochs--; 1228b411b363SPhilipp Reisner kfree(epoch); 1229b411b363SPhilipp Reisner 1230b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1231b411b363SPhilipp Reisner rv = FE_DESTROYED; 1232b411b363SPhilipp Reisner } else { 1233b411b363SPhilipp Reisner epoch->flags = 0; 1234b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1235698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1236b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1237b411b363SPhilipp Reisner rv = FE_RECYCLED; 1238b411b363SPhilipp Reisner } 1239b411b363SPhilipp Reisner } 1240b411b363SPhilipp Reisner 1241b411b363SPhilipp Reisner if (!next_epoch) 1242b411b363SPhilipp Reisner break; 1243b411b363SPhilipp Reisner 1244b411b363SPhilipp Reisner epoch = next_epoch; 1245b411b363SPhilipp Reisner } while (1); 1246b411b363SPhilipp Reisner 1247bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1248b411b363SPhilipp Reisner 1249b411b363SPhilipp Reisner return rv; 1250b411b363SPhilipp Reisner } 1251b411b363SPhilipp Reisner 1252b411b363SPhilipp Reisner /** 1253b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1254bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1255b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1256b411b363SPhilipp Reisner */ 1257bde89a9eSAndreas Gruenbacher void drbd_bump_write_ordering(struct drbd_connection *connection, enum write_ordering_e wo) 1258b411b363SPhilipp Reisner { 1259daeda1ccSPhilipp Reisner struct disk_conf *dc; 1260c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1261b411b363SPhilipp Reisner enum write_ordering_e pwo; 12624b0007c0SPhilipp Reisner int vnr; 1263b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1264b411b363SPhilipp Reisner [WO_none] = "none", 1265b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1266b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1267b411b363SPhilipp Reisner }; 1268b411b363SPhilipp Reisner 1269bde89a9eSAndreas Gruenbacher pwo = connection->write_ordering; 1270b411b363SPhilipp Reisner wo = min(pwo, wo); 1271daeda1ccSPhilipp Reisner rcu_read_lock(); 1272c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1273c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1274c06ece6bSAndreas Gruenbacher 1275b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_ATTACHING)) 12764b0007c0SPhilipp Reisner continue; 1277b30ab791SAndreas Gruenbacher dc = rcu_dereference(device->ldev->disk_conf); 1278daeda1ccSPhilipp Reisner 127966b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1280b411b363SPhilipp Reisner wo = WO_drain_io; 1281d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1282b411b363SPhilipp Reisner wo = WO_none; 1283b30ab791SAndreas Gruenbacher put_ldev(device); 12844b0007c0SPhilipp Reisner } 1285daeda1ccSPhilipp Reisner rcu_read_unlock(); 1286bde89a9eSAndreas Gruenbacher connection->write_ordering = wo; 1287bde89a9eSAndreas Gruenbacher if (pwo != connection->write_ordering || wo == WO_bdev_flush) 12881ec861ebSAndreas Gruenbacher drbd_info(connection, "Method to ensure write ordering: %s\n", write_ordering_str[connection->write_ordering]); 1289b411b363SPhilipp Reisner } 1290b411b363SPhilipp Reisner 1291b411b363SPhilipp Reisner /** 1292fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1293b30ab791SAndreas Gruenbacher * @device: DRBD device. 1294db830c46SAndreas Gruenbacher * @peer_req: peer request 129545bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 129610f6d992SLars Ellenberg * 129710f6d992SLars Ellenberg * May spread the pages to multiple bios, 129810f6d992SLars Ellenberg * depending on bio_add_page restrictions. 129910f6d992SLars Ellenberg * 130010f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 130110f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 130210f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 130310f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 130410f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 130510f6d992SLars Ellenberg * on certain Xen deployments. 130645bb912bSLars Ellenberg */ 130745bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1308b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1309fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 131045bb912bSLars Ellenberg const unsigned rw, const int fault_type) 131145bb912bSLars Ellenberg { 131245bb912bSLars Ellenberg struct bio *bios = NULL; 131345bb912bSLars Ellenberg struct bio *bio; 1314db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1315db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1316db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 131745bb912bSLars Ellenberg unsigned n_bios = 0; 131845bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 131910f6d992SLars Ellenberg int err = -ENOMEM; 132045bb912bSLars Ellenberg 132145bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 132245bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 132345bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 13249476f39dSLars Ellenberg * request in more than one bio. 13259476f39dSLars Ellenberg * 13269476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 13279476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 13289476f39dSLars Ellenberg */ 132945bb912bSLars Ellenberg next_bio: 133045bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 133145bb912bSLars Ellenberg if (!bio) { 1332d0180171SAndreas Gruenbacher drbd_err(device, "submit_ee: Allocation of a bio failed\n"); 133345bb912bSLars Ellenberg goto fail; 133445bb912bSLars Ellenberg } 1335db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 13364f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 1337b30ab791SAndreas Gruenbacher bio->bi_bdev = device->ldev->backing_bdev; 133845bb912bSLars Ellenberg bio->bi_rw = rw; 1339db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1340fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 134145bb912bSLars Ellenberg 134245bb912bSLars Ellenberg bio->bi_next = bios; 134345bb912bSLars Ellenberg bios = bio; 134445bb912bSLars Ellenberg ++n_bios; 134545bb912bSLars Ellenberg 134645bb912bSLars Ellenberg page_chain_for_each(page) { 134745bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 134845bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 134910f6d992SLars Ellenberg /* A single page must always be possible! 135010f6d992SLars Ellenberg * But in case it fails anyways, 135110f6d992SLars Ellenberg * we deal with it, and complain (below). */ 135210f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 1353d0180171SAndreas Gruenbacher drbd_err(device, 135410f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 135510f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 13564f024f37SKent Overstreet len, (uint64_t)bio->bi_iter.bi_sector); 135710f6d992SLars Ellenberg err = -ENOSPC; 135810f6d992SLars Ellenberg goto fail; 135910f6d992SLars Ellenberg } 136045bb912bSLars Ellenberg goto next_bio; 136145bb912bSLars Ellenberg } 136245bb912bSLars Ellenberg ds -= len; 136345bb912bSLars Ellenberg sector += len >> 9; 136445bb912bSLars Ellenberg --nr_pages; 136545bb912bSLars Ellenberg } 13660b0ba1efSAndreas Gruenbacher D_ASSERT(device, page == NULL); 13670b0ba1efSAndreas Gruenbacher D_ASSERT(device, ds == 0); 136845bb912bSLars Ellenberg 1369db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 137045bb912bSLars Ellenberg do { 137145bb912bSLars Ellenberg bio = bios; 137245bb912bSLars Ellenberg bios = bios->bi_next; 137345bb912bSLars Ellenberg bio->bi_next = NULL; 137445bb912bSLars Ellenberg 1375b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 137645bb912bSLars Ellenberg } while (bios); 137745bb912bSLars Ellenberg return 0; 137845bb912bSLars Ellenberg 137945bb912bSLars Ellenberg fail: 138045bb912bSLars Ellenberg while (bios) { 138145bb912bSLars Ellenberg bio = bios; 138245bb912bSLars Ellenberg bios = bios->bi_next; 138345bb912bSLars Ellenberg bio_put(bio); 138445bb912bSLars Ellenberg } 138510f6d992SLars Ellenberg return err; 138645bb912bSLars Ellenberg } 138745bb912bSLars Ellenberg 1388b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1389db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 139053840641SAndreas Gruenbacher { 1391db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 139253840641SAndreas Gruenbacher 1393b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 139453840641SAndreas Gruenbacher drbd_clear_interval(i); 139553840641SAndreas Gruenbacher 13966c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 139753840641SAndreas Gruenbacher if (i->waiting) 1398b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 139953840641SAndreas Gruenbacher } 140053840641SAndreas Gruenbacher 1401bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 140277fede51SPhilipp Reisner { 1403c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 140477fede51SPhilipp Reisner int vnr; 140577fede51SPhilipp Reisner 140677fede51SPhilipp Reisner rcu_read_lock(); 1407c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1408c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1409c06ece6bSAndreas Gruenbacher 1410b30ab791SAndreas Gruenbacher kref_get(&device->kref); 141177fede51SPhilipp Reisner rcu_read_unlock(); 1412b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 141305a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 141477fede51SPhilipp Reisner rcu_read_lock(); 141577fede51SPhilipp Reisner } 141677fede51SPhilipp Reisner rcu_read_unlock(); 141777fede51SPhilipp Reisner } 141877fede51SPhilipp Reisner 14199f4fe9adSAndreas Gruenbacher static struct drbd_peer_device * 14209f4fe9adSAndreas Gruenbacher conn_peer_device(struct drbd_connection *connection, int volume_number) 14219f4fe9adSAndreas Gruenbacher { 14229f4fe9adSAndreas Gruenbacher return idr_find(&connection->peer_devices, volume_number); 14239f4fe9adSAndreas Gruenbacher } 14249f4fe9adSAndreas Gruenbacher 1425bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1426b411b363SPhilipp Reisner { 14272451fc3bSPhilipp Reisner int rv; 1428e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1429b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1430b411b363SPhilipp Reisner 14319ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 14329ed57dcbSLars Ellenberg * not a specific (peer)device. 14339ed57dcbSLars Ellenberg */ 1434bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1435bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1436bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1437b411b363SPhilipp Reisner 1438b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1439b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1440b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1441b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1442b411b363SPhilipp Reisner * completed. */ 1443bde89a9eSAndreas Gruenbacher switch (connection->write_ordering) { 1444b411b363SPhilipp Reisner case WO_none: 1445b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 144682bc0194SAndreas Gruenbacher return 0; 1447b411b363SPhilipp Reisner 1448b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1449b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1450b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14512451fc3bSPhilipp Reisner if (epoch) 14522451fc3bSPhilipp Reisner break; 14532451fc3bSPhilipp Reisner else 14541ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 14552451fc3bSPhilipp Reisner /* Fall through */ 14562451fc3bSPhilipp Reisner 14572451fc3bSPhilipp Reisner case WO_bdev_flush: 14582451fc3bSPhilipp Reisner case WO_drain_io: 1459bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1460bde89a9eSAndreas Gruenbacher drbd_flush(connection); 14612451fc3bSPhilipp Reisner 1462bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 14632451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14642451fc3bSPhilipp Reisner if (epoch) 14652451fc3bSPhilipp Reisner break; 1466b411b363SPhilipp Reisner } 1467b411b363SPhilipp Reisner 146882bc0194SAndreas Gruenbacher return 0; 14692451fc3bSPhilipp Reisner default: 14701ec861ebSAndreas Gruenbacher drbd_err(connection, "Strangeness in connection->write_ordering %d\n", connection->write_ordering); 147182bc0194SAndreas Gruenbacher return -EIO; 1472b411b363SPhilipp Reisner } 1473b411b363SPhilipp Reisner 1474b411b363SPhilipp Reisner epoch->flags = 0; 1475b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1476b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1477b411b363SPhilipp Reisner 1478bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1479bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1480bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1481bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1482bde89a9eSAndreas Gruenbacher connection->epochs++; 1483b411b363SPhilipp Reisner } else { 1484b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1485b411b363SPhilipp Reisner kfree(epoch); 1486b411b363SPhilipp Reisner } 1487bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1488b411b363SPhilipp Reisner 148982bc0194SAndreas Gruenbacher return 0; 1490b411b363SPhilipp Reisner } 1491b411b363SPhilipp Reisner 1492b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1493b411b363SPhilipp Reisner * and from receive_Data */ 1494f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 149569a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1496f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1497b411b363SPhilipp Reisner { 149869a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1499b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1500db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1501b411b363SPhilipp Reisner struct page *page; 1502a5c31904SAndreas Gruenbacher int dgs, ds, err; 150369a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 150469a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 15056b4388acSPhilipp Reisner unsigned long *data; 1506b411b363SPhilipp Reisner 150788104ca4SAndreas Gruenbacher dgs = 0; 150869a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 150969a22773SAndreas Gruenbacher dgs = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 15109f5bdc33SAndreas Gruenbacher /* 15119f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 15129f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 15139f5bdc33SAndreas Gruenbacher */ 151469a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, dgs); 1515a5c31904SAndreas Gruenbacher if (err) 1516b411b363SPhilipp Reisner return NULL; 1517b411b363SPhilipp Reisner data_size -= dgs; 151888104ca4SAndreas Gruenbacher } 1519b411b363SPhilipp Reisner 1520841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1521841ce241SAndreas Gruenbacher return NULL; 1522841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1523841ce241SAndreas Gruenbacher return NULL; 1524b411b363SPhilipp Reisner 15256666032aSLars Ellenberg /* even though we trust out peer, 15266666032aSLars Ellenberg * we sometimes have to double check. */ 15276666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1528d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1529fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 15306666032aSLars Ellenberg (unsigned long long)capacity, 15316666032aSLars Ellenberg (unsigned long long)sector, data_size); 15326666032aSLars Ellenberg return NULL; 15336666032aSLars Ellenberg } 15346666032aSLars Ellenberg 1535b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1536b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1537b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 153869a22773SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(peer_device, id, sector, data_size, GFP_NOIO); 1539db830c46SAndreas Gruenbacher if (!peer_req) 1540b411b363SPhilipp Reisner return NULL; 154145bb912bSLars Ellenberg 1542a73ff323SLars Ellenberg if (!data_size) 154381a3537aSLars Ellenberg return peer_req; 1544a73ff323SLars Ellenberg 1545b411b363SPhilipp Reisner ds = data_size; 1546db830c46SAndreas Gruenbacher page = peer_req->pages; 154745bb912bSLars Ellenberg page_chain_for_each(page) { 154845bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 15496b4388acSPhilipp Reisner data = kmap(page); 155069a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1551b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1552d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 15536b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 15546b4388acSPhilipp Reisner } 1555b411b363SPhilipp Reisner kunmap(page); 1556a5c31904SAndreas Gruenbacher if (err) { 1557b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1558b411b363SPhilipp Reisner return NULL; 1559b411b363SPhilipp Reisner } 1560a5c31904SAndreas Gruenbacher ds -= len; 1561b411b363SPhilipp Reisner } 1562b411b363SPhilipp Reisner 1563b411b363SPhilipp Reisner if (dgs) { 156469a22773SAndreas Gruenbacher drbd_csum_ee(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv); 1565b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1566d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1567470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1568b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1569b411b363SPhilipp Reisner return NULL; 1570b411b363SPhilipp Reisner } 1571b411b363SPhilipp Reisner } 1572b30ab791SAndreas Gruenbacher device->recv_cnt += data_size>>9; 1573db830c46SAndreas Gruenbacher return peer_req; 1574b411b363SPhilipp Reisner } 1575b411b363SPhilipp Reisner 1576b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1577b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1578b411b363SPhilipp Reisner */ 157969a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1580b411b363SPhilipp Reisner { 1581b411b363SPhilipp Reisner struct page *page; 1582a5c31904SAndreas Gruenbacher int err = 0; 1583b411b363SPhilipp Reisner void *data; 1584b411b363SPhilipp Reisner 1585c3470cdeSLars Ellenberg if (!data_size) 1586fc5be839SAndreas Gruenbacher return 0; 1587c3470cdeSLars Ellenberg 158869a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1589b411b363SPhilipp Reisner 1590b411b363SPhilipp Reisner data = kmap(page); 1591b411b363SPhilipp Reisner while (data_size) { 1592fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1593fc5be839SAndreas Gruenbacher 159469a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1595a5c31904SAndreas Gruenbacher if (err) 1596b411b363SPhilipp Reisner break; 1597a5c31904SAndreas Gruenbacher data_size -= len; 1598b411b363SPhilipp Reisner } 1599b411b363SPhilipp Reisner kunmap(page); 160069a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1601fc5be839SAndreas Gruenbacher return err; 1602b411b363SPhilipp Reisner } 1603b411b363SPhilipp Reisner 160469a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1605b411b363SPhilipp Reisner sector_t sector, int data_size) 1606b411b363SPhilipp Reisner { 16077988613bSKent Overstreet struct bio_vec bvec; 16087988613bSKent Overstreet struct bvec_iter iter; 1609b411b363SPhilipp Reisner struct bio *bio; 16107988613bSKent Overstreet int dgs, err, expect; 161169a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 161269a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1613b411b363SPhilipp Reisner 161488104ca4SAndreas Gruenbacher dgs = 0; 161569a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 161669a22773SAndreas Gruenbacher dgs = crypto_hash_digestsize(peer_device->connection->peer_integrity_tfm); 161769a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, dgs); 1618a5c31904SAndreas Gruenbacher if (err) 1619a5c31904SAndreas Gruenbacher return err; 1620b411b363SPhilipp Reisner data_size -= dgs; 162188104ca4SAndreas Gruenbacher } 1622b411b363SPhilipp Reisner 1623b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1624b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 162569a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1626b411b363SPhilipp Reisner 1627b411b363SPhilipp Reisner bio = req->master_bio; 162869a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1629b411b363SPhilipp Reisner 16307988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 16317988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 16327988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 163369a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 16347988613bSKent Overstreet kunmap(bvec.bv_page); 1635a5c31904SAndreas Gruenbacher if (err) 1636a5c31904SAndreas Gruenbacher return err; 1637a5c31904SAndreas Gruenbacher data_size -= expect; 1638b411b363SPhilipp Reisner } 1639b411b363SPhilipp Reisner 1640b411b363SPhilipp Reisner if (dgs) { 164169a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 1642b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 164369a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 164428284cefSAndreas Gruenbacher return -EINVAL; 1645b411b363SPhilipp Reisner } 1646b411b363SPhilipp Reisner } 1647b411b363SPhilipp Reisner 164869a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 164928284cefSAndreas Gruenbacher return 0; 1650b411b363SPhilipp Reisner } 1651b411b363SPhilipp Reisner 1652a990be46SAndreas Gruenbacher /* 1653a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1654a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1655a990be46SAndreas Gruenbacher */ 165699920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1657b411b363SPhilipp Reisner { 16588050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1659a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1660a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1661a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1662db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 166399920dc5SAndreas Gruenbacher int err; 1664b411b363SPhilipp Reisner 16650b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1666b411b363SPhilipp Reisner 1667db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1668b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1669a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 1670b411b363SPhilipp Reisner } else { 1671b411b363SPhilipp Reisner /* Record failure to sync */ 1672b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 1673b411b363SPhilipp Reisner 1674a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1675b411b363SPhilipp Reisner } 1676b30ab791SAndreas Gruenbacher dec_unacked(device); 1677b411b363SPhilipp Reisner 167899920dc5SAndreas Gruenbacher return err; 1679b411b363SPhilipp Reisner } 1680b411b363SPhilipp Reisner 168169a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 168269a22773SAndreas Gruenbacher int data_size) __releases(local) 1683b411b363SPhilipp Reisner { 168469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1685db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1686b411b363SPhilipp Reisner 168769a22773SAndreas Gruenbacher peer_req = read_in_block(peer_device, ID_SYNCER, sector, data_size); 1688db830c46SAndreas Gruenbacher if (!peer_req) 168945bb912bSLars Ellenberg goto fail; 1690b411b363SPhilipp Reisner 1691b30ab791SAndreas Gruenbacher dec_rs_pending(device); 1692b411b363SPhilipp Reisner 1693b30ab791SAndreas Gruenbacher inc_unacked(device); 1694b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1695b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1696b411b363SPhilipp Reisner 1697a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 169845bb912bSLars Ellenberg 16990500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1700a8cd15baSAndreas Gruenbacher list_add(&peer_req->w.list, &device->sync_ee); 17010500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1702b411b363SPhilipp Reisner 1703b30ab791SAndreas Gruenbacher atomic_add(data_size >> 9, &device->rs_sect_ev); 1704b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1705e1c1b0fcSAndreas Gruenbacher return 0; 170645bb912bSLars Ellenberg 170710f6d992SLars Ellenberg /* don't care for the reason here */ 1708d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 17090500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1710a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 17110500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 171222cc37a9SLars Ellenberg 1713b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 171445bb912bSLars Ellenberg fail: 1715b30ab791SAndreas Gruenbacher put_ldev(device); 1716e1c1b0fcSAndreas Gruenbacher return -EIO; 1717b411b363SPhilipp Reisner } 1718b411b363SPhilipp Reisner 1719668eebc6SAndreas Gruenbacher static struct drbd_request * 1720b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 1721bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1722b411b363SPhilipp Reisner { 1723b411b363SPhilipp Reisner struct drbd_request *req; 1724668eebc6SAndreas Gruenbacher 1725bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1726bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 17275e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1728668eebc6SAndreas Gruenbacher return req; 1729c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1730d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 1731c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1732c3afd8f5SAndreas Gruenbacher } 1733668eebc6SAndreas Gruenbacher return NULL; 1734668eebc6SAndreas Gruenbacher } 1735668eebc6SAndreas Gruenbacher 1736bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 1737b411b363SPhilipp Reisner { 17389f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1739b30ab791SAndreas Gruenbacher struct drbd_device *device; 1740b411b363SPhilipp Reisner struct drbd_request *req; 1741b411b363SPhilipp Reisner sector_t sector; 174282bc0194SAndreas Gruenbacher int err; 1743e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17444a76b161SAndreas Gruenbacher 17459f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 17469f4fe9adSAndreas Gruenbacher if (!peer_device) 17474a76b161SAndreas Gruenbacher return -EIO; 17489f4fe9adSAndreas Gruenbacher device = peer_device->device; 1749b411b363SPhilipp Reisner 1750b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1751b411b363SPhilipp Reisner 17520500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1753b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 17540500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1755c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 175682bc0194SAndreas Gruenbacher return -EIO; 1757b411b363SPhilipp Reisner 175824c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1759b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1760b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 176169a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 176282bc0194SAndreas Gruenbacher if (!err) 17638554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1764b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1765b411b363SPhilipp Reisner * I don't think we may complete this just yet 1766b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1767b411b363SPhilipp Reisner 176882bc0194SAndreas Gruenbacher return err; 1769b411b363SPhilipp Reisner } 1770b411b363SPhilipp Reisner 1771bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 1772b411b363SPhilipp Reisner { 17739f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1774b30ab791SAndreas Gruenbacher struct drbd_device *device; 1775b411b363SPhilipp Reisner sector_t sector; 177682bc0194SAndreas Gruenbacher int err; 1777e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17784a76b161SAndreas Gruenbacher 17799f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 17809f4fe9adSAndreas Gruenbacher if (!peer_device) 17814a76b161SAndreas Gruenbacher return -EIO; 17829f4fe9adSAndreas Gruenbacher device = peer_device->device; 1783b411b363SPhilipp Reisner 1784b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 17850b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 1786b411b363SPhilipp Reisner 1787b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 1788b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1789b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1790fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 179169a22773SAndreas Gruenbacher err = recv_resync_read(peer_device, sector, pi->size); 1792b411b363SPhilipp Reisner } else { 1793b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1794d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 1795b411b363SPhilipp Reisner 179669a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 1797b411b363SPhilipp Reisner 179869a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 1799b411b363SPhilipp Reisner } 1800b411b363SPhilipp Reisner 1801b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 1802778f271dSPhilipp Reisner 180382bc0194SAndreas Gruenbacher return err; 1804b411b363SPhilipp Reisner } 1805b411b363SPhilipp Reisner 1806b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 18077be8da07SAndreas Gruenbacher sector_t sector, int size) 1808b411b363SPhilipp Reisner { 18097be8da07SAndreas Gruenbacher struct drbd_interval *i; 18107be8da07SAndreas Gruenbacher struct drbd_request *req; 1811b411b363SPhilipp Reisner 1812b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 18137be8da07SAndreas Gruenbacher if (!i->local) 18147be8da07SAndreas Gruenbacher continue; 18157be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18167be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 18177be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 18187be8da07SAndreas Gruenbacher continue; 18192312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 18202312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 1821d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 18227be8da07SAndreas Gruenbacher } 18237be8da07SAndreas Gruenbacher } 18247be8da07SAndreas Gruenbacher 1825a990be46SAndreas Gruenbacher /* 1826a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1827b411b363SPhilipp Reisner */ 182899920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1829b411b363SPhilipp Reisner { 18308050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1831a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1832a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1833a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1834db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 183599920dc5SAndreas Gruenbacher int err = 0, pcmd; 1836b411b363SPhilipp Reisner 1837303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1838db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1839b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 1840b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 1841db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1842b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1843a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 1844b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1845b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1846b411b363SPhilipp Reisner } else { 1847a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1848b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1849b411b363SPhilipp Reisner * maybe assert this? */ 1850b411b363SPhilipp Reisner } 1851b30ab791SAndreas Gruenbacher dec_unacked(device); 1852b411b363SPhilipp Reisner } 1853b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1854b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1855302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 18560500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 18570b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 1858b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 18597be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 1860b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 18610500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1862bb3bfe96SAndreas Gruenbacher } else 18630b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1864b411b363SPhilipp Reisner 1865a6b32bc3SAndreas Gruenbacher drbd_may_finish_epoch(first_peer_device(device)->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1866b411b363SPhilipp Reisner 186799920dc5SAndreas Gruenbacher return err; 1868b411b363SPhilipp Reisner } 1869b411b363SPhilipp Reisner 1870a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1871b411b363SPhilipp Reisner { 18728050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1873a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1874a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 187599920dc5SAndreas Gruenbacher int err; 1876b411b363SPhilipp Reisner 1877a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 1878a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 1879b411b363SPhilipp Reisner 188099920dc5SAndreas Gruenbacher return err; 1881b411b363SPhilipp Reisner } 1882b411b363SPhilipp Reisner 1883d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 1884b6a370baSPhilipp Reisner { 1885a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 18867be8da07SAndreas Gruenbacher } 1887b6a370baSPhilipp Reisner 188899920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18897be8da07SAndreas Gruenbacher { 1890a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 1891a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1892a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 18937be8da07SAndreas Gruenbacher 1894a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 1895d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 18967be8da07SAndreas Gruenbacher } 18977be8da07SAndreas Gruenbacher 18983e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18993e394da1SAndreas Gruenbacher { 19003e394da1SAndreas Gruenbacher /* 19013e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 19023e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 19033e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 19043e394da1SAndreas Gruenbacher */ 19053e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 19063e394da1SAndreas Gruenbacher } 19073e394da1SAndreas Gruenbacher 19083e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 19093e394da1SAndreas Gruenbacher { 19103e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 19113e394da1SAndreas Gruenbacher } 19123e394da1SAndreas Gruenbacher 191369a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 19143e394da1SAndreas Gruenbacher { 191569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 19163c13b680SLars Ellenberg unsigned int newest_peer_seq; 19173e394da1SAndreas Gruenbacher 191869a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 1919b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 1920b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 1921b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 1922b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 1923b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 19243c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 1925b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 19263e394da1SAndreas Gruenbacher } 19277be8da07SAndreas Gruenbacher } 19283e394da1SAndreas Gruenbacher 1929d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1930d93f6302SLars Ellenberg { 1931d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1932d93f6302SLars Ellenberg } 1933d93f6302SLars Ellenberg 1934d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 1935b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 1936d93f6302SLars Ellenberg { 1937d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1938b6a370baSPhilipp Reisner bool rv = 0; 1939b6a370baSPhilipp Reisner 19400500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1941a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 1942d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1943d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 1944b6a370baSPhilipp Reisner rv = 1; 1945b6a370baSPhilipp Reisner break; 1946b6a370baSPhilipp Reisner } 1947b6a370baSPhilipp Reisner } 19480500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1949b6a370baSPhilipp Reisner 1950b6a370baSPhilipp Reisner return rv; 1951b6a370baSPhilipp Reisner } 1952b6a370baSPhilipp Reisner 1953b411b363SPhilipp Reisner /* Called from receive_Data. 1954b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1955b411b363SPhilipp Reisner * 1956b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1957b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1958b411b363SPhilipp Reisner * been sent. 1959b411b363SPhilipp Reisner * 1960b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1961b411b363SPhilipp Reisner * 1962b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 1963b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1964b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 1965b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1966b411b363SPhilipp Reisner * 1967b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1968b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1969b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1970b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1971b411b363SPhilipp Reisner * 1972b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1973b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 197469a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 1975b411b363SPhilipp Reisner { 197669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1977b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1978b411b363SPhilipp Reisner long timeout; 1979b874d231SPhilipp Reisner int ret = 0, tp; 19807be8da07SAndreas Gruenbacher 198169a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 19827be8da07SAndreas Gruenbacher return 0; 19837be8da07SAndreas Gruenbacher 1984b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 1985b411b363SPhilipp Reisner for (;;) { 1986b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 1987b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 1988b411b363SPhilipp Reisner break; 19897be8da07SAndreas Gruenbacher } 1990b874d231SPhilipp Reisner 1991b411b363SPhilipp Reisner if (signal_pending(current)) { 1992b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1993b411b363SPhilipp Reisner break; 1994b411b363SPhilipp Reisner } 1995b874d231SPhilipp Reisner 1996b874d231SPhilipp Reisner rcu_read_lock(); 1997a6b32bc3SAndreas Gruenbacher tp = rcu_dereference(first_peer_device(device)->connection->net_conf)->two_primaries; 1998b874d231SPhilipp Reisner rcu_read_unlock(); 1999b874d231SPhilipp Reisner 2000b874d231SPhilipp Reisner if (!tp) 2001b874d231SPhilipp Reisner break; 2002b874d231SPhilipp Reisner 2003b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2004b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2005b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 200644ed167dSPhilipp Reisner rcu_read_lock(); 200769a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 200844ed167dSPhilipp Reisner rcu_read_unlock(); 200971b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2010b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 20117be8da07SAndreas Gruenbacher if (!timeout) { 2012b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2013d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2014b411b363SPhilipp Reisner break; 2015b411b363SPhilipp Reisner } 2016b411b363SPhilipp Reisner } 2017b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2018b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2019b411b363SPhilipp Reisner return ret; 2020b411b363SPhilipp Reisner } 2021b411b363SPhilipp Reisner 2022688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2023688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2024688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 202581f0ffd2SAndreas Gruenbacher static unsigned long wire_flags_to_bio(u32 dpf) 202676d2e7ecSPhilipp Reisner { 202776d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 202876d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 2029688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 203076d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 203176d2e7ecSPhilipp Reisner } 203276d2e7ecSPhilipp Reisner 2033b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 20347be8da07SAndreas Gruenbacher unsigned int size) 2035b411b363SPhilipp Reisner { 20367be8da07SAndreas Gruenbacher struct drbd_interval *i; 20377be8da07SAndreas Gruenbacher 20387be8da07SAndreas Gruenbacher repeat: 2039b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 20407be8da07SAndreas Gruenbacher struct drbd_request *req; 20417be8da07SAndreas Gruenbacher struct bio_and_error m; 20427be8da07SAndreas Gruenbacher 20437be8da07SAndreas Gruenbacher if (!i->local) 20447be8da07SAndreas Gruenbacher continue; 20457be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 20467be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 20477be8da07SAndreas Gruenbacher continue; 20487be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 20497be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 20500500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 20517be8da07SAndreas Gruenbacher if (m.bio) 2052b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 20530500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 20547be8da07SAndreas Gruenbacher goto repeat; 20557be8da07SAndreas Gruenbacher } 20567be8da07SAndreas Gruenbacher } 20577be8da07SAndreas Gruenbacher 2058b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 20597be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 20607be8da07SAndreas Gruenbacher { 2061e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2062bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 20637be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 20647be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 20657be8da07SAndreas Gruenbacher struct drbd_interval *i; 20667be8da07SAndreas Gruenbacher bool equal; 20677be8da07SAndreas Gruenbacher int err; 20687be8da07SAndreas Gruenbacher 20697be8da07SAndreas Gruenbacher /* 20707be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 20717be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 20727be8da07SAndreas Gruenbacher */ 2073b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 20747be8da07SAndreas Gruenbacher 20757be8da07SAndreas Gruenbacher repeat: 2076b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 20777be8da07SAndreas Gruenbacher if (i == &peer_req->i) 20787be8da07SAndreas Gruenbacher continue; 20797be8da07SAndreas Gruenbacher 20807be8da07SAndreas Gruenbacher if (!i->local) { 20817be8da07SAndreas Gruenbacher /* 20827be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20837be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20847be8da07SAndreas Gruenbacher * earlier peer request to complete. 20857be8da07SAndreas Gruenbacher */ 2086b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 20877be8da07SAndreas Gruenbacher if (err) 20887be8da07SAndreas Gruenbacher goto out; 20897be8da07SAndreas Gruenbacher goto repeat; 20907be8da07SAndreas Gruenbacher } 20917be8da07SAndreas Gruenbacher 20927be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20937be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20947be8da07SAndreas Gruenbacher /* 20957be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2096d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2097d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2098d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 20997be8da07SAndreas Gruenbacher */ 2100d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 21017be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 21027be8da07SAndreas Gruenbacher 21037be8da07SAndreas Gruenbacher if (!equal) 2104d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21057be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 21067be8da07SAndreas Gruenbacher "assuming %s came first\n", 21077be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21087be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2109d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 21107be8da07SAndreas Gruenbacher 2111b30ab791SAndreas Gruenbacher inc_unacked(device); 2112a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 21137be8da07SAndreas Gruenbacher e_send_retry_write; 2114a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2115e33b32deSAndreas Gruenbacher wake_asender(connection); 21167be8da07SAndreas Gruenbacher 21177be8da07SAndreas Gruenbacher err = -ENOENT; 21187be8da07SAndreas Gruenbacher goto out; 21197be8da07SAndreas Gruenbacher } else { 21207be8da07SAndreas Gruenbacher struct drbd_request *req = 21217be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 21227be8da07SAndreas Gruenbacher 21237be8da07SAndreas Gruenbacher if (!equal) 2124d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 21257be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 21267be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 21277be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 21287be8da07SAndreas Gruenbacher 21297be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21307be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 21317be8da07SAndreas Gruenbacher /* 21327be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2133d4dabbe2SLars Ellenberg * decide if this request has been superseded 2134d4dabbe2SLars Ellenberg * or needs to be retried. 2135d4dabbe2SLars Ellenberg * Requests that have been superseded will 21367be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 21377be8da07SAndreas Gruenbacher * 21387be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 21397be8da07SAndreas Gruenbacher * request to finish locally before submitting 21407be8da07SAndreas Gruenbacher * the conflicting peer request. 21417be8da07SAndreas Gruenbacher */ 2142b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 21437be8da07SAndreas Gruenbacher if (err) { 2144e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2145b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 21467be8da07SAndreas Gruenbacher goto out; 21477be8da07SAndreas Gruenbacher } 21487be8da07SAndreas Gruenbacher goto repeat; 21497be8da07SAndreas Gruenbacher } 21507be8da07SAndreas Gruenbacher /* 21517be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 21527be8da07SAndreas Gruenbacher * the new peer request has completed. 21537be8da07SAndreas Gruenbacher */ 21547be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 21557be8da07SAndreas Gruenbacher } 21567be8da07SAndreas Gruenbacher } 21577be8da07SAndreas Gruenbacher err = 0; 21587be8da07SAndreas Gruenbacher 21597be8da07SAndreas Gruenbacher out: 21607be8da07SAndreas Gruenbacher if (err) 2161b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 21627be8da07SAndreas Gruenbacher return err; 21637be8da07SAndreas Gruenbacher } 21647be8da07SAndreas Gruenbacher 2165b411b363SPhilipp Reisner /* mirrored write */ 2166bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2167b411b363SPhilipp Reisner { 21689f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2169b30ab791SAndreas Gruenbacher struct drbd_device *device; 2170b411b363SPhilipp Reisner sector_t sector; 2171db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2172e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21737be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2174b411b363SPhilipp Reisner int rw = WRITE; 2175b411b363SPhilipp Reisner u32 dp_flags; 2176302bdeaeSPhilipp Reisner int err, tp; 21777be8da07SAndreas Gruenbacher 21789f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 21799f4fe9adSAndreas Gruenbacher if (!peer_device) 21804a76b161SAndreas Gruenbacher return -EIO; 21819f4fe9adSAndreas Gruenbacher device = peer_device->device; 2182b411b363SPhilipp Reisner 2183b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 218482bc0194SAndreas Gruenbacher int err2; 2185b411b363SPhilipp Reisner 218669a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 218769a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2188bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 218969a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 219082bc0194SAndreas Gruenbacher if (!err) 219182bc0194SAndreas Gruenbacher err = err2; 219282bc0194SAndreas Gruenbacher return err; 2193b411b363SPhilipp Reisner } 2194b411b363SPhilipp Reisner 2195fcefa62eSAndreas Gruenbacher /* 2196fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2197fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2198fcefa62eSAndreas Gruenbacher * end of this function. 2199fcefa62eSAndreas Gruenbacher */ 2200b411b363SPhilipp Reisner 2201b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 220269a22773SAndreas Gruenbacher peer_req = read_in_block(peer_device, p->block_id, sector, pi->size); 2203db830c46SAndreas Gruenbacher if (!peer_req) { 2204b30ab791SAndreas Gruenbacher put_ldev(device); 220582bc0194SAndreas Gruenbacher return -EIO; 2206b411b363SPhilipp Reisner } 2207b411b363SPhilipp Reisner 2208a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 2209b411b363SPhilipp Reisner 2210688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 221181f0ffd2SAndreas Gruenbacher rw |= wire_flags_to_bio(dp_flags); 221281a3537aSLars Ellenberg if (peer_req->pages == NULL) { 22130b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 22140b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2215a73ff323SLars Ellenberg } 2216688593c5SLars Ellenberg 2217688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2218db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2219688593c5SLars Ellenberg 2220bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2221bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2222db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2223db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2224bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2225b411b363SPhilipp Reisner 2226302bdeaeSPhilipp Reisner rcu_read_lock(); 22279f4fe9adSAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2228302bdeaeSPhilipp Reisner rcu_read_unlock(); 2229302bdeaeSPhilipp Reisner if (tp) { 2230302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 223169a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 22327be8da07SAndreas Gruenbacher if (err) 2233b411b363SPhilipp Reisner goto out_interrupted; 22340500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2235b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 22367be8da07SAndreas Gruenbacher if (err) { 22370500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 22387be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2239b30ab791SAndreas Gruenbacher put_ldev(device); 224082bc0194SAndreas Gruenbacher return 0; 2241b411b363SPhilipp Reisner } 2242b411b363SPhilipp Reisner goto out_interrupted; 2243b411b363SPhilipp Reisner } 2244b874d231SPhilipp Reisner } else { 224569a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 22460500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2247b874d231SPhilipp Reisner } 2248a8cd15baSAndreas Gruenbacher list_add(&peer_req->w.list, &device->active_ee); 22490500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2250b411b363SPhilipp Reisner 2251b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2252b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2253b6a370baSPhilipp Reisner 22549f4fe9adSAndreas Gruenbacher if (peer_device->connection->agreed_pro_version < 100) { 225544ed167dSPhilipp Reisner rcu_read_lock(); 22569f4fe9adSAndreas Gruenbacher switch (rcu_dereference(peer_device->connection->net_conf)->wire_protocol) { 2257b411b363SPhilipp Reisner case DRBD_PROT_C: 2258303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2259303d1448SPhilipp Reisner break; 2260303d1448SPhilipp Reisner case DRBD_PROT_B: 2261303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2262303d1448SPhilipp Reisner break; 2263303d1448SPhilipp Reisner } 226444ed167dSPhilipp Reisner rcu_read_unlock(); 2265303d1448SPhilipp Reisner } 2266303d1448SPhilipp Reisner 2267303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2268303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2269b30ab791SAndreas Gruenbacher inc_unacked(device); 2270b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2271b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2272303d1448SPhilipp Reisner } 2273303d1448SPhilipp Reisner 2274303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2275b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2276b411b363SPhilipp Reisner * sends on the msock, but anyways */ 227769a22773SAndreas Gruenbacher drbd_send_ack(first_peer_device(device), P_RECV_ACK, peer_req); 2278b411b363SPhilipp Reisner } 2279b411b363SPhilipp Reisner 2280b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2281b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2282b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2283db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2284db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2285b30ab791SAndreas Gruenbacher drbd_al_begin_io(device, &peer_req->i, true); 2286b411b363SPhilipp Reisner } 2287b411b363SPhilipp Reisner 2288b30ab791SAndreas Gruenbacher err = drbd_submit_peer_request(device, peer_req, rw, DRBD_FAULT_DT_WR); 228982bc0194SAndreas Gruenbacher if (!err) 229082bc0194SAndreas Gruenbacher return 0; 2291b411b363SPhilipp Reisner 229210f6d992SLars Ellenberg /* don't care for the reason here */ 2293d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 22940500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2295a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2296b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 22970500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2298db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2299b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 230022cc37a9SLars Ellenberg 2301b411b363SPhilipp Reisner out_interrupted: 2302bde89a9eSAndreas Gruenbacher drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT + EV_CLEANUP); 2303b30ab791SAndreas Gruenbacher put_ldev(device); 2304b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 230582bc0194SAndreas Gruenbacher return err; 2306b411b363SPhilipp Reisner } 2307b411b363SPhilipp Reisner 23080f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 23090f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 23100f0601f4SLars Ellenberg * 23110f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 23120f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 23130f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 23140f0601f4SLars Ellenberg * activity, it obviously is "busy". 23150f0601f4SLars Ellenberg * 23160f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 23170f0601f4SLars Ellenberg * to have a short time average so we can react faster. 23180f0601f4SLars Ellenberg */ 2319b30ab791SAndreas Gruenbacher int drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector) 23200f0601f4SLars Ellenberg { 2321b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 23220f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2323e3555d85SPhilipp Reisner struct lc_element *tmp; 23240f0601f4SLars Ellenberg int curr_events; 23250f0601f4SLars Ellenberg int throttle = 0; 2326daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2327daeda1ccSPhilipp Reisner 2328daeda1ccSPhilipp Reisner rcu_read_lock(); 2329b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2330daeda1ccSPhilipp Reisner rcu_read_unlock(); 23310f0601f4SLars Ellenberg 23320f0601f4SLars Ellenberg /* feature disabled? */ 2333daeda1ccSPhilipp Reisner if (c_min_rate == 0) 23340f0601f4SLars Ellenberg return 0; 23350f0601f4SLars Ellenberg 2336b30ab791SAndreas Gruenbacher spin_lock_irq(&device->al_lock); 2337b30ab791SAndreas Gruenbacher tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2338e3555d85SPhilipp Reisner if (tmp) { 2339e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2340e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2341b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->al_lock); 2342e3555d85SPhilipp Reisner return 0; 2343e3555d85SPhilipp Reisner } 2344e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2345e3555d85SPhilipp Reisner } 2346b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->al_lock); 2347e3555d85SPhilipp Reisner 23480f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 23490f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2350b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2351e3555d85SPhilipp Reisner 2352b30ab791SAndreas Gruenbacher if (!device->rs_last_events || curr_events - device->rs_last_events > 64) { 23530f0601f4SLars Ellenberg unsigned long rs_left; 23540f0601f4SLars Ellenberg int i; 23550f0601f4SLars Ellenberg 2356b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 23570f0601f4SLars Ellenberg 23580f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 23590f0601f4SLars Ellenberg * approx. */ 2360b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 23612649f080SLars Ellenberg 2362b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2363b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 23642649f080SLars Ellenberg else 2365b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 23660f0601f4SLars Ellenberg 2367b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 23680f0601f4SLars Ellenberg if (!dt) 23690f0601f4SLars Ellenberg dt++; 2370b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 23710f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 23720f0601f4SLars Ellenberg 2373daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 23740f0601f4SLars Ellenberg throttle = 1; 23750f0601f4SLars Ellenberg } 23760f0601f4SLars Ellenberg return throttle; 23770f0601f4SLars Ellenberg } 23780f0601f4SLars Ellenberg 23790f0601f4SLars Ellenberg 2380bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2381b411b363SPhilipp Reisner { 23829f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2383b30ab791SAndreas Gruenbacher struct drbd_device *device; 2384b411b363SPhilipp Reisner sector_t sector; 23854a76b161SAndreas Gruenbacher sector_t capacity; 2386db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2387b411b363SPhilipp Reisner struct digest_info *di = NULL; 2388b18b37beSPhilipp Reisner int size, verb; 2389b411b363SPhilipp Reisner unsigned int fault_type; 2390e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 23914a76b161SAndreas Gruenbacher 23929f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 23939f4fe9adSAndreas Gruenbacher if (!peer_device) 23944a76b161SAndreas Gruenbacher return -EIO; 23959f4fe9adSAndreas Gruenbacher device = peer_device->device; 2396b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2397b411b363SPhilipp Reisner 2398b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2399b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2400b411b363SPhilipp Reisner 2401c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2402d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2403b411b363SPhilipp Reisner (unsigned long long)sector, size); 240482bc0194SAndreas Gruenbacher return -EINVAL; 2405b411b363SPhilipp Reisner } 2406b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2407d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2408b411b363SPhilipp Reisner (unsigned long long)sector, size); 240982bc0194SAndreas Gruenbacher return -EINVAL; 2410b411b363SPhilipp Reisner } 2411b411b363SPhilipp Reisner 2412b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2413b18b37beSPhilipp Reisner verb = 1; 2414e2857216SAndreas Gruenbacher switch (pi->cmd) { 2415b18b37beSPhilipp Reisner case P_DATA_REQUEST: 241669a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2417b18b37beSPhilipp Reisner break; 2418b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2419b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2420b18b37beSPhilipp Reisner case P_OV_REQUEST: 242169a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2422b18b37beSPhilipp Reisner break; 2423b18b37beSPhilipp Reisner case P_OV_REPLY: 2424b18b37beSPhilipp Reisner verb = 0; 2425b30ab791SAndreas Gruenbacher dec_rs_pending(device); 242669a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2427b18b37beSPhilipp Reisner break; 2428b18b37beSPhilipp Reisner default: 242949ba9b1bSAndreas Gruenbacher BUG(); 2430b18b37beSPhilipp Reisner } 2431b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2432d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2433b411b363SPhilipp Reisner "no local data.\n"); 2434b18b37beSPhilipp Reisner 2435a821cc4aSLars Ellenberg /* drain possibly payload */ 243669a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2437b411b363SPhilipp Reisner } 2438b411b363SPhilipp Reisner 2439b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2440b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2441b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 244269a22773SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, GFP_NOIO); 2443db830c46SAndreas Gruenbacher if (!peer_req) { 2444b30ab791SAndreas Gruenbacher put_ldev(device); 244582bc0194SAndreas Gruenbacher return -ENOMEM; 2446b411b363SPhilipp Reisner } 2447b411b363SPhilipp Reisner 2448e2857216SAndreas Gruenbacher switch (pi->cmd) { 2449b411b363SPhilipp Reisner case P_DATA_REQUEST: 2450a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2451b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 245280a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 245380a40e43SLars Ellenberg goto submit; 245480a40e43SLars Ellenberg 2455b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2456a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2457b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 24585f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2459b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2460b411b363SPhilipp Reisner break; 2461b411b363SPhilipp Reisner 2462b411b363SPhilipp Reisner case P_OV_REPLY: 2463b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2464b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2465e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2466b411b363SPhilipp Reisner if (!di) 2467b411b363SPhilipp Reisner goto out_free_e; 2468b411b363SPhilipp Reisner 2469e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2470b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2471b411b363SPhilipp Reisner 2472db830c46SAndreas Gruenbacher peer_req->digest = di; 2473db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2474c36c3cedSLars Ellenberg 24759f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2476b411b363SPhilipp Reisner goto out_free_e; 2477b411b363SPhilipp Reisner 2478e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 24799f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2480a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 24815f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2482b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2483e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 24842649f080SLars Ellenberg /* track progress, we may need to throttle */ 2485b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2486a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2487b30ab791SAndreas Gruenbacher dec_rs_pending(device); 24880f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 24890f0601f4SLars Ellenberg * but accounting still needs to be done. */ 24900f0601f4SLars Ellenberg goto submit_for_resync; 2491b411b363SPhilipp Reisner } 2492b411b363SPhilipp Reisner break; 2493b411b363SPhilipp Reisner 2494b411b363SPhilipp Reisner case P_OV_REQUEST: 2495b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 24969f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2497de228bbaSLars Ellenberg unsigned long now = jiffies; 2498de228bbaSLars Ellenberg int i; 2499b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2500b30ab791SAndreas Gruenbacher device->ov_position = sector; 2501b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2502b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2503de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2504b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2505b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2506de228bbaSLars Ellenberg } 2507d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2508b411b363SPhilipp Reisner (unsigned long long)sector); 2509b411b363SPhilipp Reisner } 2510a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2511b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2512b411b363SPhilipp Reisner break; 2513b411b363SPhilipp Reisner 2514b411b363SPhilipp Reisner default: 251549ba9b1bSAndreas Gruenbacher BUG(); 2516b411b363SPhilipp Reisner } 2517b411b363SPhilipp Reisner 25180f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 25190f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 25200f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 25210f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 25220f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 25230f0601f4SLars Ellenberg * 25240f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 25250f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 25260f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 25270f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 25280f0601f4SLars Ellenberg * a while, anyways. 25290f0601f4SLars Ellenberg */ 2530b411b363SPhilipp Reisner 25310f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 25320f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 25330f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 25340f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 25350f0601f4SLars Ellenberg * 25360f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 25370f0601f4SLars Ellenberg * we would also throttle its application reads. 25380f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 25390f0601f4SLars Ellenberg */ 2540b30ab791SAndreas Gruenbacher if (device->state.peer != R_PRIMARY && drbd_rs_should_slow_down(device, sector)) 2541e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2542b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 254380a40e43SLars Ellenberg goto out_free_e; 2544b411b363SPhilipp Reisner 25450f0601f4SLars Ellenberg submit_for_resync: 2546b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 25470f0601f4SLars Ellenberg 254880a40e43SLars Ellenberg submit: 2549b30ab791SAndreas Gruenbacher inc_unacked(device); 25500500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2551a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->read_ee); 25520500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2553b411b363SPhilipp Reisner 2554b30ab791SAndreas Gruenbacher if (drbd_submit_peer_request(device, peer_req, READ, fault_type) == 0) 255582bc0194SAndreas Gruenbacher return 0; 2556b411b363SPhilipp Reisner 255710f6d992SLars Ellenberg /* don't care for the reason here */ 2558d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 25590500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2560a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 25610500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 256222cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 256322cc37a9SLars Ellenberg 2564b411b363SPhilipp Reisner out_free_e: 2565b30ab791SAndreas Gruenbacher put_ldev(device); 2566b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 256782bc0194SAndreas Gruenbacher return -EIO; 2568b411b363SPhilipp Reisner } 2569b411b363SPhilipp Reisner 257069a22773SAndreas Gruenbacher /** 257169a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 257269a22773SAndreas Gruenbacher */ 257369a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2574b411b363SPhilipp Reisner { 257569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2576b411b363SPhilipp Reisner int self, peer, rv = -100; 2577b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 257844ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2579b411b363SPhilipp Reisner 2580b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2581b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2582b411b363SPhilipp Reisner 2583b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2584b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2585b411b363SPhilipp Reisner 258644ed167dSPhilipp Reisner rcu_read_lock(); 258769a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 258844ed167dSPhilipp Reisner rcu_read_unlock(); 258944ed167dSPhilipp Reisner switch (after_sb_0p) { 2590b411b363SPhilipp Reisner case ASB_CONSENSUS: 2591b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2592b411b363SPhilipp Reisner case ASB_CALL_HELPER: 259344ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2594d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2595b411b363SPhilipp Reisner break; 2596b411b363SPhilipp Reisner case ASB_DISCONNECT: 2597b411b363SPhilipp Reisner break; 2598b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2599b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2600b411b363SPhilipp Reisner rv = -1; 2601b411b363SPhilipp Reisner break; 2602b411b363SPhilipp Reisner } 2603b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2604b411b363SPhilipp Reisner rv = 1; 2605b411b363SPhilipp Reisner break; 2606b411b363SPhilipp Reisner } 2607b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2608b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2609b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2610b411b363SPhilipp Reisner rv = 1; 2611b411b363SPhilipp Reisner break; 2612b411b363SPhilipp Reisner } 2613b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2614b411b363SPhilipp Reisner rv = -1; 2615b411b363SPhilipp Reisner break; 2616b411b363SPhilipp Reisner } 2617b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2618d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 2619b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2620b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2621b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 262269a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2623b411b363SPhilipp Reisner ? -1 : 1; 2624b411b363SPhilipp Reisner break; 2625b411b363SPhilipp Reisner } else { 2626b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2627b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2628b411b363SPhilipp Reisner } 262944ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2630b411b363SPhilipp Reisner break; 2631b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2632b411b363SPhilipp Reisner if (ch_self < ch_peer) 2633b411b363SPhilipp Reisner rv = -1; 2634b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2635b411b363SPhilipp Reisner rv = 1; 2636b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2637b411b363SPhilipp Reisner /* Well, then use something else. */ 263869a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2639b411b363SPhilipp Reisner ? -1 : 1; 2640b411b363SPhilipp Reisner break; 2641b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2642b411b363SPhilipp Reisner rv = -1; 2643b411b363SPhilipp Reisner break; 2644b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2645b411b363SPhilipp Reisner rv = 1; 2646b411b363SPhilipp Reisner } 2647b411b363SPhilipp Reisner 2648b411b363SPhilipp Reisner return rv; 2649b411b363SPhilipp Reisner } 2650b411b363SPhilipp Reisner 265169a22773SAndreas Gruenbacher /** 265269a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 265369a22773SAndreas Gruenbacher */ 265469a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 2655b411b363SPhilipp Reisner { 265669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 26576184ea21SAndreas Gruenbacher int hg, rv = -100; 265844ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2659b411b363SPhilipp Reisner 266044ed167dSPhilipp Reisner rcu_read_lock(); 266169a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 266244ed167dSPhilipp Reisner rcu_read_unlock(); 266344ed167dSPhilipp Reisner switch (after_sb_1p) { 2664b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2665b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2666b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2667b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2668b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 266944ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2670d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2671b411b363SPhilipp Reisner break; 2672b411b363SPhilipp Reisner case ASB_DISCONNECT: 2673b411b363SPhilipp Reisner break; 2674b411b363SPhilipp Reisner case ASB_CONSENSUS: 267569a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2676b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 2677b411b363SPhilipp Reisner rv = hg; 2678b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 2679b411b363SPhilipp Reisner rv = hg; 2680b411b363SPhilipp Reisner break; 2681b411b363SPhilipp Reisner case ASB_VIOLENTLY: 268269a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2683b411b363SPhilipp Reisner break; 2684b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2685b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 2686b411b363SPhilipp Reisner case ASB_CALL_HELPER: 268769a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2688b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 2689bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2690bb437946SAndreas Gruenbacher 2691b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2692b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2693b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2694b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2695bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2696b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2697b411b363SPhilipp Reisner } else { 2698d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2699b411b363SPhilipp Reisner rv = hg; 2700b411b363SPhilipp Reisner } 2701b411b363SPhilipp Reisner } else 2702b411b363SPhilipp Reisner rv = hg; 2703b411b363SPhilipp Reisner } 2704b411b363SPhilipp Reisner 2705b411b363SPhilipp Reisner return rv; 2706b411b363SPhilipp Reisner } 2707b411b363SPhilipp Reisner 270869a22773SAndreas Gruenbacher /** 270969a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 271069a22773SAndreas Gruenbacher */ 271169a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 2712b411b363SPhilipp Reisner { 271369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 27146184ea21SAndreas Gruenbacher int hg, rv = -100; 271544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2716b411b363SPhilipp Reisner 271744ed167dSPhilipp Reisner rcu_read_lock(); 271869a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 271944ed167dSPhilipp Reisner rcu_read_unlock(); 272044ed167dSPhilipp Reisner switch (after_sb_2p) { 2721b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2722b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2723b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2724b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2725b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2726b411b363SPhilipp Reisner case ASB_CONSENSUS: 2727b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 272844ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2729d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2730b411b363SPhilipp Reisner break; 2731b411b363SPhilipp Reisner case ASB_VIOLENTLY: 273269a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 2733b411b363SPhilipp Reisner break; 2734b411b363SPhilipp Reisner case ASB_DISCONNECT: 2735b411b363SPhilipp Reisner break; 2736b411b363SPhilipp Reisner case ASB_CALL_HELPER: 273769a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 2738b411b363SPhilipp Reisner if (hg == -1) { 2739bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2740bb437946SAndreas Gruenbacher 2741b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2742b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2743b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2744b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 2745bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2746b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 2747b411b363SPhilipp Reisner } else { 2748d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 2749b411b363SPhilipp Reisner rv = hg; 2750b411b363SPhilipp Reisner } 2751b411b363SPhilipp Reisner } else 2752b411b363SPhilipp Reisner rv = hg; 2753b411b363SPhilipp Reisner } 2754b411b363SPhilipp Reisner 2755b411b363SPhilipp Reisner return rv; 2756b411b363SPhilipp Reisner } 2757b411b363SPhilipp Reisner 2758b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 2759b411b363SPhilipp Reisner u64 bits, u64 flags) 2760b411b363SPhilipp Reisner { 2761b411b363SPhilipp Reisner if (!uuid) { 2762d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 2763b411b363SPhilipp Reisner return; 2764b411b363SPhilipp Reisner } 2765d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2766b411b363SPhilipp Reisner text, 2767b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2768b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2769b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2770b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2771b411b363SPhilipp Reisner (unsigned long long)bits, 2772b411b363SPhilipp Reisner (unsigned long long)flags); 2773b411b363SPhilipp Reisner } 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner /* 2776b411b363SPhilipp Reisner 100 after split brain try auto recover 2777b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2778b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2779b411b363SPhilipp Reisner 0 no Sync 2780b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2781b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2782b411b363SPhilipp Reisner -100 after split brain, disconnect 2783b411b363SPhilipp Reisner -1000 unrelated data 27844a23f264SPhilipp Reisner -1091 requires proto 91 27854a23f264SPhilipp Reisner -1096 requires proto 96 2786b411b363SPhilipp Reisner */ 2787b30ab791SAndreas Gruenbacher static int drbd_uuid_compare(struct drbd_device *device, int *rule_nr) __must_hold(local) 2788b411b363SPhilipp Reisner { 2789b411b363SPhilipp Reisner u64 self, peer; 2790b411b363SPhilipp Reisner int i, j; 2791b411b363SPhilipp Reisner 2792b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2793b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2794b411b363SPhilipp Reisner 2795b411b363SPhilipp Reisner *rule_nr = 10; 2796b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2797b411b363SPhilipp Reisner return 0; 2798b411b363SPhilipp Reisner 2799b411b363SPhilipp Reisner *rule_nr = 20; 2800b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2801b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2802b411b363SPhilipp Reisner return -2; 2803b411b363SPhilipp Reisner 2804b411b363SPhilipp Reisner *rule_nr = 30; 2805b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2806b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2807b411b363SPhilipp Reisner return 2; 2808b411b363SPhilipp Reisner 2809b411b363SPhilipp Reisner if (self == peer) { 2810b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2811b411b363SPhilipp Reisner 2812b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2813b411b363SPhilipp Reisner 2814a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 28154a23f264SPhilipp Reisner return -1091; 2816b411b363SPhilipp Reisner 2817b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2818b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2819d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2820b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 2821b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 2822b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 2823b411b363SPhilipp Reisner 2824b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 2825b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 2826b411b363SPhilipp Reisner *rule_nr = 34; 2827b411b363SPhilipp Reisner } else { 2828d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 2829b411b363SPhilipp Reisner *rule_nr = 36; 2830b411b363SPhilipp Reisner } 2831b411b363SPhilipp Reisner 2832b411b363SPhilipp Reisner return 1; 2833b411b363SPhilipp Reisner } 2834b411b363SPhilipp Reisner 2835b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 2836b411b363SPhilipp Reisner 2837a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 28384a23f264SPhilipp Reisner return -1091; 2839b411b363SPhilipp Reisner 2840b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 2841b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2842d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2843b411b363SPhilipp Reisner 2844b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 2845b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 2846b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 2847b411b363SPhilipp Reisner 2848b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 2849b411b363SPhilipp Reisner *rule_nr = 35; 2850b411b363SPhilipp Reisner } else { 2851d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 2852b411b363SPhilipp Reisner *rule_nr = 37; 2853b411b363SPhilipp Reisner } 2854b411b363SPhilipp Reisner 2855b411b363SPhilipp Reisner return -1; 2856b411b363SPhilipp Reisner } 2857b411b363SPhilipp Reisner 2858b411b363SPhilipp Reisner /* Common power [off|failure] */ 2859b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 2860b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 2861b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2862b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2863b411b363SPhilipp Reisner *rule_nr = 40; 2864b411b363SPhilipp Reisner 2865b411b363SPhilipp Reisner switch (rct) { 2866b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2867b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2868b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2869b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 2870a6b32bc3SAndreas Gruenbacher dc = test_bit(RESOLVE_CONFLICTS, &first_peer_device(device)->connection->flags); 2871b411b363SPhilipp Reisner return dc ? -1 : 1; 2872b411b363SPhilipp Reisner } 2873b411b363SPhilipp Reisner } 2874b411b363SPhilipp Reisner 2875b411b363SPhilipp Reisner *rule_nr = 50; 2876b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 2877b411b363SPhilipp Reisner if (self == peer) 2878b411b363SPhilipp Reisner return -1; 2879b411b363SPhilipp Reisner 2880b411b363SPhilipp Reisner *rule_nr = 51; 2881b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 2882b411b363SPhilipp Reisner if (self == peer) { 2883a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 96 ? 2884b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 2885b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 2886b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 2887b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2888b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2889b411b363SPhilipp Reisner 2890a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 28914a23f264SPhilipp Reisner return -1091; 2892b411b363SPhilipp Reisner 2893b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 2894b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 28954a23f264SPhilipp Reisner 2896d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 2897b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 28984a23f264SPhilipp Reisner 2899b411b363SPhilipp Reisner return -1; 2900b411b363SPhilipp Reisner } 2901b411b363SPhilipp Reisner } 2902b411b363SPhilipp Reisner 2903b411b363SPhilipp Reisner *rule_nr = 60; 2904b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2905b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2906b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 2907b411b363SPhilipp Reisner if (self == peer) 2908b411b363SPhilipp Reisner return -2; 2909b411b363SPhilipp Reisner } 2910b411b363SPhilipp Reisner 2911b411b363SPhilipp Reisner *rule_nr = 70; 2912b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2913b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2914b411b363SPhilipp Reisner if (self == peer) 2915b411b363SPhilipp Reisner return 1; 2916b411b363SPhilipp Reisner 2917b411b363SPhilipp Reisner *rule_nr = 71; 2918b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2919b411b363SPhilipp Reisner if (self == peer) { 2920a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 96 ? 2921b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 2922b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 2923b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2924b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2925b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2926b411b363SPhilipp Reisner 2927a6b32bc3SAndreas Gruenbacher if (first_peer_device(device)->connection->agreed_pro_version < 91) 29284a23f264SPhilipp Reisner return -1091; 2929b411b363SPhilipp Reisner 2930b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 2931b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 2932b411b363SPhilipp Reisner 2933d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 2934b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 2935b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 2936b411b363SPhilipp Reisner 2937b411b363SPhilipp Reisner return 1; 2938b411b363SPhilipp Reisner } 2939b411b363SPhilipp Reisner } 2940b411b363SPhilipp Reisner 2941b411b363SPhilipp Reisner 2942b411b363SPhilipp Reisner *rule_nr = 80; 2943b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 2944b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2945b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 2946b411b363SPhilipp Reisner if (self == peer) 2947b411b363SPhilipp Reisner return 2; 2948b411b363SPhilipp Reisner } 2949b411b363SPhilipp Reisner 2950b411b363SPhilipp Reisner *rule_nr = 90; 2951b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2952b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 2953b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2954b411b363SPhilipp Reisner return 100; 2955b411b363SPhilipp Reisner 2956b411b363SPhilipp Reisner *rule_nr = 100; 2957b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2958b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 2959b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2960b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 2961b411b363SPhilipp Reisner if (self == peer) 2962b411b363SPhilipp Reisner return -100; 2963b411b363SPhilipp Reisner } 2964b411b363SPhilipp Reisner } 2965b411b363SPhilipp Reisner 2966b411b363SPhilipp Reisner return -1000; 2967b411b363SPhilipp Reisner } 2968b411b363SPhilipp Reisner 2969b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2970b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2971b411b363SPhilipp Reisner */ 297269a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 297369a22773SAndreas Gruenbacher enum drbd_role peer_role, 2974b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2975b411b363SPhilipp Reisner { 297669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2977b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2978b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 297944ed167dSPhilipp Reisner struct net_conf *nc; 29806dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2981b411b363SPhilipp Reisner 2982b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 2983b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2984b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 2985b411b363SPhilipp Reisner 2986d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 29879f2247bbSPhilipp Reisner 2988b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 2989b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 2990b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 2991b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 2992b411b363SPhilipp Reisner 2993b30ab791SAndreas Gruenbacher hg = drbd_uuid_compare(device, &rule_nr); 2994b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 2995b411b363SPhilipp Reisner 2996d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2997b411b363SPhilipp Reisner 2998b411b363SPhilipp Reisner if (hg == -1000) { 2999d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3000b411b363SPhilipp Reisner return C_MASK; 3001b411b363SPhilipp Reisner } 30024a23f264SPhilipp Reisner if (hg < -1000) { 3003d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3004b411b363SPhilipp Reisner return C_MASK; 3005b411b363SPhilipp Reisner } 3006b411b363SPhilipp Reisner 3007b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3008b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3009b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3010b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3011b411b363SPhilipp Reisner if (f) 3012b411b363SPhilipp Reisner hg = hg*2; 3013d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3014b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3015b411b363SPhilipp Reisner } 3016b411b363SPhilipp Reisner 30173a11a487SAdam Gandelman if (abs(hg) == 100) 3018b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 30193a11a487SAdam Gandelman 302044ed167dSPhilipp Reisner rcu_read_lock(); 302169a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 302244ed167dSPhilipp Reisner 302344ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3024b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3025b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3026b411b363SPhilipp Reisner int forced = (hg == -100); 3027b411b363SPhilipp Reisner 3028b411b363SPhilipp Reisner switch (pcount) { 3029b411b363SPhilipp Reisner case 0: 303069a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3031b411b363SPhilipp Reisner break; 3032b411b363SPhilipp Reisner case 1: 303369a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3034b411b363SPhilipp Reisner break; 3035b411b363SPhilipp Reisner case 2: 303669a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3037b411b363SPhilipp Reisner break; 3038b411b363SPhilipp Reisner } 3039b411b363SPhilipp Reisner if (abs(hg) < 100) { 3040d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3041b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3042b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3043b411b363SPhilipp Reisner if (forced) { 3044d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3045b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3046b411b363SPhilipp Reisner hg = hg*2; 3047b411b363SPhilipp Reisner } 3048b411b363SPhilipp Reisner } 3049b411b363SPhilipp Reisner } 3050b411b363SPhilipp Reisner 3051b411b363SPhilipp Reisner if (hg == -100) { 3052b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3053b411b363SPhilipp Reisner hg = -1; 3054b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3055b411b363SPhilipp Reisner hg = 1; 3056b411b363SPhilipp Reisner 3057b411b363SPhilipp Reisner if (abs(hg) < 100) 3058d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3059b411b363SPhilipp Reisner "Sync from %s node\n", 3060b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3061b411b363SPhilipp Reisner } 306244ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 30636dff2902SAndreas Gruenbacher tentative = nc->tentative; 306444ed167dSPhilipp Reisner rcu_read_unlock(); 3065b411b363SPhilipp Reisner 3066b411b363SPhilipp Reisner if (hg == -100) { 3067580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3068580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3069580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3070580b9767SLars Ellenberg * to that disk, in a way... */ 3071d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3072b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3073b411b363SPhilipp Reisner return C_MASK; 3074b411b363SPhilipp Reisner } 3075b411b363SPhilipp Reisner 3076b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3077d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3078b411b363SPhilipp Reisner return C_MASK; 3079b411b363SPhilipp Reisner } 3080b411b363SPhilipp Reisner 3081b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3082b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 308344ed167dSPhilipp Reisner switch (rr_conflict) { 3084b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3085b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3086b411b363SPhilipp Reisner /* fall through */ 3087b411b363SPhilipp Reisner case ASB_DISCONNECT: 3088d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3089b411b363SPhilipp Reisner return C_MASK; 3090b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3091d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3092b411b363SPhilipp Reisner "assumption\n"); 3093b411b363SPhilipp Reisner } 3094b411b363SPhilipp Reisner } 3095b411b363SPhilipp Reisner 309669a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3097cf14c2e9SPhilipp Reisner if (hg == 0) 3098d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3099cf14c2e9SPhilipp Reisner else 3100d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3101cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3102cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3103cf14c2e9SPhilipp Reisner return C_MASK; 3104cf14c2e9SPhilipp Reisner } 3105cf14c2e9SPhilipp Reisner 3106b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3107d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3108b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 310920ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3110b411b363SPhilipp Reisner return C_MASK; 3111b411b363SPhilipp Reisner } 3112b411b363SPhilipp Reisner 3113b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3114b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3115b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3116b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3117b411b363SPhilipp Reisner } else { 3118b411b363SPhilipp Reisner rv = C_CONNECTED; 3119b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3120d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3121b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3122b411b363SPhilipp Reisner } 3123b411b363SPhilipp Reisner } 3124b411b363SPhilipp Reisner 3125b411b363SPhilipp Reisner return rv; 3126b411b363SPhilipp Reisner } 3127b411b363SPhilipp Reisner 3128f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3129b411b363SPhilipp Reisner { 3130b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3131f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3132f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3133b411b363SPhilipp Reisner 3134b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3135f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3136f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3137b411b363SPhilipp Reisner 3138b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3139f179d76dSPhilipp Reisner return peer; 3140b411b363SPhilipp Reisner } 3141b411b363SPhilipp Reisner 3142bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3143b411b363SPhilipp Reisner { 3144e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3145036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3146036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3147036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3148036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3149accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 31507aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3151b411b363SPhilipp Reisner 3152b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3153b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3154b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3155b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3156b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3157cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 31586139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3159cf14c2e9SPhilipp Reisner 3160bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 316186db0618SAndreas Gruenbacher int err; 316286db0618SAndreas Gruenbacher 316388104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 316486db0618SAndreas Gruenbacher return -EIO; 3165bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 316686db0618SAndreas Gruenbacher if (err) 316786db0618SAndreas Gruenbacher return err; 316888104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3169036b17eaSPhilipp Reisner } 317086db0618SAndreas Gruenbacher 31717d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3172bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3173cf14c2e9SPhilipp Reisner 3174cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3175bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3176b411b363SPhilipp Reisner 317744ed167dSPhilipp Reisner rcu_read_lock(); 3178bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 317944ed167dSPhilipp Reisner 3180036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 31811ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 318244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3183b411b363SPhilipp Reisner } 3184b411b363SPhilipp Reisner 3185f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 31861ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 318744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3188b411b363SPhilipp Reisner } 3189b411b363SPhilipp Reisner 3190f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 31911ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 319244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3193b411b363SPhilipp Reisner } 3194b411b363SPhilipp Reisner 3195f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 31961ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 319744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3198b411b363SPhilipp Reisner } 3199b411b363SPhilipp Reisner 32006139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 32011ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 320244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3203b411b363SPhilipp Reisner } 3204b411b363SPhilipp Reisner 320544ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 32061ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 320744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3208b411b363SPhilipp Reisner } 3209b411b363SPhilipp Reisner 3210036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 32111ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3212036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3213036b17eaSPhilipp Reisner } 3214036b17eaSPhilipp Reisner 321586db0618SAndreas Gruenbacher rcu_read_unlock(); 3216fbc12f45SAndreas Gruenbacher } 32177d4c782cSAndreas Gruenbacher 32187d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 32197d4c782cSAndreas Gruenbacher int hash_size; 32207d4c782cSAndreas Gruenbacher 32217d4c782cSAndreas Gruenbacher /* 32227d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 32237d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 32247d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 32257d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 32267d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 32277d4c782cSAndreas Gruenbacher * change. 32287d4c782cSAndreas Gruenbacher */ 32297d4c782cSAndreas Gruenbacher 32307d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 32317d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 32321ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 32337d4c782cSAndreas Gruenbacher integrity_alg); 3234b411b363SPhilipp Reisner goto disconnect; 3235b411b363SPhilipp Reisner } 3236b411b363SPhilipp Reisner 32377d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 32387d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 32397d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 32407d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 32411ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 32427d4c782cSAndreas Gruenbacher goto disconnect; 32437d4c782cSAndreas Gruenbacher } 32447d4c782cSAndreas Gruenbacher } 32457d4c782cSAndreas Gruenbacher 32467d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 32477d4c782cSAndreas Gruenbacher if (!new_net_conf) { 32481ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3249b411b363SPhilipp Reisner goto disconnect; 3250b411b363SPhilipp Reisner } 3251b411b363SPhilipp Reisner 3252bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 32530500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3254bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 32557d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3256b411b363SPhilipp Reisner 32577d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 32587d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 32597d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 32607d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 32617d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3262b411b363SPhilipp Reisner 3263bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 32640500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3265bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3266b411b363SPhilipp Reisner 3267bde89a9eSAndreas Gruenbacher crypto_free_hash(connection->peer_integrity_tfm); 3268bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3269bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3270bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3271bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3272bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3273b411b363SPhilipp Reisner 32747d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 32751ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 32767d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3277b411b363SPhilipp Reisner 32787d4c782cSAndreas Gruenbacher synchronize_rcu(); 32797d4c782cSAndreas Gruenbacher kfree(old_net_conf); 328082bc0194SAndreas Gruenbacher return 0; 3281b411b363SPhilipp Reisner 328244ed167dSPhilipp Reisner disconnect_rcu_unlock: 328344ed167dSPhilipp Reisner rcu_read_unlock(); 3284b411b363SPhilipp Reisner disconnect: 3285b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3286036b17eaSPhilipp Reisner kfree(int_dig_in); 3287036b17eaSPhilipp Reisner kfree(int_dig_vv); 3288bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 328982bc0194SAndreas Gruenbacher return -EIO; 3290b411b363SPhilipp Reisner } 3291b411b363SPhilipp Reisner 3292b411b363SPhilipp Reisner /* helper function 3293b411b363SPhilipp Reisner * input: alg name, feature name 3294b411b363SPhilipp Reisner * return: NULL (alg name was "") 3295b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3296b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3297f63e631aSRashika Kheria static 3298b30ab791SAndreas Gruenbacher struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3299b411b363SPhilipp Reisner const char *alg, const char *name) 3300b411b363SPhilipp Reisner { 3301b411b363SPhilipp Reisner struct crypto_hash *tfm; 3302b411b363SPhilipp Reisner 3303b411b363SPhilipp Reisner if (!alg[0]) 3304b411b363SPhilipp Reisner return NULL; 3305b411b363SPhilipp Reisner 3306b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3307b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3308d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3309b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3310b411b363SPhilipp Reisner return tfm; 3311b411b363SPhilipp Reisner } 3312b411b363SPhilipp Reisner return tfm; 3313b411b363SPhilipp Reisner } 3314b411b363SPhilipp Reisner 3315bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3316b411b363SPhilipp Reisner { 3317bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 33184a76b161SAndreas Gruenbacher int size = pi->size; 33194a76b161SAndreas Gruenbacher 33204a76b161SAndreas Gruenbacher while (size) { 33214a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3322bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 33234a76b161SAndreas Gruenbacher if (s <= 0) { 33244a76b161SAndreas Gruenbacher if (s < 0) 33254a76b161SAndreas Gruenbacher return s; 33264a76b161SAndreas Gruenbacher break; 33274a76b161SAndreas Gruenbacher } 33284a76b161SAndreas Gruenbacher size -= s; 33294a76b161SAndreas Gruenbacher } 33304a76b161SAndreas Gruenbacher if (size) 33314a76b161SAndreas Gruenbacher return -EIO; 33324a76b161SAndreas Gruenbacher return 0; 33334a76b161SAndreas Gruenbacher } 33344a76b161SAndreas Gruenbacher 33354a76b161SAndreas Gruenbacher /* 33364a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 33374a76b161SAndreas Gruenbacher * 33384a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 33394a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 33404a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 33414a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 33424a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 33434a76b161SAndreas Gruenbacher * 33444a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 33454a76b161SAndreas Gruenbacher */ 3346bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 33474a76b161SAndreas Gruenbacher { 33481ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 33492fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3350bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 33514a76b161SAndreas Gruenbacher } 33524a76b161SAndreas Gruenbacher 3353bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 33544a76b161SAndreas Gruenbacher { 33559f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3356b30ab791SAndreas Gruenbacher struct drbd_device *device; 3357e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3358b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3359b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3360b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 33612ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3362813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3363bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3364813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3365778f271dSPhilipp Reisner int fifo_size = 0; 336682bc0194SAndreas Gruenbacher int err; 3367b411b363SPhilipp Reisner 33689f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 33699f4fe9adSAndreas Gruenbacher if (!peer_device) 3370bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 33719f4fe9adSAndreas Gruenbacher device = peer_device->device; 3372b411b363SPhilipp Reisner 3373b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3374b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3375b411b363SPhilipp Reisner + SHARED_SECRET_MAX 33768e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 33778e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3378b411b363SPhilipp Reisner 3379e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3380d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3381e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 338282bc0194SAndreas Gruenbacher return -EIO; 3383b411b363SPhilipp Reisner } 3384b411b363SPhilipp Reisner 3385b411b363SPhilipp Reisner if (apv <= 88) { 3386e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3387e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33888e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3389e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3390e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33910b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 33928e26f9ccSPhilipp Reisner } else { 3393e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3394e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33950b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3396b411b363SPhilipp Reisner } 3397b411b363SPhilipp Reisner 3398b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3399e658983aSAndreas Gruenbacher p = pi->data; 3400b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3401b411b363SPhilipp Reisner 34029f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 340382bc0194SAndreas Gruenbacher if (err) 340482bc0194SAndreas Gruenbacher return err; 3405b411b363SPhilipp Reisner 34060500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 34079f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3408b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3409daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3410daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3411b30ab791SAndreas Gruenbacher put_ldev(device); 34120500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3413d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3414daeda1ccSPhilipp Reisner return -ENOMEM; 3415f399002eSLars Ellenberg } 3416b411b363SPhilipp Reisner 3417b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3418daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3419daeda1ccSPhilipp Reisner 34206394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3421813472ceSPhilipp Reisner } 3422b411b363SPhilipp Reisner 3423b411b363SPhilipp Reisner if (apv >= 88) { 3424b411b363SPhilipp Reisner if (apv == 88) { 34255de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3426d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 34275de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3428b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3429813472ceSPhilipp Reisner err = -EIO; 3430813472ceSPhilipp Reisner goto reconnect; 3431b411b363SPhilipp Reisner } 3432b411b363SPhilipp Reisner 34339f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3434813472ceSPhilipp Reisner if (err) 3435813472ceSPhilipp Reisner goto reconnect; 3436b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3437b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 34380b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3439b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3440b411b363SPhilipp Reisner 3441b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3442b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3443b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 34440b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 34450b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3446b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3447b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3448b411b363SPhilipp Reisner } 3449b411b363SPhilipp Reisner 34502ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3451b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3452d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 34532ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3454b411b363SPhilipp Reisner goto disconnect; 3455b411b363SPhilipp Reisner } 3456b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3457b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3458b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3459b411b363SPhilipp Reisner verify_tfm = NULL; 3460b411b363SPhilipp Reisner goto disconnect; 3461b411b363SPhilipp Reisner } 3462b411b363SPhilipp Reisner } 3463b411b363SPhilipp Reisner 34642ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3465b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3466d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 34672ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3468b411b363SPhilipp Reisner goto disconnect; 3469b411b363SPhilipp Reisner } 3470b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3471b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3472b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3473b411b363SPhilipp Reisner csums_tfm = NULL; 3474b411b363SPhilipp Reisner goto disconnect; 3475b411b363SPhilipp Reisner } 3476b411b363SPhilipp Reisner } 3477b411b363SPhilipp Reisner 3478813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3479daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3480daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3481daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3482daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3483778f271dSPhilipp Reisner 3484daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3485b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3486813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3487813472ceSPhilipp Reisner if (!new_plan) { 3488d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3489b30ab791SAndreas Gruenbacher put_ldev(device); 3490778f271dSPhilipp Reisner goto disconnect; 3491778f271dSPhilipp Reisner } 3492778f271dSPhilipp Reisner } 34938e26f9ccSPhilipp Reisner } 3494b411b363SPhilipp Reisner 349591fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 34962ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 34972ec91e0eSPhilipp Reisner if (!new_net_conf) { 3498d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 349991fd4dadSPhilipp Reisner goto disconnect; 350091fd4dadSPhilipp Reisner } 350191fd4dadSPhilipp Reisner 35022ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 350391fd4dadSPhilipp Reisner 3504b411b363SPhilipp Reisner if (verify_tfm) { 35052ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 35062ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 35079f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->verify_tfm); 35089f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3509d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3510b411b363SPhilipp Reisner } 3511b411b363SPhilipp Reisner if (csums_tfm) { 35122ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 35132ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 35149f4fe9adSAndreas Gruenbacher crypto_free_hash(peer_device->connection->csums_tfm); 35159f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3516d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3517b411b363SPhilipp Reisner } 3518bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3519778f271dSPhilipp Reisner } 3520b411b363SPhilipp Reisner } 3521b411b363SPhilipp Reisner 3522813472ceSPhilipp Reisner if (new_disk_conf) { 3523b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3524b30ab791SAndreas Gruenbacher put_ldev(device); 3525b411b363SPhilipp Reisner } 3526813472ceSPhilipp Reisner 3527813472ceSPhilipp Reisner if (new_plan) { 3528b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3529b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3530813472ceSPhilipp Reisner } 3531daeda1ccSPhilipp Reisner 35320500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3533daeda1ccSPhilipp Reisner synchronize_rcu(); 3534daeda1ccSPhilipp Reisner if (new_net_conf) 3535daeda1ccSPhilipp Reisner kfree(old_net_conf); 3536daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3537813472ceSPhilipp Reisner kfree(old_plan); 3538daeda1ccSPhilipp Reisner 353982bc0194SAndreas Gruenbacher return 0; 3540b411b363SPhilipp Reisner 3541813472ceSPhilipp Reisner reconnect: 3542813472ceSPhilipp Reisner if (new_disk_conf) { 3543b30ab791SAndreas Gruenbacher put_ldev(device); 3544813472ceSPhilipp Reisner kfree(new_disk_conf); 3545813472ceSPhilipp Reisner } 35460500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3547813472ceSPhilipp Reisner return -EIO; 3548813472ceSPhilipp Reisner 3549b411b363SPhilipp Reisner disconnect: 3550813472ceSPhilipp Reisner kfree(new_plan); 3551813472ceSPhilipp Reisner if (new_disk_conf) { 3552b30ab791SAndreas Gruenbacher put_ldev(device); 3553813472ceSPhilipp Reisner kfree(new_disk_conf); 3554813472ceSPhilipp Reisner } 35550500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3556b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3557b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3558b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3559b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3560b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 35619f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 356282bc0194SAndreas Gruenbacher return -EIO; 3563b411b363SPhilipp Reisner } 3564b411b363SPhilipp Reisner 3565b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3566b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 3567b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3568b411b363SPhilipp Reisner { 3569b411b363SPhilipp Reisner sector_t d; 3570b411b363SPhilipp Reisner if (a == 0 || b == 0) 3571b411b363SPhilipp Reisner return; 3572b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3573b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3574d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 3575b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3576b411b363SPhilipp Reisner } 3577b411b363SPhilipp Reisner 3578bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 3579b411b363SPhilipp Reisner { 35809f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3581b30ab791SAndreas Gruenbacher struct drbd_device *device; 3582e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3583e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 3584b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3585b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3586e89b591cSPhilipp Reisner enum dds_flags ddsf; 3587b411b363SPhilipp Reisner 35889f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 35899f4fe9adSAndreas Gruenbacher if (!peer_device) 3590bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 35919f4fe9adSAndreas Gruenbacher device = peer_device->device; 35924a76b161SAndreas Gruenbacher 3593b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3594b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3595b411b363SPhilipp Reisner 3596b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3597b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3598b30ab791SAndreas Gruenbacher device->p_size = p_size; 3599b411b363SPhilipp Reisner 3600b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3601daeda1ccSPhilipp Reisner rcu_read_lock(); 3602b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 3603daeda1ccSPhilipp Reisner rcu_read_unlock(); 3604daeda1ccSPhilipp Reisner 3605b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 3606b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 3607b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 3608daeda1ccSPhilipp Reisner p_usize, my_usize); 3609b411b363SPhilipp Reisner 3610b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3611b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3612b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 3613daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3614b411b363SPhilipp Reisner 3615b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3616b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3617b30ab791SAndreas Gruenbacher if (drbd_new_dev_size(device, device->ldev, p_usize, 0) < 3618b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) && 3619b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 3620b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 3621d0180171SAndreas Gruenbacher drbd_err(device, "The peer's disk size is too small!\n"); 36229f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 3623b30ab791SAndreas Gruenbacher put_ldev(device); 362482bc0194SAndreas Gruenbacher return -EIO; 3625b411b363SPhilipp Reisner } 3626daeda1ccSPhilipp Reisner 3627daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3628daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3629daeda1ccSPhilipp Reisner 3630daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3631daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3632d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3633b30ab791SAndreas Gruenbacher put_ldev(device); 3634daeda1ccSPhilipp Reisner return -ENOMEM; 3635daeda1ccSPhilipp Reisner } 3636daeda1ccSPhilipp Reisner 36370500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3638b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3639daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3640daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3641daeda1ccSPhilipp Reisner 3642b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 36430500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3644daeda1ccSPhilipp Reisner synchronize_rcu(); 3645daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3646daeda1ccSPhilipp Reisner 3647d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 3648daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3649daeda1ccSPhilipp Reisner } 3650daeda1ccSPhilipp Reisner 3651b30ab791SAndreas Gruenbacher put_ldev(device); 3652b411b363SPhilipp Reisner } 3653b411b363SPhilipp Reisner 3654e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3655b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3656b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 3657b30ab791SAndreas Gruenbacher put_ldev(device); 3658e96c9633SPhilipp Reisner if (dd == DS_ERROR) 365982bc0194SAndreas Gruenbacher return -EIO; 3660b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3661b411b363SPhilipp Reisner } else { 3662b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3663b30ab791SAndreas Gruenbacher drbd_set_my_capacity(device, p_size); 3664b411b363SPhilipp Reisner } 3665b411b363SPhilipp Reisner 3666b30ab791SAndreas Gruenbacher device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 3667b30ab791SAndreas Gruenbacher drbd_reconsider_max_bio_size(device); 366899432fccSPhilipp Reisner 3669b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3670b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 3671b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 3672b411b363SPhilipp Reisner ldsc = 1; 3673b411b363SPhilipp Reisner } 3674b411b363SPhilipp Reisner 3675b30ab791SAndreas Gruenbacher put_ldev(device); 3676b411b363SPhilipp Reisner } 3677b411b363SPhilipp Reisner 3678b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 3679b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3680b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 3681b411b363SPhilipp Reisner /* we have different sizes, probably peer 3682b411b363SPhilipp Reisner * needs to know my new size... */ 368369a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 3684b411b363SPhilipp Reisner } 3685b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 3686b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 3687b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 3688b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 3689e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3690d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 3691b411b363SPhilipp Reisner else 3692b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 3693e89b591cSPhilipp Reisner } else 3694b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 3695b411b363SPhilipp Reisner } 3696b411b363SPhilipp Reisner } 3697b411b363SPhilipp Reisner 369882bc0194SAndreas Gruenbacher return 0; 3699b411b363SPhilipp Reisner } 3700b411b363SPhilipp Reisner 3701bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 3702b411b363SPhilipp Reisner { 37039f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3704b30ab791SAndreas Gruenbacher struct drbd_device *device; 3705e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3706b411b363SPhilipp Reisner u64 *p_uuid; 370762b0da3aSLars Ellenberg int i, updated_uuids = 0; 3708b411b363SPhilipp Reisner 37099f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 37109f4fe9adSAndreas Gruenbacher if (!peer_device) 3711bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 37129f4fe9adSAndreas Gruenbacher device = peer_device->device; 37134a76b161SAndreas Gruenbacher 3714b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3715063eacf8SJing Wang if (!p_uuid) { 3716d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 3717063eacf8SJing Wang return false; 3718063eacf8SJing Wang } 3719b411b363SPhilipp Reisner 3720b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3721b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3722b411b363SPhilipp Reisner 3723b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 3724b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 3725b411b363SPhilipp Reisner 3726b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 3727b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 3728b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 3729b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3730d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 3731b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 37329f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 373382bc0194SAndreas Gruenbacher return -EIO; 3734b411b363SPhilipp Reisner } 3735b411b363SPhilipp Reisner 3736b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3737b411b363SPhilipp Reisner int skip_initial_sync = 3738b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 37399f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 3740b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3741b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3742b411b363SPhilipp Reisner if (skip_initial_sync) { 3743d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 3744b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 374520ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 374620ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3747b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 3748b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 3749b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3750b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3751b30ab791SAndreas Gruenbacher drbd_md_sync(device); 375262b0da3aSLars Ellenberg updated_uuids = 1; 3753b411b363SPhilipp Reisner } 3754b30ab791SAndreas Gruenbacher put_ldev(device); 3755b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 3756b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 375718a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 375818a50fa2SPhilipp Reisner for me. */ 3759b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 3760b411b363SPhilipp Reisner } 3761b411b363SPhilipp Reisner 3762b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3763b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3764b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3765b411b363SPhilipp Reisner new disk state... */ 3766b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 3767b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 3768b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 3769b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 377062b0da3aSLars Ellenberg 377162b0da3aSLars Ellenberg if (updated_uuids) 3772b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 3773b411b363SPhilipp Reisner 377482bc0194SAndreas Gruenbacher return 0; 3775b411b363SPhilipp Reisner } 3776b411b363SPhilipp Reisner 3777b411b363SPhilipp Reisner /** 3778b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3779b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3780b411b363SPhilipp Reisner */ 3781b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3782b411b363SPhilipp Reisner { 3783b411b363SPhilipp Reisner union drbd_state ms; 3784b411b363SPhilipp Reisner 3785b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3786369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3787b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3788b411b363SPhilipp Reisner 3789b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3790b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3791b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3792b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3793b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3794b411b363SPhilipp Reisner }; 3795b411b363SPhilipp Reisner 3796b411b363SPhilipp Reisner ms.i = ps.i; 3797b411b363SPhilipp Reisner 3798b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3799b411b363SPhilipp Reisner ms.peer = ps.role; 3800b411b363SPhilipp Reisner ms.role = ps.peer; 3801b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3802b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3803b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3804b411b363SPhilipp Reisner 3805b411b363SPhilipp Reisner return ms; 3806b411b363SPhilipp Reisner } 3807b411b363SPhilipp Reisner 3808bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 3809b411b363SPhilipp Reisner { 38109f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3811b30ab791SAndreas Gruenbacher struct drbd_device *device; 3812e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3813b411b363SPhilipp Reisner union drbd_state mask, val; 3814bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3815b411b363SPhilipp Reisner 38169f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38179f4fe9adSAndreas Gruenbacher if (!peer_device) 38184a76b161SAndreas Gruenbacher return -EIO; 38199f4fe9adSAndreas Gruenbacher device = peer_device->device; 38204a76b161SAndreas Gruenbacher 3821b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3822b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3823b411b363SPhilipp Reisner 38249f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 3825b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 382669a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 382782bc0194SAndreas Gruenbacher return 0; 3828b411b363SPhilipp Reisner } 3829b411b363SPhilipp Reisner 3830b411b363SPhilipp Reisner mask = convert_state(mask); 3831b411b363SPhilipp Reisner val = convert_state(val); 3832b411b363SPhilipp Reisner 3833b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 383469a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 3835047cd4a6SPhilipp Reisner 3836b30ab791SAndreas Gruenbacher drbd_md_sync(device); 3837b411b363SPhilipp Reisner 383882bc0194SAndreas Gruenbacher return 0; 3839b411b363SPhilipp Reisner } 3840b411b363SPhilipp Reisner 3841bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 3842b411b363SPhilipp Reisner { 3843e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3844dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3845dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3846dfafcc8aSPhilipp Reisner 3847dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3848dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3849dfafcc8aSPhilipp Reisner 3850bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 3851bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 3852bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 385382bc0194SAndreas Gruenbacher return 0; 3854dfafcc8aSPhilipp Reisner } 3855dfafcc8aSPhilipp Reisner 3856dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3857dfafcc8aSPhilipp Reisner val = convert_state(val); 3858dfafcc8aSPhilipp Reisner 3859bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3860bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 3861dfafcc8aSPhilipp Reisner 386282bc0194SAndreas Gruenbacher return 0; 3863dfafcc8aSPhilipp Reisner } 3864dfafcc8aSPhilipp Reisner 3865bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 3866b411b363SPhilipp Reisner { 38679f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3868b30ab791SAndreas Gruenbacher struct drbd_device *device; 3869e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 38704ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3871b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 387265d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3873b411b363SPhilipp Reisner int rv; 3874b411b363SPhilipp Reisner 38759f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38769f4fe9adSAndreas Gruenbacher if (!peer_device) 3877bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 38789f4fe9adSAndreas Gruenbacher device = peer_device->device; 38794a76b161SAndreas Gruenbacher 3880b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3881b411b363SPhilipp Reisner 3882b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3883b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3884b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3885d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3886b411b363SPhilipp Reisner } 3887b411b363SPhilipp Reisner 38880500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 3889b411b363SPhilipp Reisner retry: 3890b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 38910500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 3892b411b363SPhilipp Reisner 3893545752d5SLars Ellenberg /* If some other part of the code (asender thread, timeout) 3894545752d5SLars Ellenberg * already decided to close the connection again, 3895545752d5SLars Ellenberg * we must not "re-establish" it here. */ 3896545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 389758ffa580SLars Ellenberg return -ECONNRESET; 3898545752d5SLars Ellenberg 389940424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 390040424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 390140424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 390240424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 390340424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 390440424e4aSLars Ellenberg */ 390540424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 390640424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 3907e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3908e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3909e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3910e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3911e9ef7bb6SLars Ellenberg * syncing states. 3912e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3913e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3914e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3915e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3916e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3917e9ef7bb6SLars Ellenberg 3918e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3919e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3920e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3921e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3922e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3923b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 3924b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 392582bc0194SAndreas Gruenbacher return 0; 3926e9ef7bb6SLars Ellenberg } 3927e9ef7bb6SLars Ellenberg } 3928e9ef7bb6SLars Ellenberg 392902b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 393002b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 393102b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 3932b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 3933b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 393458ffa580SLars Ellenberg return 0; 393502b91b55SLars Ellenberg } 393602b91b55SLars Ellenberg 3937e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3938e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3939e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3940e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3941e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3942e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3943e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3944e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3945e9ef7bb6SLars Ellenberg 39464ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 39474ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3948b411b363SPhilipp Reisner 394967531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 395067531718SPhilipp Reisner ns.conn = C_BEHIND; 395167531718SPhilipp Reisner 3952b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 3953b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 3954b411b363SPhilipp Reisner int cr; /* consider resync */ 3955b411b363SPhilipp Reisner 3956b411b363SPhilipp Reisner /* if we established a new connection */ 39574ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3958b411b363SPhilipp Reisner /* if we had an established connection 3959b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 39604ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3961b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 39624ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3963b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3964b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3965b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 3966b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3967b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 39684ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3969b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3970b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3971b411b363SPhilipp Reisner 3972b411b363SPhilipp Reisner if (cr) 397369a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 3974b411b363SPhilipp Reisner 3975b30ab791SAndreas Gruenbacher put_ldev(device); 39764ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 39774ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3978b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 3979b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 3980b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3981d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 3982b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3983580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3984b411b363SPhilipp Reisner } else { 39859f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 398682bc0194SAndreas Gruenbacher return -EIO; 39870b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 39889f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 398982bc0194SAndreas Gruenbacher return -EIO; 3990b411b363SPhilipp Reisner } 3991b411b363SPhilipp Reisner } 3992b411b363SPhilipp Reisner } 3993b411b363SPhilipp Reisner 39940500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 3995b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 3996b411b363SPhilipp Reisner goto retry; 3997b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 3998b411b363SPhilipp Reisner ns.peer = peer_state.role; 3999b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4000b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 40014ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4002b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 40034ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4004b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4005b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 40068554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4007481c6f50SPhilipp Reisner for temporal network outages! */ 40080500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4009d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 40109f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4011b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4012b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 40139f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 401482bc0194SAndreas Gruenbacher return -EIO; 4015481c6f50SPhilipp Reisner } 4016b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4017b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 40180500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4019b411b363SPhilipp Reisner 4020b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 40219f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 402282bc0194SAndreas Gruenbacher return -EIO; 4023b411b363SPhilipp Reisner } 4024b411b363SPhilipp Reisner 40254ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 40264ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4027b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4028b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4029b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4030b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 403169a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 403269a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4033b411b363SPhilipp Reisner } 4034b411b363SPhilipp Reisner } 4035b411b363SPhilipp Reisner 4036b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4037b411b363SPhilipp Reisner 4038b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4039b411b363SPhilipp Reisner 404082bc0194SAndreas Gruenbacher return 0; 4041b411b363SPhilipp Reisner } 4042b411b363SPhilipp Reisner 4043bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4044b411b363SPhilipp Reisner { 40459f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4046b30ab791SAndreas Gruenbacher struct drbd_device *device; 4047e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 40484a76b161SAndreas Gruenbacher 40499f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 40509f4fe9adSAndreas Gruenbacher if (!peer_device) 40514a76b161SAndreas Gruenbacher return -EIO; 40529f4fe9adSAndreas Gruenbacher device = peer_device->device; 4053b411b363SPhilipp Reisner 4054b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4055b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4056b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4057b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4058b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4059b411b363SPhilipp Reisner 40600b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4061b411b363SPhilipp Reisner 4062b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4063b411b363SPhilipp Reisner _not_ be rotated into the history */ 4064b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4065b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4066b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4067b411b363SPhilipp Reisner 4068b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4069b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4070b411b363SPhilipp Reisner 4071b30ab791SAndreas Gruenbacher put_ldev(device); 4072b411b363SPhilipp Reisner } else 4073d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4074b411b363SPhilipp Reisner 407582bc0194SAndreas Gruenbacher return 0; 4076b411b363SPhilipp Reisner } 4077b411b363SPhilipp Reisner 40782c46407dSAndreas Gruenbacher /** 40792c46407dSAndreas Gruenbacher * receive_bitmap_plain 40802c46407dSAndreas Gruenbacher * 40812c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40822c46407dSAndreas Gruenbacher * code upon failure. 40832c46407dSAndreas Gruenbacher */ 40842c46407dSAndreas Gruenbacher static int 408569a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4086e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4087b411b363SPhilipp Reisner { 408850d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 408969a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4090e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 409150d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4092e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 40932c46407dSAndreas Gruenbacher int err; 4094b411b363SPhilipp Reisner 409550d0b1adSAndreas Gruenbacher if (want != size) { 409669a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 40972c46407dSAndreas Gruenbacher return -EIO; 4098b411b363SPhilipp Reisner } 4099b411b363SPhilipp Reisner if (want == 0) 41002c46407dSAndreas Gruenbacher return 0; 410169a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 410282bc0194SAndreas Gruenbacher if (err) 41032c46407dSAndreas Gruenbacher return err; 4104b411b363SPhilipp Reisner 410569a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4106b411b363SPhilipp Reisner 4107b411b363SPhilipp Reisner c->word_offset += num_words; 4108b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4109b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4110b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4111b411b363SPhilipp Reisner 41122c46407dSAndreas Gruenbacher return 1; 4113b411b363SPhilipp Reisner } 4114b411b363SPhilipp Reisner 4115a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4116a02d1240SAndreas Gruenbacher { 4117a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4118a02d1240SAndreas Gruenbacher } 4119a02d1240SAndreas Gruenbacher 4120a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4121a02d1240SAndreas Gruenbacher { 4122a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4123a02d1240SAndreas Gruenbacher } 4124a02d1240SAndreas Gruenbacher 4125a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4126a02d1240SAndreas Gruenbacher { 4127a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4128a02d1240SAndreas Gruenbacher } 4129a02d1240SAndreas Gruenbacher 41302c46407dSAndreas Gruenbacher /** 41312c46407dSAndreas Gruenbacher * recv_bm_rle_bits 41322c46407dSAndreas Gruenbacher * 41332c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 41342c46407dSAndreas Gruenbacher * code upon failure. 41352c46407dSAndreas Gruenbacher */ 41362c46407dSAndreas Gruenbacher static int 413769a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4138b411b363SPhilipp Reisner struct p_compressed_bm *p, 4139c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4140c6d25cfeSPhilipp Reisner unsigned int len) 4141b411b363SPhilipp Reisner { 4142b411b363SPhilipp Reisner struct bitstream bs; 4143b411b363SPhilipp Reisner u64 look_ahead; 4144b411b363SPhilipp Reisner u64 rl; 4145b411b363SPhilipp Reisner u64 tmp; 4146b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4147b411b363SPhilipp Reisner unsigned long e; 4148a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4149b411b363SPhilipp Reisner int have; 4150b411b363SPhilipp Reisner int bits; 4151b411b363SPhilipp Reisner 4152a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4153b411b363SPhilipp Reisner 4154b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4155b411b363SPhilipp Reisner if (bits < 0) 41562c46407dSAndreas Gruenbacher return -EIO; 4157b411b363SPhilipp Reisner 4158b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4159b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4160b411b363SPhilipp Reisner if (bits <= 0) 41612c46407dSAndreas Gruenbacher return -EIO; 4162b411b363SPhilipp Reisner 4163b411b363SPhilipp Reisner if (toggle) { 4164b411b363SPhilipp Reisner e = s + rl -1; 4165b411b363SPhilipp Reisner if (e >= c->bm_bits) { 416669a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 41672c46407dSAndreas Gruenbacher return -EIO; 4168b411b363SPhilipp Reisner } 416969a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4170b411b363SPhilipp Reisner } 4171b411b363SPhilipp Reisner 4172b411b363SPhilipp Reisner if (have < bits) { 417369a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4174b411b363SPhilipp Reisner have, bits, look_ahead, 4175b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4176b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 41772c46407dSAndreas Gruenbacher return -EIO; 4178b411b363SPhilipp Reisner } 4179d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4180d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4181b411b363SPhilipp Reisner look_ahead >>= bits; 4182d2da5b0cSLars Ellenberg else 4183d2da5b0cSLars Ellenberg look_ahead = 0; 4184b411b363SPhilipp Reisner have -= bits; 4185b411b363SPhilipp Reisner 4186b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4187b411b363SPhilipp Reisner if (bits < 0) 41882c46407dSAndreas Gruenbacher return -EIO; 4189b411b363SPhilipp Reisner look_ahead |= tmp << have; 4190b411b363SPhilipp Reisner have += bits; 4191b411b363SPhilipp Reisner } 4192b411b363SPhilipp Reisner 4193b411b363SPhilipp Reisner c->bit_offset = s; 4194b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4195b411b363SPhilipp Reisner 41962c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4197b411b363SPhilipp Reisner } 4198b411b363SPhilipp Reisner 41992c46407dSAndreas Gruenbacher /** 42002c46407dSAndreas Gruenbacher * decode_bitmap_c 42012c46407dSAndreas Gruenbacher * 42022c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 42032c46407dSAndreas Gruenbacher * code upon failure. 42042c46407dSAndreas Gruenbacher */ 42052c46407dSAndreas Gruenbacher static int 420669a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4207b411b363SPhilipp Reisner struct p_compressed_bm *p, 4208c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4209c6d25cfeSPhilipp Reisner unsigned int len) 4210b411b363SPhilipp Reisner { 4211a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 421269a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4213b411b363SPhilipp Reisner 4214b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4215b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4216b411b363SPhilipp Reisner * during all our tests. */ 4217b411b363SPhilipp Reisner 421869a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 421969a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 42202c46407dSAndreas Gruenbacher return -EIO; 4221b411b363SPhilipp Reisner } 4222b411b363SPhilipp Reisner 4223b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4224b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4225b411b363SPhilipp Reisner { 4226b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4227a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 422850d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 422950d0b1adSAndreas Gruenbacher unsigned int plain = 423050d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 423150d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 423250d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 423350d0b1adSAndreas Gruenbacher unsigned int r; 4234b411b363SPhilipp Reisner 4235b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4236b411b363SPhilipp Reisner if (total == 0) 4237b411b363SPhilipp Reisner return; 4238b411b363SPhilipp Reisner 4239b411b363SPhilipp Reisner /* don't report if not compressed */ 4240b411b363SPhilipp Reisner if (total >= plain) 4241b411b363SPhilipp Reisner return; 4242b411b363SPhilipp Reisner 4243b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4244b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4245b411b363SPhilipp Reisner : (1000 * total / plain); 4246b411b363SPhilipp Reisner 4247b411b363SPhilipp Reisner if (r > 1000) 4248b411b363SPhilipp Reisner r = 1000; 4249b411b363SPhilipp Reisner 4250b411b363SPhilipp Reisner r = 1000 - r; 4251d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4252b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4253b411b363SPhilipp Reisner direction, 4254b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4255b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4256b411b363SPhilipp Reisner total, r/10, r % 10); 4257b411b363SPhilipp Reisner } 4258b411b363SPhilipp Reisner 4259b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4260b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4261b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4262b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4263b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4264b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4265b411b363SPhilipp Reisner 4266b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4267bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4268b411b363SPhilipp Reisner { 42699f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4270b30ab791SAndreas Gruenbacher struct drbd_device *device; 4271b411b363SPhilipp Reisner struct bm_xfer_ctx c; 42722c46407dSAndreas Gruenbacher int err; 42734a76b161SAndreas Gruenbacher 42749f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42759f4fe9adSAndreas Gruenbacher if (!peer_device) 42764a76b161SAndreas Gruenbacher return -EIO; 42779f4fe9adSAndreas Gruenbacher device = peer_device->device; 4278b411b363SPhilipp Reisner 4279b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 428020ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 428120ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4282b411b363SPhilipp Reisner 4283b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4284b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4285b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4286b411b363SPhilipp Reisner }; 4287b411b363SPhilipp Reisner 42882c46407dSAndreas Gruenbacher for(;;) { 4289e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 429069a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4291e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4292b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4293b411b363SPhilipp Reisner * and the feature is enabled! */ 4294e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4295b411b363SPhilipp Reisner 4296bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4297d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 429882bc0194SAndreas Gruenbacher err = -EIO; 4299b411b363SPhilipp Reisner goto out; 4300b411b363SPhilipp Reisner } 4301e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4302d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 430382bc0194SAndreas Gruenbacher err = -EIO; 430478fcbdaeSAndreas Gruenbacher goto out; 4305b411b363SPhilipp Reisner } 43069f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4307e658983aSAndreas Gruenbacher if (err) 4308e658983aSAndreas Gruenbacher goto out; 430969a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4310b411b363SPhilipp Reisner } else { 4311d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 431282bc0194SAndreas Gruenbacher err = -EIO; 4313b411b363SPhilipp Reisner goto out; 4314b411b363SPhilipp Reisner } 4315b411b363SPhilipp Reisner 4316e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4317bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4318b411b363SPhilipp Reisner 43192c46407dSAndreas Gruenbacher if (err <= 0) { 43202c46407dSAndreas Gruenbacher if (err < 0) 43212c46407dSAndreas Gruenbacher goto out; 4322b411b363SPhilipp Reisner break; 43232c46407dSAndreas Gruenbacher } 43249f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 432582bc0194SAndreas Gruenbacher if (err) 4326b411b363SPhilipp Reisner goto out; 43272c46407dSAndreas Gruenbacher } 4328b411b363SPhilipp Reisner 4329b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4330b411b363SPhilipp Reisner 4331b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4332de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4333de1f8e4aSAndreas Gruenbacher 4334b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 433582bc0194SAndreas Gruenbacher if (err) 4336b411b363SPhilipp Reisner goto out; 4337b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4338b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 43390b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4340b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4341b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4342b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4343d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4344b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4345b411b363SPhilipp Reisner } 434682bc0194SAndreas Gruenbacher err = 0; 4347b411b363SPhilipp Reisner 4348b411b363SPhilipp Reisner out: 4349b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4350b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4351b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 435282bc0194SAndreas Gruenbacher return err; 4353b411b363SPhilipp Reisner } 4354b411b363SPhilipp Reisner 4355bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4356b411b363SPhilipp Reisner { 43571ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4358e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4359b411b363SPhilipp Reisner 4360bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4361b411b363SPhilipp Reisner } 4362b411b363SPhilipp Reisner 4363bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4364b411b363SPhilipp Reisner { 4365b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4366b411b363SPhilipp Reisner * with the data requests being unplugged */ 4367bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4368b411b363SPhilipp Reisner 436982bc0194SAndreas Gruenbacher return 0; 4370b411b363SPhilipp Reisner } 4371b411b363SPhilipp Reisner 4372bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 437373a01a18SPhilipp Reisner { 43749f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4375b30ab791SAndreas Gruenbacher struct drbd_device *device; 4376e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 43774a76b161SAndreas Gruenbacher 43789f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 43799f4fe9adSAndreas Gruenbacher if (!peer_device) 43804a76b161SAndreas Gruenbacher return -EIO; 43819f4fe9adSAndreas Gruenbacher device = peer_device->device; 438273a01a18SPhilipp Reisner 4383b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4384f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4385f735e363SLars Ellenberg case C_WF_BITMAP_T: 4386f735e363SLars Ellenberg case C_BEHIND: 4387f735e363SLars Ellenberg break; 4388f735e363SLars Ellenberg default: 4389d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4390b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4391f735e363SLars Ellenberg } 4392f735e363SLars Ellenberg 4393b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 439473a01a18SPhilipp Reisner 439582bc0194SAndreas Gruenbacher return 0; 439673a01a18SPhilipp Reisner } 439773a01a18SPhilipp Reisner 439802918be2SPhilipp Reisner struct data_cmd { 439902918be2SPhilipp Reisner int expect_payload; 440002918be2SPhilipp Reisner size_t pkt_size; 4401bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4402b411b363SPhilipp Reisner }; 4403b411b363SPhilipp Reisner 440402918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 440502918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 440602918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 440702918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 440802918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4409e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4410e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4411e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 441202918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 441302918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4414e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4415e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 441602918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 441702918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 441802918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 441902918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 442002918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 442102918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 442202918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 442302918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 442402918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 442502918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 442673a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 44274a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4428036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 442902918be2SPhilipp Reisner }; 443002918be2SPhilipp Reisner 4431bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4432b411b363SPhilipp Reisner { 443377351055SPhilipp Reisner struct packet_info pi; 443402918be2SPhilipp Reisner size_t shs; /* sub header size */ 443582bc0194SAndreas Gruenbacher int err; 4436b411b363SPhilipp Reisner 4437bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 4438deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4439deebe195SAndreas Gruenbacher 4440bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4441bde89a9eSAndreas Gruenbacher if (drbd_recv_header(connection, &pi)) 444202918be2SPhilipp Reisner goto err_out; 444302918be2SPhilipp Reisner 4444deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 44454a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 44461ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 44472fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 444802918be2SPhilipp Reisner goto err_out; 44490b33a916SLars Ellenberg } 4450b411b363SPhilipp Reisner 4451e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4452e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 44531ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 44542fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4455c13f7e1aSLars Ellenberg goto err_out; 4456c13f7e1aSLars Ellenberg } 4457c13f7e1aSLars Ellenberg 4458c13f7e1aSLars Ellenberg if (shs) { 4459bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 4460a5c31904SAndreas Gruenbacher if (err) 446102918be2SPhilipp Reisner goto err_out; 4462e2857216SAndreas Gruenbacher pi.size -= shs; 4463b411b363SPhilipp Reisner } 446402918be2SPhilipp Reisner 4465bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 44664a76b161SAndreas Gruenbacher if (err) { 44671ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 44689f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 446902918be2SPhilipp Reisner goto err_out; 447002918be2SPhilipp Reisner } 447102918be2SPhilipp Reisner } 447282bc0194SAndreas Gruenbacher return; 447302918be2SPhilipp Reisner 447402918be2SPhilipp Reisner err_out: 4475bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4476b411b363SPhilipp Reisner } 4477b411b363SPhilipp Reisner 4478bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 4479f70b3511SPhilipp Reisner { 4480c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4481bbeb641cSPhilipp Reisner enum drbd_conns oc; 4482376694a0SPhilipp Reisner int vnr; 4483f70b3511SPhilipp Reisner 4484bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 4485b411b363SPhilipp Reisner return; 4486b411b363SPhilipp Reisner 4487545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4488545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4489545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4490545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4491545752d5SLars Ellenberg */ 4492bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4493545752d5SLars Ellenberg 4494b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4495bde89a9eSAndreas Gruenbacher drbd_thread_stop(&connection->asender); 4496bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 4497360cc740SPhilipp Reisner 4498c141ebdaSPhilipp Reisner rcu_read_lock(); 4499c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 4500c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4501b30ab791SAndreas Gruenbacher kref_get(&device->kref); 4502c141ebdaSPhilipp Reisner rcu_read_unlock(); 450369a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 4504c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 4505c141ebdaSPhilipp Reisner rcu_read_lock(); 4506c141ebdaSPhilipp Reisner } 4507c141ebdaSPhilipp Reisner rcu_read_unlock(); 4508c141ebdaSPhilipp Reisner 4509bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 45101ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 451112038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4512bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 4513bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 451412038a3aSPhilipp Reisner 45151ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 4516360cc740SPhilipp Reisner 4517bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 4518bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 4519cb703454SPhilipp Reisner 45200500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 4521bde89a9eSAndreas Gruenbacher oc = connection->cstate; 4522bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4523bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4524bbeb641cSPhilipp Reisner 45250500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 4526360cc740SPhilipp Reisner 4527f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4528bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4529360cc740SPhilipp Reisner } 4530360cc740SPhilipp Reisner 453169a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 4532360cc740SPhilipp Reisner { 453369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4534360cc740SPhilipp Reisner unsigned int i; 4535b411b363SPhilipp Reisner 453685719573SPhilipp Reisner /* wait for current activity to cease. */ 45370500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4538b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 4539b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 4540b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 45410500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4542b411b363SPhilipp Reisner 4543b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4544b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4545b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4546b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4547b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4548b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4549b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4550b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4551b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4552b411b363SPhilipp Reisner * on the fly. */ 4553b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4554b30ab791SAndreas Gruenbacher device->rs_total = 0; 4555b30ab791SAndreas Gruenbacher device->rs_failed = 0; 4556b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 4557b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 4558b411b363SPhilipp Reisner 4559b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 4560b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 4561b411b363SPhilipp Reisner 4562b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4563b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4564b411b363SPhilipp Reisner * to be "canceled" */ 4565b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4566b411b363SPhilipp Reisner 4567b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 4568b411b363SPhilipp Reisner 4569d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4570d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4571d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4572b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 4573d10b4ea3SPhilipp Reisner 457408332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 457508332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 4576b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 4577b411b363SPhilipp Reisner 4578b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4579b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 4580b411b363SPhilipp Reisner 4581b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 458269a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 4583b411b363SPhilipp Reisner 4584b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4585b411b363SPhilipp Reisner 458620ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 458720ceb2b2SLars Ellenberg * if any. */ 4588b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, !test_bit(BITMAP_IO, &device->flags)); 458920ceb2b2SLars Ellenberg 4590b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4591b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4592b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4593b411b363SPhilipp Reisner * 4594b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4595b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4596b411b363SPhilipp Reisner */ 4597b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 4598b411b363SPhilipp Reisner if (i) 4599d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 4600b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 4601435f0740SLars Ellenberg if (i) 4602d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 4603b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 4604b411b363SPhilipp Reisner if (i) 4605d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 4606b411b363SPhilipp Reisner 46070b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 46080b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 46090b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 46100b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 4611b411b363SPhilipp Reisner 4612360cc740SPhilipp Reisner return 0; 4613b411b363SPhilipp Reisner } 4614b411b363SPhilipp Reisner 4615b411b363SPhilipp Reisner /* 4616b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4617b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4618b411b363SPhilipp Reisner * 4619b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4620b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4621b411b363SPhilipp Reisner * 4622b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4623b411b363SPhilipp Reisner */ 4624bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 4625b411b363SPhilipp Reisner { 46269f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 46279f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4628b411b363SPhilipp Reisner 4629bde89a9eSAndreas Gruenbacher sock = &connection->data; 4630bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 46319f5bdc33SAndreas Gruenbacher if (!p) 4632e8d17b01SAndreas Gruenbacher return -EIO; 4633b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4634b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4635b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 4636bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4637b411b363SPhilipp Reisner } 4638b411b363SPhilipp Reisner 4639b411b363SPhilipp Reisner /* 4640b411b363SPhilipp Reisner * return values: 4641b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4642b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4643b411b363SPhilipp Reisner * -1 peer talks different language, 4644b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4645b411b363SPhilipp Reisner */ 4646bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 4647b411b363SPhilipp Reisner { 4648bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 4649e658983aSAndreas Gruenbacher struct p_connection_features *p; 4650e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 465177351055SPhilipp Reisner struct packet_info pi; 4652a5c31904SAndreas Gruenbacher int err; 4653b411b363SPhilipp Reisner 4654bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 4655e8d17b01SAndreas Gruenbacher if (err) 4656b411b363SPhilipp Reisner return 0; 4657b411b363SPhilipp Reisner 4658bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 465969bc7bc3SAndreas Gruenbacher if (err) 4660b411b363SPhilipp Reisner return 0; 4661b411b363SPhilipp Reisner 46626038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 46631ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 466477351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4665b411b363SPhilipp Reisner return -1; 4666b411b363SPhilipp Reisner } 4667b411b363SPhilipp Reisner 466877351055SPhilipp Reisner if (pi.size != expect) { 46691ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 467077351055SPhilipp Reisner expect, pi.size); 4671b411b363SPhilipp Reisner return -1; 4672b411b363SPhilipp Reisner } 4673b411b363SPhilipp Reisner 4674e658983aSAndreas Gruenbacher p = pi.data; 4675bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 4676a5c31904SAndreas Gruenbacher if (err) 4677b411b363SPhilipp Reisner return 0; 4678b411b363SPhilipp Reisner 4679b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4680b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4681b411b363SPhilipp Reisner if (p->protocol_max == 0) 4682b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4683b411b363SPhilipp Reisner 4684b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4685b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4686b411b363SPhilipp Reisner goto incompat; 4687b411b363SPhilipp Reisner 4688bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4689b411b363SPhilipp Reisner 46901ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 4691bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 4692b411b363SPhilipp Reisner 4693b411b363SPhilipp Reisner return 1; 4694b411b363SPhilipp Reisner 4695b411b363SPhilipp Reisner incompat: 46961ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 4697b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4698b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4699b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4700b411b363SPhilipp Reisner return -1; 4701b411b363SPhilipp Reisner } 4702b411b363SPhilipp Reisner 4703b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 4704bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4705b411b363SPhilipp Reisner { 47061ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 47071ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4708b10d96cbSJohannes Thoma return -1; 4709b411b363SPhilipp Reisner } 4710b411b363SPhilipp Reisner #else 4711b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4712b10d96cbSJohannes Thoma 4713b10d96cbSJohannes Thoma /* Return value: 4714b10d96cbSJohannes Thoma 1 - auth succeeded, 4715b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4716b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4717b10d96cbSJohannes Thoma */ 4718b10d96cbSJohannes Thoma 4719bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 4720b411b363SPhilipp Reisner { 47219f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4722b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4723b411b363SPhilipp Reisner struct scatterlist sg; 4724b411b363SPhilipp Reisner char *response = NULL; 4725b411b363SPhilipp Reisner char *right_response = NULL; 4726b411b363SPhilipp Reisner char *peers_ch = NULL; 472744ed167dSPhilipp Reisner unsigned int key_len; 472844ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4729b411b363SPhilipp Reisner unsigned int resp_size; 4730b411b363SPhilipp Reisner struct hash_desc desc; 473177351055SPhilipp Reisner struct packet_info pi; 473244ed167dSPhilipp Reisner struct net_conf *nc; 473369bc7bc3SAndreas Gruenbacher int err, rv; 4734b411b363SPhilipp Reisner 47359f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 47369f5bdc33SAndreas Gruenbacher 473744ed167dSPhilipp Reisner rcu_read_lock(); 4738bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 473944ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 474044ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 474144ed167dSPhilipp Reisner rcu_read_unlock(); 474244ed167dSPhilipp Reisner 4743bde89a9eSAndreas Gruenbacher desc.tfm = connection->cram_hmac_tfm; 4744b411b363SPhilipp Reisner desc.flags = 0; 4745b411b363SPhilipp Reisner 4746bde89a9eSAndreas Gruenbacher rv = crypto_hash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 4747b411b363SPhilipp Reisner if (rv) { 47481ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_setkey() failed with %d\n", rv); 4749b10d96cbSJohannes Thoma rv = -1; 4750b411b363SPhilipp Reisner goto fail; 4751b411b363SPhilipp Reisner } 4752b411b363SPhilipp Reisner 4753b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4754b411b363SPhilipp Reisner 4755bde89a9eSAndreas Gruenbacher sock = &connection->data; 4756bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 47579f5bdc33SAndreas Gruenbacher rv = 0; 47589f5bdc33SAndreas Gruenbacher goto fail; 47599f5bdc33SAndreas Gruenbacher } 4760bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 47619f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4762b411b363SPhilipp Reisner if (!rv) 4763b411b363SPhilipp Reisner goto fail; 4764b411b363SPhilipp Reisner 4765bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 476669bc7bc3SAndreas Gruenbacher if (err) { 4767b411b363SPhilipp Reisner rv = 0; 4768b411b363SPhilipp Reisner goto fail; 4769b411b363SPhilipp Reisner } 4770b411b363SPhilipp Reisner 477177351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 47721ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 477377351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4774b411b363SPhilipp Reisner rv = 0; 4775b411b363SPhilipp Reisner goto fail; 4776b411b363SPhilipp Reisner } 4777b411b363SPhilipp Reisner 477877351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 47791ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 4780b10d96cbSJohannes Thoma rv = -1; 4781b411b363SPhilipp Reisner goto fail; 4782b411b363SPhilipp Reisner } 4783b411b363SPhilipp Reisner 478477351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4785b411b363SPhilipp Reisner if (peers_ch == NULL) { 47861ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 4787b10d96cbSJohannes Thoma rv = -1; 4788b411b363SPhilipp Reisner goto fail; 4789b411b363SPhilipp Reisner } 4790b411b363SPhilipp Reisner 4791bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 4792a5c31904SAndreas Gruenbacher if (err) { 4793b411b363SPhilipp Reisner rv = 0; 4794b411b363SPhilipp Reisner goto fail; 4795b411b363SPhilipp Reisner } 4796b411b363SPhilipp Reisner 4797bde89a9eSAndreas Gruenbacher resp_size = crypto_hash_digestsize(connection->cram_hmac_tfm); 4798b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4799b411b363SPhilipp Reisner if (response == NULL) { 48001ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 4801b10d96cbSJohannes Thoma rv = -1; 4802b411b363SPhilipp Reisner goto fail; 4803b411b363SPhilipp Reisner } 4804b411b363SPhilipp Reisner 4805b411b363SPhilipp Reisner sg_init_table(&sg, 1); 480677351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4807b411b363SPhilipp Reisner 4808b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4809b411b363SPhilipp Reisner if (rv) { 48101ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4811b10d96cbSJohannes Thoma rv = -1; 4812b411b363SPhilipp Reisner goto fail; 4813b411b363SPhilipp Reisner } 4814b411b363SPhilipp Reisner 4815bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 48169f5bdc33SAndreas Gruenbacher rv = 0; 48179f5bdc33SAndreas Gruenbacher goto fail; 48189f5bdc33SAndreas Gruenbacher } 4819bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 48209f5bdc33SAndreas Gruenbacher response, resp_size); 4821b411b363SPhilipp Reisner if (!rv) 4822b411b363SPhilipp Reisner goto fail; 4823b411b363SPhilipp Reisner 4824bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 482569bc7bc3SAndreas Gruenbacher if (err) { 4826b411b363SPhilipp Reisner rv = 0; 4827b411b363SPhilipp Reisner goto fail; 4828b411b363SPhilipp Reisner } 4829b411b363SPhilipp Reisner 483077351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 48311ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 483277351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4833b411b363SPhilipp Reisner rv = 0; 4834b411b363SPhilipp Reisner goto fail; 4835b411b363SPhilipp Reisner } 4836b411b363SPhilipp Reisner 483777351055SPhilipp Reisner if (pi.size != resp_size) { 48381ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 4839b411b363SPhilipp Reisner rv = 0; 4840b411b363SPhilipp Reisner goto fail; 4841b411b363SPhilipp Reisner } 4842b411b363SPhilipp Reisner 4843bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 4844a5c31904SAndreas Gruenbacher if (err) { 4845b411b363SPhilipp Reisner rv = 0; 4846b411b363SPhilipp Reisner goto fail; 4847b411b363SPhilipp Reisner } 4848b411b363SPhilipp Reisner 4849b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 48502d1ee87dSJulia Lawall if (right_response == NULL) { 48511ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 4852b10d96cbSJohannes Thoma rv = -1; 4853b411b363SPhilipp Reisner goto fail; 4854b411b363SPhilipp Reisner } 4855b411b363SPhilipp Reisner 4856b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4857b411b363SPhilipp Reisner 4858b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4859b411b363SPhilipp Reisner if (rv) { 48601ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 4861b10d96cbSJohannes Thoma rv = -1; 4862b411b363SPhilipp Reisner goto fail; 4863b411b363SPhilipp Reisner } 4864b411b363SPhilipp Reisner 4865b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4866b411b363SPhilipp Reisner 4867b411b363SPhilipp Reisner if (rv) 48681ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 486944ed167dSPhilipp Reisner resp_size); 4870b10d96cbSJohannes Thoma else 4871b10d96cbSJohannes Thoma rv = -1; 4872b411b363SPhilipp Reisner 4873b411b363SPhilipp Reisner fail: 4874b411b363SPhilipp Reisner kfree(peers_ch); 4875b411b363SPhilipp Reisner kfree(response); 4876b411b363SPhilipp Reisner kfree(right_response); 4877b411b363SPhilipp Reisner 4878b411b363SPhilipp Reisner return rv; 4879b411b363SPhilipp Reisner } 4880b411b363SPhilipp Reisner #endif 4881b411b363SPhilipp Reisner 48828fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 4883b411b363SPhilipp Reisner { 4884bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 4885b411b363SPhilipp Reisner int h; 4886b411b363SPhilipp Reisner 48871ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 4888b411b363SPhilipp Reisner 4889b411b363SPhilipp Reisner do { 4890bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 4891b411b363SPhilipp Reisner if (h == 0) { 4892bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 489320ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4894b411b363SPhilipp Reisner } 4895b411b363SPhilipp Reisner if (h == -1) { 48961ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 4897bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 4898b411b363SPhilipp Reisner } 4899b411b363SPhilipp Reisner } while (h == 0); 4900b411b363SPhilipp Reisner 490191fd4dadSPhilipp Reisner if (h > 0) 4902bde89a9eSAndreas Gruenbacher drbdd(connection); 4903b411b363SPhilipp Reisner 4904bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 4905b411b363SPhilipp Reisner 49061ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 4907b411b363SPhilipp Reisner return 0; 4908b411b363SPhilipp Reisner } 4909b411b363SPhilipp Reisner 4910b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4911b411b363SPhilipp Reisner 4912bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 4913b411b363SPhilipp Reisner { 4914e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4915b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4916b411b363SPhilipp Reisner 4917b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4918bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 4919b411b363SPhilipp Reisner } else { 4920bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 49211ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 4922fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4923fc3b10a4SPhilipp Reisner } 4924bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 4925e4f78edeSPhilipp Reisner 49262735a594SAndreas Gruenbacher return 0; 4927fc3b10a4SPhilipp Reisner } 4928e4f78edeSPhilipp Reisner 4929bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 4930e4f78edeSPhilipp Reisner { 49319f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4932b30ab791SAndreas Gruenbacher struct drbd_device *device; 4933e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4934e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4935e4f78edeSPhilipp Reisner 49369f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 49379f4fe9adSAndreas Gruenbacher if (!peer_device) 49382735a594SAndreas Gruenbacher return -EIO; 49399f4fe9adSAndreas Gruenbacher device = peer_device->device; 49401952e916SAndreas Gruenbacher 4941bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 49420b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 4943bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 49444d0fc3fdSPhilipp Reisner } 49454d0fc3fdSPhilipp Reisner 4946e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4947b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 4948e4f78edeSPhilipp Reisner } else { 4949b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 4950d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 4951b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4952b411b363SPhilipp Reisner } 4953b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 4954b411b363SPhilipp Reisner 49552735a594SAndreas Gruenbacher return 0; 4956b411b363SPhilipp Reisner } 4957b411b363SPhilipp Reisner 4958bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 4959b411b363SPhilipp Reisner { 4960bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 4961b411b363SPhilipp Reisner 4962b411b363SPhilipp Reisner } 4963b411b363SPhilipp Reisner 4964bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 4965b411b363SPhilipp Reisner { 4966b411b363SPhilipp Reisner /* restore idle timeout */ 4967bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 4968bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 4969bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 4970b411b363SPhilipp Reisner 49712735a594SAndreas Gruenbacher return 0; 4972b411b363SPhilipp Reisner } 4973b411b363SPhilipp Reisner 4974bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 4975b411b363SPhilipp Reisner { 49769f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4977b30ab791SAndreas Gruenbacher struct drbd_device *device; 4978e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4979b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4980b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4981b411b363SPhilipp Reisner 49829f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 49839f4fe9adSAndreas Gruenbacher if (!peer_device) 49842735a594SAndreas Gruenbacher return -EIO; 49859f4fe9adSAndreas Gruenbacher device = peer_device->device; 49861952e916SAndreas Gruenbacher 49879f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 4988b411b363SPhilipp Reisner 498969a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 4990b411b363SPhilipp Reisner 4991b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4992b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 4993b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 4994b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4995b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 4996b30ab791SAndreas Gruenbacher put_ldev(device); 49971d53f09eSLars Ellenberg } 4998b30ab791SAndreas Gruenbacher dec_rs_pending(device); 4999b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5000b411b363SPhilipp Reisner 50012735a594SAndreas Gruenbacher return 0; 5002b411b363SPhilipp Reisner } 5003b411b363SPhilipp Reisner 5004bc9c5c41SAndreas Gruenbacher static int 5005b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5006bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5007bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5008b411b363SPhilipp Reisner { 5009b411b363SPhilipp Reisner struct drbd_request *req; 5010b411b363SPhilipp Reisner struct bio_and_error m; 5011b411b363SPhilipp Reisner 50120500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5013b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5014b411b363SPhilipp Reisner if (unlikely(!req)) { 50150500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 501685997675SAndreas Gruenbacher return -EIO; 5017b411b363SPhilipp Reisner } 5018b411b363SPhilipp Reisner __req_mod(req, what, &m); 50190500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5020b411b363SPhilipp Reisner 5021b411b363SPhilipp Reisner if (m.bio) 5022b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 502385997675SAndreas Gruenbacher return 0; 5024b411b363SPhilipp Reisner } 5025b411b363SPhilipp Reisner 5026bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5027b411b363SPhilipp Reisner { 50289f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5029b30ab791SAndreas Gruenbacher struct drbd_device *device; 5030e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5031b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5032b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5033b411b363SPhilipp Reisner enum drbd_req_event what; 5034b411b363SPhilipp Reisner 50359f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 50369f4fe9adSAndreas Gruenbacher if (!peer_device) 50372735a594SAndreas Gruenbacher return -EIO; 50389f4fe9adSAndreas Gruenbacher device = peer_device->device; 50391952e916SAndreas Gruenbacher 504069a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5041b411b363SPhilipp Reisner 5042579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5043b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5044b30ab791SAndreas Gruenbacher dec_rs_pending(device); 50452735a594SAndreas Gruenbacher return 0; 5046b411b363SPhilipp Reisner } 5047e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5048b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 50498554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5050b411b363SPhilipp Reisner break; 5051b411b363SPhilipp Reisner case P_WRITE_ACK: 50528554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5053b411b363SPhilipp Reisner break; 5054b411b363SPhilipp Reisner case P_RECV_ACK: 50558554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5056b411b363SPhilipp Reisner break; 5057d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5058d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 50597be8da07SAndreas Gruenbacher break; 50607be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 50617be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5062b411b363SPhilipp Reisner break; 5063b411b363SPhilipp Reisner default: 50642735a594SAndreas Gruenbacher BUG(); 5065b411b363SPhilipp Reisner } 5066b411b363SPhilipp Reisner 5067b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5068b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5069bc9c5c41SAndreas Gruenbacher what, false); 5070b411b363SPhilipp Reisner } 5071b411b363SPhilipp Reisner 5072bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5073b411b363SPhilipp Reisner { 50749f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5075b30ab791SAndreas Gruenbacher struct drbd_device *device; 5076e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5077b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 50782deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 507985997675SAndreas Gruenbacher int err; 5080b411b363SPhilipp Reisner 50819f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 50829f4fe9adSAndreas Gruenbacher if (!peer_device) 50832735a594SAndreas Gruenbacher return -EIO; 50849f4fe9adSAndreas Gruenbacher device = peer_device->device; 5085b411b363SPhilipp Reisner 508669a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5087b411b363SPhilipp Reisner 5088579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5089b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5090b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 50912735a594SAndreas Gruenbacher return 0; 5092b411b363SPhilipp Reisner } 50932deb8336SPhilipp Reisner 5094b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5095b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5096303d1448SPhilipp Reisner NEG_ACKED, true); 509785997675SAndreas Gruenbacher if (err) { 50982deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 50992deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5100c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 51012deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 51022deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5103b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 51042deb8336SPhilipp Reisner } 51052735a594SAndreas Gruenbacher return 0; 5106b411b363SPhilipp Reisner } 5107b411b363SPhilipp Reisner 5108bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5109b411b363SPhilipp Reisner { 51109f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5111b30ab791SAndreas Gruenbacher struct drbd_device *device; 5112e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5113b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5114b411b363SPhilipp Reisner 51159f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51169f4fe9adSAndreas Gruenbacher if (!peer_device) 51172735a594SAndreas Gruenbacher return -EIO; 51189f4fe9adSAndreas Gruenbacher device = peer_device->device; 51191952e916SAndreas Gruenbacher 512069a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 51217be8da07SAndreas Gruenbacher 5122d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5123b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5124b411b363SPhilipp Reisner 5125b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5126b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 51278554df1cSAndreas Gruenbacher NEG_ACKED, false); 5128b411b363SPhilipp Reisner } 5129b411b363SPhilipp Reisner 5130bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5131b411b363SPhilipp Reisner { 51329f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5133b30ab791SAndreas Gruenbacher struct drbd_device *device; 5134b411b363SPhilipp Reisner sector_t sector; 5135b411b363SPhilipp Reisner int size; 5136e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 51371952e916SAndreas Gruenbacher 51389f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 51399f4fe9adSAndreas Gruenbacher if (!peer_device) 51402735a594SAndreas Gruenbacher return -EIO; 51419f4fe9adSAndreas Gruenbacher device = peer_device->device; 5142b411b363SPhilipp Reisner 5143b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5144b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5145b411b363SPhilipp Reisner 514669a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5147b411b363SPhilipp Reisner 5148b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5149b411b363SPhilipp Reisner 5150b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5151b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5152e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5153d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5154b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5155d612d309SPhilipp Reisner case P_RS_CANCEL: 5156d612d309SPhilipp Reisner break; 5157d612d309SPhilipp Reisner default: 51582735a594SAndreas Gruenbacher BUG(); 5159d612d309SPhilipp Reisner } 5160b30ab791SAndreas Gruenbacher put_ldev(device); 5161b411b363SPhilipp Reisner } 5162b411b363SPhilipp Reisner 51632735a594SAndreas Gruenbacher return 0; 5164b411b363SPhilipp Reisner } 5165b411b363SPhilipp Reisner 5166bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5167b411b363SPhilipp Reisner { 5168e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5169c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 51709ed57dcbSLars Ellenberg int vnr; 5171b411b363SPhilipp Reisner 5172bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5173b411b363SPhilipp Reisner 51749ed57dcbSLars Ellenberg rcu_read_lock(); 5175c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5176c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5177c06ece6bSAndreas Gruenbacher 5178b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5179b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5180b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5181b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5182b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5183c4752ef1SPhilipp Reisner } 51849ed57dcbSLars Ellenberg } 51859ed57dcbSLars Ellenberg rcu_read_unlock(); 5186c4752ef1SPhilipp Reisner 51872735a594SAndreas Gruenbacher return 0; 5188b411b363SPhilipp Reisner } 5189b411b363SPhilipp Reisner 5190bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5191b411b363SPhilipp Reisner { 51929f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5193b30ab791SAndreas Gruenbacher struct drbd_device *device; 5194e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 519584b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5196b411b363SPhilipp Reisner sector_t sector; 5197b411b363SPhilipp Reisner int size; 5198b411b363SPhilipp Reisner 51999f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 52009f4fe9adSAndreas Gruenbacher if (!peer_device) 52012735a594SAndreas Gruenbacher return -EIO; 52029f4fe9adSAndreas Gruenbacher device = peer_device->device; 52031952e916SAndreas Gruenbacher 5204b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5205b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5206b411b363SPhilipp Reisner 520769a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5208b411b363SPhilipp Reisner 5209b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5210b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5211b411b363SPhilipp Reisner else 5212b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5213b411b363SPhilipp Reisner 5214b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 52152735a594SAndreas Gruenbacher return 0; 52161d53f09eSLars Ellenberg 5217b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5218b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5219b411b363SPhilipp Reisner 5220b30ab791SAndreas Gruenbacher --device->ov_left; 5221ea5442afSLars Ellenberg 5222ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5223b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5224b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5225ea5442afSLars Ellenberg 5226b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 522784b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 522884b8c06bSAndreas Gruenbacher if (dw) { 522984b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 523084b8c06bSAndreas Gruenbacher dw->device = device; 523184b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5232b411b363SPhilipp Reisner } else { 523384b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5234b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5235b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5236b411b363SPhilipp Reisner } 5237b411b363SPhilipp Reisner } 5238b30ab791SAndreas Gruenbacher put_ldev(device); 52392735a594SAndreas Gruenbacher return 0; 5240b411b363SPhilipp Reisner } 5241b411b363SPhilipp Reisner 5242bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 52430ced55a3SPhilipp Reisner { 52442735a594SAndreas Gruenbacher return 0; 52450ced55a3SPhilipp Reisner } 52460ced55a3SPhilipp Reisner 5247bde89a9eSAndreas Gruenbacher static int connection_finish_peer_reqs(struct drbd_connection *connection) 524832862ec7SPhilipp Reisner { 5249c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5250c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 525132862ec7SPhilipp Reisner 525232862ec7SPhilipp Reisner do { 5253bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 525432862ec7SPhilipp Reisner flush_signals(current); 5255c141ebdaSPhilipp Reisner 5256c141ebdaSPhilipp Reisner rcu_read_lock(); 5257c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5258c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5259b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5260c141ebdaSPhilipp Reisner rcu_read_unlock(); 5261b30ab791SAndreas Gruenbacher if (drbd_finish_peer_reqs(device)) { 526205a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5263c141ebdaSPhilipp Reisner return 1; 5264082a3439SPhilipp Reisner } 526505a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5266c141ebdaSPhilipp Reisner rcu_read_lock(); 5267d3fcb490SPhilipp Reisner } 5268bde89a9eSAndreas Gruenbacher set_bit(SIGNAL_ASENDER, &connection->flags); 5269082a3439SPhilipp Reisner 52700500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5271c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5272c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5273b30ab791SAndreas Gruenbacher not_empty = !list_empty(&device->done_ee); 5274082a3439SPhilipp Reisner if (not_empty) 5275082a3439SPhilipp Reisner break; 5276082a3439SPhilipp Reisner } 52770500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5278c141ebdaSPhilipp Reisner rcu_read_unlock(); 527932862ec7SPhilipp Reisner } while (not_empty); 528032862ec7SPhilipp Reisner 528132862ec7SPhilipp Reisner return 0; 5282b411b363SPhilipp Reisner } 5283b411b363SPhilipp Reisner 5284b411b363SPhilipp Reisner struct asender_cmd { 5285b411b363SPhilipp Reisner size_t pkt_size; 5286bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5287b411b363SPhilipp Reisner }; 5288b411b363SPhilipp Reisner 5289b411b363SPhilipp Reisner static struct asender_cmd asender_tbl[] = { 5290e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5291e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5292b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5293b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5294b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5295d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5296b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5297b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5298b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5299b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5300b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5301b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5302b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 530302918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5304d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 53051952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 53061952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5307b411b363SPhilipp Reisner }; 5308b411b363SPhilipp Reisner 5309b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5310b411b363SPhilipp Reisner { 5311bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5312b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 531377351055SPhilipp Reisner struct packet_info pi; 5314257d0af6SPhilipp Reisner int rv; 5315bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5316b411b363SPhilipp Reisner int received = 0; 5317bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 531852b061a4SAndreas Gruenbacher int expect = header_size; 531944ed167dSPhilipp Reisner bool ping_timeout_active = false; 532044ed167dSPhilipp Reisner struct net_conf *nc; 5321bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 53223990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5323b411b363SPhilipp Reisner 53243990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 53253990e04dSPhilipp Reisner if (rv < 0) 53261ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_asender: ERROR set priority, ret=%d\n", rv); 5327b411b363SPhilipp Reisner 5328e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 532980822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 533044ed167dSPhilipp Reisner 533144ed167dSPhilipp Reisner rcu_read_lock(); 5332bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 533344ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5334bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 533544ed167dSPhilipp Reisner ping_int = nc->ping_int; 533644ed167dSPhilipp Reisner rcu_read_unlock(); 533744ed167dSPhilipp Reisner 5338bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5339bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 53401ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5341841ce241SAndreas Gruenbacher goto reconnect; 5342841ce241SAndreas Gruenbacher } 5343bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 534444ed167dSPhilipp Reisner ping_timeout_active = true; 5345b411b363SPhilipp Reisner } 5346b411b363SPhilipp Reisner 534732862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 534832862ec7SPhilipp Reisner much to send */ 5349bb77d34eSAndreas Gruenbacher if (tcp_cork) 5350bde89a9eSAndreas Gruenbacher drbd_tcp_cork(connection->meta.socket); 5351bde89a9eSAndreas Gruenbacher if (connection_finish_peer_reqs(connection)) { 53521ec861ebSAndreas Gruenbacher drbd_err(connection, "connection_finish_peer_reqs() failed\n"); 5353b411b363SPhilipp Reisner goto reconnect; 5354b411b363SPhilipp Reisner } 5355b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5356bb77d34eSAndreas Gruenbacher if (tcp_cork) 5357bde89a9eSAndreas Gruenbacher drbd_tcp_uncork(connection->meta.socket); 5358b411b363SPhilipp Reisner 5359b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5360b411b363SPhilipp Reisner if (signal_pending(current)) 5361b411b363SPhilipp Reisner continue; 5362b411b363SPhilipp Reisner 5363bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5364bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5365b411b363SPhilipp Reisner 5366b411b363SPhilipp Reisner flush_signals(current); 5367b411b363SPhilipp Reisner 5368b411b363SPhilipp Reisner /* Note: 5369b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5370b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5371b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5372b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5373b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5374b411b363SPhilipp Reisner * rv == expected: full header or command 5375b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5376b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5377b411b363SPhilipp Reisner */ 5378b411b363SPhilipp Reisner if (likely(rv > 0)) { 5379b411b363SPhilipp Reisner received += rv; 5380b411b363SPhilipp Reisner buf += rv; 5381b411b363SPhilipp Reisner } else if (rv == 0) { 5382bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5383b66623e3SPhilipp Reisner long t; 5384b66623e3SPhilipp Reisner rcu_read_lock(); 5385bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5386b66623e3SPhilipp Reisner rcu_read_unlock(); 5387b66623e3SPhilipp Reisner 5388bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5389bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5390b66623e3SPhilipp Reisner t); 5391599377acSPhilipp Reisner if (t) 5392599377acSPhilipp Reisner break; 5393599377acSPhilipp Reisner } 53941ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5395b411b363SPhilipp Reisner goto reconnect; 5396b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5397cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5398cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5399bde89a9eSAndreas Gruenbacher if (time_after(connection->last_received, 5400bde89a9eSAndreas Gruenbacher jiffies - connection->meta.socket->sk->sk_rcvtimeo)) 5401cb6518cbSLars Ellenberg continue; 5402f36af18cSLars Ellenberg if (ping_timeout_active) { 54031ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5404b411b363SPhilipp Reisner goto reconnect; 5405b411b363SPhilipp Reisner } 5406bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5407b411b363SPhilipp Reisner continue; 5408b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5409b411b363SPhilipp Reisner continue; 5410b411b363SPhilipp Reisner } else { 54111ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5412b411b363SPhilipp Reisner goto reconnect; 5413b411b363SPhilipp Reisner } 5414b411b363SPhilipp Reisner 5415b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5416bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5417b411b363SPhilipp Reisner goto reconnect; 54187201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 54191952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 54201ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 54212fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5422b411b363SPhilipp Reisner goto disconnect; 5423b411b363SPhilipp Reisner } 5424e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 542552b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 54261ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 542777351055SPhilipp Reisner pi.cmd, pi.size); 5428b411b363SPhilipp Reisner goto reconnect; 5429b411b363SPhilipp Reisner } 5430257d0af6SPhilipp Reisner } 5431b411b363SPhilipp Reisner if (received == expect) { 54322735a594SAndreas Gruenbacher bool err; 5433a4fbda8eSPhilipp Reisner 5434bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 54352735a594SAndreas Gruenbacher if (err) { 54361ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5437b411b363SPhilipp Reisner goto reconnect; 54381952e916SAndreas Gruenbacher } 5439b411b363SPhilipp Reisner 5440bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5441f36af18cSLars Ellenberg 544244ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 544344ed167dSPhilipp Reisner /* restore idle timeout */ 5444bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 544544ed167dSPhilipp Reisner ping_timeout_active = false; 544644ed167dSPhilipp Reisner } 5447b411b363SPhilipp Reisner 5448bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5449b411b363SPhilipp Reisner received = 0; 545052b061a4SAndreas Gruenbacher expect = header_size; 5451b411b363SPhilipp Reisner cmd = NULL; 5452b411b363SPhilipp Reisner } 5453b411b363SPhilipp Reisner } 5454b411b363SPhilipp Reisner 5455b411b363SPhilipp Reisner if (0) { 5456b411b363SPhilipp Reisner reconnect: 5457bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5458bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5459b411b363SPhilipp Reisner } 5460b411b363SPhilipp Reisner if (0) { 5461b411b363SPhilipp Reisner disconnect: 5462bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5463b411b363SPhilipp Reisner } 5464bde89a9eSAndreas Gruenbacher clear_bit(SIGNAL_ASENDER, &connection->flags); 5465b411b363SPhilipp Reisner 54661ec861ebSAndreas Gruenbacher drbd_info(connection, "asender terminated\n"); 5467b411b363SPhilipp Reisner 5468b411b363SPhilipp Reisner return 0; 5469b411b363SPhilipp Reisner } 5470