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 287e5fec31SFabian Frederick #include <linux/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> 39ae7e81c0SIngo Molnar #include <uapi/linux/sched/types.h> 40b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 41b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 42b411b363SPhilipp Reisner #include <linux/unistd.h> 43b411b363SPhilipp Reisner #include <linux/vmalloc.h> 44b411b363SPhilipp Reisner #include <linux/random.h> 45b411b363SPhilipp Reisner #include <linux/string.h> 46b411b363SPhilipp Reisner #include <linux/scatterlist.h> 47b411b363SPhilipp Reisner #include "drbd_int.h" 48a3603a6eSAndreas Gruenbacher #include "drbd_protocol.h" 49b411b363SPhilipp Reisner #include "drbd_req.h" 50b411b363SPhilipp Reisner #include "drbd_vli.h" 51b411b363SPhilipp Reisner 529104d31aSLars Ellenberg #define PRO_FEATURES (DRBD_FF_TRIM|DRBD_FF_THIN_RESYNC|DRBD_FF_WSAME) 5320c68fdeSLars Ellenberg 5477351055SPhilipp Reisner struct packet_info { 5577351055SPhilipp Reisner enum drbd_packet cmd; 56e2857216SAndreas Gruenbacher unsigned int size; 57e2857216SAndreas Gruenbacher unsigned int vnr; 58e658983aSAndreas Gruenbacher void *data; 5977351055SPhilipp Reisner }; 6077351055SPhilipp Reisner 61b411b363SPhilipp Reisner enum finish_epoch { 62b411b363SPhilipp Reisner FE_STILL_LIVE, 63b411b363SPhilipp Reisner FE_DESTROYED, 64b411b363SPhilipp Reisner FE_RECYCLED, 65b411b363SPhilipp Reisner }; 66b411b363SPhilipp Reisner 67bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection); 68bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection); 6969a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *); 70a0fb3c47SLars Ellenberg static void conn_wait_active_ee_empty(struct drbd_connection *connection); 71bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *, struct drbd_epoch *, enum epoch_event); 7299920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 73b411b363SPhilipp Reisner 74b411b363SPhilipp Reisner 75b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 76b411b363SPhilipp Reisner 7745bb912bSLars Ellenberg /* 7845bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7945bb912bSLars Ellenberg * page->private being our "next" pointer. 8045bb912bSLars Ellenberg */ 8145bb912bSLars Ellenberg 8245bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8345bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8445bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8545bb912bSLars Ellenberg */ 8645bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8745bb912bSLars Ellenberg { 8845bb912bSLars Ellenberg struct page *page; 8945bb912bSLars Ellenberg struct page *tmp; 9045bb912bSLars Ellenberg 9145bb912bSLars Ellenberg BUG_ON(!n); 9245bb912bSLars Ellenberg BUG_ON(!head); 9345bb912bSLars Ellenberg 9445bb912bSLars Ellenberg page = *head; 9523ce4227SPhilipp Reisner 9623ce4227SPhilipp Reisner if (!page) 9723ce4227SPhilipp Reisner return NULL; 9823ce4227SPhilipp Reisner 9945bb912bSLars Ellenberg while (page) { 10045bb912bSLars Ellenberg tmp = page_chain_next(page); 10145bb912bSLars Ellenberg if (--n == 0) 10245bb912bSLars Ellenberg break; /* found sufficient pages */ 10345bb912bSLars Ellenberg if (tmp == NULL) 10445bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10545bb912bSLars Ellenberg return NULL; 10645bb912bSLars Ellenberg page = tmp; 10745bb912bSLars Ellenberg } 10845bb912bSLars Ellenberg 10945bb912bSLars Ellenberg /* add end of list marker for the returned list */ 11045bb912bSLars Ellenberg set_page_private(page, 0); 11145bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11245bb912bSLars Ellenberg page = *head; 11345bb912bSLars Ellenberg *head = tmp; 11445bb912bSLars Ellenberg return page; 11545bb912bSLars Ellenberg } 11645bb912bSLars Ellenberg 11745bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11845bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11945bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 12045bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 12145bb912bSLars Ellenberg { 12245bb912bSLars Ellenberg struct page *tmp; 12345bb912bSLars Ellenberg int i = 1; 12445bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12545bb912bSLars Ellenberg ++i, page = tmp; 12645bb912bSLars Ellenberg if (len) 12745bb912bSLars Ellenberg *len = i; 12845bb912bSLars Ellenberg return page; 12945bb912bSLars Ellenberg } 13045bb912bSLars Ellenberg 13145bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13245bb912bSLars Ellenberg { 13345bb912bSLars Ellenberg struct page *tmp; 13445bb912bSLars Ellenberg int i = 0; 13545bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13645bb912bSLars Ellenberg put_page(page); 13745bb912bSLars Ellenberg ++i; 13845bb912bSLars Ellenberg } 13945bb912bSLars Ellenberg return i; 14045bb912bSLars Ellenberg } 14145bb912bSLars Ellenberg 14245bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14345bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14445bb912bSLars Ellenberg { 14545bb912bSLars Ellenberg #if 1 14645bb912bSLars Ellenberg struct page *tmp; 14745bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14845bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14945bb912bSLars Ellenberg #endif 15045bb912bSLars Ellenberg 15145bb912bSLars Ellenberg /* add chain to head */ 15245bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15345bb912bSLars Ellenberg *head = chain_first; 15445bb912bSLars Ellenberg } 15545bb912bSLars Ellenberg 156b30ab791SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_device *device, 15718c2d522SAndreas Gruenbacher unsigned int number) 158b411b363SPhilipp Reisner { 159b411b363SPhilipp Reisner struct page *page = NULL; 16045bb912bSLars Ellenberg struct page *tmp = NULL; 16118c2d522SAndreas Gruenbacher unsigned int i = 0; 162b411b363SPhilipp Reisner 163b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 164b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16545bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 166b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16745bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16845bb912bSLars Ellenberg if (page) 16945bb912bSLars Ellenberg drbd_pp_vacant -= number; 170b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 17145bb912bSLars Ellenberg if (page) 17245bb912bSLars Ellenberg return page; 173b411b363SPhilipp Reisner } 17445bb912bSLars Ellenberg 175b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 176b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 177b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17845bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17945bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 18045bb912bSLars Ellenberg if (!tmp) 18145bb912bSLars Ellenberg break; 18245bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18345bb912bSLars Ellenberg page = tmp; 18445bb912bSLars Ellenberg } 18545bb912bSLars Ellenberg 18645bb912bSLars Ellenberg if (i == number) 187b411b363SPhilipp Reisner return page; 18845bb912bSLars Ellenberg 18945bb912bSLars Ellenberg /* Not enough pages immediately available this time. 190c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 19145bb912bSLars Ellenberg * function "soon". */ 19245bb912bSLars Ellenberg if (page) { 19345bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19445bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19545bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19645bb912bSLars Ellenberg drbd_pp_vacant += i; 19745bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19845bb912bSLars Ellenberg } 19945bb912bSLars Ellenberg return NULL; 200b411b363SPhilipp Reisner } 201b411b363SPhilipp Reisner 202b30ab791SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_device *device, 203a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 204b411b363SPhilipp Reisner { 205a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req, *tmp; 206b411b363SPhilipp Reisner 207b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 208b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 209b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 210b411b363SPhilipp Reisner stop to examine the list... */ 211b411b363SPhilipp Reisner 212a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, tmp, &device->net_ee, w.list) { 213045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 214b411b363SPhilipp Reisner break; 215a8cd15baSAndreas Gruenbacher list_move(&peer_req->w.list, to_be_freed); 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner } 218b411b363SPhilipp Reisner 219668700b4SPhilipp Reisner static void drbd_reclaim_net_peer_reqs(struct drbd_device *device) 220b411b363SPhilipp Reisner { 221b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 222db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 223b411b363SPhilipp Reisner 2240500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 225b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 2260500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 227a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 228b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 229b411b363SPhilipp Reisner } 230b411b363SPhilipp Reisner 231668700b4SPhilipp Reisner static void conn_reclaim_net_peer_reqs(struct drbd_connection *connection) 232668700b4SPhilipp Reisner { 233668700b4SPhilipp Reisner struct drbd_peer_device *peer_device; 234668700b4SPhilipp Reisner int vnr; 235668700b4SPhilipp Reisner 236668700b4SPhilipp Reisner rcu_read_lock(); 237668700b4SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 238668700b4SPhilipp Reisner struct drbd_device *device = peer_device->device; 239668700b4SPhilipp Reisner if (!atomic_read(&device->pp_in_use_by_net)) 240668700b4SPhilipp Reisner continue; 241668700b4SPhilipp Reisner 242668700b4SPhilipp Reisner kref_get(&device->kref); 243668700b4SPhilipp Reisner rcu_read_unlock(); 244668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 245668700b4SPhilipp Reisner kref_put(&device->kref, drbd_destroy_device); 246668700b4SPhilipp Reisner rcu_read_lock(); 247668700b4SPhilipp Reisner } 248668700b4SPhilipp Reisner rcu_read_unlock(); 249668700b4SPhilipp Reisner } 250668700b4SPhilipp Reisner 251b411b363SPhilipp Reisner /** 252c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 253b30ab791SAndreas Gruenbacher * @device: DRBD device. 25445bb912bSLars Ellenberg * @number: number of pages requested 25545bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 256b411b363SPhilipp Reisner * 25745bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 2580e49d7b0SLars Ellenberg * the kernel. 25945bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 26045bb912bSLars Ellenberg * 2610e49d7b0SLars Ellenberg * If this allocation would exceed the max_buffers setting, we throttle 2620e49d7b0SLars Ellenberg * allocation (schedule_timeout) to give the system some room to breathe. 2630e49d7b0SLars Ellenberg * 2640e49d7b0SLars Ellenberg * We do not use max-buffers as hard limit, because it could lead to 2650e49d7b0SLars Ellenberg * congestion and further to a distributed deadlock during online-verify or 2660e49d7b0SLars Ellenberg * (checksum based) resync, if the max-buffers, socket buffer sizes and 2670e49d7b0SLars Ellenberg * resync-rate settings are mis-configured. 2680e49d7b0SLars Ellenberg * 26945bb912bSLars Ellenberg * Returns a page chain linked via page->private. 270b411b363SPhilipp Reisner */ 27169a22773SAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_peer_device *peer_device, unsigned int number, 272c37c8ecfSAndreas Gruenbacher bool retry) 273b411b363SPhilipp Reisner { 27469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 275b411b363SPhilipp Reisner struct page *page = NULL; 27644ed167dSPhilipp Reisner struct net_conf *nc; 277b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2780e49d7b0SLars Ellenberg unsigned int mxb; 279b411b363SPhilipp Reisner 28044ed167dSPhilipp Reisner rcu_read_lock(); 28169a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 28244ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 28344ed167dSPhilipp Reisner rcu_read_unlock(); 28444ed167dSPhilipp Reisner 285b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) 286b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 287b411b363SPhilipp Reisner 288668700b4SPhilipp Reisner /* Try to keep the fast path fast, but occasionally we need 289668700b4SPhilipp Reisner * to reclaim the pages we lended to the network stack. */ 290668700b4SPhilipp Reisner if (page && atomic_read(&device->pp_in_use_by_net) > 512) 291668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 292668700b4SPhilipp Reisner 29345bb912bSLars Ellenberg while (page == NULL) { 294b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 295b411b363SPhilipp Reisner 296668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 297b411b363SPhilipp Reisner 298b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) { 299b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 300b411b363SPhilipp Reisner if (page) 301b411b363SPhilipp Reisner break; 302b411b363SPhilipp Reisner } 303b411b363SPhilipp Reisner 304b411b363SPhilipp Reisner if (!retry) 305b411b363SPhilipp Reisner break; 306b411b363SPhilipp Reisner 307b411b363SPhilipp Reisner if (signal_pending(current)) { 308d0180171SAndreas Gruenbacher drbd_warn(device, "drbd_alloc_pages interrupted!\n"); 309b411b363SPhilipp Reisner break; 310b411b363SPhilipp Reisner } 311b411b363SPhilipp Reisner 3120e49d7b0SLars Ellenberg if (schedule_timeout(HZ/10) == 0) 3130e49d7b0SLars Ellenberg mxb = UINT_MAX; 314b411b363SPhilipp Reisner } 315b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 316b411b363SPhilipp Reisner 31745bb912bSLars Ellenberg if (page) 318b30ab791SAndreas Gruenbacher atomic_add(number, &device->pp_in_use); 319b411b363SPhilipp Reisner return page; 320b411b363SPhilipp Reisner } 321b411b363SPhilipp Reisner 322c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 3230500813fSAndreas Gruenbacher * Is also used from inside an other spin_lock_irq(&resource->req_lock); 32445bb912bSLars Ellenberg * Either links the page chain back to the global pool, 32545bb912bSLars Ellenberg * or returns all pages to the system. */ 326b30ab791SAndreas Gruenbacher static void drbd_free_pages(struct drbd_device *device, struct page *page, int is_net) 327b411b363SPhilipp Reisner { 328b30ab791SAndreas Gruenbacher atomic_t *a = is_net ? &device->pp_in_use_by_net : &device->pp_in_use; 329b411b363SPhilipp Reisner int i; 330435f0740SLars Ellenberg 331a73ff323SLars Ellenberg if (page == NULL) 332a73ff323SLars Ellenberg return; 333a73ff323SLars Ellenberg 3341816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 33545bb912bSLars Ellenberg i = page_chain_free(page); 33645bb912bSLars Ellenberg else { 33745bb912bSLars Ellenberg struct page *tmp; 33845bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 339b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 34045bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 34145bb912bSLars Ellenberg drbd_pp_vacant += i; 342b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 343b411b363SPhilipp Reisner } 344435f0740SLars Ellenberg i = atomic_sub_return(i, a); 34545bb912bSLars Ellenberg if (i < 0) 346d0180171SAndreas Gruenbacher drbd_warn(device, "ASSERTION FAILED: %s: %d < 0\n", 347435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 348b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 349b411b363SPhilipp Reisner } 350b411b363SPhilipp Reisner 351b411b363SPhilipp Reisner /* 352b411b363SPhilipp Reisner You need to hold the req_lock: 353b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 354b411b363SPhilipp Reisner 355b411b363SPhilipp Reisner You must not have the req_lock: 3563967deb1SAndreas Gruenbacher drbd_free_peer_req() 3570db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3587721f567SAndreas Gruenbacher drbd_free_peer_reqs() 359b411b363SPhilipp Reisner drbd_ee_fix_bhs() 360a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 361b411b363SPhilipp Reisner drbd_clear_done_ee() 362b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 363b411b363SPhilipp Reisner */ 364b411b363SPhilipp Reisner 3659104d31aSLars Ellenberg /* normal: payload_size == request size (bi_size) 3669104d31aSLars Ellenberg * w_same: payload_size == logical_block_size 3679104d31aSLars Ellenberg * trim: payload_size == 0 */ 368f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 36969a22773SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 3709104d31aSLars Ellenberg unsigned int request_size, unsigned int payload_size, gfp_t gfp_mask) __must_hold(local) 371b411b363SPhilipp Reisner { 37269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 373db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 374a73ff323SLars Ellenberg struct page *page = NULL; 3759104d31aSLars Ellenberg unsigned nr_pages = (payload_size + PAGE_SIZE -1) >> PAGE_SHIFT; 376b411b363SPhilipp Reisner 377b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_AL_EE)) 378b411b363SPhilipp Reisner return NULL; 379b411b363SPhilipp Reisner 380db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 381db830c46SAndreas Gruenbacher if (!peer_req) { 382b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 383d0180171SAndreas Gruenbacher drbd_err(device, "%s: allocation failed\n", __func__); 384b411b363SPhilipp Reisner return NULL; 385b411b363SPhilipp Reisner } 386b411b363SPhilipp Reisner 3879104d31aSLars Ellenberg if (nr_pages) { 388d0164adcSMel Gorman page = drbd_alloc_pages(peer_device, nr_pages, 389d0164adcSMel Gorman gfpflags_allow_blocking(gfp_mask)); 39045bb912bSLars Ellenberg if (!page) 39145bb912bSLars Ellenberg goto fail; 392a73ff323SLars Ellenberg } 393b411b363SPhilipp Reisner 394c5a2c150SLars Ellenberg memset(peer_req, 0, sizeof(*peer_req)); 395c5a2c150SLars Ellenberg INIT_LIST_HEAD(&peer_req->w.list); 396db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 3979104d31aSLars Ellenberg peer_req->i.size = request_size; 398db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 399c5a2c150SLars Ellenberg peer_req->submit_jif = jiffies; 400a8cd15baSAndreas Gruenbacher peer_req->peer_device = peer_device; 401db830c46SAndreas Gruenbacher peer_req->pages = page; 4029a8e7753SAndreas Gruenbacher /* 4039a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 4049a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 4059a8e7753SAndreas Gruenbacher */ 406db830c46SAndreas Gruenbacher peer_req->block_id = id; 407b411b363SPhilipp Reisner 408db830c46SAndreas Gruenbacher return peer_req; 409b411b363SPhilipp Reisner 41045bb912bSLars Ellenberg fail: 411db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 412b411b363SPhilipp Reisner return NULL; 413b411b363SPhilipp Reisner } 414b411b363SPhilipp Reisner 415b30ab791SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_device *device, struct drbd_peer_request *peer_req, 416f6ffca9fSAndreas Gruenbacher int is_net) 417b411b363SPhilipp Reisner { 41821ae5d7fSLars Ellenberg might_sleep(); 419db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 420db830c46SAndreas Gruenbacher kfree(peer_req->digest); 421b30ab791SAndreas Gruenbacher drbd_free_pages(device, peer_req->pages, is_net); 4220b0ba1efSAndreas Gruenbacher D_ASSERT(device, atomic_read(&peer_req->pending_bios) == 0); 4230b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 42421ae5d7fSLars Ellenberg if (!expect(!(peer_req->flags & EE_CALL_AL_COMPLETE_IO))) { 42521ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 42621ae5d7fSLars Ellenberg drbd_al_complete_io(device, &peer_req->i); 42721ae5d7fSLars Ellenberg } 428db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 429b411b363SPhilipp Reisner } 430b411b363SPhilipp Reisner 431b30ab791SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_device *device, struct list_head *list) 432b411b363SPhilipp Reisner { 433b411b363SPhilipp Reisner LIST_HEAD(work_list); 434db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 435b411b363SPhilipp Reisner int count = 0; 436b30ab791SAndreas Gruenbacher int is_net = list == &device->net_ee; 437b411b363SPhilipp Reisner 4380500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 439b411b363SPhilipp Reisner list_splice_init(list, &work_list); 4400500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 441b411b363SPhilipp Reisner 442a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 443b30ab791SAndreas Gruenbacher __drbd_free_peer_req(device, peer_req, is_net); 444b411b363SPhilipp Reisner count++; 445b411b363SPhilipp Reisner } 446b411b363SPhilipp Reisner return count; 447b411b363SPhilipp Reisner } 448b411b363SPhilipp Reisner 449b411b363SPhilipp Reisner /* 450a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 451b411b363SPhilipp Reisner */ 452b30ab791SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_device *device) 453b411b363SPhilipp Reisner { 454b411b363SPhilipp Reisner LIST_HEAD(work_list); 455b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 456db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 457e2b3032bSAndreas Gruenbacher int err = 0; 458b411b363SPhilipp Reisner 4590500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 460b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 461b30ab791SAndreas Gruenbacher list_splice_init(&device->done_ee, &work_list); 4620500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 463b411b363SPhilipp Reisner 464a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 465b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 466b411b363SPhilipp Reisner 467b411b363SPhilipp Reisner /* possible callbacks here: 468d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 469b411b363SPhilipp Reisner * all ignore the last argument. 470b411b363SPhilipp Reisner */ 471a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 472e2b3032bSAndreas Gruenbacher int err2; 473e2b3032bSAndreas Gruenbacher 474b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 475a8cd15baSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 476e2b3032bSAndreas Gruenbacher if (!err) 477e2b3032bSAndreas Gruenbacher err = err2; 478b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 479b411b363SPhilipp Reisner } 480b30ab791SAndreas Gruenbacher wake_up(&device->ee_wait); 481b411b363SPhilipp Reisner 482e2b3032bSAndreas Gruenbacher return err; 483b411b363SPhilipp Reisner } 484b411b363SPhilipp Reisner 485b30ab791SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_device *device, 486d4da1537SAndreas Gruenbacher struct list_head *head) 487b411b363SPhilipp Reisner { 488b411b363SPhilipp Reisner DEFINE_WAIT(wait); 489b411b363SPhilipp Reisner 490b411b363SPhilipp Reisner /* avoids spin_lock/unlock 491b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 492b411b363SPhilipp Reisner while (!list_empty(head)) { 493b30ab791SAndreas Gruenbacher prepare_to_wait(&device->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 4940500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4957eaceaccSJens Axboe io_schedule(); 496b30ab791SAndreas Gruenbacher finish_wait(&device->ee_wait, &wait); 4970500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 498b411b363SPhilipp Reisner } 499b411b363SPhilipp Reisner } 500b411b363SPhilipp Reisner 501b30ab791SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_device *device, 502d4da1537SAndreas Gruenbacher struct list_head *head) 503b411b363SPhilipp Reisner { 5040500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 505b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, head); 5060500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 507b411b363SPhilipp Reisner } 508b411b363SPhilipp Reisner 509dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 510b411b363SPhilipp Reisner { 511b411b363SPhilipp Reisner struct kvec iov = { 512b411b363SPhilipp Reisner .iov_base = buf, 513b411b363SPhilipp Reisner .iov_len = size, 514b411b363SPhilipp Reisner }; 515b411b363SPhilipp Reisner struct msghdr msg = { 516b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 517b411b363SPhilipp Reisner }; 518f730c848SAl Viro return kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); 519b411b363SPhilipp Reisner } 520b411b363SPhilipp Reisner 521bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 522b411b363SPhilipp Reisner { 523b411b363SPhilipp Reisner int rv; 524b411b363SPhilipp Reisner 525bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 526b411b363SPhilipp Reisner 527b411b363SPhilipp Reisner if (rv < 0) { 528b411b363SPhilipp Reisner if (rv == -ECONNRESET) 5291ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 530b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 5311ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 532b411b363SPhilipp Reisner } else if (rv == 0) { 533bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 534b66623e3SPhilipp Reisner long t; 535b66623e3SPhilipp Reisner rcu_read_lock(); 536bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 537b66623e3SPhilipp Reisner rcu_read_unlock(); 538b66623e3SPhilipp Reisner 539bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 540b66623e3SPhilipp Reisner 541599377acSPhilipp Reisner if (t) 542599377acSPhilipp Reisner goto out; 543599377acSPhilipp Reisner } 5441ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 545599377acSPhilipp Reisner } 546599377acSPhilipp Reisner 547b411b363SPhilipp Reisner if (rv != size) 548bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 549b411b363SPhilipp Reisner 550599377acSPhilipp Reisner out: 551b411b363SPhilipp Reisner return rv; 552b411b363SPhilipp Reisner } 553b411b363SPhilipp Reisner 554bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 555c6967746SAndreas Gruenbacher { 556c6967746SAndreas Gruenbacher int err; 557c6967746SAndreas Gruenbacher 558bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 559c6967746SAndreas Gruenbacher if (err != size) { 560c6967746SAndreas Gruenbacher if (err >= 0) 561c6967746SAndreas Gruenbacher err = -EIO; 562c6967746SAndreas Gruenbacher } else 563c6967746SAndreas Gruenbacher err = 0; 564c6967746SAndreas Gruenbacher return err; 565c6967746SAndreas Gruenbacher } 566c6967746SAndreas Gruenbacher 567bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 568a5c31904SAndreas Gruenbacher { 569a5c31904SAndreas Gruenbacher int err; 570a5c31904SAndreas Gruenbacher 571bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 572a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5731ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 574a5c31904SAndreas Gruenbacher return err; 575a5c31904SAndreas Gruenbacher } 576a5c31904SAndreas Gruenbacher 5775dbf1673SLars Ellenberg /* quoting tcp(7): 5785dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5795dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5805dbf1673SLars Ellenberg * This is our wrapper to do so. 5815dbf1673SLars Ellenberg */ 5825dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5835dbf1673SLars Ellenberg unsigned int rcv) 5845dbf1673SLars Ellenberg { 5855dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5865dbf1673SLars Ellenberg if (snd) { 5875dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5885dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5895dbf1673SLars Ellenberg } 5905dbf1673SLars Ellenberg if (rcv) { 5915dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5925dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5935dbf1673SLars Ellenberg } 5945dbf1673SLars Ellenberg } 5955dbf1673SLars Ellenberg 596bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 597b411b363SPhilipp Reisner { 598b411b363SPhilipp Reisner const char *what; 599b411b363SPhilipp Reisner struct socket *sock; 600b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 60144ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 60244ed167dSPhilipp Reisner struct net_conf *nc; 60344ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 60469ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 605b411b363SPhilipp Reisner int disconnect_on_error = 1; 606b411b363SPhilipp Reisner 60744ed167dSPhilipp Reisner rcu_read_lock(); 608bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 60944ed167dSPhilipp Reisner if (!nc) { 61044ed167dSPhilipp Reisner rcu_read_unlock(); 611b411b363SPhilipp Reisner return NULL; 61244ed167dSPhilipp Reisner } 61344ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 61444ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 61569ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 616089c075dSAndreas Gruenbacher rcu_read_unlock(); 61744ed167dSPhilipp Reisner 618bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 619bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 62044ed167dSPhilipp Reisner 621bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 62244ed167dSPhilipp Reisner src_in6.sin6_port = 0; 62344ed167dSPhilipp Reisner else 62444ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 62544ed167dSPhilipp Reisner 626bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 627bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 628b411b363SPhilipp Reisner 629b411b363SPhilipp Reisner what = "sock_create_kern"; 630eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&src_in6)->sa_family, 631b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 632b411b363SPhilipp Reisner if (err < 0) { 633b411b363SPhilipp Reisner sock = NULL; 634b411b363SPhilipp Reisner goto out; 635b411b363SPhilipp Reisner } 636b411b363SPhilipp Reisner 637b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 63869ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 63944ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 640b411b363SPhilipp Reisner 641b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 642b411b363SPhilipp Reisner * for the outgoing connections. 643b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 644b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 645b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 646b411b363SPhilipp Reisner * a free one dynamically. 647b411b363SPhilipp Reisner */ 648b411b363SPhilipp Reisner what = "bind before connect"; 64944ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 650b411b363SPhilipp Reisner if (err < 0) 651b411b363SPhilipp Reisner goto out; 652b411b363SPhilipp Reisner 653b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 654b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 655b411b363SPhilipp Reisner disconnect_on_error = 0; 656b411b363SPhilipp Reisner what = "connect"; 65744ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 658b411b363SPhilipp Reisner 659b411b363SPhilipp Reisner out: 660b411b363SPhilipp Reisner if (err < 0) { 661b411b363SPhilipp Reisner if (sock) { 662b411b363SPhilipp Reisner sock_release(sock); 663b411b363SPhilipp Reisner sock = NULL; 664b411b363SPhilipp Reisner } 665b411b363SPhilipp Reisner switch (-err) { 666b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 667b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 668b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 669b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 670b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 671b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 672b411b363SPhilipp Reisner disconnect_on_error = 0; 673b411b363SPhilipp Reisner break; 674b411b363SPhilipp Reisner default: 6751ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 676b411b363SPhilipp Reisner } 677b411b363SPhilipp Reisner if (disconnect_on_error) 678bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 679b411b363SPhilipp Reisner } 68044ed167dSPhilipp Reisner 681b411b363SPhilipp Reisner return sock; 682b411b363SPhilipp Reisner } 683b411b363SPhilipp Reisner 6847a426fd8SPhilipp Reisner struct accept_wait_data { 685bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6867a426fd8SPhilipp Reisner struct socket *s_listen; 6877a426fd8SPhilipp Reisner struct completion door_bell; 6887a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6897a426fd8SPhilipp Reisner 6907a426fd8SPhilipp Reisner }; 6917a426fd8SPhilipp Reisner 692715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 693b411b363SPhilipp Reisner { 6947a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 695715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6967a426fd8SPhilipp Reisner 697715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 698715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6997a426fd8SPhilipp Reisner complete(&ad->door_bell); 700715306f6SAndreas Gruenbacher state_change(sk); 7017a426fd8SPhilipp Reisner } 7027a426fd8SPhilipp Reisner 703bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 704b411b363SPhilipp Reisner { 7051f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 70644ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 7071f3e509bSPhilipp Reisner struct socket *s_listen; 70844ed167dSPhilipp Reisner struct net_conf *nc; 709b411b363SPhilipp Reisner const char *what; 710b411b363SPhilipp Reisner 71144ed167dSPhilipp Reisner rcu_read_lock(); 712bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 71344ed167dSPhilipp Reisner if (!nc) { 71444ed167dSPhilipp Reisner rcu_read_unlock(); 7157a426fd8SPhilipp Reisner return -EIO; 71644ed167dSPhilipp Reisner } 71744ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71844ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 71944ed167dSPhilipp Reisner rcu_read_unlock(); 720b411b363SPhilipp Reisner 721bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 722bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 723b411b363SPhilipp Reisner 724b411b363SPhilipp Reisner what = "sock_create_kern"; 725eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&my_addr)->sa_family, 726b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 727b411b363SPhilipp Reisner if (err) { 728b411b363SPhilipp Reisner s_listen = NULL; 729b411b363SPhilipp Reisner goto out; 730b411b363SPhilipp Reisner } 731b411b363SPhilipp Reisner 7324a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 73344ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 734b411b363SPhilipp Reisner 735b411b363SPhilipp Reisner what = "bind before listen"; 73644ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 737b411b363SPhilipp Reisner if (err < 0) 738b411b363SPhilipp Reisner goto out; 739b411b363SPhilipp Reisner 7407a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7417a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7427a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 743715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7447a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7457a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 746b411b363SPhilipp Reisner 7472820fd39SPhilipp Reisner what = "listen"; 7482820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7492820fd39SPhilipp Reisner if (err < 0) 7502820fd39SPhilipp Reisner goto out; 7512820fd39SPhilipp Reisner 7527a426fd8SPhilipp Reisner return 0; 753b411b363SPhilipp Reisner out: 754b411b363SPhilipp Reisner if (s_listen) 755b411b363SPhilipp Reisner sock_release(s_listen); 756b411b363SPhilipp Reisner if (err < 0) { 757b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7581ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 759bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 760b411b363SPhilipp Reisner } 761b411b363SPhilipp Reisner } 7621f3e509bSPhilipp Reisner 7637a426fd8SPhilipp Reisner return -EIO; 7641f3e509bSPhilipp Reisner } 7651f3e509bSPhilipp Reisner 766715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 767715306f6SAndreas Gruenbacher { 768715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 769715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 770715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 771715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 772715306f6SAndreas Gruenbacher } 773715306f6SAndreas Gruenbacher 774bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7751f3e509bSPhilipp Reisner { 7761f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7771f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7781f3e509bSPhilipp Reisner struct net_conf *nc; 7791f3e509bSPhilipp Reisner 7801f3e509bSPhilipp Reisner rcu_read_lock(); 781bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7821f3e509bSPhilipp Reisner if (!nc) { 7831f3e509bSPhilipp Reisner rcu_read_unlock(); 7841f3e509bSPhilipp Reisner return NULL; 7851f3e509bSPhilipp Reisner } 7861f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7871f3e509bSPhilipp Reisner rcu_read_unlock(); 7881f3e509bSPhilipp Reisner 7891f3e509bSPhilipp Reisner timeo = connect_int * HZ; 79038b682b2SAkinobu Mita /* 28.5% random jitter */ 79138b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7921f3e509bSPhilipp Reisner 7937a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7947a426fd8SPhilipp Reisner if (err <= 0) 7957a426fd8SPhilipp Reisner return NULL; 7961f3e509bSPhilipp Reisner 7977a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 798b411b363SPhilipp Reisner if (err < 0) { 799b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 8001ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 801bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 802b411b363SPhilipp Reisner } 803b411b363SPhilipp Reisner } 804b411b363SPhilipp Reisner 805715306f6SAndreas Gruenbacher if (s_estab) 806715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 807b411b363SPhilipp Reisner 808b411b363SPhilipp Reisner return s_estab; 809b411b363SPhilipp Reisner } 810b411b363SPhilipp Reisner 811bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 812b411b363SPhilipp Reisner 813bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 8149f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 8159f5bdc33SAndreas Gruenbacher { 816bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 8179f5bdc33SAndreas Gruenbacher return -EIO; 818bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 819b411b363SPhilipp Reisner } 820b411b363SPhilipp Reisner 821bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 822b411b363SPhilipp Reisner { 823bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 8249f5bdc33SAndreas Gruenbacher struct packet_info pi; 8254920e37aSPhilipp Reisner struct net_conf *nc; 8269f5bdc33SAndreas Gruenbacher int err; 827b411b363SPhilipp Reisner 8284920e37aSPhilipp Reisner rcu_read_lock(); 8294920e37aSPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8304920e37aSPhilipp Reisner if (!nc) { 8314920e37aSPhilipp Reisner rcu_read_unlock(); 8324920e37aSPhilipp Reisner return -EIO; 8334920e37aSPhilipp Reisner } 8344920e37aSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo * 4 * HZ / 10; 8354920e37aSPhilipp Reisner rcu_read_unlock(); 8364920e37aSPhilipp Reisner 837bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 8389f5bdc33SAndreas Gruenbacher if (err != header_size) { 8399f5bdc33SAndreas Gruenbacher if (err >= 0) 8409f5bdc33SAndreas Gruenbacher err = -EIO; 8419f5bdc33SAndreas Gruenbacher return err; 8429f5bdc33SAndreas Gruenbacher } 843bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8449f5bdc33SAndreas Gruenbacher if (err) 8459f5bdc33SAndreas Gruenbacher return err; 8469f5bdc33SAndreas Gruenbacher return pi.cmd; 847b411b363SPhilipp Reisner } 848b411b363SPhilipp Reisner 849b411b363SPhilipp Reisner /** 850b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 851b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 852b411b363SPhilipp Reisner */ 8535d0b17f1SPhilipp Reisner static bool drbd_socket_okay(struct socket **sock) 854b411b363SPhilipp Reisner { 855b411b363SPhilipp Reisner int rr; 856b411b363SPhilipp Reisner char tb[4]; 857b411b363SPhilipp Reisner 858b411b363SPhilipp Reisner if (!*sock) 85981e84650SAndreas Gruenbacher return false; 860b411b363SPhilipp Reisner 861dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 862b411b363SPhilipp Reisner 863b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 86481e84650SAndreas Gruenbacher return true; 865b411b363SPhilipp Reisner } else { 866b411b363SPhilipp Reisner sock_release(*sock); 867b411b363SPhilipp Reisner *sock = NULL; 86881e84650SAndreas Gruenbacher return false; 869b411b363SPhilipp Reisner } 870b411b363SPhilipp Reisner } 8715d0b17f1SPhilipp Reisner 8725d0b17f1SPhilipp Reisner static bool connection_established(struct drbd_connection *connection, 8735d0b17f1SPhilipp Reisner struct socket **sock1, 8745d0b17f1SPhilipp Reisner struct socket **sock2) 8755d0b17f1SPhilipp Reisner { 8765d0b17f1SPhilipp Reisner struct net_conf *nc; 8775d0b17f1SPhilipp Reisner int timeout; 8785d0b17f1SPhilipp Reisner bool ok; 8795d0b17f1SPhilipp Reisner 8805d0b17f1SPhilipp Reisner if (!*sock1 || !*sock2) 8815d0b17f1SPhilipp Reisner return false; 8825d0b17f1SPhilipp Reisner 8835d0b17f1SPhilipp Reisner rcu_read_lock(); 8845d0b17f1SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8855d0b17f1SPhilipp Reisner timeout = (nc->sock_check_timeo ?: nc->ping_timeo) * HZ / 10; 8865d0b17f1SPhilipp Reisner rcu_read_unlock(); 8875d0b17f1SPhilipp Reisner schedule_timeout_interruptible(timeout); 8885d0b17f1SPhilipp Reisner 8895d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock1); 8905d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock2) && ok; 8915d0b17f1SPhilipp Reisner 8925d0b17f1SPhilipp Reisner return ok; 8935d0b17f1SPhilipp Reisner } 8945d0b17f1SPhilipp Reisner 8952325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8962325eb66SPhilipp Reisner in a connection */ 89769a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 898907599e0SPhilipp Reisner { 89969a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 9000829f5edSAndreas Gruenbacher int err; 901907599e0SPhilipp Reisner 902b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 903b30ab791SAndreas Gruenbacher device->peer_seq = 0; 904907599e0SPhilipp Reisner 90569a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 90669a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 907b30ab791SAndreas Gruenbacher &device->own_state_mutex; 9088410da8fSPhilipp Reisner 90969a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 9100829f5edSAndreas Gruenbacher if (!err) 91169a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 9120829f5edSAndreas Gruenbacher if (!err) 91369a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 9140829f5edSAndreas Gruenbacher if (!err) 91569a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 916b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 917b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 918b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 919b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 9200829f5edSAndreas Gruenbacher return err; 921907599e0SPhilipp Reisner } 922b411b363SPhilipp Reisner 923b411b363SPhilipp Reisner /* 924b411b363SPhilipp Reisner * return values: 925b411b363SPhilipp Reisner * 1 yes, we have a valid connection 926b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 927b411b363SPhilipp Reisner * -1 peer talks different language, 928b411b363SPhilipp Reisner * no point in trying again, please go standalone. 929b411b363SPhilipp Reisner * -2 We do not have a network config... 930b411b363SPhilipp Reisner */ 931bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 932b411b363SPhilipp Reisner { 9337da35862SPhilipp Reisner struct drbd_socket sock, msock; 934c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 93544ed167dSPhilipp Reisner struct net_conf *nc; 9365d0b17f1SPhilipp Reisner int vnr, timeout, h; 9375d0b17f1SPhilipp Reisner bool discard_my_data, ok; 938197296ffSPhilipp Reisner enum drbd_state_rv rv; 9397a426fd8SPhilipp Reisner struct accept_wait_data ad = { 940bde89a9eSAndreas Gruenbacher .connection = connection, 9417a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 9427a426fd8SPhilipp Reisner }; 943b411b363SPhilipp Reisner 944bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 945bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 946b411b363SPhilipp Reisner return -2; 947b411b363SPhilipp Reisner 9487da35862SPhilipp Reisner mutex_init(&sock.mutex); 949bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 950bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 9517da35862SPhilipp Reisner sock.socket = NULL; 9527da35862SPhilipp Reisner mutex_init(&msock.mutex); 953bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 954bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 9557da35862SPhilipp Reisner msock.socket = NULL; 9567da35862SPhilipp Reisner 9570916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 958bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 959b411b363SPhilipp Reisner 960bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 9617a426fd8SPhilipp Reisner return 0; 962b411b363SPhilipp Reisner 963b411b363SPhilipp Reisner do { 9642bf89621SAndreas Gruenbacher struct socket *s; 965b411b363SPhilipp Reisner 966bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 967b411b363SPhilipp Reisner if (s) { 9687da35862SPhilipp Reisner if (!sock.socket) { 9697da35862SPhilipp Reisner sock.socket = s; 970bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9717da35862SPhilipp Reisner } else if (!msock.socket) { 972bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9737da35862SPhilipp Reisner msock.socket = s; 974bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 975b411b363SPhilipp Reisner } else { 9761ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 977b411b363SPhilipp Reisner goto out_release_sockets; 978b411b363SPhilipp Reisner } 979b411b363SPhilipp Reisner } 980b411b363SPhilipp Reisner 9815d0b17f1SPhilipp Reisner if (connection_established(connection, &sock.socket, &msock.socket)) 982b411b363SPhilipp Reisner break; 983b411b363SPhilipp Reisner 984b411b363SPhilipp Reisner retry: 985bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 986b411b363SPhilipp Reisner if (s) { 987bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9887da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9897da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 99092f14951SPhilipp Reisner switch (fp) { 991e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9927da35862SPhilipp Reisner if (sock.socket) { 9931ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9947da35862SPhilipp Reisner sock_release(sock.socket); 99580c6eed4SPhilipp Reisner sock.socket = s; 99680c6eed4SPhilipp Reisner goto randomize; 997b411b363SPhilipp Reisner } 9987da35862SPhilipp Reisner sock.socket = s; 999b411b363SPhilipp Reisner break; 1000e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 1001bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 10027da35862SPhilipp Reisner if (msock.socket) { 10031ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 10047da35862SPhilipp Reisner sock_release(msock.socket); 100580c6eed4SPhilipp Reisner msock.socket = s; 100680c6eed4SPhilipp Reisner goto randomize; 1007b411b363SPhilipp Reisner } 10087da35862SPhilipp Reisner msock.socket = s; 1009b411b363SPhilipp Reisner break; 1010b411b363SPhilipp Reisner default: 10111ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 1012b411b363SPhilipp Reisner sock_release(s); 101380c6eed4SPhilipp Reisner randomize: 101438b682b2SAkinobu Mita if (prandom_u32() & 1) 1015b411b363SPhilipp Reisner goto retry; 1016b411b363SPhilipp Reisner } 1017b411b363SPhilipp Reisner } 1018b411b363SPhilipp Reisner 1019bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 1020b411b363SPhilipp Reisner goto out_release_sockets; 1021b411b363SPhilipp Reisner if (signal_pending(current)) { 1022b411b363SPhilipp Reisner flush_signals(current); 1023b411b363SPhilipp Reisner smp_rmb(); 1024bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 1025b411b363SPhilipp Reisner goto out_release_sockets; 1026b411b363SPhilipp Reisner } 1027b411b363SPhilipp Reisner 10285d0b17f1SPhilipp Reisner ok = connection_established(connection, &sock.socket, &msock.socket); 1029b666dbf8SPhilipp Reisner } while (!ok); 1030b411b363SPhilipp Reisner 10317a426fd8SPhilipp Reisner if (ad.s_listen) 10327a426fd8SPhilipp Reisner sock_release(ad.s_listen); 1033b411b363SPhilipp Reisner 103498683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 103598683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 1036b411b363SPhilipp Reisner 10377da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 10387da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 1039b411b363SPhilipp Reisner 10407da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 10417da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 1042b411b363SPhilipp Reisner 1043b411b363SPhilipp Reisner /* NOT YET ... 1044bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 10457da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10466038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1047b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 104844ed167dSPhilipp Reisner rcu_read_lock(); 1049bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 1050b411b363SPhilipp Reisner 10517da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10527da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 105344ed167dSPhilipp Reisner 10547da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 105544ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 105608b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 105744ed167dSPhilipp Reisner rcu_read_unlock(); 105844ed167dSPhilipp Reisner 10597da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1060b411b363SPhilipp Reisner 1061b411b363SPhilipp Reisner /* we don't want delays. 106225985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10637da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10647da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1065b411b363SPhilipp Reisner 1066bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1067bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1068bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1069b411b363SPhilipp Reisner 1070bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1071b411b363SPhilipp Reisner if (h <= 0) 1072b411b363SPhilipp Reisner return h; 1073b411b363SPhilipp Reisner 1074bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1075b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1076bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1077b10d96cbSJohannes Thoma case -1: 10781ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1079b411b363SPhilipp Reisner return -1; 1080b10d96cbSJohannes Thoma case 0: 10811ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1082b10d96cbSJohannes Thoma return 0; 1083b411b363SPhilipp Reisner } 1084b411b363SPhilipp Reisner } 1085b411b363SPhilipp Reisner 1086bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1087bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1088b411b363SPhilipp Reisner 1089bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10907e2455c1SPhilipp Reisner return -1; 10911e86ac48SPhilipp Reisner 109213c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 109313c76abaSPhilipp Reisner * being promoted to Primary. 109413c76abaSPhilipp Reisner * 109513c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 109613c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 109713c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 109813c76abaSPhilipp Reisner */ 109931007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 110031007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 110131007745SPhilipp Reisner 110231007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 110331007745SPhilipp Reisner 110431007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 110531007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 110631007745SPhilipp Reisner 110731007745SPhilipp Reisner rcu_read_lock(); 110831007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 110931007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 111031007745SPhilipp Reisner kref_get(&device->kref); 111131007745SPhilipp Reisner rcu_read_unlock(); 111213c76abaSPhilipp Reisner 111308b165baSPhilipp Reisner if (discard_my_data) 1114b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 111508b165baSPhilipp Reisner else 1116b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 111708b165baSPhilipp Reisner 111869a22773SAndreas Gruenbacher drbd_connected(peer_device); 111905a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1120c141ebdaSPhilipp Reisner rcu_read_lock(); 1121c141ebdaSPhilipp Reisner } 1122c141ebdaSPhilipp Reisner rcu_read_unlock(); 1123c141ebdaSPhilipp Reisner 1124bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1125bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1126bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 11271e86ac48SPhilipp Reisner return 0; 1128a1096a6eSPhilipp Reisner } 11291e86ac48SPhilipp Reisner 11301c03e520SPhilipp Reisner drbd_thread_start(&connection->ack_receiver); 113139e91a60SLars Ellenberg /* opencoded create_singlethread_workqueue(), 113239e91a60SLars Ellenberg * to be able to use format string arguments */ 113339e91a60SLars Ellenberg connection->ack_sender = 113439e91a60SLars Ellenberg alloc_ordered_workqueue("drbd_as_%s", WQ_MEM_RECLAIM, connection->resource->name); 1135668700b4SPhilipp Reisner if (!connection->ack_sender) { 1136668700b4SPhilipp Reisner drbd_err(connection, "Failed to create workqueue ack_sender\n"); 1137668700b4SPhilipp Reisner return 0; 1138668700b4SPhilipp Reisner } 1139b411b363SPhilipp Reisner 11400500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 114108b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 114208b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 114308b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 114408b165baSPhilipp Reisner * just to clear a single value. */ 1145bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 11460500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 114708b165baSPhilipp Reisner 1148d3fcb490SPhilipp Reisner return h; 1149b411b363SPhilipp Reisner 1150b411b363SPhilipp Reisner out_release_sockets: 11517a426fd8SPhilipp Reisner if (ad.s_listen) 11527a426fd8SPhilipp Reisner sock_release(ad.s_listen); 11537da35862SPhilipp Reisner if (sock.socket) 11547da35862SPhilipp Reisner sock_release(sock.socket); 11557da35862SPhilipp Reisner if (msock.socket) 11567da35862SPhilipp Reisner sock_release(msock.socket); 1157b411b363SPhilipp Reisner return -1; 1158b411b363SPhilipp Reisner } 1159b411b363SPhilipp Reisner 1160bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1161b411b363SPhilipp Reisner { 1162bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1163b411b363SPhilipp Reisner 11640c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11650c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11660c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11670c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11681ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11690c8e36d9SAndreas Gruenbacher return -EINVAL; 117002918be2SPhilipp Reisner } 11710c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11720c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11730c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11740c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1175e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1176e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1177e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1178b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1179eefc2f7dSPhilipp Reisner pi->vnr = 0; 1180e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1181e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1182e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1183e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1184e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 118577351055SPhilipp Reisner pi->vnr = 0; 118602918be2SPhilipp Reisner } else { 11871ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1188e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1189bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11908172f3e9SAndreas Gruenbacher return -EINVAL; 1191b411b363SPhilipp Reisner } 1192e658983aSAndreas Gruenbacher pi->data = header + header_size; 11938172f3e9SAndreas Gruenbacher return 0; 1194b411b363SPhilipp Reisner } 1195b411b363SPhilipp Reisner 1196bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1197257d0af6SPhilipp Reisner { 1198bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 119969bc7bc3SAndreas Gruenbacher int err; 1200257d0af6SPhilipp Reisner 1201bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1202a5c31904SAndreas Gruenbacher if (err) 120369bc7bc3SAndreas Gruenbacher return err; 1204257d0af6SPhilipp Reisner 1205bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1206bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1207b411b363SPhilipp Reisner 120869bc7bc3SAndreas Gruenbacher return err; 1209b411b363SPhilipp Reisner } 1210b411b363SPhilipp Reisner 1211f9ff0da5SLars Ellenberg /* This is blkdev_issue_flush, but asynchronous. 1212f9ff0da5SLars Ellenberg * We want to submit to all component volumes in parallel, 1213f9ff0da5SLars Ellenberg * then wait for all completions. 1214f9ff0da5SLars Ellenberg */ 1215f9ff0da5SLars Ellenberg struct issue_flush_context { 1216f9ff0da5SLars Ellenberg atomic_t pending; 1217f9ff0da5SLars Ellenberg int error; 1218f9ff0da5SLars Ellenberg struct completion done; 1219f9ff0da5SLars Ellenberg }; 1220f9ff0da5SLars Ellenberg struct one_flush_context { 1221f9ff0da5SLars Ellenberg struct drbd_device *device; 1222f9ff0da5SLars Ellenberg struct issue_flush_context *ctx; 1223f9ff0da5SLars Ellenberg }; 1224f9ff0da5SLars Ellenberg 1225f9ff0da5SLars Ellenberg void one_flush_endio(struct bio *bio) 1226f9ff0da5SLars Ellenberg { 1227f9ff0da5SLars Ellenberg struct one_flush_context *octx = bio->bi_private; 1228f9ff0da5SLars Ellenberg struct drbd_device *device = octx->device; 1229f9ff0da5SLars Ellenberg struct issue_flush_context *ctx = octx->ctx; 1230f9ff0da5SLars Ellenberg 1231f9ff0da5SLars Ellenberg if (bio->bi_error) { 1232f9ff0da5SLars Ellenberg ctx->error = bio->bi_error; 1233f9ff0da5SLars Ellenberg drbd_info(device, "local disk FLUSH FAILED with status %d\n", bio->bi_error); 1234f9ff0da5SLars Ellenberg } 1235f9ff0da5SLars Ellenberg kfree(octx); 1236f9ff0da5SLars Ellenberg bio_put(bio); 1237f9ff0da5SLars Ellenberg 1238f9ff0da5SLars Ellenberg clear_bit(FLUSH_PENDING, &device->flags); 1239f9ff0da5SLars Ellenberg put_ldev(device); 1240f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1241f9ff0da5SLars Ellenberg 1242f9ff0da5SLars Ellenberg if (atomic_dec_and_test(&ctx->pending)) 1243f9ff0da5SLars Ellenberg complete(&ctx->done); 1244f9ff0da5SLars Ellenberg } 1245f9ff0da5SLars Ellenberg 1246f9ff0da5SLars Ellenberg static void submit_one_flush(struct drbd_device *device, struct issue_flush_context *ctx) 1247f9ff0da5SLars Ellenberg { 1248f9ff0da5SLars Ellenberg struct bio *bio = bio_alloc(GFP_NOIO, 0); 1249f9ff0da5SLars Ellenberg struct one_flush_context *octx = kmalloc(sizeof(*octx), GFP_NOIO); 1250f9ff0da5SLars Ellenberg if (!bio || !octx) { 1251f9ff0da5SLars Ellenberg drbd_warn(device, "Could not allocate a bio, CANNOT ISSUE FLUSH\n"); 1252f9ff0da5SLars Ellenberg /* FIXME: what else can I do now? disconnecting or detaching 1253f9ff0da5SLars Ellenberg * really does not help to improve the state of the world, either. 1254f9ff0da5SLars Ellenberg */ 1255f9ff0da5SLars Ellenberg kfree(octx); 1256f9ff0da5SLars Ellenberg if (bio) 1257f9ff0da5SLars Ellenberg bio_put(bio); 1258f9ff0da5SLars Ellenberg 1259f9ff0da5SLars Ellenberg ctx->error = -ENOMEM; 1260f9ff0da5SLars Ellenberg put_ldev(device); 1261f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1262f9ff0da5SLars Ellenberg return; 1263f9ff0da5SLars Ellenberg } 1264f9ff0da5SLars Ellenberg 1265f9ff0da5SLars Ellenberg octx->device = device; 1266f9ff0da5SLars Ellenberg octx->ctx = ctx; 1267f9ff0da5SLars Ellenberg bio->bi_bdev = device->ldev->backing_bdev; 1268f9ff0da5SLars Ellenberg bio->bi_private = octx; 1269f9ff0da5SLars Ellenberg bio->bi_end_io = one_flush_endio; 127070fd7614SChristoph Hellwig bio->bi_opf = REQ_OP_FLUSH | REQ_PREFLUSH; 1271f9ff0da5SLars Ellenberg 1272f9ff0da5SLars Ellenberg device->flush_jif = jiffies; 1273f9ff0da5SLars Ellenberg set_bit(FLUSH_PENDING, &device->flags); 1274f9ff0da5SLars Ellenberg atomic_inc(&ctx->pending); 1275f9ff0da5SLars Ellenberg submit_bio(bio); 1276f9ff0da5SLars Ellenberg } 1277f9ff0da5SLars Ellenberg 1278bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1279b411b363SPhilipp Reisner { 1280f9ff0da5SLars Ellenberg if (connection->resource->write_ordering >= WO_BDEV_FLUSH) { 1281c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1282f9ff0da5SLars Ellenberg struct issue_flush_context ctx; 12834b0007c0SPhilipp Reisner int vnr; 1284b411b363SPhilipp Reisner 1285f9ff0da5SLars Ellenberg atomic_set(&ctx.pending, 1); 1286f9ff0da5SLars Ellenberg ctx.error = 0; 1287f9ff0da5SLars Ellenberg init_completion(&ctx.done); 1288f9ff0da5SLars Ellenberg 1289615e087fSLars Ellenberg rcu_read_lock(); 1290c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1291c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1292c06ece6bSAndreas Gruenbacher 1293b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1294615e087fSLars Ellenberg continue; 1295b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1296615e087fSLars Ellenberg rcu_read_unlock(); 12974b0007c0SPhilipp Reisner 1298f9ff0da5SLars Ellenberg submit_one_flush(device, &ctx); 1299f9ff0da5SLars Ellenberg 1300f9ff0da5SLars Ellenberg rcu_read_lock(); 1301f9ff0da5SLars Ellenberg } 1302f9ff0da5SLars Ellenberg rcu_read_unlock(); 1303f9ff0da5SLars Ellenberg 1304f9ff0da5SLars Ellenberg /* Do we want to add a timeout, 1305f9ff0da5SLars Ellenberg * if disk-timeout is set? */ 1306f9ff0da5SLars Ellenberg if (!atomic_dec_and_test(&ctx.pending)) 1307f9ff0da5SLars Ellenberg wait_for_completion(&ctx.done); 1308f9ff0da5SLars Ellenberg 1309f9ff0da5SLars Ellenberg if (ctx.error) { 1310b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1311b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1312b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1313f9ff0da5SLars Ellenberg /* Any error is already reported by bio_endio callback. */ 1314f6ba8636SAndreas Gruenbacher drbd_bump_write_ordering(connection->resource, NULL, WO_DRAIN_IO); 1315b411b363SPhilipp Reisner } 1316b411b363SPhilipp Reisner } 1317b411b363SPhilipp Reisner } 1318b411b363SPhilipp Reisner 1319b411b363SPhilipp Reisner /** 1320b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1321b30ab791SAndreas Gruenbacher * @device: DRBD device. 1322b411b363SPhilipp Reisner * @epoch: Epoch object. 1323b411b363SPhilipp Reisner * @ev: Epoch event. 1324b411b363SPhilipp Reisner */ 1325bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1326b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1327b411b363SPhilipp Reisner enum epoch_event ev) 1328b411b363SPhilipp Reisner { 13292451fc3bSPhilipp Reisner int epoch_size; 1330b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1331b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1332b411b363SPhilipp Reisner 1333bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1334b411b363SPhilipp Reisner do { 1335b411b363SPhilipp Reisner next_epoch = NULL; 1336b411b363SPhilipp Reisner 1337b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1338b411b363SPhilipp Reisner 1339b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1340b411b363SPhilipp Reisner case EV_PUT: 1341b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1342b411b363SPhilipp Reisner break; 1343b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1344b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1345b411b363SPhilipp Reisner break; 1346b411b363SPhilipp Reisner case EV_BECAME_LAST: 1347b411b363SPhilipp Reisner /* nothing to do*/ 1348b411b363SPhilipp Reisner break; 1349b411b363SPhilipp Reisner } 1350b411b363SPhilipp Reisner 1351b411b363SPhilipp Reisner if (epoch_size != 0 && 1352b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 135380f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1354b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1355bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1356bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1357bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1358b411b363SPhilipp Reisner } 13599ed57dcbSLars Ellenberg #if 0 13609ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 13619ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 136280f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1363bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 13649ed57dcbSLars Ellenberg #endif 1365b411b363SPhilipp Reisner 1366bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1367b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1368b411b363SPhilipp Reisner list_del(&epoch->list); 1369b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1370bde89a9eSAndreas Gruenbacher connection->epochs--; 1371b411b363SPhilipp Reisner kfree(epoch); 1372b411b363SPhilipp Reisner 1373b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1374b411b363SPhilipp Reisner rv = FE_DESTROYED; 1375b411b363SPhilipp Reisner } else { 1376b411b363SPhilipp Reisner epoch->flags = 0; 1377b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1378698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1379b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1380b411b363SPhilipp Reisner rv = FE_RECYCLED; 1381b411b363SPhilipp Reisner } 1382b411b363SPhilipp Reisner } 1383b411b363SPhilipp Reisner 1384b411b363SPhilipp Reisner if (!next_epoch) 1385b411b363SPhilipp Reisner break; 1386b411b363SPhilipp Reisner 1387b411b363SPhilipp Reisner epoch = next_epoch; 1388b411b363SPhilipp Reisner } while (1); 1389b411b363SPhilipp Reisner 1390bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1391b411b363SPhilipp Reisner 1392b411b363SPhilipp Reisner return rv; 1393b411b363SPhilipp Reisner } 1394b411b363SPhilipp Reisner 13958fe39aacSPhilipp Reisner static enum write_ordering_e 13968fe39aacSPhilipp Reisner max_allowed_wo(struct drbd_backing_dev *bdev, enum write_ordering_e wo) 13978fe39aacSPhilipp Reisner { 13988fe39aacSPhilipp Reisner struct disk_conf *dc; 13998fe39aacSPhilipp Reisner 14008fe39aacSPhilipp Reisner dc = rcu_dereference(bdev->disk_conf); 14018fe39aacSPhilipp Reisner 1402f6ba8636SAndreas Gruenbacher if (wo == WO_BDEV_FLUSH && !dc->disk_flushes) 1403f6ba8636SAndreas Gruenbacher wo = WO_DRAIN_IO; 1404f6ba8636SAndreas Gruenbacher if (wo == WO_DRAIN_IO && !dc->disk_drain) 1405f6ba8636SAndreas Gruenbacher wo = WO_NONE; 14068fe39aacSPhilipp Reisner 14078fe39aacSPhilipp Reisner return wo; 14088fe39aacSPhilipp Reisner } 14098fe39aacSPhilipp Reisner 1410b411b363SPhilipp Reisner /** 1411b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1412bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1413b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1414b411b363SPhilipp Reisner */ 14158fe39aacSPhilipp Reisner void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, 14168fe39aacSPhilipp Reisner enum write_ordering_e wo) 1417b411b363SPhilipp Reisner { 1418e9526580SPhilipp Reisner struct drbd_device *device; 1419b411b363SPhilipp Reisner enum write_ordering_e pwo; 14204b0007c0SPhilipp Reisner int vnr; 1421b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1422f6ba8636SAndreas Gruenbacher [WO_NONE] = "none", 1423f6ba8636SAndreas Gruenbacher [WO_DRAIN_IO] = "drain", 1424f6ba8636SAndreas Gruenbacher [WO_BDEV_FLUSH] = "flush", 1425b411b363SPhilipp Reisner }; 1426b411b363SPhilipp Reisner 1427e9526580SPhilipp Reisner pwo = resource->write_ordering; 1428f6ba8636SAndreas Gruenbacher if (wo != WO_BDEV_FLUSH) 1429b411b363SPhilipp Reisner wo = min(pwo, wo); 1430daeda1ccSPhilipp Reisner rcu_read_lock(); 1431e9526580SPhilipp Reisner idr_for_each_entry(&resource->devices, device, vnr) { 14328fe39aacSPhilipp Reisner if (get_ldev(device)) { 14338fe39aacSPhilipp Reisner wo = max_allowed_wo(device->ldev, wo); 14348fe39aacSPhilipp Reisner if (device->ldev == bdev) 14358fe39aacSPhilipp Reisner bdev = NULL; 1436b30ab791SAndreas Gruenbacher put_ldev(device); 14374b0007c0SPhilipp Reisner } 14388fe39aacSPhilipp Reisner } 14398fe39aacSPhilipp Reisner 14408fe39aacSPhilipp Reisner if (bdev) 14418fe39aacSPhilipp Reisner wo = max_allowed_wo(bdev, wo); 14428fe39aacSPhilipp Reisner 144370df7092SLars Ellenberg rcu_read_unlock(); 144470df7092SLars Ellenberg 1445e9526580SPhilipp Reisner resource->write_ordering = wo; 1446f6ba8636SAndreas Gruenbacher if (pwo != resource->write_ordering || wo == WO_BDEV_FLUSH) 1447e9526580SPhilipp Reisner drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]); 1448b411b363SPhilipp Reisner } 1449b411b363SPhilipp Reisner 1450dd4f699dSLars Ellenberg /* 1451dd4f699dSLars Ellenberg * We *may* ignore the discard-zeroes-data setting, if so configured. 1452dd4f699dSLars Ellenberg * 1453dd4f699dSLars Ellenberg * Assumption is that it "discard_zeroes_data=0" is only because the backend 1454dd4f699dSLars Ellenberg * may ignore partial unaligned discards. 1455dd4f699dSLars Ellenberg * 1456dd4f699dSLars Ellenberg * LVM/DM thin as of at least 1457dd4f699dSLars Ellenberg * LVM version: 2.02.115(2)-RHEL7 (2015-01-28) 1458dd4f699dSLars Ellenberg * Library version: 1.02.93-RHEL7 (2015-01-28) 1459dd4f699dSLars Ellenberg * Driver version: 4.29.0 1460dd4f699dSLars Ellenberg * still behaves this way. 1461dd4f699dSLars Ellenberg * 1462dd4f699dSLars Ellenberg * For unaligned (wrt. alignment and granularity) or too small discards, 1463dd4f699dSLars Ellenberg * we zero-out the initial (and/or) trailing unaligned partial chunks, 1464dd4f699dSLars Ellenberg * but discard all the aligned full chunks. 1465dd4f699dSLars Ellenberg * 1466dd4f699dSLars Ellenberg * At least for LVM/DM thin, the result is effectively "discard_zeroes_data=1". 1467dd4f699dSLars Ellenberg */ 1468dd4f699dSLars Ellenberg int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, unsigned int nr_sectors, bool discard) 1469dd4f699dSLars Ellenberg { 1470dd4f699dSLars Ellenberg struct block_device *bdev = device->ldev->backing_bdev; 1471dd4f699dSLars Ellenberg struct request_queue *q = bdev_get_queue(bdev); 1472dd4f699dSLars Ellenberg sector_t tmp, nr; 1473dd4f699dSLars Ellenberg unsigned int max_discard_sectors, granularity; 1474dd4f699dSLars Ellenberg int alignment; 1475dd4f699dSLars Ellenberg int err = 0; 1476dd4f699dSLars Ellenberg 1477dd4f699dSLars Ellenberg if (!discard) 1478dd4f699dSLars Ellenberg goto zero_out; 1479dd4f699dSLars Ellenberg 1480dd4f699dSLars Ellenberg /* Zero-sector (unknown) and one-sector granularities are the same. */ 1481dd4f699dSLars Ellenberg granularity = max(q->limits.discard_granularity >> 9, 1U); 1482dd4f699dSLars Ellenberg alignment = (bdev_discard_alignment(bdev) >> 9) % granularity; 1483dd4f699dSLars Ellenberg 1484dd4f699dSLars Ellenberg max_discard_sectors = min(q->limits.max_discard_sectors, (1U << 22)); 1485dd4f699dSLars Ellenberg max_discard_sectors -= max_discard_sectors % granularity; 1486dd4f699dSLars Ellenberg if (unlikely(!max_discard_sectors)) 1487dd4f699dSLars Ellenberg goto zero_out; 1488dd4f699dSLars Ellenberg 1489dd4f699dSLars Ellenberg if (nr_sectors < granularity) 1490dd4f699dSLars Ellenberg goto zero_out; 1491dd4f699dSLars Ellenberg 1492dd4f699dSLars Ellenberg tmp = start; 1493dd4f699dSLars Ellenberg if (sector_div(tmp, granularity) != alignment) { 1494dd4f699dSLars Ellenberg if (nr_sectors < 2*granularity) 1495dd4f699dSLars Ellenberg goto zero_out; 1496dd4f699dSLars Ellenberg /* start + gran - (start + gran - align) % gran */ 1497dd4f699dSLars Ellenberg tmp = start + granularity - alignment; 1498dd4f699dSLars Ellenberg tmp = start + granularity - sector_div(tmp, granularity); 1499dd4f699dSLars Ellenberg 1500dd4f699dSLars Ellenberg nr = tmp - start; 1501dd4f699dSLars Ellenberg err |= blkdev_issue_zeroout(bdev, start, nr, GFP_NOIO, 0); 1502dd4f699dSLars Ellenberg nr_sectors -= nr; 1503dd4f699dSLars Ellenberg start = tmp; 1504dd4f699dSLars Ellenberg } 1505dd4f699dSLars Ellenberg while (nr_sectors >= granularity) { 1506dd4f699dSLars Ellenberg nr = min_t(sector_t, nr_sectors, max_discard_sectors); 1507dd4f699dSLars Ellenberg err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO, 0); 1508dd4f699dSLars Ellenberg nr_sectors -= nr; 1509dd4f699dSLars Ellenberg start += nr; 1510dd4f699dSLars Ellenberg } 1511dd4f699dSLars Ellenberg zero_out: 1512dd4f699dSLars Ellenberg if (nr_sectors) { 1513dd4f699dSLars Ellenberg err |= blkdev_issue_zeroout(bdev, start, nr_sectors, GFP_NOIO, 0); 1514dd4f699dSLars Ellenberg } 1515dd4f699dSLars Ellenberg return err != 0; 1516dd4f699dSLars Ellenberg } 1517dd4f699dSLars Ellenberg 1518dd4f699dSLars Ellenberg static bool can_do_reliable_discards(struct drbd_device *device) 1519dd4f699dSLars Ellenberg { 1520dd4f699dSLars Ellenberg struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); 1521dd4f699dSLars Ellenberg struct disk_conf *dc; 1522dd4f699dSLars Ellenberg bool can_do; 1523dd4f699dSLars Ellenberg 1524dd4f699dSLars Ellenberg if (!blk_queue_discard(q)) 1525dd4f699dSLars Ellenberg return false; 1526dd4f699dSLars Ellenberg 1527dd4f699dSLars Ellenberg if (q->limits.discard_zeroes_data) 1528dd4f699dSLars Ellenberg return true; 1529dd4f699dSLars Ellenberg 1530dd4f699dSLars Ellenberg rcu_read_lock(); 1531dd4f699dSLars Ellenberg dc = rcu_dereference(device->ldev->disk_conf); 1532dd4f699dSLars Ellenberg can_do = dc->discard_zeroes_if_aligned; 1533dd4f699dSLars Ellenberg rcu_read_unlock(); 1534dd4f699dSLars Ellenberg return can_do; 1535dd4f699dSLars Ellenberg } 1536dd4f699dSLars Ellenberg 15379104d31aSLars Ellenberg static void drbd_issue_peer_discard(struct drbd_device *device, struct drbd_peer_request *peer_req) 1538dd4f699dSLars Ellenberg { 1539dd4f699dSLars Ellenberg /* If the backend cannot discard, or does not guarantee 1540dd4f699dSLars Ellenberg * read-back zeroes in discarded ranges, we fall back to 1541dd4f699dSLars Ellenberg * zero-out. Unless configuration specifically requested 1542dd4f699dSLars Ellenberg * otherwise. */ 1543dd4f699dSLars Ellenberg if (!can_do_reliable_discards(device)) 1544dd4f699dSLars Ellenberg peer_req->flags |= EE_IS_TRIM_USE_ZEROOUT; 1545dd4f699dSLars Ellenberg 1546dd4f699dSLars Ellenberg if (drbd_issue_discard_or_zero_out(device, peer_req->i.sector, 1547dd4f699dSLars Ellenberg peer_req->i.size >> 9, !(peer_req->flags & EE_IS_TRIM_USE_ZEROOUT))) 1548dd4f699dSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 1549dd4f699dSLars Ellenberg drbd_endio_write_sec_final(peer_req); 1550dd4f699dSLars Ellenberg } 1551dd4f699dSLars Ellenberg 15529104d31aSLars Ellenberg static void drbd_issue_peer_wsame(struct drbd_device *device, 15539104d31aSLars Ellenberg struct drbd_peer_request *peer_req) 15549104d31aSLars Ellenberg { 15559104d31aSLars Ellenberg struct block_device *bdev = device->ldev->backing_bdev; 15569104d31aSLars Ellenberg sector_t s = peer_req->i.sector; 15579104d31aSLars Ellenberg sector_t nr = peer_req->i.size >> 9; 15589104d31aSLars Ellenberg if (blkdev_issue_write_same(bdev, s, nr, GFP_NOIO, peer_req->pages)) 15599104d31aSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 15609104d31aSLars Ellenberg drbd_endio_write_sec_final(peer_req); 15619104d31aSLars Ellenberg } 15629104d31aSLars Ellenberg 15639104d31aSLars Ellenberg 1564b411b363SPhilipp Reisner /** 1565fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1566b30ab791SAndreas Gruenbacher * @device: DRBD device. 1567db830c46SAndreas Gruenbacher * @peer_req: peer request 15681eff9d32SJens Axboe * @rw: flag field, see bio->bi_opf 156910f6d992SLars Ellenberg * 157010f6d992SLars Ellenberg * May spread the pages to multiple bios, 157110f6d992SLars Ellenberg * depending on bio_add_page restrictions. 157210f6d992SLars Ellenberg * 157310f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 157410f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 157510f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 157610f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 157710f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 157810f6d992SLars Ellenberg * on certain Xen deployments. 157945bb912bSLars Ellenberg */ 158045bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1581b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1582fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 1583bb3cc85eSMike Christie const unsigned op, const unsigned op_flags, 1584bb3cc85eSMike Christie const int fault_type) 158545bb912bSLars Ellenberg { 158645bb912bSLars Ellenberg struct bio *bios = NULL; 158745bb912bSLars Ellenberg struct bio *bio; 1588db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1589db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 159011f8b2b6SAndreas Gruenbacher unsigned data_size = peer_req->i.size; 159145bb912bSLars Ellenberg unsigned n_bios = 0; 159211f8b2b6SAndreas Gruenbacher unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 159310f6d992SLars Ellenberg int err = -ENOMEM; 159445bb912bSLars Ellenberg 1595dd4f699dSLars Ellenberg /* TRIM/DISCARD: for now, always use the helper function 1596dd4f699dSLars Ellenberg * blkdev_issue_zeroout(..., discard=true). 1597dd4f699dSLars Ellenberg * It's synchronous, but it does the right thing wrt. bio splitting. 1598dd4f699dSLars Ellenberg * Correctness first, performance later. Next step is to code an 1599dd4f699dSLars Ellenberg * asynchronous variant of the same. 1600dd4f699dSLars Ellenberg */ 16019104d31aSLars Ellenberg if (peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) { 1602a0fb3c47SLars Ellenberg /* wait for all pending IO completions, before we start 1603a0fb3c47SLars Ellenberg * zeroing things out. */ 16045dd2ca19SAndreas Gruenbacher conn_wait_active_ee_empty(peer_req->peer_device->connection); 160545d2933cSLars Ellenberg /* add it to the active list now, 160645d2933cSLars Ellenberg * so we can find it to present it in debugfs */ 160721ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 160821ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 1609700ca8c0SPhilipp Reisner 1610700ca8c0SPhilipp Reisner /* If this was a resync request from receive_rs_deallocated(), 1611700ca8c0SPhilipp Reisner * it is already on the sync_ee list */ 1612700ca8c0SPhilipp Reisner if (list_empty(&peer_req->w.list)) { 161345d2933cSLars Ellenberg spin_lock_irq(&device->resource->req_lock); 161445d2933cSLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 161545d2933cSLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 1616700ca8c0SPhilipp Reisner } 1617700ca8c0SPhilipp Reisner 16189104d31aSLars Ellenberg if (peer_req->flags & EE_IS_TRIM) 1619dd4f699dSLars Ellenberg drbd_issue_peer_discard(device, peer_req); 16209104d31aSLars Ellenberg else /* EE_WRITE_SAME */ 16219104d31aSLars Ellenberg drbd_issue_peer_wsame(device, peer_req); 1622a0fb3c47SLars Ellenberg return 0; 1623a0fb3c47SLars Ellenberg } 1624a0fb3c47SLars Ellenberg 162545bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 162645bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 162745bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 16289476f39dSLars Ellenberg * request in more than one bio. 16299476f39dSLars Ellenberg * 16309476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 16319476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 16329476f39dSLars Ellenberg */ 163345bb912bSLars Ellenberg next_bio: 163445bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 163545bb912bSLars Ellenberg if (!bio) { 1636a0fb3c47SLars Ellenberg drbd_err(device, "submit_ee: Allocation of a bio failed (nr_pages=%u)\n", nr_pages); 163745bb912bSLars Ellenberg goto fail; 163845bb912bSLars Ellenberg } 1639db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 16404f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 1641b30ab791SAndreas Gruenbacher bio->bi_bdev = device->ldev->backing_bdev; 1642bb3cc85eSMike Christie bio_set_op_attrs(bio, op, op_flags); 1643db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1644fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 164545bb912bSLars Ellenberg 164645bb912bSLars Ellenberg bio->bi_next = bios; 164745bb912bSLars Ellenberg bios = bio; 164845bb912bSLars Ellenberg ++n_bios; 164945bb912bSLars Ellenberg 165045bb912bSLars Ellenberg page_chain_for_each(page) { 165111f8b2b6SAndreas Gruenbacher unsigned len = min_t(unsigned, data_size, PAGE_SIZE); 165206efffdaSMing Lei if (!bio_add_page(bio, page, len, 0)) 165345bb912bSLars Ellenberg goto next_bio; 165411f8b2b6SAndreas Gruenbacher data_size -= len; 165545bb912bSLars Ellenberg sector += len >> 9; 165645bb912bSLars Ellenberg --nr_pages; 165745bb912bSLars Ellenberg } 165811f8b2b6SAndreas Gruenbacher D_ASSERT(device, data_size == 0); 1659a0fb3c47SLars Ellenberg D_ASSERT(device, page == NULL); 166045bb912bSLars Ellenberg 1661db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 166221ae5d7fSLars Ellenberg /* for debugfs: update timestamp, mark as submitted */ 166321ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 166421ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 166545bb912bSLars Ellenberg do { 166645bb912bSLars Ellenberg bio = bios; 166745bb912bSLars Ellenberg bios = bios->bi_next; 166845bb912bSLars Ellenberg bio->bi_next = NULL; 166945bb912bSLars Ellenberg 1670b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 167145bb912bSLars Ellenberg } while (bios); 167245bb912bSLars Ellenberg return 0; 167345bb912bSLars Ellenberg 167445bb912bSLars Ellenberg fail: 167545bb912bSLars Ellenberg while (bios) { 167645bb912bSLars Ellenberg bio = bios; 167745bb912bSLars Ellenberg bios = bios->bi_next; 167845bb912bSLars Ellenberg bio_put(bio); 167945bb912bSLars Ellenberg } 168010f6d992SLars Ellenberg return err; 168145bb912bSLars Ellenberg } 168245bb912bSLars Ellenberg 1683b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1684db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 168553840641SAndreas Gruenbacher { 1686db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 168753840641SAndreas Gruenbacher 1688b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 168953840641SAndreas Gruenbacher drbd_clear_interval(i); 169053840641SAndreas Gruenbacher 16916c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 169253840641SAndreas Gruenbacher if (i->waiting) 1693b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 169453840641SAndreas Gruenbacher } 169553840641SAndreas Gruenbacher 1696bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 169777fede51SPhilipp Reisner { 1698c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 169977fede51SPhilipp Reisner int vnr; 170077fede51SPhilipp Reisner 170177fede51SPhilipp Reisner rcu_read_lock(); 1702c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1703c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1704c06ece6bSAndreas Gruenbacher 1705b30ab791SAndreas Gruenbacher kref_get(&device->kref); 170677fede51SPhilipp Reisner rcu_read_unlock(); 1707b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 170805a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 170977fede51SPhilipp Reisner rcu_read_lock(); 171077fede51SPhilipp Reisner } 171177fede51SPhilipp Reisner rcu_read_unlock(); 171277fede51SPhilipp Reisner } 171377fede51SPhilipp Reisner 1714bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1715b411b363SPhilipp Reisner { 17162451fc3bSPhilipp Reisner int rv; 1717e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1718b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1719b411b363SPhilipp Reisner 17209ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 17219ed57dcbSLars Ellenberg * not a specific (peer)device. 17229ed57dcbSLars Ellenberg */ 1723bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1724bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1725bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1726b411b363SPhilipp Reisner 1727b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1728b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1729b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1730b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1731b411b363SPhilipp Reisner * completed. */ 1732e9526580SPhilipp Reisner switch (connection->resource->write_ordering) { 1733f6ba8636SAndreas Gruenbacher case WO_NONE: 1734b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 173582bc0194SAndreas Gruenbacher return 0; 1736b411b363SPhilipp Reisner 1737b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1738b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1739b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 17402451fc3bSPhilipp Reisner if (epoch) 17412451fc3bSPhilipp Reisner break; 17422451fc3bSPhilipp Reisner else 17431ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 17442451fc3bSPhilipp Reisner /* Fall through */ 17452451fc3bSPhilipp Reisner 1746f6ba8636SAndreas Gruenbacher case WO_BDEV_FLUSH: 1747f6ba8636SAndreas Gruenbacher case WO_DRAIN_IO: 1748bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1749bde89a9eSAndreas Gruenbacher drbd_flush(connection); 17502451fc3bSPhilipp Reisner 1751bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 17522451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 17532451fc3bSPhilipp Reisner if (epoch) 17542451fc3bSPhilipp Reisner break; 1755b411b363SPhilipp Reisner } 1756b411b363SPhilipp Reisner 175782bc0194SAndreas Gruenbacher return 0; 17582451fc3bSPhilipp Reisner default: 1759e9526580SPhilipp Reisner drbd_err(connection, "Strangeness in connection->write_ordering %d\n", 1760e9526580SPhilipp Reisner connection->resource->write_ordering); 176182bc0194SAndreas Gruenbacher return -EIO; 1762b411b363SPhilipp Reisner } 1763b411b363SPhilipp Reisner 1764b411b363SPhilipp Reisner epoch->flags = 0; 1765b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1766b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1767b411b363SPhilipp Reisner 1768bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1769bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1770bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1771bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1772bde89a9eSAndreas Gruenbacher connection->epochs++; 1773b411b363SPhilipp Reisner } else { 1774b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1775b411b363SPhilipp Reisner kfree(epoch); 1776b411b363SPhilipp Reisner } 1777bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1778b411b363SPhilipp Reisner 177982bc0194SAndreas Gruenbacher return 0; 1780b411b363SPhilipp Reisner } 1781b411b363SPhilipp Reisner 17829104d31aSLars Ellenberg /* quick wrapper in case payload size != request_size (write same) */ 17839104d31aSLars Ellenberg static void drbd_csum_ee_size(struct crypto_ahash *h, 17849104d31aSLars Ellenberg struct drbd_peer_request *r, void *d, 17859104d31aSLars Ellenberg unsigned int payload_size) 17869104d31aSLars Ellenberg { 17879104d31aSLars Ellenberg unsigned int tmp = r->i.size; 17889104d31aSLars Ellenberg r->i.size = payload_size; 17899104d31aSLars Ellenberg drbd_csum_ee(h, r, d); 17909104d31aSLars Ellenberg r->i.size = tmp; 17919104d31aSLars Ellenberg } 17929104d31aSLars Ellenberg 1793b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 17949104d31aSLars Ellenberg * and from receive_Data. 17959104d31aSLars Ellenberg * data_size: actual payload ("data in") 17969104d31aSLars Ellenberg * for normal writes that is bi_size. 17979104d31aSLars Ellenberg * for discards, that is zero. 17989104d31aSLars Ellenberg * for write same, it is logical_block_size. 17999104d31aSLars Ellenberg * both trim and write same have the bi_size ("data len to be affected") 18009104d31aSLars Ellenberg * as extra argument in the packet header. 18019104d31aSLars Ellenberg */ 1802f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 180369a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1804a0fb3c47SLars Ellenberg struct packet_info *pi) __must_hold(local) 1805b411b363SPhilipp Reisner { 180669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1807b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1808db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1809b411b363SPhilipp Reisner struct page *page; 181011f8b2b6SAndreas Gruenbacher int digest_size, err; 181111f8b2b6SAndreas Gruenbacher unsigned int data_size = pi->size, ds; 181269a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 181369a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 18146b4388acSPhilipp Reisner unsigned long *data; 1815a0fb3c47SLars Ellenberg struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; 18169104d31aSLars Ellenberg struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL; 1817b411b363SPhilipp Reisner 181811f8b2b6SAndreas Gruenbacher digest_size = 0; 1819a0fb3c47SLars Ellenberg if (!trim && peer_device->connection->peer_integrity_tfm) { 18209534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 18219f5bdc33SAndreas Gruenbacher /* 18229f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 18239f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 18249f5bdc33SAndreas Gruenbacher */ 182511f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1826a5c31904SAndreas Gruenbacher if (err) 1827b411b363SPhilipp Reisner return NULL; 182811f8b2b6SAndreas Gruenbacher data_size -= digest_size; 182988104ca4SAndreas Gruenbacher } 1830b411b363SPhilipp Reisner 18319104d31aSLars Ellenberg /* assume request_size == data_size, but special case trim and wsame. */ 18329104d31aSLars Ellenberg ds = data_size; 1833a0fb3c47SLars Ellenberg if (trim) { 18349104d31aSLars Ellenberg if (!expect(data_size == 0)) 18359104d31aSLars Ellenberg return NULL; 18369104d31aSLars Ellenberg ds = be32_to_cpu(trim->size); 18379104d31aSLars Ellenberg } else if (wsame) { 18389104d31aSLars Ellenberg if (data_size != queue_logical_block_size(device->rq_queue)) { 18399104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n", 18409104d31aSLars Ellenberg data_size, queue_logical_block_size(device->rq_queue)); 18419104d31aSLars Ellenberg return NULL; 18429104d31aSLars Ellenberg } 18439104d31aSLars Ellenberg if (data_size != bdev_logical_block_size(device->ldev->backing_bdev)) { 18449104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != backend logical block size (%u)\n", 18459104d31aSLars Ellenberg data_size, bdev_logical_block_size(device->ldev->backing_bdev)); 18469104d31aSLars Ellenberg return NULL; 18479104d31aSLars Ellenberg } 18489104d31aSLars Ellenberg ds = be32_to_cpu(wsame->size); 1849a0fb3c47SLars Ellenberg } 1850a0fb3c47SLars Ellenberg 18519104d31aSLars Ellenberg if (!expect(IS_ALIGNED(ds, 512))) 1852841ce241SAndreas Gruenbacher return NULL; 18539104d31aSLars Ellenberg if (trim || wsame) { 18549104d31aSLars Ellenberg if (!expect(ds <= (DRBD_MAX_BBIO_SECTORS << 9))) 18559104d31aSLars Ellenberg return NULL; 18569104d31aSLars Ellenberg } else if (!expect(ds <= DRBD_MAX_BIO_SIZE)) 1857841ce241SAndreas Gruenbacher return NULL; 1858b411b363SPhilipp Reisner 18596666032aSLars Ellenberg /* even though we trust out peer, 18606666032aSLars Ellenberg * we sometimes have to double check. */ 18619104d31aSLars Ellenberg if (sector + (ds>>9) > capacity) { 1862d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1863fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 18646666032aSLars Ellenberg (unsigned long long)capacity, 18659104d31aSLars Ellenberg (unsigned long long)sector, ds); 18666666032aSLars Ellenberg return NULL; 18676666032aSLars Ellenberg } 18686666032aSLars Ellenberg 1869b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1870b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1871b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 18729104d31aSLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, id, sector, ds, data_size, GFP_NOIO); 1873db830c46SAndreas Gruenbacher if (!peer_req) 1874b411b363SPhilipp Reisner return NULL; 187545bb912bSLars Ellenberg 187621ae5d7fSLars Ellenberg peer_req->flags |= EE_WRITE; 18779104d31aSLars Ellenberg if (trim) { 18789104d31aSLars Ellenberg peer_req->flags |= EE_IS_TRIM; 187981a3537aSLars Ellenberg return peer_req; 18809104d31aSLars Ellenberg } 18819104d31aSLars Ellenberg if (wsame) 18829104d31aSLars Ellenberg peer_req->flags |= EE_WRITE_SAME; 1883a73ff323SLars Ellenberg 18849104d31aSLars Ellenberg /* receive payload size bytes into page chain */ 1885b411b363SPhilipp Reisner ds = data_size; 1886db830c46SAndreas Gruenbacher page = peer_req->pages; 188745bb912bSLars Ellenberg page_chain_for_each(page) { 188845bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 18896b4388acSPhilipp Reisner data = kmap(page); 189069a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1891b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1892d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 18936b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 18946b4388acSPhilipp Reisner } 1895b411b363SPhilipp Reisner kunmap(page); 1896a5c31904SAndreas Gruenbacher if (err) { 1897b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1898b411b363SPhilipp Reisner return NULL; 1899b411b363SPhilipp Reisner } 1900a5c31904SAndreas Gruenbacher ds -= len; 1901b411b363SPhilipp Reisner } 1902b411b363SPhilipp Reisner 190311f8b2b6SAndreas Gruenbacher if (digest_size) { 19049104d31aSLars Ellenberg drbd_csum_ee_size(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv, data_size); 190511f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 1906d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1907470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1908b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1909b411b363SPhilipp Reisner return NULL; 1910b411b363SPhilipp Reisner } 1911b411b363SPhilipp Reisner } 1912b30ab791SAndreas Gruenbacher device->recv_cnt += data_size >> 9; 1913db830c46SAndreas Gruenbacher return peer_req; 1914b411b363SPhilipp Reisner } 1915b411b363SPhilipp Reisner 1916b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1917b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1918b411b363SPhilipp Reisner */ 191969a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1920b411b363SPhilipp Reisner { 1921b411b363SPhilipp Reisner struct page *page; 1922a5c31904SAndreas Gruenbacher int err = 0; 1923b411b363SPhilipp Reisner void *data; 1924b411b363SPhilipp Reisner 1925c3470cdeSLars Ellenberg if (!data_size) 1926fc5be839SAndreas Gruenbacher return 0; 1927c3470cdeSLars Ellenberg 192869a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1929b411b363SPhilipp Reisner 1930b411b363SPhilipp Reisner data = kmap(page); 1931b411b363SPhilipp Reisner while (data_size) { 1932fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1933fc5be839SAndreas Gruenbacher 193469a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1935a5c31904SAndreas Gruenbacher if (err) 1936b411b363SPhilipp Reisner break; 1937a5c31904SAndreas Gruenbacher data_size -= len; 1938b411b363SPhilipp Reisner } 1939b411b363SPhilipp Reisner kunmap(page); 194069a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1941fc5be839SAndreas Gruenbacher return err; 1942b411b363SPhilipp Reisner } 1943b411b363SPhilipp Reisner 194469a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1945b411b363SPhilipp Reisner sector_t sector, int data_size) 1946b411b363SPhilipp Reisner { 19477988613bSKent Overstreet struct bio_vec bvec; 19487988613bSKent Overstreet struct bvec_iter iter; 1949b411b363SPhilipp Reisner struct bio *bio; 195011f8b2b6SAndreas Gruenbacher int digest_size, err, expect; 195169a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 195269a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1953b411b363SPhilipp Reisner 195411f8b2b6SAndreas Gruenbacher digest_size = 0; 195569a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 19569534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 195711f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1958a5c31904SAndreas Gruenbacher if (err) 1959a5c31904SAndreas Gruenbacher return err; 196011f8b2b6SAndreas Gruenbacher data_size -= digest_size; 196188104ca4SAndreas Gruenbacher } 1962b411b363SPhilipp Reisner 1963b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1964b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 196569a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1966b411b363SPhilipp Reisner 1967b411b363SPhilipp Reisner bio = req->master_bio; 196869a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1969b411b363SPhilipp Reisner 19707988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 19717988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 19727988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 197369a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 19747988613bSKent Overstreet kunmap(bvec.bv_page); 1975a5c31904SAndreas Gruenbacher if (err) 1976a5c31904SAndreas Gruenbacher return err; 1977a5c31904SAndreas Gruenbacher data_size -= expect; 1978b411b363SPhilipp Reisner } 1979b411b363SPhilipp Reisner 198011f8b2b6SAndreas Gruenbacher if (digest_size) { 198169a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 198211f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 198369a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 198428284cefSAndreas Gruenbacher return -EINVAL; 1985b411b363SPhilipp Reisner } 1986b411b363SPhilipp Reisner } 1987b411b363SPhilipp Reisner 198869a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 198928284cefSAndreas Gruenbacher return 0; 1990b411b363SPhilipp Reisner } 1991b411b363SPhilipp Reisner 1992a990be46SAndreas Gruenbacher /* 1993668700b4SPhilipp Reisner * e_end_resync_block() is called in ack_sender context via 1994a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1995a990be46SAndreas Gruenbacher */ 199699920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1997b411b363SPhilipp Reisner { 19988050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1999a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2000a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 2001a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2002db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 200399920dc5SAndreas Gruenbacher int err; 2004b411b363SPhilipp Reisner 20050b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 2006b411b363SPhilipp Reisner 2007db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 2008b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 2009a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 2010b411b363SPhilipp Reisner } else { 2011b411b363SPhilipp Reisner /* Record failure to sync */ 2012b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 2013b411b363SPhilipp Reisner 2014a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 2015b411b363SPhilipp Reisner } 2016b30ab791SAndreas Gruenbacher dec_unacked(device); 2017b411b363SPhilipp Reisner 201899920dc5SAndreas Gruenbacher return err; 2019b411b363SPhilipp Reisner } 2020b411b363SPhilipp Reisner 202169a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 2022a0fb3c47SLars Ellenberg struct packet_info *pi) __releases(local) 2023b411b363SPhilipp Reisner { 202469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2025db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2026b411b363SPhilipp Reisner 2027a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi); 2028db830c46SAndreas Gruenbacher if (!peer_req) 202945bb912bSLars Ellenberg goto fail; 2030b411b363SPhilipp Reisner 2031b30ab791SAndreas Gruenbacher dec_rs_pending(device); 2032b411b363SPhilipp Reisner 2033b30ab791SAndreas Gruenbacher inc_unacked(device); 2034b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 2035b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2036b411b363SPhilipp Reisner 2037a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 203821ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 203945bb912bSLars Ellenberg 20400500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2041b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->sync_ee); 20420500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2043b411b363SPhilipp Reisner 2044a0fb3c47SLars Ellenberg atomic_add(pi->size >> 9, &device->rs_sect_ev); 2045bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_WRITE, 0, 2046bb3cc85eSMike Christie DRBD_FAULT_RS_WR) == 0) 2047e1c1b0fcSAndreas Gruenbacher return 0; 204845bb912bSLars Ellenberg 204910f6d992SLars Ellenberg /* don't care for the reason here */ 2050d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 20510500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2052a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 20530500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 205422cc37a9SLars Ellenberg 2055b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 205645bb912bSLars Ellenberg fail: 2057b30ab791SAndreas Gruenbacher put_ldev(device); 2058e1c1b0fcSAndreas Gruenbacher return -EIO; 2059b411b363SPhilipp Reisner } 2060b411b363SPhilipp Reisner 2061668eebc6SAndreas Gruenbacher static struct drbd_request * 2062b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 2063bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 2064b411b363SPhilipp Reisner { 2065b411b363SPhilipp Reisner struct drbd_request *req; 2066668eebc6SAndreas Gruenbacher 2067bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 2068bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 20695e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 2070668eebc6SAndreas Gruenbacher return req; 2071c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 2072d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 2073c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 2074c3afd8f5SAndreas Gruenbacher } 2075668eebc6SAndreas Gruenbacher return NULL; 2076668eebc6SAndreas Gruenbacher } 2077668eebc6SAndreas Gruenbacher 2078bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 2079b411b363SPhilipp Reisner { 20809f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2081b30ab791SAndreas Gruenbacher struct drbd_device *device; 2082b411b363SPhilipp Reisner struct drbd_request *req; 2083b411b363SPhilipp Reisner sector_t sector; 208482bc0194SAndreas Gruenbacher int err; 2085e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20864a76b161SAndreas Gruenbacher 20879f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 20889f4fe9adSAndreas Gruenbacher if (!peer_device) 20894a76b161SAndreas Gruenbacher return -EIO; 20909f4fe9adSAndreas Gruenbacher device = peer_device->device; 2091b411b363SPhilipp Reisner 2092b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2093b411b363SPhilipp Reisner 20940500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2095b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 20960500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2097c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 209882bc0194SAndreas Gruenbacher return -EIO; 2099b411b363SPhilipp Reisner 210024c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 2101b411b363SPhilipp Reisner * special casing it there for the various failure cases. 2102b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 210369a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 210482bc0194SAndreas Gruenbacher if (!err) 21058554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 2106b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 2107b411b363SPhilipp Reisner * I don't think we may complete this just yet 2108b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 2109b411b363SPhilipp Reisner 211082bc0194SAndreas Gruenbacher return err; 2111b411b363SPhilipp Reisner } 2112b411b363SPhilipp Reisner 2113bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 2114b411b363SPhilipp Reisner { 21159f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2116b30ab791SAndreas Gruenbacher struct drbd_device *device; 2117b411b363SPhilipp Reisner sector_t sector; 211882bc0194SAndreas Gruenbacher int err; 2119e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21204a76b161SAndreas Gruenbacher 21219f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 21229f4fe9adSAndreas Gruenbacher if (!peer_device) 21234a76b161SAndreas Gruenbacher return -EIO; 21249f4fe9adSAndreas Gruenbacher device = peer_device->device; 2125b411b363SPhilipp Reisner 2126b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 21270b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 2128b411b363SPhilipp Reisner 2129b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 2130b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 2131b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 2132fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 2133a0fb3c47SLars Ellenberg err = recv_resync_read(peer_device, sector, pi); 2134b411b363SPhilipp Reisner } else { 2135b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 2136d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 2137b411b363SPhilipp Reisner 213869a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 2139b411b363SPhilipp Reisner 214069a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2141b411b363SPhilipp Reisner } 2142b411b363SPhilipp Reisner 2143b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 2144778f271dSPhilipp Reisner 214582bc0194SAndreas Gruenbacher return err; 2146b411b363SPhilipp Reisner } 2147b411b363SPhilipp Reisner 2148b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 21497be8da07SAndreas Gruenbacher sector_t sector, int size) 2150b411b363SPhilipp Reisner { 21517be8da07SAndreas Gruenbacher struct drbd_interval *i; 21527be8da07SAndreas Gruenbacher struct drbd_request *req; 2153b411b363SPhilipp Reisner 2154b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21557be8da07SAndreas Gruenbacher if (!i->local) 21567be8da07SAndreas Gruenbacher continue; 21577be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 21587be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21597be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 21607be8da07SAndreas Gruenbacher continue; 21612312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 21622312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 2163d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 21647be8da07SAndreas Gruenbacher } 21657be8da07SAndreas Gruenbacher } 21667be8da07SAndreas Gruenbacher 2167a990be46SAndreas Gruenbacher /* 2168668700b4SPhilipp Reisner * e_end_block() is called in ack_sender context via drbd_finish_peer_reqs(). 2169b411b363SPhilipp Reisner */ 217099920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 2171b411b363SPhilipp Reisner { 21728050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2173a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2174a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 2175a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2176db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 217799920dc5SAndreas Gruenbacher int err = 0, pcmd; 2178b411b363SPhilipp Reisner 2179303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 2180db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 2181b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 2182b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 2183db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 2184b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 2185a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 2186b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 2187b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 2188b411b363SPhilipp Reisner } else { 2189a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 2190b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 2191b411b363SPhilipp Reisner * maybe assert this? */ 2192b411b363SPhilipp Reisner } 2193b30ab791SAndreas Gruenbacher dec_unacked(device); 2194b411b363SPhilipp Reisner } 219508d0dabfSLars Ellenberg 2196b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 2197b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 2198302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 21990500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 22000b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 2201b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 22027be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 2203b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 22040500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2205bb3bfe96SAndreas Gruenbacher } else 22060b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 2207b411b363SPhilipp Reisner 22085dd2ca19SAndreas Gruenbacher drbd_may_finish_epoch(peer_device->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 2209b411b363SPhilipp Reisner 221099920dc5SAndreas Gruenbacher return err; 2211b411b363SPhilipp Reisner } 2212b411b363SPhilipp Reisner 2213a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 2214b411b363SPhilipp Reisner { 22158050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2216a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2217a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 221899920dc5SAndreas Gruenbacher int err; 2219b411b363SPhilipp Reisner 2220a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 2221a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 2222b411b363SPhilipp Reisner 222399920dc5SAndreas Gruenbacher return err; 2224b411b363SPhilipp Reisner } 2225b411b363SPhilipp Reisner 2226d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 2227b6a370baSPhilipp Reisner { 2228a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 22297be8da07SAndreas Gruenbacher } 2230b6a370baSPhilipp Reisner 223199920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 22327be8da07SAndreas Gruenbacher { 2233a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 2234a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2235a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 22367be8da07SAndreas Gruenbacher 2237a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 2238d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 22397be8da07SAndreas Gruenbacher } 22407be8da07SAndreas Gruenbacher 22413e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 22423e394da1SAndreas Gruenbacher { 22433e394da1SAndreas Gruenbacher /* 22443e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 22453e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 22463e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 22473e394da1SAndreas Gruenbacher */ 22483e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 22493e394da1SAndreas Gruenbacher } 22503e394da1SAndreas Gruenbacher 22513e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 22523e394da1SAndreas Gruenbacher { 22533e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 22543e394da1SAndreas Gruenbacher } 22553e394da1SAndreas Gruenbacher 225669a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 22573e394da1SAndreas Gruenbacher { 225869a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 22593c13b680SLars Ellenberg unsigned int newest_peer_seq; 22603e394da1SAndreas Gruenbacher 226169a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 2262b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2263b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 2264b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 2265b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2266b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 22673c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 2268b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 22693e394da1SAndreas Gruenbacher } 22707be8da07SAndreas Gruenbacher } 22713e394da1SAndreas Gruenbacher 2272d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 2273d93f6302SLars Ellenberg { 2274d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 2275d93f6302SLars Ellenberg } 2276d93f6302SLars Ellenberg 2277d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 2278b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 2279d93f6302SLars Ellenberg { 2280d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 22817e5fec31SFabian Frederick bool rv = false; 2282b6a370baSPhilipp Reisner 22830500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2284a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 2285d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 2286d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 22877e5fec31SFabian Frederick rv = true; 2288b6a370baSPhilipp Reisner break; 2289b6a370baSPhilipp Reisner } 2290b6a370baSPhilipp Reisner } 22910500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2292b6a370baSPhilipp Reisner 2293b6a370baSPhilipp Reisner return rv; 2294b6a370baSPhilipp Reisner } 2295b6a370baSPhilipp Reisner 2296b411b363SPhilipp Reisner /* Called from receive_Data. 2297b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 2298b411b363SPhilipp Reisner * 2299b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 2300b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 2301b411b363SPhilipp Reisner * been sent. 2302b411b363SPhilipp Reisner * 2303b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 2304b411b363SPhilipp Reisner * 2305b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 2306b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 2307b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 2308b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 2309b411b363SPhilipp Reisner * 2310b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 2311b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 2312b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 2313b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 2314b411b363SPhilipp Reisner * 2315b411b363SPhilipp Reisner * returns 0 if we may process the packet, 2316b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 231769a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 2318b411b363SPhilipp Reisner { 231969a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2320b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2321b411b363SPhilipp Reisner long timeout; 2322b874d231SPhilipp Reisner int ret = 0, tp; 23237be8da07SAndreas Gruenbacher 232469a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 23257be8da07SAndreas Gruenbacher return 0; 23267be8da07SAndreas Gruenbacher 2327b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2328b411b363SPhilipp Reisner for (;;) { 2329b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 2330b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 2331b411b363SPhilipp Reisner break; 23327be8da07SAndreas Gruenbacher } 2333b874d231SPhilipp Reisner 2334b411b363SPhilipp Reisner if (signal_pending(current)) { 2335b411b363SPhilipp Reisner ret = -ERESTARTSYS; 2336b411b363SPhilipp Reisner break; 2337b411b363SPhilipp Reisner } 2338b874d231SPhilipp Reisner 2339b874d231SPhilipp Reisner rcu_read_lock(); 23405dd2ca19SAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2341b874d231SPhilipp Reisner rcu_read_unlock(); 2342b874d231SPhilipp Reisner 2343b874d231SPhilipp Reisner if (!tp) 2344b874d231SPhilipp Reisner break; 2345b874d231SPhilipp Reisner 2346b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2347b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2348b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 234944ed167dSPhilipp Reisner rcu_read_lock(); 235069a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 235144ed167dSPhilipp Reisner rcu_read_unlock(); 235271b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2353b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 23547be8da07SAndreas Gruenbacher if (!timeout) { 2355b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2356d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2357b411b363SPhilipp Reisner break; 2358b411b363SPhilipp Reisner } 2359b411b363SPhilipp Reisner } 2360b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2361b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2362b411b363SPhilipp Reisner return ret; 2363b411b363SPhilipp Reisner } 2364b411b363SPhilipp Reisner 2365688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2366688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2367688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2368bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_flags(u32 dpf) 236976d2e7ecSPhilipp Reisner { 237076d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 237176d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 237228a8f0d3SMike Christie (dpf & DP_FLUSH ? REQ_PREFLUSH : 0); 2373bb3cc85eSMike Christie } 2374bb3cc85eSMike Christie 2375bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_op(u32 dpf) 2376bb3cc85eSMike Christie { 2377bb3cc85eSMike Christie if (dpf & DP_DISCARD) 2378bb3cc85eSMike Christie return REQ_OP_DISCARD; 2379bb3cc85eSMike Christie else 2380bb3cc85eSMike Christie return REQ_OP_WRITE; 238176d2e7ecSPhilipp Reisner } 238276d2e7ecSPhilipp Reisner 2383b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 23847be8da07SAndreas Gruenbacher unsigned int size) 2385b411b363SPhilipp Reisner { 23867be8da07SAndreas Gruenbacher struct drbd_interval *i; 23877be8da07SAndreas Gruenbacher 23887be8da07SAndreas Gruenbacher repeat: 2389b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 23907be8da07SAndreas Gruenbacher struct drbd_request *req; 23917be8da07SAndreas Gruenbacher struct bio_and_error m; 23927be8da07SAndreas Gruenbacher 23937be8da07SAndreas Gruenbacher if (!i->local) 23947be8da07SAndreas Gruenbacher continue; 23957be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 23967be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 23977be8da07SAndreas Gruenbacher continue; 23987be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 23997be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 24000500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 24017be8da07SAndreas Gruenbacher if (m.bio) 2402b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 24030500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 24047be8da07SAndreas Gruenbacher goto repeat; 24057be8da07SAndreas Gruenbacher } 24067be8da07SAndreas Gruenbacher } 24077be8da07SAndreas Gruenbacher 2408b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 24097be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 24107be8da07SAndreas Gruenbacher { 2411e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2412bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 24137be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 24147be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 24157be8da07SAndreas Gruenbacher struct drbd_interval *i; 24167be8da07SAndreas Gruenbacher bool equal; 24177be8da07SAndreas Gruenbacher int err; 24187be8da07SAndreas Gruenbacher 24197be8da07SAndreas Gruenbacher /* 24207be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 24217be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 24227be8da07SAndreas Gruenbacher */ 2423b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 24247be8da07SAndreas Gruenbacher 24257be8da07SAndreas Gruenbacher repeat: 2426b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 24277be8da07SAndreas Gruenbacher if (i == &peer_req->i) 24287be8da07SAndreas Gruenbacher continue; 242908d0dabfSLars Ellenberg if (i->completed) 243008d0dabfSLars Ellenberg continue; 24317be8da07SAndreas Gruenbacher 24327be8da07SAndreas Gruenbacher if (!i->local) { 24337be8da07SAndreas Gruenbacher /* 24347be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 24357be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 24367be8da07SAndreas Gruenbacher * earlier peer request to complete. 24377be8da07SAndreas Gruenbacher */ 2438b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 24397be8da07SAndreas Gruenbacher if (err) 24407be8da07SAndreas Gruenbacher goto out; 24417be8da07SAndreas Gruenbacher goto repeat; 24427be8da07SAndreas Gruenbacher } 24437be8da07SAndreas Gruenbacher 24447be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 24457be8da07SAndreas Gruenbacher if (resolve_conflicts) { 24467be8da07SAndreas Gruenbacher /* 24477be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2448d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2449d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2450d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 24517be8da07SAndreas Gruenbacher */ 2452d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 24537be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 24547be8da07SAndreas Gruenbacher 24557be8da07SAndreas Gruenbacher if (!equal) 2456d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24577be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 24587be8da07SAndreas Gruenbacher "assuming %s came first\n", 24597be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24607be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2461d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 24627be8da07SAndreas Gruenbacher 2463a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 24647be8da07SAndreas Gruenbacher e_send_retry_write; 2465a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2466668700b4SPhilipp Reisner queue_work(connection->ack_sender, &peer_req->peer_device->send_acks_work); 24677be8da07SAndreas Gruenbacher 24687be8da07SAndreas Gruenbacher err = -ENOENT; 24697be8da07SAndreas Gruenbacher goto out; 24707be8da07SAndreas Gruenbacher } else { 24717be8da07SAndreas Gruenbacher struct drbd_request *req = 24727be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 24737be8da07SAndreas Gruenbacher 24747be8da07SAndreas Gruenbacher if (!equal) 2475d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24767be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 24777be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24787be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 24797be8da07SAndreas Gruenbacher 24807be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 24817be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 24827be8da07SAndreas Gruenbacher /* 24837be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2484d4dabbe2SLars Ellenberg * decide if this request has been superseded 2485d4dabbe2SLars Ellenberg * or needs to be retried. 2486d4dabbe2SLars Ellenberg * Requests that have been superseded will 24877be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 24887be8da07SAndreas Gruenbacher * 24897be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 24907be8da07SAndreas Gruenbacher * request to finish locally before submitting 24917be8da07SAndreas Gruenbacher * the conflicting peer request. 24927be8da07SAndreas Gruenbacher */ 2493b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 24947be8da07SAndreas Gruenbacher if (err) { 2495e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2496b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 24977be8da07SAndreas Gruenbacher goto out; 24987be8da07SAndreas Gruenbacher } 24997be8da07SAndreas Gruenbacher goto repeat; 25007be8da07SAndreas Gruenbacher } 25017be8da07SAndreas Gruenbacher /* 25027be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 25037be8da07SAndreas Gruenbacher * the new peer request has completed. 25047be8da07SAndreas Gruenbacher */ 25057be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 25067be8da07SAndreas Gruenbacher } 25077be8da07SAndreas Gruenbacher } 25087be8da07SAndreas Gruenbacher err = 0; 25097be8da07SAndreas Gruenbacher 25107be8da07SAndreas Gruenbacher out: 25117be8da07SAndreas Gruenbacher if (err) 2512b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 25137be8da07SAndreas Gruenbacher return err; 25147be8da07SAndreas Gruenbacher } 25157be8da07SAndreas Gruenbacher 2516b411b363SPhilipp Reisner /* mirrored write */ 2517bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2518b411b363SPhilipp Reisner { 25199f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2520b30ab791SAndreas Gruenbacher struct drbd_device *device; 252121ae5d7fSLars Ellenberg struct net_conf *nc; 2522b411b363SPhilipp Reisner sector_t sector; 2523db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2524e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 25257be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2526bb3cc85eSMike Christie int op, op_flags; 2527b411b363SPhilipp Reisner u32 dp_flags; 2528302bdeaeSPhilipp Reisner int err, tp; 25297be8da07SAndreas Gruenbacher 25309f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 25319f4fe9adSAndreas Gruenbacher if (!peer_device) 25324a76b161SAndreas Gruenbacher return -EIO; 25339f4fe9adSAndreas Gruenbacher device = peer_device->device; 2534b411b363SPhilipp Reisner 2535b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 253682bc0194SAndreas Gruenbacher int err2; 2537b411b363SPhilipp Reisner 253869a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 253969a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2540bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 254169a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 254282bc0194SAndreas Gruenbacher if (!err) 254382bc0194SAndreas Gruenbacher err = err2; 254482bc0194SAndreas Gruenbacher return err; 2545b411b363SPhilipp Reisner } 2546b411b363SPhilipp Reisner 2547fcefa62eSAndreas Gruenbacher /* 2548fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2549fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2550fcefa62eSAndreas Gruenbacher * end of this function. 2551fcefa62eSAndreas Gruenbacher */ 2552b411b363SPhilipp Reisner 2553b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2554a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, p->block_id, sector, pi); 2555db830c46SAndreas Gruenbacher if (!peer_req) { 2556b30ab791SAndreas Gruenbacher put_ldev(device); 255782bc0194SAndreas Gruenbacher return -EIO; 2558b411b363SPhilipp Reisner } 2559b411b363SPhilipp Reisner 2560a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 256121ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 256221ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 2563b411b363SPhilipp Reisner 2564688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2565bb3cc85eSMike Christie op = wire_flags_to_bio_op(dp_flags); 2566bb3cc85eSMike Christie op_flags = wire_flags_to_bio_flags(dp_flags); 2567a0fb3c47SLars Ellenberg if (pi->cmd == P_TRIM) { 2568a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->i.size > 0); 2569bb3cc85eSMike Christie D_ASSERT(peer_device, op == REQ_OP_DISCARD); 2570a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->pages == NULL); 2571a0fb3c47SLars Ellenberg } else if (peer_req->pages == NULL) { 25720b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 25730b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2574a73ff323SLars Ellenberg } 2575688593c5SLars Ellenberg 2576688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2577db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2578688593c5SLars Ellenberg 2579bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2580bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2581db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2582db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2583bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2584b411b363SPhilipp Reisner 2585302bdeaeSPhilipp Reisner rcu_read_lock(); 258621ae5d7fSLars Ellenberg nc = rcu_dereference(peer_device->connection->net_conf); 258721ae5d7fSLars Ellenberg tp = nc->two_primaries; 258821ae5d7fSLars Ellenberg if (peer_device->connection->agreed_pro_version < 100) { 258921ae5d7fSLars Ellenberg switch (nc->wire_protocol) { 259021ae5d7fSLars Ellenberg case DRBD_PROT_C: 259121ae5d7fSLars Ellenberg dp_flags |= DP_SEND_WRITE_ACK; 259221ae5d7fSLars Ellenberg break; 259321ae5d7fSLars Ellenberg case DRBD_PROT_B: 259421ae5d7fSLars Ellenberg dp_flags |= DP_SEND_RECEIVE_ACK; 259521ae5d7fSLars Ellenberg break; 259621ae5d7fSLars Ellenberg } 259721ae5d7fSLars Ellenberg } 2598302bdeaeSPhilipp Reisner rcu_read_unlock(); 259921ae5d7fSLars Ellenberg 260021ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_WRITE_ACK) { 260121ae5d7fSLars Ellenberg peer_req->flags |= EE_SEND_WRITE_ACK; 260221ae5d7fSLars Ellenberg inc_unacked(device); 260321ae5d7fSLars Ellenberg /* corresponding dec_unacked() in e_end_block() 260421ae5d7fSLars Ellenberg * respective _drbd_clear_done_ee */ 260521ae5d7fSLars Ellenberg } 260621ae5d7fSLars Ellenberg 260721ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_RECEIVE_ACK) { 260821ae5d7fSLars Ellenberg /* I really don't like it that the receiver thread 260921ae5d7fSLars Ellenberg * sends on the msock, but anyways */ 26105dd2ca19SAndreas Gruenbacher drbd_send_ack(peer_device, P_RECV_ACK, peer_req); 261121ae5d7fSLars Ellenberg } 261221ae5d7fSLars Ellenberg 2613302bdeaeSPhilipp Reisner if (tp) { 261421ae5d7fSLars Ellenberg /* two primaries implies protocol C */ 261521ae5d7fSLars Ellenberg D_ASSERT(device, dp_flags & DP_SEND_WRITE_ACK); 2616302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 261769a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 26187be8da07SAndreas Gruenbacher if (err) 2619b411b363SPhilipp Reisner goto out_interrupted; 26200500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2621b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 26227be8da07SAndreas Gruenbacher if (err) { 26230500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 26247be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2625b30ab791SAndreas Gruenbacher put_ldev(device); 262682bc0194SAndreas Gruenbacher return 0; 2627b411b363SPhilipp Reisner } 2628b411b363SPhilipp Reisner goto out_interrupted; 2629b411b363SPhilipp Reisner } 2630b874d231SPhilipp Reisner } else { 263169a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 26320500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2633b874d231SPhilipp Reisner } 26349104d31aSLars Ellenberg /* TRIM and WRITE_SAME are processed synchronously, 26359104d31aSLars Ellenberg * we wait for all pending requests, respectively wait for 2636a0fb3c47SLars Ellenberg * active_ee to become empty in drbd_submit_peer_request(); 2637a0fb3c47SLars Ellenberg * better not add ourselves here. */ 26389104d31aSLars Ellenberg if ((peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) == 0) 2639b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 26400500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2641b411b363SPhilipp Reisner 2642b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2643b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2644b6a370baSPhilipp Reisner 2645b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2646b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2647b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2648db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 26494dd726f0SLars Ellenberg drbd_al_begin_io(device, &peer_req->i); 265021ae5d7fSLars Ellenberg peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2651b411b363SPhilipp Reisner } 2652b411b363SPhilipp Reisner 2653bb3cc85eSMike Christie err = drbd_submit_peer_request(device, peer_req, op, op_flags, 2654bb3cc85eSMike Christie DRBD_FAULT_DT_WR); 265582bc0194SAndreas Gruenbacher if (!err) 265682bc0194SAndreas Gruenbacher return 0; 2657b411b363SPhilipp Reisner 265810f6d992SLars Ellenberg /* don't care for the reason here */ 2659d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 26600500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2661a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2662b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 26630500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 266421ae5d7fSLars Ellenberg if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) { 266521ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 2666b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 266721ae5d7fSLars Ellenberg } 266822cc37a9SLars Ellenberg 2669b411b363SPhilipp Reisner out_interrupted: 26707e5fec31SFabian Frederick drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT | EV_CLEANUP); 2671b30ab791SAndreas Gruenbacher put_ldev(device); 2672b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 267382bc0194SAndreas Gruenbacher return err; 2674b411b363SPhilipp Reisner } 2675b411b363SPhilipp Reisner 26760f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 26770f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 26780f0601f4SLars Ellenberg * 26790f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 26800f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 26810f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 26820f0601f4SLars Ellenberg * activity, it obviously is "busy". 26830f0601f4SLars Ellenberg * 26840f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 26850f0601f4SLars Ellenberg * to have a short time average so we can react faster. 26860f0601f4SLars Ellenberg */ 2687ad3fee79SLars Ellenberg bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector, 2688ad3fee79SLars Ellenberg bool throttle_if_app_is_waiting) 2689e8299874SLars Ellenberg { 2690e8299874SLars Ellenberg struct lc_element *tmp; 2691ad3fee79SLars Ellenberg bool throttle = drbd_rs_c_min_rate_throttle(device); 2692e8299874SLars Ellenberg 2693ad3fee79SLars Ellenberg if (!throttle || throttle_if_app_is_waiting) 2694ad3fee79SLars Ellenberg return throttle; 2695e8299874SLars Ellenberg 2696e8299874SLars Ellenberg spin_lock_irq(&device->al_lock); 2697e8299874SLars Ellenberg tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2698e8299874SLars Ellenberg if (tmp) { 2699e8299874SLars Ellenberg struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2700e8299874SLars Ellenberg if (test_bit(BME_PRIORITY, &bm_ext->flags)) 2701e8299874SLars Ellenberg throttle = false; 2702ad3fee79SLars Ellenberg /* Do not slow down if app IO is already waiting for this extent, 2703ad3fee79SLars Ellenberg * and our progress is necessary for application IO to complete. */ 2704e8299874SLars Ellenberg } 2705e8299874SLars Ellenberg spin_unlock_irq(&device->al_lock); 2706e8299874SLars Ellenberg 2707e8299874SLars Ellenberg return throttle; 2708e8299874SLars Ellenberg } 2709e8299874SLars Ellenberg 2710e8299874SLars Ellenberg bool drbd_rs_c_min_rate_throttle(struct drbd_device *device) 27110f0601f4SLars Ellenberg { 2712b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 27130f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2714daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2715e8299874SLars Ellenberg int curr_events; 2716daeda1ccSPhilipp Reisner 2717daeda1ccSPhilipp Reisner rcu_read_lock(); 2718b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2719daeda1ccSPhilipp Reisner rcu_read_unlock(); 27200f0601f4SLars Ellenberg 27210f0601f4SLars Ellenberg /* feature disabled? */ 2722daeda1ccSPhilipp Reisner if (c_min_rate == 0) 2723e8299874SLars Ellenberg return false; 2724e3555d85SPhilipp Reisner 27250f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 27260f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2727b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2728ad3fee79SLars Ellenberg 2729ad3fee79SLars Ellenberg if (atomic_read(&device->ap_actlog_cnt) 2730ff8bd88bSLars Ellenberg || curr_events - device->rs_last_events > 64) { 27310f0601f4SLars Ellenberg unsigned long rs_left; 27320f0601f4SLars Ellenberg int i; 27330f0601f4SLars Ellenberg 2734b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 27350f0601f4SLars Ellenberg 27360f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 27370f0601f4SLars Ellenberg * approx. */ 2738b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 27392649f080SLars Ellenberg 2740b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2741b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 27422649f080SLars Ellenberg else 2743b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 27440f0601f4SLars Ellenberg 2745b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 27460f0601f4SLars Ellenberg if (!dt) 27470f0601f4SLars Ellenberg dt++; 2748b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 27490f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 27500f0601f4SLars Ellenberg 2751daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 2752e8299874SLars Ellenberg return true; 27530f0601f4SLars Ellenberg } 2754e8299874SLars Ellenberg return false; 27550f0601f4SLars Ellenberg } 27560f0601f4SLars Ellenberg 2757bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2758b411b363SPhilipp Reisner { 27599f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2760b30ab791SAndreas Gruenbacher struct drbd_device *device; 2761b411b363SPhilipp Reisner sector_t sector; 27624a76b161SAndreas Gruenbacher sector_t capacity; 2763db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2764b411b363SPhilipp Reisner struct digest_info *di = NULL; 2765b18b37beSPhilipp Reisner int size, verb; 2766b411b363SPhilipp Reisner unsigned int fault_type; 2767e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 27684a76b161SAndreas Gruenbacher 27699f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 27709f4fe9adSAndreas Gruenbacher if (!peer_device) 27714a76b161SAndreas Gruenbacher return -EIO; 27729f4fe9adSAndreas Gruenbacher device = peer_device->device; 2773b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2776b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2777b411b363SPhilipp Reisner 2778c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2779d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2780b411b363SPhilipp Reisner (unsigned long long)sector, size); 278182bc0194SAndreas Gruenbacher return -EINVAL; 2782b411b363SPhilipp Reisner } 2783b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2784d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2785b411b363SPhilipp Reisner (unsigned long long)sector, size); 278682bc0194SAndreas Gruenbacher return -EINVAL; 2787b411b363SPhilipp Reisner } 2788b411b363SPhilipp Reisner 2789b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2790b18b37beSPhilipp Reisner verb = 1; 2791e2857216SAndreas Gruenbacher switch (pi->cmd) { 2792b18b37beSPhilipp Reisner case P_DATA_REQUEST: 279369a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2794b18b37beSPhilipp Reisner break; 2795700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2796b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2797b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2798b18b37beSPhilipp Reisner case P_OV_REQUEST: 279969a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2800b18b37beSPhilipp Reisner break; 2801b18b37beSPhilipp Reisner case P_OV_REPLY: 2802b18b37beSPhilipp Reisner verb = 0; 2803b30ab791SAndreas Gruenbacher dec_rs_pending(device); 280469a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2805b18b37beSPhilipp Reisner break; 2806b18b37beSPhilipp Reisner default: 280749ba9b1bSAndreas Gruenbacher BUG(); 2808b18b37beSPhilipp Reisner } 2809b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2810d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2811b411b363SPhilipp Reisner "no local data.\n"); 2812b18b37beSPhilipp Reisner 2813a821cc4aSLars Ellenberg /* drain possibly payload */ 281469a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2815b411b363SPhilipp Reisner } 2816b411b363SPhilipp Reisner 2817b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2818b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2819b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2820a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, 28219104d31aSLars Ellenberg size, GFP_NOIO); 2822db830c46SAndreas Gruenbacher if (!peer_req) { 2823b30ab791SAndreas Gruenbacher put_ldev(device); 282482bc0194SAndreas Gruenbacher return -ENOMEM; 2825b411b363SPhilipp Reisner } 2826b411b363SPhilipp Reisner 2827e2857216SAndreas Gruenbacher switch (pi->cmd) { 2828b411b363SPhilipp Reisner case P_DATA_REQUEST: 2829a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2830b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 283180a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 283221ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 283380a40e43SLars Ellenberg goto submit; 283480a40e43SLars Ellenberg 2835700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2836700ca8c0SPhilipp Reisner /* If at some point in the future we have a smart way to 2837700ca8c0SPhilipp Reisner find out if this data block is completely deallocated, 2838700ca8c0SPhilipp Reisner then we would do something smarter here than reading 2839700ca8c0SPhilipp Reisner the block... */ 2840700ca8c0SPhilipp Reisner peer_req->flags |= EE_RS_THIN_REQ; 2841b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2842a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2843b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 28445f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2845b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2846b411b363SPhilipp Reisner break; 2847b411b363SPhilipp Reisner 2848b411b363SPhilipp Reisner case P_OV_REPLY: 2849b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2850b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2851e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2852b411b363SPhilipp Reisner if (!di) 2853b411b363SPhilipp Reisner goto out_free_e; 2854b411b363SPhilipp Reisner 2855e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2856b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2857b411b363SPhilipp Reisner 2858db830c46SAndreas Gruenbacher peer_req->digest = di; 2859db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2860c36c3cedSLars Ellenberg 28619f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2862b411b363SPhilipp Reisner goto out_free_e; 2863b411b363SPhilipp Reisner 2864e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 28659f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2866a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 28675f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2868b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2869aaaba345SLars Ellenberg /* remember to report stats in drbd_resync_finished */ 2870aaaba345SLars Ellenberg device->use_csums = true; 2871e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 28722649f080SLars Ellenberg /* track progress, we may need to throttle */ 2873b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2874a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2875b30ab791SAndreas Gruenbacher dec_rs_pending(device); 28760f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 28770f0601f4SLars Ellenberg * but accounting still needs to be done. */ 28780f0601f4SLars Ellenberg goto submit_for_resync; 2879b411b363SPhilipp Reisner } 2880b411b363SPhilipp Reisner break; 2881b411b363SPhilipp Reisner 2882b411b363SPhilipp Reisner case P_OV_REQUEST: 2883b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 28849f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2885de228bbaSLars Ellenberg unsigned long now = jiffies; 2886de228bbaSLars Ellenberg int i; 2887b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2888b30ab791SAndreas Gruenbacher device->ov_position = sector; 2889b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2890b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2891de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2892b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2893b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2894de228bbaSLars Ellenberg } 2895d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2896b411b363SPhilipp Reisner (unsigned long long)sector); 2897b411b363SPhilipp Reisner } 2898a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2899b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2900b411b363SPhilipp Reisner break; 2901b411b363SPhilipp Reisner 2902b411b363SPhilipp Reisner default: 290349ba9b1bSAndreas Gruenbacher BUG(); 2904b411b363SPhilipp Reisner } 2905b411b363SPhilipp Reisner 29060f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 29070f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 29080f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 29090f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 29100f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 29110f0601f4SLars Ellenberg * 29120f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 29130f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 29140f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 29150f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 29160f0601f4SLars Ellenberg * a while, anyways. 29170f0601f4SLars Ellenberg */ 2918b411b363SPhilipp Reisner 29190f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 29200f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 29210f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 29220f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 29230f0601f4SLars Ellenberg * 29240f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 29250f0601f4SLars Ellenberg * we would also throttle its application reads. 29260f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 29270f0601f4SLars Ellenberg */ 2928c5a2c150SLars Ellenberg 2929c5a2c150SLars Ellenberg /* Even though this may be a resync request, we do add to "read_ee"; 2930c5a2c150SLars Ellenberg * "sync_ee" is only used for resync WRITEs. 2931c5a2c150SLars Ellenberg * Add to list early, so debugfs can find this request 2932c5a2c150SLars Ellenberg * even if we have to sleep below. */ 2933c5a2c150SLars Ellenberg spin_lock_irq(&device->resource->req_lock); 2934c5a2c150SLars Ellenberg list_add_tail(&peer_req->w.list, &device->read_ee); 2935c5a2c150SLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 2936c5a2c150SLars Ellenberg 2937944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_should_slow_down); 2938ad3fee79SLars Ellenberg if (device->state.peer != R_PRIMARY 2939ad3fee79SLars Ellenberg && drbd_rs_should_slow_down(device, sector, false)) 2940e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2941944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_begin_io); 2942b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 294380a40e43SLars Ellenberg goto out_free_e; 2944b411b363SPhilipp Reisner 29450f0601f4SLars Ellenberg submit_for_resync: 2946b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 29470f0601f4SLars Ellenberg 294880a40e43SLars Ellenberg submit: 2949944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_submit_peer_request); 2950b30ab791SAndreas Gruenbacher inc_unacked(device); 2951bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ, 0, 2952bb3cc85eSMike Christie fault_type) == 0) 295382bc0194SAndreas Gruenbacher return 0; 2954b411b363SPhilipp Reisner 295510f6d992SLars Ellenberg /* don't care for the reason here */ 2956d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 2957c5a2c150SLars Ellenberg 2958c5a2c150SLars Ellenberg out_free_e: 29590500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2960a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 29610500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 296222cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 296322cc37a9SLars Ellenberg 2964b30ab791SAndreas Gruenbacher put_ldev(device); 2965b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 296682bc0194SAndreas Gruenbacher return -EIO; 2967b411b363SPhilipp Reisner } 2968b411b363SPhilipp Reisner 296969a22773SAndreas Gruenbacher /** 297069a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 297169a22773SAndreas Gruenbacher */ 297269a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2973b411b363SPhilipp Reisner { 297469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2975b411b363SPhilipp Reisner int self, peer, rv = -100; 2976b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 297744ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2978b411b363SPhilipp Reisner 2979b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2980b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2981b411b363SPhilipp Reisner 2982b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2983b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2984b411b363SPhilipp Reisner 298544ed167dSPhilipp Reisner rcu_read_lock(); 298669a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 298744ed167dSPhilipp Reisner rcu_read_unlock(); 298844ed167dSPhilipp Reisner switch (after_sb_0p) { 2989b411b363SPhilipp Reisner case ASB_CONSENSUS: 2990b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2991b411b363SPhilipp Reisner case ASB_CALL_HELPER: 299244ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2993d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2994b411b363SPhilipp Reisner break; 2995b411b363SPhilipp Reisner case ASB_DISCONNECT: 2996b411b363SPhilipp Reisner break; 2997b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2998b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2999b411b363SPhilipp Reisner rv = -1; 3000b411b363SPhilipp Reisner break; 3001b411b363SPhilipp Reisner } 3002b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 3003b411b363SPhilipp Reisner rv = 1; 3004b411b363SPhilipp Reisner break; 3005b411b363SPhilipp Reisner } 3006b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 3007b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3008b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 3009b411b363SPhilipp Reisner rv = 1; 3010b411b363SPhilipp Reisner break; 3011b411b363SPhilipp Reisner } 3012b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 3013b411b363SPhilipp Reisner rv = -1; 3014b411b363SPhilipp Reisner break; 3015b411b363SPhilipp Reisner } 3016b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 3017d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 3018b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 3019b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3020b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 302169a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 3022b411b363SPhilipp Reisner ? -1 : 1; 3023b411b363SPhilipp Reisner break; 3024b411b363SPhilipp Reisner } else { 3025b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 3026b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 3027b411b363SPhilipp Reisner } 302844ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 3029b411b363SPhilipp Reisner break; 3030b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3031b411b363SPhilipp Reisner if (ch_self < ch_peer) 3032b411b363SPhilipp Reisner rv = -1; 3033b411b363SPhilipp Reisner else if (ch_self > ch_peer) 3034b411b363SPhilipp Reisner rv = 1; 3035b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 3036b411b363SPhilipp Reisner /* Well, then use something else. */ 303769a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 3038b411b363SPhilipp Reisner ? -1 : 1; 3039b411b363SPhilipp Reisner break; 3040b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3041b411b363SPhilipp Reisner rv = -1; 3042b411b363SPhilipp Reisner break; 3043b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 3044b411b363SPhilipp Reisner rv = 1; 3045b411b363SPhilipp Reisner } 3046b411b363SPhilipp Reisner 3047b411b363SPhilipp Reisner return rv; 3048b411b363SPhilipp Reisner } 3049b411b363SPhilipp Reisner 305069a22773SAndreas Gruenbacher /** 305169a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 305269a22773SAndreas Gruenbacher */ 305369a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 3054b411b363SPhilipp Reisner { 305569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 30566184ea21SAndreas Gruenbacher int hg, rv = -100; 305744ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 3058b411b363SPhilipp Reisner 305944ed167dSPhilipp Reisner rcu_read_lock(); 306069a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 306144ed167dSPhilipp Reisner rcu_read_unlock(); 306244ed167dSPhilipp Reisner switch (after_sb_1p) { 3063b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3064b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3065b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3066b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3067b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 306844ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3069d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3070b411b363SPhilipp Reisner break; 3071b411b363SPhilipp Reisner case ASB_DISCONNECT: 3072b411b363SPhilipp Reisner break; 3073b411b363SPhilipp Reisner case ASB_CONSENSUS: 307469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3075b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 3076b411b363SPhilipp Reisner rv = hg; 3077b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 3078b411b363SPhilipp Reisner rv = hg; 3079b411b363SPhilipp Reisner break; 3080b411b363SPhilipp Reisner case ASB_VIOLENTLY: 308169a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3082b411b363SPhilipp Reisner break; 3083b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 3084b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 3085b411b363SPhilipp Reisner case ASB_CALL_HELPER: 308669a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3087b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 3088bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3089bb437946SAndreas Gruenbacher 3090b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3091b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3092b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3093b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3094bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3095b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3096b411b363SPhilipp Reisner } else { 3097d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3098b411b363SPhilipp Reisner rv = hg; 3099b411b363SPhilipp Reisner } 3100b411b363SPhilipp Reisner } else 3101b411b363SPhilipp Reisner rv = hg; 3102b411b363SPhilipp Reisner } 3103b411b363SPhilipp Reisner 3104b411b363SPhilipp Reisner return rv; 3105b411b363SPhilipp Reisner } 3106b411b363SPhilipp Reisner 310769a22773SAndreas Gruenbacher /** 310869a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 310969a22773SAndreas Gruenbacher */ 311069a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 3111b411b363SPhilipp Reisner { 311269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 31136184ea21SAndreas Gruenbacher int hg, rv = -100; 311444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 3115b411b363SPhilipp Reisner 311644ed167dSPhilipp Reisner rcu_read_lock(); 311769a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 311844ed167dSPhilipp Reisner rcu_read_unlock(); 311944ed167dSPhilipp Reisner switch (after_sb_2p) { 3120b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3121b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3122b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3123b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3124b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 3125b411b363SPhilipp Reisner case ASB_CONSENSUS: 3126b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 312744ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3128d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3129b411b363SPhilipp Reisner break; 3130b411b363SPhilipp Reisner case ASB_VIOLENTLY: 313169a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3132b411b363SPhilipp Reisner break; 3133b411b363SPhilipp Reisner case ASB_DISCONNECT: 3134b411b363SPhilipp Reisner break; 3135b411b363SPhilipp Reisner case ASB_CALL_HELPER: 313669a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3137b411b363SPhilipp Reisner if (hg == -1) { 3138bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3139bb437946SAndreas Gruenbacher 3140b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3141b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3142b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3143b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3144bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3145b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3146b411b363SPhilipp Reisner } else { 3147d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3148b411b363SPhilipp Reisner rv = hg; 3149b411b363SPhilipp Reisner } 3150b411b363SPhilipp Reisner } else 3151b411b363SPhilipp Reisner rv = hg; 3152b411b363SPhilipp Reisner } 3153b411b363SPhilipp Reisner 3154b411b363SPhilipp Reisner return rv; 3155b411b363SPhilipp Reisner } 3156b411b363SPhilipp Reisner 3157b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 3158b411b363SPhilipp Reisner u64 bits, u64 flags) 3159b411b363SPhilipp Reisner { 3160b411b363SPhilipp Reisner if (!uuid) { 3161d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 3162b411b363SPhilipp Reisner return; 3163b411b363SPhilipp Reisner } 3164d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 3165b411b363SPhilipp Reisner text, 3166b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 3167b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 3168b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 3169b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 3170b411b363SPhilipp Reisner (unsigned long long)bits, 3171b411b363SPhilipp Reisner (unsigned long long)flags); 3172b411b363SPhilipp Reisner } 3173b411b363SPhilipp Reisner 3174b411b363SPhilipp Reisner /* 3175b411b363SPhilipp Reisner 100 after split brain try auto recover 3176b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 3177b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 3178b411b363SPhilipp Reisner 0 no Sync 3179b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 3180b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 3181b411b363SPhilipp Reisner -100 after split brain, disconnect 3182b411b363SPhilipp Reisner -1000 unrelated data 31834a23f264SPhilipp Reisner -1091 requires proto 91 31844a23f264SPhilipp Reisner -1096 requires proto 96 3185b411b363SPhilipp Reisner */ 3186f2d3d75bSLars Ellenberg 3187f2d3d75bSLars Ellenberg static int drbd_uuid_compare(struct drbd_device *const device, enum drbd_role const peer_role, int *rule_nr) __must_hold(local) 3188b411b363SPhilipp Reisner { 318944a4d551SLars Ellenberg struct drbd_peer_device *const peer_device = first_peer_device(device); 319044a4d551SLars Ellenberg struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; 3191b411b363SPhilipp Reisner u64 self, peer; 3192b411b363SPhilipp Reisner int i, j; 3193b411b363SPhilipp Reisner 3194b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3195b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3196b411b363SPhilipp Reisner 3197b411b363SPhilipp Reisner *rule_nr = 10; 3198b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 3199b411b363SPhilipp Reisner return 0; 3200b411b363SPhilipp Reisner 3201b411b363SPhilipp Reisner *rule_nr = 20; 3202b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 3203b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 3204b411b363SPhilipp Reisner return -2; 3205b411b363SPhilipp Reisner 3206b411b363SPhilipp Reisner *rule_nr = 30; 3207b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 3208b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 3209b411b363SPhilipp Reisner return 2; 3210b411b363SPhilipp Reisner 3211b411b363SPhilipp Reisner if (self == peer) { 3212b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 3213b411b363SPhilipp Reisner 3214b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 3215b411b363SPhilipp Reisner 321644a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 32174a23f264SPhilipp Reisner return -1091; 3218b411b363SPhilipp Reisner 3219b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 3220b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 3221d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 3222b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 3223b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 3224b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 3225b411b363SPhilipp Reisner 3226b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3227b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3228b411b363SPhilipp Reisner *rule_nr = 34; 3229b411b363SPhilipp Reisner } else { 3230d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 3231b411b363SPhilipp Reisner *rule_nr = 36; 3232b411b363SPhilipp Reisner } 3233b411b363SPhilipp Reisner 3234b411b363SPhilipp Reisner return 1; 3235b411b363SPhilipp Reisner } 3236b411b363SPhilipp Reisner 3237b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 3238b411b363SPhilipp Reisner 323944a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 32404a23f264SPhilipp Reisner return -1091; 3241b411b363SPhilipp Reisner 3242b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 3243b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 3244d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 3245b411b363SPhilipp Reisner 3246b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 3247b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 3248b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 3249b411b363SPhilipp Reisner 3250b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3251b411b363SPhilipp Reisner *rule_nr = 35; 3252b411b363SPhilipp Reisner } else { 3253d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 3254b411b363SPhilipp Reisner *rule_nr = 37; 3255b411b363SPhilipp Reisner } 3256b411b363SPhilipp Reisner 3257b411b363SPhilipp Reisner return -1; 3258b411b363SPhilipp Reisner } 3259b411b363SPhilipp Reisner 3260b411b363SPhilipp Reisner /* Common power [off|failure] */ 3261b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 3262b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 3263b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 3264b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 3265b411b363SPhilipp Reisner *rule_nr = 40; 3266b411b363SPhilipp Reisner 3267f2d3d75bSLars Ellenberg /* Neither has the "crashed primary" flag set, 3268f2d3d75bSLars Ellenberg * only a replication link hickup. */ 3269f2d3d75bSLars Ellenberg if (rct == 0) 3270f2d3d75bSLars Ellenberg return 0; 3271f2d3d75bSLars Ellenberg 3272f2d3d75bSLars Ellenberg /* Current UUID equal and no bitmap uuid; does not necessarily 3273f2d3d75bSLars Ellenberg * mean this was a "simultaneous hard crash", maybe IO was 3274f2d3d75bSLars Ellenberg * frozen, so no UUID-bump happened. 3275f2d3d75bSLars Ellenberg * This is a protocol change, overload DRBD_FF_WSAME as flag 3276f2d3d75bSLars Ellenberg * for "new-enough" peer DRBD version. */ 3277f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY || peer_role == R_PRIMARY) { 3278f2d3d75bSLars Ellenberg *rule_nr = 41; 3279f2d3d75bSLars Ellenberg if (!(connection->agreed_features & DRBD_FF_WSAME)) { 3280f2d3d75bSLars Ellenberg drbd_warn(peer_device, "Equivalent unrotated UUIDs, but current primary present.\n"); 3281f2d3d75bSLars Ellenberg return -(0x10000 | PRO_VERSION_MAX | (DRBD_FF_WSAME << 8)); 3282f2d3d75bSLars Ellenberg } 3283f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY && peer_role == R_PRIMARY) { 3284f2d3d75bSLars Ellenberg /* At least one has the "crashed primary" bit set, 3285f2d3d75bSLars Ellenberg * both are primary now, but neither has rotated its UUIDs? 3286f2d3d75bSLars Ellenberg * "Can not happen." */ 3287f2d3d75bSLars Ellenberg drbd_err(peer_device, "Equivalent unrotated UUIDs, but both are primary. Can not resolve this.\n"); 3288f2d3d75bSLars Ellenberg return -100; 3289f2d3d75bSLars Ellenberg } 3290f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY) 3291f2d3d75bSLars Ellenberg return 1; 3292f2d3d75bSLars Ellenberg return -1; 3293f2d3d75bSLars Ellenberg } 3294f2d3d75bSLars Ellenberg 3295f2d3d75bSLars Ellenberg /* Both are secondary. 3296f2d3d75bSLars Ellenberg * Really looks like recovery from simultaneous hard crash. 3297f2d3d75bSLars Ellenberg * Check which had been primary before, and arbitrate. */ 3298b411b363SPhilipp Reisner switch (rct) { 3299f2d3d75bSLars Ellenberg case 0: /* !self_pri && !peer_pri */ return 0; /* already handled */ 3300b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 3301b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 3302b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 330344a4d551SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); 3304b411b363SPhilipp Reisner return dc ? -1 : 1; 3305b411b363SPhilipp Reisner } 3306b411b363SPhilipp Reisner } 3307b411b363SPhilipp Reisner 3308b411b363SPhilipp Reisner *rule_nr = 50; 3309b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3310b411b363SPhilipp Reisner if (self == peer) 3311b411b363SPhilipp Reisner return -1; 3312b411b363SPhilipp Reisner 3313b411b363SPhilipp Reisner *rule_nr = 51; 3314b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 3315b411b363SPhilipp Reisner if (self == peer) { 331644a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3317b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 3318b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 3319b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 3320b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3321b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 3322b411b363SPhilipp Reisner 332344a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 33244a23f264SPhilipp Reisner return -1091; 3325b411b363SPhilipp Reisner 3326b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 3327b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 33284a23f264SPhilipp Reisner 3329d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 3330b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 33314a23f264SPhilipp Reisner 3332b411b363SPhilipp Reisner return -1; 3333b411b363SPhilipp Reisner } 3334b411b363SPhilipp Reisner } 3335b411b363SPhilipp Reisner 3336b411b363SPhilipp Reisner *rule_nr = 60; 3337b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3338b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3339b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 3340b411b363SPhilipp Reisner if (self == peer) 3341b411b363SPhilipp Reisner return -2; 3342b411b363SPhilipp Reisner } 3343b411b363SPhilipp Reisner 3344b411b363SPhilipp Reisner *rule_nr = 70; 3345b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3346b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3347b411b363SPhilipp Reisner if (self == peer) 3348b411b363SPhilipp Reisner return 1; 3349b411b363SPhilipp Reisner 3350b411b363SPhilipp Reisner *rule_nr = 71; 3351b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 3352b411b363SPhilipp Reisner if (self == peer) { 335344a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3354b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 3355b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 3356b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 3357b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3358b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 3359b411b363SPhilipp Reisner 336044a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 33614a23f264SPhilipp Reisner return -1091; 3362b411b363SPhilipp Reisner 3363b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 3364b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 3365b411b363SPhilipp Reisner 3366d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 3367b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3368b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3369b411b363SPhilipp Reisner 3370b411b363SPhilipp Reisner return 1; 3371b411b363SPhilipp Reisner } 3372b411b363SPhilipp Reisner } 3373b411b363SPhilipp Reisner 3374b411b363SPhilipp Reisner 3375b411b363SPhilipp Reisner *rule_nr = 80; 3376b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3377b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3378b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3379b411b363SPhilipp Reisner if (self == peer) 3380b411b363SPhilipp Reisner return 2; 3381b411b363SPhilipp Reisner } 3382b411b363SPhilipp Reisner 3383b411b363SPhilipp Reisner *rule_nr = 90; 3384b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3385b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3386b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 3387b411b363SPhilipp Reisner return 100; 3388b411b363SPhilipp Reisner 3389b411b363SPhilipp Reisner *rule_nr = 100; 3390b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3391b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3392b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 3393b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 3394b411b363SPhilipp Reisner if (self == peer) 3395b411b363SPhilipp Reisner return -100; 3396b411b363SPhilipp Reisner } 3397b411b363SPhilipp Reisner } 3398b411b363SPhilipp Reisner 3399b411b363SPhilipp Reisner return -1000; 3400b411b363SPhilipp Reisner } 3401b411b363SPhilipp Reisner 3402b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 3403b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 3404b411b363SPhilipp Reisner */ 340569a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 340669a22773SAndreas Gruenbacher enum drbd_role peer_role, 3407b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 3408b411b363SPhilipp Reisner { 340969a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 3410b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 3411b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 341244ed167dSPhilipp Reisner struct net_conf *nc; 34136dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 3414b411b363SPhilipp Reisner 3415b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 3416b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 3417b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 3418b411b363SPhilipp Reisner 3419d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 34209f2247bbSPhilipp Reisner 3421b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 3422b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 3423b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 3424b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3425b411b363SPhilipp Reisner 3426f2d3d75bSLars Ellenberg hg = drbd_uuid_compare(device, peer_role, &rule_nr); 3427b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 3428b411b363SPhilipp Reisner 3429d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 3430b411b363SPhilipp Reisner 3431b411b363SPhilipp Reisner if (hg == -1000) { 3432d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3433b411b363SPhilipp Reisner return C_MASK; 3434b411b363SPhilipp Reisner } 3435f2d3d75bSLars Ellenberg if (hg < -0x10000) { 3436f2d3d75bSLars Ellenberg int proto, fflags; 3437f2d3d75bSLars Ellenberg hg = -hg; 3438f2d3d75bSLars Ellenberg proto = hg & 0xff; 3439f2d3d75bSLars Ellenberg fflags = (hg >> 8) & 0xff; 3440f2d3d75bSLars Ellenberg drbd_alert(device, "To resolve this both sides have to support at least protocol %d and feature flags 0x%x\n", 3441f2d3d75bSLars Ellenberg proto, fflags); 3442f2d3d75bSLars Ellenberg return C_MASK; 3443f2d3d75bSLars Ellenberg } 34444a23f264SPhilipp Reisner if (hg < -1000) { 3445d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3446b411b363SPhilipp Reisner return C_MASK; 3447b411b363SPhilipp Reisner } 3448b411b363SPhilipp Reisner 3449b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3450b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3451b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3452b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3453b411b363SPhilipp Reisner if (f) 3454b411b363SPhilipp Reisner hg = hg*2; 3455d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3456b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3457b411b363SPhilipp Reisner } 3458b411b363SPhilipp Reisner 34593a11a487SAdam Gandelman if (abs(hg) == 100) 3460b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 34613a11a487SAdam Gandelman 346244ed167dSPhilipp Reisner rcu_read_lock(); 346369a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 346444ed167dSPhilipp Reisner 346544ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3466b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3467b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3468b411b363SPhilipp Reisner int forced = (hg == -100); 3469b411b363SPhilipp Reisner 3470b411b363SPhilipp Reisner switch (pcount) { 3471b411b363SPhilipp Reisner case 0: 347269a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3473b411b363SPhilipp Reisner break; 3474b411b363SPhilipp Reisner case 1: 347569a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3476b411b363SPhilipp Reisner break; 3477b411b363SPhilipp Reisner case 2: 347869a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3479b411b363SPhilipp Reisner break; 3480b411b363SPhilipp Reisner } 3481b411b363SPhilipp Reisner if (abs(hg) < 100) { 3482d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3483b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3484b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3485b411b363SPhilipp Reisner if (forced) { 3486d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3487b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3488b411b363SPhilipp Reisner hg = hg*2; 3489b411b363SPhilipp Reisner } 3490b411b363SPhilipp Reisner } 3491b411b363SPhilipp Reisner } 3492b411b363SPhilipp Reisner 3493b411b363SPhilipp Reisner if (hg == -100) { 3494b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3495b411b363SPhilipp Reisner hg = -1; 3496b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3497b411b363SPhilipp Reisner hg = 1; 3498b411b363SPhilipp Reisner 3499b411b363SPhilipp Reisner if (abs(hg) < 100) 3500d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3501b411b363SPhilipp Reisner "Sync from %s node\n", 3502b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3503b411b363SPhilipp Reisner } 350444ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 35056dff2902SAndreas Gruenbacher tentative = nc->tentative; 350644ed167dSPhilipp Reisner rcu_read_unlock(); 3507b411b363SPhilipp Reisner 3508b411b363SPhilipp Reisner if (hg == -100) { 3509580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3510580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3511580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3512580b9767SLars Ellenberg * to that disk, in a way... */ 3513d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3514b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3515b411b363SPhilipp Reisner return C_MASK; 3516b411b363SPhilipp Reisner } 3517b411b363SPhilipp Reisner 3518b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3519d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3520b411b363SPhilipp Reisner return C_MASK; 3521b411b363SPhilipp Reisner } 3522b411b363SPhilipp Reisner 3523b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3524b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 352544ed167dSPhilipp Reisner switch (rr_conflict) { 3526b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3527b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3528b411b363SPhilipp Reisner /* fall through */ 3529b411b363SPhilipp Reisner case ASB_DISCONNECT: 3530d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3531b411b363SPhilipp Reisner return C_MASK; 3532b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3533d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3534b411b363SPhilipp Reisner "assumption\n"); 3535b411b363SPhilipp Reisner } 3536b411b363SPhilipp Reisner } 3537b411b363SPhilipp Reisner 353869a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3539cf14c2e9SPhilipp Reisner if (hg == 0) 3540d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3541cf14c2e9SPhilipp Reisner else 3542d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3543cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3544cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3545cf14c2e9SPhilipp Reisner return C_MASK; 3546cf14c2e9SPhilipp Reisner } 3547cf14c2e9SPhilipp Reisner 3548b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3549d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3550b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 355120ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3552b411b363SPhilipp Reisner return C_MASK; 3553b411b363SPhilipp Reisner } 3554b411b363SPhilipp Reisner 3555b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3556b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3557b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3558b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3559b411b363SPhilipp Reisner } else { 3560b411b363SPhilipp Reisner rv = C_CONNECTED; 3561b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3562d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3563b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3564b411b363SPhilipp Reisner } 3565b411b363SPhilipp Reisner } 3566b411b363SPhilipp Reisner 3567b411b363SPhilipp Reisner return rv; 3568b411b363SPhilipp Reisner } 3569b411b363SPhilipp Reisner 3570f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3571b411b363SPhilipp Reisner { 3572b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3573f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3574f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3575b411b363SPhilipp Reisner 3576b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3577f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3578f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3579b411b363SPhilipp Reisner 3580b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3581f179d76dSPhilipp Reisner return peer; 3582b411b363SPhilipp Reisner } 3583b411b363SPhilipp Reisner 3584bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3585b411b363SPhilipp Reisner { 3586e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3587036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3588036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3589036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3590036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 35919534d671SHerbert Xu struct crypto_ahash *peer_integrity_tfm = NULL; 35927aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3593b411b363SPhilipp Reisner 3594b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3595b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3596b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3597b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3598b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3599cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 36006139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3601cf14c2e9SPhilipp Reisner 3602bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 360386db0618SAndreas Gruenbacher int err; 360486db0618SAndreas Gruenbacher 360588104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 360686db0618SAndreas Gruenbacher return -EIO; 3607bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 360886db0618SAndreas Gruenbacher if (err) 360986db0618SAndreas Gruenbacher return err; 361088104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3611036b17eaSPhilipp Reisner } 361286db0618SAndreas Gruenbacher 36137d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3614bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3615cf14c2e9SPhilipp Reisner 3616cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3617bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3618b411b363SPhilipp Reisner 361944ed167dSPhilipp Reisner rcu_read_lock(); 3620bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 362144ed167dSPhilipp Reisner 3622036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 36231ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 362444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3625b411b363SPhilipp Reisner } 3626b411b363SPhilipp Reisner 3627f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 36281ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 362944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3630b411b363SPhilipp Reisner } 3631b411b363SPhilipp Reisner 3632f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 36331ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 363444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3635b411b363SPhilipp Reisner } 3636b411b363SPhilipp Reisner 3637f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 36381ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 363944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3640b411b363SPhilipp Reisner } 3641b411b363SPhilipp Reisner 36426139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 36431ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 364444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3645b411b363SPhilipp Reisner } 3646b411b363SPhilipp Reisner 364744ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 36481ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 364944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3650b411b363SPhilipp Reisner } 3651b411b363SPhilipp Reisner 3652036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 36531ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3654036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3655036b17eaSPhilipp Reisner } 3656036b17eaSPhilipp Reisner 365786db0618SAndreas Gruenbacher rcu_read_unlock(); 3658fbc12f45SAndreas Gruenbacher } 36597d4c782cSAndreas Gruenbacher 36607d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 36617d4c782cSAndreas Gruenbacher int hash_size; 36627d4c782cSAndreas Gruenbacher 36637d4c782cSAndreas Gruenbacher /* 36647d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 36657d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 36667d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 36677d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 36687d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 36697d4c782cSAndreas Gruenbacher * change. 36707d4c782cSAndreas Gruenbacher */ 36717d4c782cSAndreas Gruenbacher 36729534d671SHerbert Xu peer_integrity_tfm = crypto_alloc_ahash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 36731b57e663SLars Ellenberg if (IS_ERR(peer_integrity_tfm)) { 36741b57e663SLars Ellenberg peer_integrity_tfm = NULL; 36751ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 36767d4c782cSAndreas Gruenbacher integrity_alg); 3677b411b363SPhilipp Reisner goto disconnect; 3678b411b363SPhilipp Reisner } 3679b411b363SPhilipp Reisner 36809534d671SHerbert Xu hash_size = crypto_ahash_digestsize(peer_integrity_tfm); 36817d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 36827d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 36837d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 36841ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 36857d4c782cSAndreas Gruenbacher goto disconnect; 36867d4c782cSAndreas Gruenbacher } 36877d4c782cSAndreas Gruenbacher } 36887d4c782cSAndreas Gruenbacher 36897d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 36907d4c782cSAndreas Gruenbacher if (!new_net_conf) { 36911ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3692b411b363SPhilipp Reisner goto disconnect; 3693b411b363SPhilipp Reisner } 3694b411b363SPhilipp Reisner 3695bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 36960500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3697bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 36987d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3699b411b363SPhilipp Reisner 37007d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 37017d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 37027d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 37037d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 37047d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3705b411b363SPhilipp Reisner 3706bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 37070500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3708bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3709b411b363SPhilipp Reisner 37109534d671SHerbert Xu crypto_free_ahash(connection->peer_integrity_tfm); 3711bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3712bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3713bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3714bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3715bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3716b411b363SPhilipp Reisner 37177d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 37181ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 37197d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3720b411b363SPhilipp Reisner 37217d4c782cSAndreas Gruenbacher synchronize_rcu(); 37227d4c782cSAndreas Gruenbacher kfree(old_net_conf); 372382bc0194SAndreas Gruenbacher return 0; 3724b411b363SPhilipp Reisner 372544ed167dSPhilipp Reisner disconnect_rcu_unlock: 372644ed167dSPhilipp Reisner rcu_read_unlock(); 3727b411b363SPhilipp Reisner disconnect: 37289534d671SHerbert Xu crypto_free_ahash(peer_integrity_tfm); 3729036b17eaSPhilipp Reisner kfree(int_dig_in); 3730036b17eaSPhilipp Reisner kfree(int_dig_vv); 3731bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 373282bc0194SAndreas Gruenbacher return -EIO; 3733b411b363SPhilipp Reisner } 3734b411b363SPhilipp Reisner 3735b411b363SPhilipp Reisner /* helper function 3736b411b363SPhilipp Reisner * input: alg name, feature name 3737b411b363SPhilipp Reisner * return: NULL (alg name was "") 3738b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3739b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 37409534d671SHerbert Xu static struct crypto_ahash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3741b411b363SPhilipp Reisner const char *alg, const char *name) 3742b411b363SPhilipp Reisner { 37439534d671SHerbert Xu struct crypto_ahash *tfm; 3744b411b363SPhilipp Reisner 3745b411b363SPhilipp Reisner if (!alg[0]) 3746b411b363SPhilipp Reisner return NULL; 3747b411b363SPhilipp Reisner 37489534d671SHerbert Xu tfm = crypto_alloc_ahash(alg, 0, CRYPTO_ALG_ASYNC); 3749b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3750d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3751b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3752b411b363SPhilipp Reisner return tfm; 3753b411b363SPhilipp Reisner } 3754b411b363SPhilipp Reisner return tfm; 3755b411b363SPhilipp Reisner } 3756b411b363SPhilipp Reisner 3757bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3758b411b363SPhilipp Reisner { 3759bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 37604a76b161SAndreas Gruenbacher int size = pi->size; 37614a76b161SAndreas Gruenbacher 37624a76b161SAndreas Gruenbacher while (size) { 37634a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3764bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 37654a76b161SAndreas Gruenbacher if (s <= 0) { 37664a76b161SAndreas Gruenbacher if (s < 0) 37674a76b161SAndreas Gruenbacher return s; 37684a76b161SAndreas Gruenbacher break; 37694a76b161SAndreas Gruenbacher } 37704a76b161SAndreas Gruenbacher size -= s; 37714a76b161SAndreas Gruenbacher } 37724a76b161SAndreas Gruenbacher if (size) 37734a76b161SAndreas Gruenbacher return -EIO; 37744a76b161SAndreas Gruenbacher return 0; 37754a76b161SAndreas Gruenbacher } 37764a76b161SAndreas Gruenbacher 37774a76b161SAndreas Gruenbacher /* 37784a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 37794a76b161SAndreas Gruenbacher * 37804a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 37814a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 37824a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 37834a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 37844a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 37854a76b161SAndreas Gruenbacher * 37864a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 37874a76b161SAndreas Gruenbacher */ 3788bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 37894a76b161SAndreas Gruenbacher { 37901ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 37912fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3792bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 37934a76b161SAndreas Gruenbacher } 37944a76b161SAndreas Gruenbacher 3795bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 37964a76b161SAndreas Gruenbacher { 37979f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3798b30ab791SAndreas Gruenbacher struct drbd_device *device; 3799e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3800b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 38019534d671SHerbert Xu struct crypto_ahash *verify_tfm = NULL; 38029534d671SHerbert Xu struct crypto_ahash *csums_tfm = NULL; 38032ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3804813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3805bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3806813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3807778f271dSPhilipp Reisner int fifo_size = 0; 380882bc0194SAndreas Gruenbacher int err; 3809b411b363SPhilipp Reisner 38109f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38119f4fe9adSAndreas Gruenbacher if (!peer_device) 3812bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 38139f4fe9adSAndreas Gruenbacher device = peer_device->device; 3814b411b363SPhilipp Reisner 3815b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3816b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3817b411b363SPhilipp Reisner + SHARED_SECRET_MAX 38188e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 38198e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3820b411b363SPhilipp Reisner 3821e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3822d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3823e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 382482bc0194SAndreas Gruenbacher return -EIO; 3825b411b363SPhilipp Reisner } 3826b411b363SPhilipp Reisner 3827b411b363SPhilipp Reisner if (apv <= 88) { 3828e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3829e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 38308e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3831e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3832e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 38330b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 38348e26f9ccSPhilipp Reisner } else { 3835e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3836e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 38370b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3838b411b363SPhilipp Reisner } 3839b411b363SPhilipp Reisner 3840b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3841e658983aSAndreas Gruenbacher p = pi->data; 3842b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3843b411b363SPhilipp Reisner 38449f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 384582bc0194SAndreas Gruenbacher if (err) 384682bc0194SAndreas Gruenbacher return err; 3847b411b363SPhilipp Reisner 38480500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 38499f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3850b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3851daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3852daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3853b30ab791SAndreas Gruenbacher put_ldev(device); 38540500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3855d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3856daeda1ccSPhilipp Reisner return -ENOMEM; 3857f399002eSLars Ellenberg } 3858b411b363SPhilipp Reisner 3859b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3860daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3861daeda1ccSPhilipp Reisner 38626394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3863813472ceSPhilipp Reisner } 3864b411b363SPhilipp Reisner 3865b411b363SPhilipp Reisner if (apv >= 88) { 3866b411b363SPhilipp Reisner if (apv == 88) { 38675de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3868d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 38695de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3870b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3871813472ceSPhilipp Reisner err = -EIO; 3872813472ceSPhilipp Reisner goto reconnect; 3873b411b363SPhilipp Reisner } 3874b411b363SPhilipp Reisner 38759f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3876813472ceSPhilipp Reisner if (err) 3877813472ceSPhilipp Reisner goto reconnect; 3878b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3879b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38800b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3881b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3882b411b363SPhilipp Reisner 3883b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3884b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3885b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38860b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 38870b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3888b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3889b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3890b411b363SPhilipp Reisner } 3891b411b363SPhilipp Reisner 38922ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3893b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3894d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 38952ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3896b411b363SPhilipp Reisner goto disconnect; 3897b411b363SPhilipp Reisner } 3898b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3899b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3900b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3901b411b363SPhilipp Reisner verify_tfm = NULL; 3902b411b363SPhilipp Reisner goto disconnect; 3903b411b363SPhilipp Reisner } 3904b411b363SPhilipp Reisner } 3905b411b363SPhilipp Reisner 39062ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3907b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3908d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 39092ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3910b411b363SPhilipp Reisner goto disconnect; 3911b411b363SPhilipp Reisner } 3912b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3913b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3914b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3915b411b363SPhilipp Reisner csums_tfm = NULL; 3916b411b363SPhilipp Reisner goto disconnect; 3917b411b363SPhilipp Reisner } 3918b411b363SPhilipp Reisner } 3919b411b363SPhilipp Reisner 3920813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3921daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3922daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3923daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3924daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3925778f271dSPhilipp Reisner 3926daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3927b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3928813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3929813472ceSPhilipp Reisner if (!new_plan) { 3930d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3931b30ab791SAndreas Gruenbacher put_ldev(device); 3932778f271dSPhilipp Reisner goto disconnect; 3933778f271dSPhilipp Reisner } 3934778f271dSPhilipp Reisner } 39358e26f9ccSPhilipp Reisner } 3936b411b363SPhilipp Reisner 393791fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 39382ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 39392ec91e0eSPhilipp Reisner if (!new_net_conf) { 3940d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 394191fd4dadSPhilipp Reisner goto disconnect; 394291fd4dadSPhilipp Reisner } 394391fd4dadSPhilipp Reisner 39442ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 394591fd4dadSPhilipp Reisner 3946b411b363SPhilipp Reisner if (verify_tfm) { 39472ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 39482ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 39499534d671SHerbert Xu crypto_free_ahash(peer_device->connection->verify_tfm); 39509f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3951d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3952b411b363SPhilipp Reisner } 3953b411b363SPhilipp Reisner if (csums_tfm) { 39542ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 39552ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 39569534d671SHerbert Xu crypto_free_ahash(peer_device->connection->csums_tfm); 39579f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3958d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3959b411b363SPhilipp Reisner } 3960bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3961778f271dSPhilipp Reisner } 3962b411b363SPhilipp Reisner } 3963b411b363SPhilipp Reisner 3964813472ceSPhilipp Reisner if (new_disk_conf) { 3965b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3966b30ab791SAndreas Gruenbacher put_ldev(device); 3967b411b363SPhilipp Reisner } 3968813472ceSPhilipp Reisner 3969813472ceSPhilipp Reisner if (new_plan) { 3970b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3971b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3972813472ceSPhilipp Reisner } 3973daeda1ccSPhilipp Reisner 39740500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3975daeda1ccSPhilipp Reisner synchronize_rcu(); 3976daeda1ccSPhilipp Reisner if (new_net_conf) 3977daeda1ccSPhilipp Reisner kfree(old_net_conf); 3978daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3979813472ceSPhilipp Reisner kfree(old_plan); 3980daeda1ccSPhilipp Reisner 398182bc0194SAndreas Gruenbacher return 0; 3982b411b363SPhilipp Reisner 3983813472ceSPhilipp Reisner reconnect: 3984813472ceSPhilipp Reisner if (new_disk_conf) { 3985b30ab791SAndreas Gruenbacher put_ldev(device); 3986813472ceSPhilipp Reisner kfree(new_disk_conf); 3987813472ceSPhilipp Reisner } 39880500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3989813472ceSPhilipp Reisner return -EIO; 3990813472ceSPhilipp Reisner 3991b411b363SPhilipp Reisner disconnect: 3992813472ceSPhilipp Reisner kfree(new_plan); 3993813472ceSPhilipp Reisner if (new_disk_conf) { 3994b30ab791SAndreas Gruenbacher put_ldev(device); 3995813472ceSPhilipp Reisner kfree(new_disk_conf); 3996813472ceSPhilipp Reisner } 39970500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3998b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3999b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 40009534d671SHerbert Xu crypto_free_ahash(csums_tfm); 4001b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 40029534d671SHerbert Xu crypto_free_ahash(verify_tfm); 40039f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 400482bc0194SAndreas Gruenbacher return -EIO; 4005b411b363SPhilipp Reisner } 4006b411b363SPhilipp Reisner 4007b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 4008b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 4009b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 4010b411b363SPhilipp Reisner { 4011b411b363SPhilipp Reisner sector_t d; 4012b411b363SPhilipp Reisner if (a == 0 || b == 0) 4013b411b363SPhilipp Reisner return; 4014b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 4015b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 4016d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 4017b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 4018b411b363SPhilipp Reisner } 4019b411b363SPhilipp Reisner 4020bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 4021b411b363SPhilipp Reisner { 40229f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4023b30ab791SAndreas Gruenbacher struct drbd_device *device; 4024e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 40259104d31aSLars Ellenberg struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL; 4026e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 40276a8d68b1SLars Ellenberg sector_t p_size, p_usize, p_csize, my_usize; 4028b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 4029e89b591cSPhilipp Reisner enum dds_flags ddsf; 4030b411b363SPhilipp Reisner 40319f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 40329f4fe9adSAndreas Gruenbacher if (!peer_device) 4033bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 40349f4fe9adSAndreas Gruenbacher device = peer_device->device; 40354a76b161SAndreas Gruenbacher 4036b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 4037b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 40386a8d68b1SLars Ellenberg p_csize = be64_to_cpu(p->c_size); 4039b411b363SPhilipp Reisner 4040b411b363SPhilipp Reisner /* just store the peer's disk size for now. 4041b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 4042b30ab791SAndreas Gruenbacher device->p_size = p_size; 4043b411b363SPhilipp Reisner 4044b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 404560bac040SLars Ellenberg sector_t new_size, cur_size; 4046daeda1ccSPhilipp Reisner rcu_read_lock(); 4047b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 4048daeda1ccSPhilipp Reisner rcu_read_unlock(); 4049daeda1ccSPhilipp Reisner 4050b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 4051b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 4052b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 4053daeda1ccSPhilipp Reisner p_usize, my_usize); 4054b411b363SPhilipp Reisner 4055b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 4056b411b363SPhilipp Reisner * param exchange, choose the minimum */ 4057b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 4058daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 4059b411b363SPhilipp Reisner 4060b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 4061b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 406260bac040SLars Ellenberg new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0); 406360bac040SLars Ellenberg cur_size = drbd_get_capacity(device->this_bdev); 406460bac040SLars Ellenberg if (new_size < cur_size && 4065b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 4066b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 406760bac040SLars Ellenberg drbd_err(device, "The peer's disk size is too small! (%llu < %llu sectors)\n", 406860bac040SLars Ellenberg (unsigned long long)new_size, (unsigned long long)cur_size); 40699f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 4070b30ab791SAndreas Gruenbacher put_ldev(device); 407182bc0194SAndreas Gruenbacher return -EIO; 4072b411b363SPhilipp Reisner } 4073daeda1ccSPhilipp Reisner 4074daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 4075daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 4076daeda1ccSPhilipp Reisner 4077daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 4078daeda1ccSPhilipp Reisner if (!new_disk_conf) { 4079d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 4080b30ab791SAndreas Gruenbacher put_ldev(device); 4081daeda1ccSPhilipp Reisner return -ENOMEM; 4082daeda1ccSPhilipp Reisner } 4083daeda1ccSPhilipp Reisner 40840500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 4085b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 4086daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 4087daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 4088daeda1ccSPhilipp Reisner 4089b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 40900500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 4091daeda1ccSPhilipp Reisner synchronize_rcu(); 4092daeda1ccSPhilipp Reisner kfree(old_disk_conf); 4093daeda1ccSPhilipp Reisner 4094d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 4095daeda1ccSPhilipp Reisner (unsigned long)my_usize); 4096daeda1ccSPhilipp Reisner } 4097daeda1ccSPhilipp Reisner 4098b30ab791SAndreas Gruenbacher put_ldev(device); 4099b411b363SPhilipp Reisner } 4100b411b363SPhilipp Reisner 410120c68fdeSLars Ellenberg device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 4102dd4f699dSLars Ellenberg /* Leave drbd_reconsider_queue_parameters() before drbd_determine_dev_size(). 410320c68fdeSLars Ellenberg In case we cleared the QUEUE_FLAG_DISCARD from our queue in 4104dd4f699dSLars Ellenberg drbd_reconsider_queue_parameters(), we can be sure that after 410520c68fdeSLars Ellenberg drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */ 410620c68fdeSLars Ellenberg 4107e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 4108b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 41099104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, device->ldev, o); 4110b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 4111b30ab791SAndreas Gruenbacher put_ldev(device); 4112e96c9633SPhilipp Reisner if (dd == DS_ERROR) 411382bc0194SAndreas Gruenbacher return -EIO; 4114b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4115b411b363SPhilipp Reisner } else { 41166a8d68b1SLars Ellenberg /* 41176a8d68b1SLars Ellenberg * I am diskless, need to accept the peer's *current* size. 41186a8d68b1SLars Ellenberg * I must NOT accept the peers backing disk size, 41196a8d68b1SLars Ellenberg * it may have been larger than mine all along... 41206a8d68b1SLars Ellenberg * 41216a8d68b1SLars Ellenberg * At this point, the peer knows more about my disk, or at 41226a8d68b1SLars Ellenberg * least about what we last agreed upon, than myself. 41236a8d68b1SLars Ellenberg * So if his c_size is less than his d_size, the most likely 41246a8d68b1SLars Ellenberg * reason is that *my* d_size was smaller last time we checked. 41256a8d68b1SLars Ellenberg * 41266a8d68b1SLars Ellenberg * However, if he sends a zero current size, 41276a8d68b1SLars Ellenberg * take his (user-capped or) backing disk size anyways. 41286a8d68b1SLars Ellenberg */ 41299104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, NULL, o); 41306a8d68b1SLars Ellenberg drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); 4131b411b363SPhilipp Reisner } 4132b411b363SPhilipp Reisner 4133b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4134b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 4135b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 4136b411b363SPhilipp Reisner ldsc = 1; 4137b411b363SPhilipp Reisner } 4138b411b363SPhilipp Reisner 4139b30ab791SAndreas Gruenbacher put_ldev(device); 4140b411b363SPhilipp Reisner } 4141b411b363SPhilipp Reisner 4142b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 4143b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 4144b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 4145b411b363SPhilipp Reisner /* we have different sizes, probably peer 4146b411b363SPhilipp Reisner * needs to know my new size... */ 414769a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 4148b411b363SPhilipp Reisner } 4149b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 4150b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 4151b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 4152b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 4153e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 4154d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 4155b411b363SPhilipp Reisner else 4156b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 4157e89b591cSPhilipp Reisner } else 4158b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 4159b411b363SPhilipp Reisner } 4160b411b363SPhilipp Reisner } 4161b411b363SPhilipp Reisner 416282bc0194SAndreas Gruenbacher return 0; 4163b411b363SPhilipp Reisner } 4164b411b363SPhilipp Reisner 4165bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 4166b411b363SPhilipp Reisner { 41679f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4168b30ab791SAndreas Gruenbacher struct drbd_device *device; 4169e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 4170b411b363SPhilipp Reisner u64 *p_uuid; 417162b0da3aSLars Ellenberg int i, updated_uuids = 0; 4172b411b363SPhilipp Reisner 41739f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 41749f4fe9adSAndreas Gruenbacher if (!peer_device) 4175bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 41769f4fe9adSAndreas Gruenbacher device = peer_device->device; 41774a76b161SAndreas Gruenbacher 4178b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 4179063eacf8SJing Wang if (!p_uuid) { 4180d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 4181063eacf8SJing Wang return false; 4182063eacf8SJing Wang } 4183b411b363SPhilipp Reisner 4184b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 4185b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 4186b411b363SPhilipp Reisner 4187b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4188b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 4189b411b363SPhilipp Reisner 4190b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 4191b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 4192b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 4193b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 4194d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 4195b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 41969f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 419782bc0194SAndreas Gruenbacher return -EIO; 4198b411b363SPhilipp Reisner } 4199b411b363SPhilipp Reisner 4200b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4201b411b363SPhilipp Reisner int skip_initial_sync = 4202b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 42039f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 4204b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 4205b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 4206b411b363SPhilipp Reisner if (skip_initial_sync) { 4207d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 4208b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 420920ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 421020ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 4211b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 4212b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 4213b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 4214b411b363SPhilipp Reisner CS_VERBOSE, NULL); 4215b30ab791SAndreas Gruenbacher drbd_md_sync(device); 421662b0da3aSLars Ellenberg updated_uuids = 1; 4217b411b363SPhilipp Reisner } 4218b30ab791SAndreas Gruenbacher put_ldev(device); 4219b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 4220b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 422118a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 422218a50fa2SPhilipp Reisner for me. */ 4223b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 4224b411b363SPhilipp Reisner } 4225b411b363SPhilipp Reisner 4226b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 4227b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 4228b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 4229b411b363SPhilipp Reisner new disk state... */ 4230b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 4231b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 4232b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 4233b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 423462b0da3aSLars Ellenberg 423562b0da3aSLars Ellenberg if (updated_uuids) 4236b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 4237b411b363SPhilipp Reisner 423882bc0194SAndreas Gruenbacher return 0; 4239b411b363SPhilipp Reisner } 4240b411b363SPhilipp Reisner 4241b411b363SPhilipp Reisner /** 4242b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 4243b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 4244b411b363SPhilipp Reisner */ 4245b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 4246b411b363SPhilipp Reisner { 4247b411b363SPhilipp Reisner union drbd_state ms; 4248b411b363SPhilipp Reisner 4249b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 4250369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 4251b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 4252b411b363SPhilipp Reisner 4253b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 4254b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 4255b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 4256b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 4257b411b363SPhilipp Reisner [C_MASK] = C_MASK, 4258b411b363SPhilipp Reisner }; 4259b411b363SPhilipp Reisner 4260b411b363SPhilipp Reisner ms.i = ps.i; 4261b411b363SPhilipp Reisner 4262b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 4263b411b363SPhilipp Reisner ms.peer = ps.role; 4264b411b363SPhilipp Reisner ms.role = ps.peer; 4265b411b363SPhilipp Reisner ms.pdsk = ps.disk; 4266b411b363SPhilipp Reisner ms.disk = ps.pdsk; 4267b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 4268b411b363SPhilipp Reisner 4269b411b363SPhilipp Reisner return ms; 4270b411b363SPhilipp Reisner } 4271b411b363SPhilipp Reisner 4272bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 4273b411b363SPhilipp Reisner { 42749f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4275b30ab791SAndreas Gruenbacher struct drbd_device *device; 4276e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4277b411b363SPhilipp Reisner union drbd_state mask, val; 4278bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 4279b411b363SPhilipp Reisner 42809f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42819f4fe9adSAndreas Gruenbacher if (!peer_device) 42824a76b161SAndreas Gruenbacher return -EIO; 42839f4fe9adSAndreas Gruenbacher device = peer_device->device; 42844a76b161SAndreas Gruenbacher 4285b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4286b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 4287b411b363SPhilipp Reisner 42889f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 4289b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 429069a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 429182bc0194SAndreas Gruenbacher return 0; 4292b411b363SPhilipp Reisner } 4293b411b363SPhilipp Reisner 4294b411b363SPhilipp Reisner mask = convert_state(mask); 4295b411b363SPhilipp Reisner val = convert_state(val); 4296b411b363SPhilipp Reisner 4297b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 429869a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 4299047cd4a6SPhilipp Reisner 4300b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4301b411b363SPhilipp Reisner 430282bc0194SAndreas Gruenbacher return 0; 4303b411b363SPhilipp Reisner } 4304b411b363SPhilipp Reisner 4305bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 4306b411b363SPhilipp Reisner { 4307e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4308dfafcc8aSPhilipp Reisner union drbd_state mask, val; 4309dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 4310dfafcc8aSPhilipp Reisner 4311dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4312dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 4313dfafcc8aSPhilipp Reisner 4314bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 4315bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 4316bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 431782bc0194SAndreas Gruenbacher return 0; 4318dfafcc8aSPhilipp Reisner } 4319dfafcc8aSPhilipp Reisner 4320dfafcc8aSPhilipp Reisner mask = convert_state(mask); 4321dfafcc8aSPhilipp Reisner val = convert_state(val); 4322dfafcc8aSPhilipp Reisner 4323bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 4324bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 4325dfafcc8aSPhilipp Reisner 432682bc0194SAndreas Gruenbacher return 0; 4327dfafcc8aSPhilipp Reisner } 4328dfafcc8aSPhilipp Reisner 4329bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 4330b411b363SPhilipp Reisner { 43319f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4332b30ab791SAndreas Gruenbacher struct drbd_device *device; 4333e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 43344ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 4335b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 433665d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 4337b411b363SPhilipp Reisner int rv; 4338b411b363SPhilipp Reisner 43399f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 43409f4fe9adSAndreas Gruenbacher if (!peer_device) 4341bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 43429f4fe9adSAndreas Gruenbacher device = peer_device->device; 43434a76b161SAndreas Gruenbacher 4344b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 4345b411b363SPhilipp Reisner 4346b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 4347b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 4348b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 4349d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 4350b411b363SPhilipp Reisner } 4351b411b363SPhilipp Reisner 43520500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4353b411b363SPhilipp Reisner retry: 4354b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 43550500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4356b411b363SPhilipp Reisner 4357668700b4SPhilipp Reisner /* If some other part of the code (ack_receiver thread, timeout) 4358545752d5SLars Ellenberg * already decided to close the connection again, 4359545752d5SLars Ellenberg * we must not "re-establish" it here. */ 4360545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 436158ffa580SLars Ellenberg return -ECONNRESET; 4362545752d5SLars Ellenberg 436340424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 436440424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 436540424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 436640424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 436740424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 436840424e4aSLars Ellenberg */ 436940424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 437040424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 4371e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 4372e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 4373e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 4374e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 4375e9ef7bb6SLars Ellenberg * syncing states. 4376e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 4377e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 4378e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 4379e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 4380e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 4381e9ef7bb6SLars Ellenberg 4382e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 4383e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 4384e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 4385e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 4386e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 4387b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 4388b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 438982bc0194SAndreas Gruenbacher return 0; 4390e9ef7bb6SLars Ellenberg } 4391e9ef7bb6SLars Ellenberg } 4392e9ef7bb6SLars Ellenberg 439302b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 439402b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 439502b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 4396b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 4397b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 439858ffa580SLars Ellenberg return 0; 439902b91b55SLars Ellenberg } 440002b91b55SLars Ellenberg 4401e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 4402e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 4403e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 4404e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 4405e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 4406e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 4407e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 4408e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 4409e9ef7bb6SLars Ellenberg 44104ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 44114ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4412b411b363SPhilipp Reisner 441367531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 441467531718SPhilipp Reisner ns.conn = C_BEHIND; 441567531718SPhilipp Reisner 4416b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 4417b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 4418b411b363SPhilipp Reisner int cr; /* consider resync */ 4419b411b363SPhilipp Reisner 4420b411b363SPhilipp Reisner /* if we established a new connection */ 44214ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 4422b411b363SPhilipp Reisner /* if we had an established connection 4423b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 44244ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4425b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 44264ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 4427b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 4428b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 4429b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 4430b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 4431b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 44324ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4433b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 4434b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 4435b411b363SPhilipp Reisner 4436b411b363SPhilipp Reisner if (cr) 443769a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 4438b411b363SPhilipp Reisner 4439b30ab791SAndreas Gruenbacher put_ldev(device); 44404ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 44414ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4442b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 4443b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 4444b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 4445d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 4446b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 4447580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 4448b411b363SPhilipp Reisner } else { 44499f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 445082bc0194SAndreas Gruenbacher return -EIO; 44510b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 44529f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 445382bc0194SAndreas Gruenbacher return -EIO; 4454b411b363SPhilipp Reisner } 4455b411b363SPhilipp Reisner } 4456b411b363SPhilipp Reisner } 4457b411b363SPhilipp Reisner 44580500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4459b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 4460b411b363SPhilipp Reisner goto retry; 4461b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 4462b411b363SPhilipp Reisner ns.peer = peer_state.role; 4463b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4464b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 44654ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4466b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 44674ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4468b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4469b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 44708554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4471481c6f50SPhilipp Reisner for temporal network outages! */ 44720500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4473d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 44749f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4475b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4476b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 44779f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 447882bc0194SAndreas Gruenbacher return -EIO; 4479481c6f50SPhilipp Reisner } 4480b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4481b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 44820500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4483b411b363SPhilipp Reisner 4484b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 44859f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 448682bc0194SAndreas Gruenbacher return -EIO; 4487b411b363SPhilipp Reisner } 4488b411b363SPhilipp Reisner 44894ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 44904ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4491b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4492b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4493b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4494b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 449569a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 449669a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4497b411b363SPhilipp Reisner } 4498b411b363SPhilipp Reisner } 4499b411b363SPhilipp Reisner 4500b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4501b411b363SPhilipp Reisner 4502b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4503b411b363SPhilipp Reisner 450482bc0194SAndreas Gruenbacher return 0; 4505b411b363SPhilipp Reisner } 4506b411b363SPhilipp Reisner 4507bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4508b411b363SPhilipp Reisner { 45099f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4510b30ab791SAndreas Gruenbacher struct drbd_device *device; 4511e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 45124a76b161SAndreas Gruenbacher 45139f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 45149f4fe9adSAndreas Gruenbacher if (!peer_device) 45154a76b161SAndreas Gruenbacher return -EIO; 45169f4fe9adSAndreas Gruenbacher device = peer_device->device; 4517b411b363SPhilipp Reisner 4518b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4519b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4520b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4521b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4522b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4523b411b363SPhilipp Reisner 45240b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4525b411b363SPhilipp Reisner 4526b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4527b411b363SPhilipp Reisner _not_ be rotated into the history */ 4528b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4529b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4530b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4531b411b363SPhilipp Reisner 4532b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4533b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4534b411b363SPhilipp Reisner 4535b30ab791SAndreas Gruenbacher put_ldev(device); 4536b411b363SPhilipp Reisner } else 4537d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4538b411b363SPhilipp Reisner 453982bc0194SAndreas Gruenbacher return 0; 4540b411b363SPhilipp Reisner } 4541b411b363SPhilipp Reisner 45422c46407dSAndreas Gruenbacher /** 45432c46407dSAndreas Gruenbacher * receive_bitmap_plain 45442c46407dSAndreas Gruenbacher * 45452c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 45462c46407dSAndreas Gruenbacher * code upon failure. 45472c46407dSAndreas Gruenbacher */ 45482c46407dSAndreas Gruenbacher static int 454969a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4550e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4551b411b363SPhilipp Reisner { 455250d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 455369a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4554e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 455550d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4556e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 45572c46407dSAndreas Gruenbacher int err; 4558b411b363SPhilipp Reisner 455950d0b1adSAndreas Gruenbacher if (want != size) { 456069a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 45612c46407dSAndreas Gruenbacher return -EIO; 4562b411b363SPhilipp Reisner } 4563b411b363SPhilipp Reisner if (want == 0) 45642c46407dSAndreas Gruenbacher return 0; 456569a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 456682bc0194SAndreas Gruenbacher if (err) 45672c46407dSAndreas Gruenbacher return err; 4568b411b363SPhilipp Reisner 456969a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4570b411b363SPhilipp Reisner 4571b411b363SPhilipp Reisner c->word_offset += num_words; 4572b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4573b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4574b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4575b411b363SPhilipp Reisner 45762c46407dSAndreas Gruenbacher return 1; 4577b411b363SPhilipp Reisner } 4578b411b363SPhilipp Reisner 4579a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4580a02d1240SAndreas Gruenbacher { 4581a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4582a02d1240SAndreas Gruenbacher } 4583a02d1240SAndreas Gruenbacher 4584a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4585a02d1240SAndreas Gruenbacher { 4586a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4587a02d1240SAndreas Gruenbacher } 4588a02d1240SAndreas Gruenbacher 4589a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4590a02d1240SAndreas Gruenbacher { 4591a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4592a02d1240SAndreas Gruenbacher } 4593a02d1240SAndreas Gruenbacher 45942c46407dSAndreas Gruenbacher /** 45952c46407dSAndreas Gruenbacher * recv_bm_rle_bits 45962c46407dSAndreas Gruenbacher * 45972c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 45982c46407dSAndreas Gruenbacher * code upon failure. 45992c46407dSAndreas Gruenbacher */ 46002c46407dSAndreas Gruenbacher static int 460169a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4602b411b363SPhilipp Reisner struct p_compressed_bm *p, 4603c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4604c6d25cfeSPhilipp Reisner unsigned int len) 4605b411b363SPhilipp Reisner { 4606b411b363SPhilipp Reisner struct bitstream bs; 4607b411b363SPhilipp Reisner u64 look_ahead; 4608b411b363SPhilipp Reisner u64 rl; 4609b411b363SPhilipp Reisner u64 tmp; 4610b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4611b411b363SPhilipp Reisner unsigned long e; 4612a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4613b411b363SPhilipp Reisner int have; 4614b411b363SPhilipp Reisner int bits; 4615b411b363SPhilipp Reisner 4616a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4617b411b363SPhilipp Reisner 4618b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4619b411b363SPhilipp Reisner if (bits < 0) 46202c46407dSAndreas Gruenbacher return -EIO; 4621b411b363SPhilipp Reisner 4622b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4623b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4624b411b363SPhilipp Reisner if (bits <= 0) 46252c46407dSAndreas Gruenbacher return -EIO; 4626b411b363SPhilipp Reisner 4627b411b363SPhilipp Reisner if (toggle) { 4628b411b363SPhilipp Reisner e = s + rl -1; 4629b411b363SPhilipp Reisner if (e >= c->bm_bits) { 463069a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 46312c46407dSAndreas Gruenbacher return -EIO; 4632b411b363SPhilipp Reisner } 463369a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4634b411b363SPhilipp Reisner } 4635b411b363SPhilipp Reisner 4636b411b363SPhilipp Reisner if (have < bits) { 463769a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4638b411b363SPhilipp Reisner have, bits, look_ahead, 4639b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4640b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 46412c46407dSAndreas Gruenbacher return -EIO; 4642b411b363SPhilipp Reisner } 4643d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4644d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4645b411b363SPhilipp Reisner look_ahead >>= bits; 4646d2da5b0cSLars Ellenberg else 4647d2da5b0cSLars Ellenberg look_ahead = 0; 4648b411b363SPhilipp Reisner have -= bits; 4649b411b363SPhilipp Reisner 4650b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4651b411b363SPhilipp Reisner if (bits < 0) 46522c46407dSAndreas Gruenbacher return -EIO; 4653b411b363SPhilipp Reisner look_ahead |= tmp << have; 4654b411b363SPhilipp Reisner have += bits; 4655b411b363SPhilipp Reisner } 4656b411b363SPhilipp Reisner 4657b411b363SPhilipp Reisner c->bit_offset = s; 4658b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4659b411b363SPhilipp Reisner 46602c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4661b411b363SPhilipp Reisner } 4662b411b363SPhilipp Reisner 46632c46407dSAndreas Gruenbacher /** 46642c46407dSAndreas Gruenbacher * decode_bitmap_c 46652c46407dSAndreas Gruenbacher * 46662c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 46672c46407dSAndreas Gruenbacher * code upon failure. 46682c46407dSAndreas Gruenbacher */ 46692c46407dSAndreas Gruenbacher static int 467069a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4671b411b363SPhilipp Reisner struct p_compressed_bm *p, 4672c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4673c6d25cfeSPhilipp Reisner unsigned int len) 4674b411b363SPhilipp Reisner { 4675a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 467669a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4677b411b363SPhilipp Reisner 4678b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4679b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4680b411b363SPhilipp Reisner * during all our tests. */ 4681b411b363SPhilipp Reisner 468269a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 468369a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 46842c46407dSAndreas Gruenbacher return -EIO; 4685b411b363SPhilipp Reisner } 4686b411b363SPhilipp Reisner 4687b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4688b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4689b411b363SPhilipp Reisner { 4690b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4691a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 469250d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 469350d0b1adSAndreas Gruenbacher unsigned int plain = 469450d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 469550d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 469650d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 469750d0b1adSAndreas Gruenbacher unsigned int r; 4698b411b363SPhilipp Reisner 4699b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4700b411b363SPhilipp Reisner if (total == 0) 4701b411b363SPhilipp Reisner return; 4702b411b363SPhilipp Reisner 4703b411b363SPhilipp Reisner /* don't report if not compressed */ 4704b411b363SPhilipp Reisner if (total >= plain) 4705b411b363SPhilipp Reisner return; 4706b411b363SPhilipp Reisner 4707b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4708b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4709b411b363SPhilipp Reisner : (1000 * total / plain); 4710b411b363SPhilipp Reisner 4711b411b363SPhilipp Reisner if (r > 1000) 4712b411b363SPhilipp Reisner r = 1000; 4713b411b363SPhilipp Reisner 4714b411b363SPhilipp Reisner r = 1000 - r; 4715d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4716b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4717b411b363SPhilipp Reisner direction, 4718b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4719b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4720b411b363SPhilipp Reisner total, r/10, r % 10); 4721b411b363SPhilipp Reisner } 4722b411b363SPhilipp Reisner 4723b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4724b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4725b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4726b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4727b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4728b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4729b411b363SPhilipp Reisner 4730b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4731bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4732b411b363SPhilipp Reisner { 47339f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4734b30ab791SAndreas Gruenbacher struct drbd_device *device; 4735b411b363SPhilipp Reisner struct bm_xfer_ctx c; 47362c46407dSAndreas Gruenbacher int err; 47374a76b161SAndreas Gruenbacher 47389f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 47399f4fe9adSAndreas Gruenbacher if (!peer_device) 47404a76b161SAndreas Gruenbacher return -EIO; 47419f4fe9adSAndreas Gruenbacher device = peer_device->device; 4742b411b363SPhilipp Reisner 4743b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 474420ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 474520ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4746b411b363SPhilipp Reisner 4747b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4748b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4749b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4750b411b363SPhilipp Reisner }; 4751b411b363SPhilipp Reisner 47522c46407dSAndreas Gruenbacher for(;;) { 4753e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 475469a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4755e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4756b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4757b411b363SPhilipp Reisner * and the feature is enabled! */ 4758e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4759b411b363SPhilipp Reisner 4760bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4761d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 476282bc0194SAndreas Gruenbacher err = -EIO; 4763b411b363SPhilipp Reisner goto out; 4764b411b363SPhilipp Reisner } 4765e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4766d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 476782bc0194SAndreas Gruenbacher err = -EIO; 476878fcbdaeSAndreas Gruenbacher goto out; 4769b411b363SPhilipp Reisner } 47709f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4771e658983aSAndreas Gruenbacher if (err) 4772e658983aSAndreas Gruenbacher goto out; 477369a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4774b411b363SPhilipp Reisner } else { 4775d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 477682bc0194SAndreas Gruenbacher err = -EIO; 4777b411b363SPhilipp Reisner goto out; 4778b411b363SPhilipp Reisner } 4779b411b363SPhilipp Reisner 4780e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4781bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4782b411b363SPhilipp Reisner 47832c46407dSAndreas Gruenbacher if (err <= 0) { 47842c46407dSAndreas Gruenbacher if (err < 0) 47852c46407dSAndreas Gruenbacher goto out; 4786b411b363SPhilipp Reisner break; 47872c46407dSAndreas Gruenbacher } 47889f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 478982bc0194SAndreas Gruenbacher if (err) 4790b411b363SPhilipp Reisner goto out; 47912c46407dSAndreas Gruenbacher } 4792b411b363SPhilipp Reisner 4793b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4794b411b363SPhilipp Reisner 4795b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4796de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4797de1f8e4aSAndreas Gruenbacher 4798b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 479982bc0194SAndreas Gruenbacher if (err) 4800b411b363SPhilipp Reisner goto out; 4801b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4802b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 48030b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4804b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4805b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4806b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4807d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4808b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4809b411b363SPhilipp Reisner } 481082bc0194SAndreas Gruenbacher err = 0; 4811b411b363SPhilipp Reisner 4812b411b363SPhilipp Reisner out: 4813b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4814b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4815b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 481682bc0194SAndreas Gruenbacher return err; 4817b411b363SPhilipp Reisner } 4818b411b363SPhilipp Reisner 4819bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4820b411b363SPhilipp Reisner { 48211ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4822e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4823b411b363SPhilipp Reisner 4824bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4825b411b363SPhilipp Reisner } 4826b411b363SPhilipp Reisner 4827bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4828b411b363SPhilipp Reisner { 4829b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4830b411b363SPhilipp Reisner * with the data requests being unplugged */ 4831bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4832b411b363SPhilipp Reisner 483382bc0194SAndreas Gruenbacher return 0; 4834b411b363SPhilipp Reisner } 4835b411b363SPhilipp Reisner 4836bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 483773a01a18SPhilipp Reisner { 48389f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4839b30ab791SAndreas Gruenbacher struct drbd_device *device; 4840e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 48414a76b161SAndreas Gruenbacher 48429f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 48439f4fe9adSAndreas Gruenbacher if (!peer_device) 48444a76b161SAndreas Gruenbacher return -EIO; 48459f4fe9adSAndreas Gruenbacher device = peer_device->device; 484673a01a18SPhilipp Reisner 4847b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4848f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4849f735e363SLars Ellenberg case C_WF_BITMAP_T: 4850f735e363SLars Ellenberg case C_BEHIND: 4851f735e363SLars Ellenberg break; 4852f735e363SLars Ellenberg default: 4853d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4854b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4855f735e363SLars Ellenberg } 4856f735e363SLars Ellenberg 4857b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 485873a01a18SPhilipp Reisner 485982bc0194SAndreas Gruenbacher return 0; 486073a01a18SPhilipp Reisner } 486173a01a18SPhilipp Reisner 4862700ca8c0SPhilipp Reisner static int receive_rs_deallocated(struct drbd_connection *connection, struct packet_info *pi) 4863700ca8c0SPhilipp Reisner { 4864700ca8c0SPhilipp Reisner struct drbd_peer_device *peer_device; 4865700ca8c0SPhilipp Reisner struct p_block_desc *p = pi->data; 4866700ca8c0SPhilipp Reisner struct drbd_device *device; 4867700ca8c0SPhilipp Reisner sector_t sector; 4868700ca8c0SPhilipp Reisner int size, err = 0; 4869700ca8c0SPhilipp Reisner 4870700ca8c0SPhilipp Reisner peer_device = conn_peer_device(connection, pi->vnr); 4871700ca8c0SPhilipp Reisner if (!peer_device) 4872700ca8c0SPhilipp Reisner return -EIO; 4873700ca8c0SPhilipp Reisner device = peer_device->device; 4874700ca8c0SPhilipp Reisner 4875700ca8c0SPhilipp Reisner sector = be64_to_cpu(p->sector); 4876700ca8c0SPhilipp Reisner size = be32_to_cpu(p->blksize); 4877700ca8c0SPhilipp Reisner 4878700ca8c0SPhilipp Reisner dec_rs_pending(device); 4879700ca8c0SPhilipp Reisner 4880700ca8c0SPhilipp Reisner if (get_ldev(device)) { 4881700ca8c0SPhilipp Reisner struct drbd_peer_request *peer_req; 4882700ca8c0SPhilipp Reisner const int op = REQ_OP_DISCARD; 4883700ca8c0SPhilipp Reisner 4884700ca8c0SPhilipp Reisner peer_req = drbd_alloc_peer_req(peer_device, ID_SYNCER, sector, 48859104d31aSLars Ellenberg size, 0, GFP_NOIO); 4886700ca8c0SPhilipp Reisner if (!peer_req) { 4887700ca8c0SPhilipp Reisner put_ldev(device); 4888700ca8c0SPhilipp Reisner return -ENOMEM; 4889700ca8c0SPhilipp Reisner } 4890700ca8c0SPhilipp Reisner 4891700ca8c0SPhilipp Reisner peer_req->w.cb = e_end_resync_block; 4892700ca8c0SPhilipp Reisner peer_req->submit_jif = jiffies; 4893700ca8c0SPhilipp Reisner peer_req->flags |= EE_IS_TRIM; 4894700ca8c0SPhilipp Reisner 4895700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4896700ca8c0SPhilipp Reisner list_add_tail(&peer_req->w.list, &device->sync_ee); 4897700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4898700ca8c0SPhilipp Reisner 4899700ca8c0SPhilipp Reisner atomic_add(pi->size >> 9, &device->rs_sect_ev); 4900700ca8c0SPhilipp Reisner err = drbd_submit_peer_request(device, peer_req, op, 0, DRBD_FAULT_RS_WR); 4901700ca8c0SPhilipp Reisner 4902700ca8c0SPhilipp Reisner if (err) { 4903700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4904700ca8c0SPhilipp Reisner list_del(&peer_req->w.list); 4905700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4906700ca8c0SPhilipp Reisner 4907700ca8c0SPhilipp Reisner drbd_free_peer_req(device, peer_req); 4908700ca8c0SPhilipp Reisner put_ldev(device); 4909700ca8c0SPhilipp Reisner err = 0; 4910700ca8c0SPhilipp Reisner goto fail; 4911700ca8c0SPhilipp Reisner } 4912700ca8c0SPhilipp Reisner 4913700ca8c0SPhilipp Reisner inc_unacked(device); 4914700ca8c0SPhilipp Reisner 4915700ca8c0SPhilipp Reisner /* No put_ldev() here. Gets called in drbd_endio_write_sec_final(), 4916700ca8c0SPhilipp Reisner as well as drbd_rs_complete_io() */ 4917700ca8c0SPhilipp Reisner } else { 4918700ca8c0SPhilipp Reisner fail: 4919700ca8c0SPhilipp Reisner drbd_rs_complete_io(device, sector); 4920700ca8c0SPhilipp Reisner drbd_send_ack_ex(peer_device, P_NEG_ACK, sector, size, ID_SYNCER); 4921700ca8c0SPhilipp Reisner } 4922700ca8c0SPhilipp Reisner 4923700ca8c0SPhilipp Reisner atomic_add(size >> 9, &device->rs_sect_in); 4924700ca8c0SPhilipp Reisner 4925700ca8c0SPhilipp Reisner return err; 4926700ca8c0SPhilipp Reisner } 4927700ca8c0SPhilipp Reisner 492802918be2SPhilipp Reisner struct data_cmd { 492902918be2SPhilipp Reisner int expect_payload; 49309104d31aSLars Ellenberg unsigned int pkt_size; 4931bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4932b411b363SPhilipp Reisner }; 4933b411b363SPhilipp Reisner 493402918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 493502918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 493602918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 493702918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 493802918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4939e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4940e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4941e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 494202918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 494302918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4944e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4945e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 494602918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 494702918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 494802918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 494902918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 495002918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 495102918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 495202918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 495302918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 495402918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 4955700ca8c0SPhilipp Reisner [P_RS_THIN_REQ] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 495602918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 495773a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 49584a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4959036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 4960a0fb3c47SLars Ellenberg [P_TRIM] = { 0, sizeof(struct p_trim), receive_Data }, 4961700ca8c0SPhilipp Reisner [P_RS_DEALLOCATED] = { 0, sizeof(struct p_block_desc), receive_rs_deallocated }, 49629104d31aSLars Ellenberg [P_WSAME] = { 1, sizeof(struct p_wsame), receive_Data }, 496302918be2SPhilipp Reisner }; 496402918be2SPhilipp Reisner 4965bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4966b411b363SPhilipp Reisner { 496777351055SPhilipp Reisner struct packet_info pi; 496802918be2SPhilipp Reisner size_t shs; /* sub header size */ 496982bc0194SAndreas Gruenbacher int err; 4970b411b363SPhilipp Reisner 4971bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 49729104d31aSLars Ellenberg struct data_cmd const *cmd; 4973deebe195SAndreas Gruenbacher 4974bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4975944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_header); 4976bde89a9eSAndreas Gruenbacher if (drbd_recv_header(connection, &pi)) 497702918be2SPhilipp Reisner goto err_out; 497802918be2SPhilipp Reisner 4979deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 49804a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 49811ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 49822fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 498302918be2SPhilipp Reisner goto err_out; 49840b33a916SLars Ellenberg } 4985b411b363SPhilipp Reisner 4986e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 49879104d31aSLars Ellenberg if (pi.cmd == P_SIZES && connection->agreed_features & DRBD_FF_WSAME) 49889104d31aSLars Ellenberg shs += sizeof(struct o_qlim); 4989e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 49901ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 49912fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4992c13f7e1aSLars Ellenberg goto err_out; 4993c13f7e1aSLars Ellenberg } 49949104d31aSLars Ellenberg if (pi.size < shs) { 49959104d31aSLars Ellenberg drbd_err(connection, "%s: unexpected packet size, expected:%d received:%d\n", 49969104d31aSLars Ellenberg cmdname(pi.cmd), (int)shs, pi.size); 49979104d31aSLars Ellenberg goto err_out; 49989104d31aSLars Ellenberg } 4999c13f7e1aSLars Ellenberg 5000c13f7e1aSLars Ellenberg if (shs) { 5001944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_all_warn); 5002bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 5003a5c31904SAndreas Gruenbacher if (err) 500402918be2SPhilipp Reisner goto err_out; 5005e2857216SAndreas Gruenbacher pi.size -= shs; 5006b411b363SPhilipp Reisner } 500702918be2SPhilipp Reisner 5008944410e9SLars Ellenberg update_receiver_timing_details(connection, cmd->fn); 5009bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 50104a76b161SAndreas Gruenbacher if (err) { 50111ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 50129f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 501302918be2SPhilipp Reisner goto err_out; 501402918be2SPhilipp Reisner } 501502918be2SPhilipp Reisner } 501682bc0194SAndreas Gruenbacher return; 501702918be2SPhilipp Reisner 501802918be2SPhilipp Reisner err_out: 5019bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 5020b411b363SPhilipp Reisner } 5021b411b363SPhilipp Reisner 5022bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 5023f70b3511SPhilipp Reisner { 5024c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5025bbeb641cSPhilipp Reisner enum drbd_conns oc; 5026376694a0SPhilipp Reisner int vnr; 5027f70b3511SPhilipp Reisner 5028bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 5029b411b363SPhilipp Reisner return; 5030b411b363SPhilipp Reisner 5031545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 5032545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 5033545752d5SLars Ellenberg * Usually we should be in some network failure state already, 5034545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 5035545752d5SLars Ellenberg */ 5036bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5037545752d5SLars Ellenberg 5038668700b4SPhilipp Reisner /* ack_receiver does not clean up anything. it must not interfere, either */ 50391c03e520SPhilipp Reisner drbd_thread_stop(&connection->ack_receiver); 5040668700b4SPhilipp Reisner if (connection->ack_sender) { 5041668700b4SPhilipp Reisner destroy_workqueue(connection->ack_sender); 5042668700b4SPhilipp Reisner connection->ack_sender = NULL; 5043668700b4SPhilipp Reisner } 5044bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 5045360cc740SPhilipp Reisner 5046c141ebdaSPhilipp Reisner rcu_read_lock(); 5047c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5048c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5049b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5050c141ebdaSPhilipp Reisner rcu_read_unlock(); 505169a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 5052c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5053c141ebdaSPhilipp Reisner rcu_read_lock(); 5054c141ebdaSPhilipp Reisner } 5055c141ebdaSPhilipp Reisner rcu_read_unlock(); 5056c141ebdaSPhilipp Reisner 5057bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 50581ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 505912038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 5060bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 5061bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 506212038a3aSPhilipp Reisner 50631ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 5064360cc740SPhilipp Reisner 5065bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 5066bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 5067cb703454SPhilipp Reisner 50680500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5069bde89a9eSAndreas Gruenbacher oc = connection->cstate; 5070bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 5071bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 5072bbeb641cSPhilipp Reisner 50730500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5074360cc740SPhilipp Reisner 5075f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 5076bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 5077360cc740SPhilipp Reisner } 5078360cc740SPhilipp Reisner 507969a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 5080360cc740SPhilipp Reisner { 508169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5082360cc740SPhilipp Reisner unsigned int i; 5083b411b363SPhilipp Reisner 508485719573SPhilipp Reisner /* wait for current activity to cease. */ 50850500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5086b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 5087b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 5088b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 50890500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5090b411b363SPhilipp Reisner 5091b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 5092b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 5093b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 5094b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 5095b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 5096b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 5097b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 5098b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 5099b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 5100b411b363SPhilipp Reisner * on the fly. */ 5101b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5102b30ab791SAndreas Gruenbacher device->rs_total = 0; 5103b30ab791SAndreas Gruenbacher device->rs_failed = 0; 5104b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 5105b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 5106b411b363SPhilipp Reisner 5107b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 5108b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 5109b411b363SPhilipp Reisner 5110b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 5111b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 5112b411b363SPhilipp Reisner * to be "canceled" */ 5113b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5114b411b363SPhilipp Reisner 5115b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 5116b411b363SPhilipp Reisner 5117d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 5118d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 5119d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 5120b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5121d10b4ea3SPhilipp Reisner 512208332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 512308332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 5124b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5125b411b363SPhilipp Reisner 5126b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 5127b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 5128b411b363SPhilipp Reisner 5129b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 513069a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 5131b411b363SPhilipp Reisner 5132b30ab791SAndreas Gruenbacher drbd_md_sync(device); 5133b411b363SPhilipp Reisner 5134be115b69SLars Ellenberg if (get_ldev(device)) { 5135be115b69SLars Ellenberg drbd_bitmap_io(device, &drbd_bm_write_copy_pages, 5136be115b69SLars Ellenberg "write from disconnected", BM_LOCKED_CHANGE_ALLOWED); 5137be115b69SLars Ellenberg put_ldev(device); 5138be115b69SLars Ellenberg } 513920ceb2b2SLars Ellenberg 5140b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 5141b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 5142b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 5143b411b363SPhilipp Reisner * 5144b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 5145b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 5146b411b363SPhilipp Reisner */ 5147b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 5148b411b363SPhilipp Reisner if (i) 5149d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 5150b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 5151435f0740SLars Ellenberg if (i) 5152d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 5153b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 5154b411b363SPhilipp Reisner if (i) 5155d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 5156b411b363SPhilipp Reisner 51570b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 51580b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 51590b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 51600b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 5161b411b363SPhilipp Reisner 5162360cc740SPhilipp Reisner return 0; 5163b411b363SPhilipp Reisner } 5164b411b363SPhilipp Reisner 5165b411b363SPhilipp Reisner /* 5166b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 5167b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 5168b411b363SPhilipp Reisner * 5169b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 5170b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 5171b411b363SPhilipp Reisner * 5172b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 5173b411b363SPhilipp Reisner */ 5174bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 5175b411b363SPhilipp Reisner { 51769f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 51779f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 5178b411b363SPhilipp Reisner 5179bde89a9eSAndreas Gruenbacher sock = &connection->data; 5180bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 51819f5bdc33SAndreas Gruenbacher if (!p) 5182e8d17b01SAndreas Gruenbacher return -EIO; 5183b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 5184b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 5185b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 518620c68fdeSLars Ellenberg p->feature_flags = cpu_to_be32(PRO_FEATURES); 5187bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 5188b411b363SPhilipp Reisner } 5189b411b363SPhilipp Reisner 5190b411b363SPhilipp Reisner /* 5191b411b363SPhilipp Reisner * return values: 5192b411b363SPhilipp Reisner * 1 yes, we have a valid connection 5193b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 5194b411b363SPhilipp Reisner * -1 peer talks different language, 5195b411b363SPhilipp Reisner * no point in trying again, please go standalone. 5196b411b363SPhilipp Reisner */ 5197bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 5198b411b363SPhilipp Reisner { 5199bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 5200e658983aSAndreas Gruenbacher struct p_connection_features *p; 5201e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 520277351055SPhilipp Reisner struct packet_info pi; 5203a5c31904SAndreas Gruenbacher int err; 5204b411b363SPhilipp Reisner 5205bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 5206e8d17b01SAndreas Gruenbacher if (err) 5207b411b363SPhilipp Reisner return 0; 5208b411b363SPhilipp Reisner 5209bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 521069bc7bc3SAndreas Gruenbacher if (err) 5211b411b363SPhilipp Reisner return 0; 5212b411b363SPhilipp Reisner 52136038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 52141ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 521577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5216b411b363SPhilipp Reisner return -1; 5217b411b363SPhilipp Reisner } 5218b411b363SPhilipp Reisner 521977351055SPhilipp Reisner if (pi.size != expect) { 52201ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 522177351055SPhilipp Reisner expect, pi.size); 5222b411b363SPhilipp Reisner return -1; 5223b411b363SPhilipp Reisner } 5224b411b363SPhilipp Reisner 5225e658983aSAndreas Gruenbacher p = pi.data; 5226bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 5227a5c31904SAndreas Gruenbacher if (err) 5228b411b363SPhilipp Reisner return 0; 5229b411b363SPhilipp Reisner 5230b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 5231b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 5232b411b363SPhilipp Reisner if (p->protocol_max == 0) 5233b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 5234b411b363SPhilipp Reisner 5235b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 5236b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 5237b411b363SPhilipp Reisner goto incompat; 5238b411b363SPhilipp Reisner 5239bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 524020c68fdeSLars Ellenberg connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); 5241b411b363SPhilipp Reisner 52421ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 5243bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 5244b411b363SPhilipp Reisner 52459104d31aSLars Ellenberg drbd_info(connection, "Feature flags enabled on protocol level: 0x%x%s%s%s.\n", 52469104d31aSLars Ellenberg connection->agreed_features, 52479104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "", 52489104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "", 52499104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" : 52509104d31aSLars Ellenberg connection->agreed_features ? "" : " none"); 525192d94ae6SPhilipp Reisner 5252b411b363SPhilipp Reisner return 1; 5253b411b363SPhilipp Reisner 5254b411b363SPhilipp Reisner incompat: 52551ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 5256b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 5257b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 5258b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 5259b411b363SPhilipp Reisner return -1; 5260b411b363SPhilipp Reisner } 5261b411b363SPhilipp Reisner 5262b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 5263bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5264b411b363SPhilipp Reisner { 52651ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 52661ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 5267b10d96cbSJohannes Thoma return -1; 5268b411b363SPhilipp Reisner } 5269b411b363SPhilipp Reisner #else 5270b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 5271b10d96cbSJohannes Thoma 5272b10d96cbSJohannes Thoma /* Return value: 5273b10d96cbSJohannes Thoma 1 - auth succeeded, 5274b10d96cbSJohannes Thoma 0 - failed, try again (network error), 5275b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 5276b10d96cbSJohannes Thoma */ 5277b10d96cbSJohannes Thoma 5278bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5279b411b363SPhilipp Reisner { 52809f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 5281b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 5282b411b363SPhilipp Reisner char *response = NULL; 5283b411b363SPhilipp Reisner char *right_response = NULL; 5284b411b363SPhilipp Reisner char *peers_ch = NULL; 528544ed167dSPhilipp Reisner unsigned int key_len; 528644ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 5287b411b363SPhilipp Reisner unsigned int resp_size; 52889534d671SHerbert Xu SHASH_DESC_ON_STACK(desc, connection->cram_hmac_tfm); 528977351055SPhilipp Reisner struct packet_info pi; 529044ed167dSPhilipp Reisner struct net_conf *nc; 529169bc7bc3SAndreas Gruenbacher int err, rv; 5292b411b363SPhilipp Reisner 52939f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 52949f5bdc33SAndreas Gruenbacher 529544ed167dSPhilipp Reisner rcu_read_lock(); 5296bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 529744ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 529844ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 529944ed167dSPhilipp Reisner rcu_read_unlock(); 530044ed167dSPhilipp Reisner 53019534d671SHerbert Xu desc->tfm = connection->cram_hmac_tfm; 53029534d671SHerbert Xu desc->flags = 0; 5303b411b363SPhilipp Reisner 53049534d671SHerbert Xu rv = crypto_shash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 5305b411b363SPhilipp Reisner if (rv) { 53069534d671SHerbert Xu drbd_err(connection, "crypto_shash_setkey() failed with %d\n", rv); 5307b10d96cbSJohannes Thoma rv = -1; 5308b411b363SPhilipp Reisner goto fail; 5309b411b363SPhilipp Reisner } 5310b411b363SPhilipp Reisner 5311b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 5312b411b363SPhilipp Reisner 5313bde89a9eSAndreas Gruenbacher sock = &connection->data; 5314bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 53159f5bdc33SAndreas Gruenbacher rv = 0; 53169f5bdc33SAndreas Gruenbacher goto fail; 53179f5bdc33SAndreas Gruenbacher } 5318bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 53199f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 5320b411b363SPhilipp Reisner if (!rv) 5321b411b363SPhilipp Reisner goto fail; 5322b411b363SPhilipp Reisner 5323bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 532469bc7bc3SAndreas Gruenbacher if (err) { 5325b411b363SPhilipp Reisner rv = 0; 5326b411b363SPhilipp Reisner goto fail; 5327b411b363SPhilipp Reisner } 5328b411b363SPhilipp Reisner 532977351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 53301ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 533177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5332b411b363SPhilipp Reisner rv = 0; 5333b411b363SPhilipp Reisner goto fail; 5334b411b363SPhilipp Reisner } 5335b411b363SPhilipp Reisner 533677351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 53371ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 5338b10d96cbSJohannes Thoma rv = -1; 5339b411b363SPhilipp Reisner goto fail; 5340b411b363SPhilipp Reisner } 5341b411b363SPhilipp Reisner 534267cca286SPhilipp Reisner if (pi.size < CHALLENGE_LEN) { 534367cca286SPhilipp Reisner drbd_err(connection, "AuthChallenge payload too small.\n"); 534467cca286SPhilipp Reisner rv = -1; 534567cca286SPhilipp Reisner goto fail; 534667cca286SPhilipp Reisner } 534767cca286SPhilipp Reisner 534877351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 5349b411b363SPhilipp Reisner if (peers_ch == NULL) { 53501ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 5351b10d96cbSJohannes Thoma rv = -1; 5352b411b363SPhilipp Reisner goto fail; 5353b411b363SPhilipp Reisner } 5354b411b363SPhilipp Reisner 5355bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 5356a5c31904SAndreas Gruenbacher if (err) { 5357b411b363SPhilipp Reisner rv = 0; 5358b411b363SPhilipp Reisner goto fail; 5359b411b363SPhilipp Reisner } 5360b411b363SPhilipp Reisner 536167cca286SPhilipp Reisner if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) { 536267cca286SPhilipp Reisner drbd_err(connection, "Peer presented the same challenge!\n"); 536367cca286SPhilipp Reisner rv = -1; 536467cca286SPhilipp Reisner goto fail; 536567cca286SPhilipp Reisner } 536667cca286SPhilipp Reisner 53679534d671SHerbert Xu resp_size = crypto_shash_digestsize(connection->cram_hmac_tfm); 5368b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 5369b411b363SPhilipp Reisner if (response == NULL) { 53701ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 5371b10d96cbSJohannes Thoma rv = -1; 5372b411b363SPhilipp Reisner goto fail; 5373b411b363SPhilipp Reisner } 5374b411b363SPhilipp Reisner 53759534d671SHerbert Xu rv = crypto_shash_digest(desc, peers_ch, pi.size, response); 5376b411b363SPhilipp Reisner if (rv) { 53771ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5378b10d96cbSJohannes Thoma rv = -1; 5379b411b363SPhilipp Reisner goto fail; 5380b411b363SPhilipp Reisner } 5381b411b363SPhilipp Reisner 5382bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 53839f5bdc33SAndreas Gruenbacher rv = 0; 53849f5bdc33SAndreas Gruenbacher goto fail; 53859f5bdc33SAndreas Gruenbacher } 5386bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 53879f5bdc33SAndreas Gruenbacher response, resp_size); 5388b411b363SPhilipp Reisner if (!rv) 5389b411b363SPhilipp Reisner goto fail; 5390b411b363SPhilipp Reisner 5391bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 539269bc7bc3SAndreas Gruenbacher if (err) { 5393b411b363SPhilipp Reisner rv = 0; 5394b411b363SPhilipp Reisner goto fail; 5395b411b363SPhilipp Reisner } 5396b411b363SPhilipp Reisner 539777351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 53981ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 539977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5400b411b363SPhilipp Reisner rv = 0; 5401b411b363SPhilipp Reisner goto fail; 5402b411b363SPhilipp Reisner } 5403b411b363SPhilipp Reisner 540477351055SPhilipp Reisner if (pi.size != resp_size) { 54051ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 5406b411b363SPhilipp Reisner rv = 0; 5407b411b363SPhilipp Reisner goto fail; 5408b411b363SPhilipp Reisner } 5409b411b363SPhilipp Reisner 5410bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 5411a5c31904SAndreas Gruenbacher if (err) { 5412b411b363SPhilipp Reisner rv = 0; 5413b411b363SPhilipp Reisner goto fail; 5414b411b363SPhilipp Reisner } 5415b411b363SPhilipp Reisner 5416b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 54172d1ee87dSJulia Lawall if (right_response == NULL) { 54181ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 5419b10d96cbSJohannes Thoma rv = -1; 5420b411b363SPhilipp Reisner goto fail; 5421b411b363SPhilipp Reisner } 5422b411b363SPhilipp Reisner 54239534d671SHerbert Xu rv = crypto_shash_digest(desc, my_challenge, CHALLENGE_LEN, 54249534d671SHerbert Xu right_response); 5425b411b363SPhilipp Reisner if (rv) { 54261ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5427b10d96cbSJohannes Thoma rv = -1; 5428b411b363SPhilipp Reisner goto fail; 5429b411b363SPhilipp Reisner } 5430b411b363SPhilipp Reisner 5431b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 5432b411b363SPhilipp Reisner 5433b411b363SPhilipp Reisner if (rv) 54341ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 543544ed167dSPhilipp Reisner resp_size); 5436b10d96cbSJohannes Thoma else 5437b10d96cbSJohannes Thoma rv = -1; 5438b411b363SPhilipp Reisner 5439b411b363SPhilipp Reisner fail: 5440b411b363SPhilipp Reisner kfree(peers_ch); 5441b411b363SPhilipp Reisner kfree(response); 5442b411b363SPhilipp Reisner kfree(right_response); 54439534d671SHerbert Xu shash_desc_zero(desc); 5444b411b363SPhilipp Reisner 5445b411b363SPhilipp Reisner return rv; 5446b411b363SPhilipp Reisner } 5447b411b363SPhilipp Reisner #endif 5448b411b363SPhilipp Reisner 54498fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 5450b411b363SPhilipp Reisner { 5451bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5452b411b363SPhilipp Reisner int h; 5453b411b363SPhilipp Reisner 54541ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 5455b411b363SPhilipp Reisner 5456b411b363SPhilipp Reisner do { 5457bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 5458b411b363SPhilipp Reisner if (h == 0) { 5459bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 546020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 5461b411b363SPhilipp Reisner } 5462b411b363SPhilipp Reisner if (h == -1) { 54631ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 5464bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5465b411b363SPhilipp Reisner } 5466b411b363SPhilipp Reisner } while (h == 0); 5467b411b363SPhilipp Reisner 546891fd4dadSPhilipp Reisner if (h > 0) 5469bde89a9eSAndreas Gruenbacher drbdd(connection); 5470b411b363SPhilipp Reisner 5471bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 5472b411b363SPhilipp Reisner 54731ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 5474b411b363SPhilipp Reisner return 0; 5475b411b363SPhilipp Reisner } 5476b411b363SPhilipp Reisner 5477b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 5478b411b363SPhilipp Reisner 5479bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5480b411b363SPhilipp Reisner { 5481e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5482b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5483b411b363SPhilipp Reisner 5484b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 5485bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 5486b411b363SPhilipp Reisner } else { 5487bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 54881ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 5489fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5490fc3b10a4SPhilipp Reisner } 5491bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5492e4f78edeSPhilipp Reisner 54932735a594SAndreas Gruenbacher return 0; 5494fc3b10a4SPhilipp Reisner } 5495e4f78edeSPhilipp Reisner 5496bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5497e4f78edeSPhilipp Reisner { 54989f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5499b30ab791SAndreas Gruenbacher struct drbd_device *device; 5500e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5501e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5502e4f78edeSPhilipp Reisner 55039f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55049f4fe9adSAndreas Gruenbacher if (!peer_device) 55052735a594SAndreas Gruenbacher return -EIO; 55069f4fe9adSAndreas Gruenbacher device = peer_device->device; 55071952e916SAndreas Gruenbacher 5508bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 55090b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 5510bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 55114d0fc3fdSPhilipp Reisner } 55124d0fc3fdSPhilipp Reisner 5513e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 5514b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 5515e4f78edeSPhilipp Reisner } else { 5516b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 5517d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 5518b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5519b411b363SPhilipp Reisner } 5520b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 5521b411b363SPhilipp Reisner 55222735a594SAndreas Gruenbacher return 0; 5523b411b363SPhilipp Reisner } 5524b411b363SPhilipp Reisner 5525bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 5526b411b363SPhilipp Reisner { 5527bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 5528b411b363SPhilipp Reisner 5529b411b363SPhilipp Reisner } 5530b411b363SPhilipp Reisner 5531bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 5532b411b363SPhilipp Reisner { 5533b411b363SPhilipp Reisner /* restore idle timeout */ 5534bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 5535bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 5536bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5537b411b363SPhilipp Reisner 55382735a594SAndreas Gruenbacher return 0; 5539b411b363SPhilipp Reisner } 5540b411b363SPhilipp Reisner 5541bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 5542b411b363SPhilipp Reisner { 55439f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5544b30ab791SAndreas Gruenbacher struct drbd_device *device; 5545e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5546b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5547b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5548b411b363SPhilipp Reisner 55499f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55509f4fe9adSAndreas Gruenbacher if (!peer_device) 55512735a594SAndreas Gruenbacher return -EIO; 55529f4fe9adSAndreas Gruenbacher device = peer_device->device; 55531952e916SAndreas Gruenbacher 55549f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 5555b411b363SPhilipp Reisner 555669a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5557b411b363SPhilipp Reisner 5558b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 5559b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5560b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5561b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 5562b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 5563b30ab791SAndreas Gruenbacher put_ldev(device); 55641d53f09eSLars Ellenberg } 5565b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5566b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5567b411b363SPhilipp Reisner 55682735a594SAndreas Gruenbacher return 0; 5569b411b363SPhilipp Reisner } 5570b411b363SPhilipp Reisner 5571bc9c5c41SAndreas Gruenbacher static int 5572b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5573bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5574bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5575b411b363SPhilipp Reisner { 5576b411b363SPhilipp Reisner struct drbd_request *req; 5577b411b363SPhilipp Reisner struct bio_and_error m; 5578b411b363SPhilipp Reisner 55790500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5580b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5581b411b363SPhilipp Reisner if (unlikely(!req)) { 55820500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 558385997675SAndreas Gruenbacher return -EIO; 5584b411b363SPhilipp Reisner } 5585b411b363SPhilipp Reisner __req_mod(req, what, &m); 55860500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5587b411b363SPhilipp Reisner 5588b411b363SPhilipp Reisner if (m.bio) 5589b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 559085997675SAndreas Gruenbacher return 0; 5591b411b363SPhilipp Reisner } 5592b411b363SPhilipp Reisner 5593bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5594b411b363SPhilipp Reisner { 55959f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5596b30ab791SAndreas Gruenbacher struct drbd_device *device; 5597e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5598b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5599b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5600b411b363SPhilipp Reisner enum drbd_req_event what; 5601b411b363SPhilipp Reisner 56029f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56039f4fe9adSAndreas Gruenbacher if (!peer_device) 56042735a594SAndreas Gruenbacher return -EIO; 56059f4fe9adSAndreas Gruenbacher device = peer_device->device; 56061952e916SAndreas Gruenbacher 560769a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5608b411b363SPhilipp Reisner 5609579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5610b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5611b30ab791SAndreas Gruenbacher dec_rs_pending(device); 56122735a594SAndreas Gruenbacher return 0; 5613b411b363SPhilipp Reisner } 5614e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5615b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 56168554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5617b411b363SPhilipp Reisner break; 5618b411b363SPhilipp Reisner case P_WRITE_ACK: 56198554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5620b411b363SPhilipp Reisner break; 5621b411b363SPhilipp Reisner case P_RECV_ACK: 56228554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5623b411b363SPhilipp Reisner break; 5624d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5625d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 56267be8da07SAndreas Gruenbacher break; 56277be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 56287be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5629b411b363SPhilipp Reisner break; 5630b411b363SPhilipp Reisner default: 56312735a594SAndreas Gruenbacher BUG(); 5632b411b363SPhilipp Reisner } 5633b411b363SPhilipp Reisner 5634b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5635b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5636bc9c5c41SAndreas Gruenbacher what, false); 5637b411b363SPhilipp Reisner } 5638b411b363SPhilipp Reisner 5639bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5640b411b363SPhilipp Reisner { 56419f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5642b30ab791SAndreas Gruenbacher struct drbd_device *device; 5643e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5644b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 56452deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 564685997675SAndreas Gruenbacher int err; 5647b411b363SPhilipp Reisner 56489f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56499f4fe9adSAndreas Gruenbacher if (!peer_device) 56502735a594SAndreas Gruenbacher return -EIO; 56519f4fe9adSAndreas Gruenbacher device = peer_device->device; 5652b411b363SPhilipp Reisner 565369a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5654b411b363SPhilipp Reisner 5655579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5656b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5657b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 56582735a594SAndreas Gruenbacher return 0; 5659b411b363SPhilipp Reisner } 56602deb8336SPhilipp Reisner 5661b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5662b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5663303d1448SPhilipp Reisner NEG_ACKED, true); 566485997675SAndreas Gruenbacher if (err) { 56652deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 56662deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5667c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 56682deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 56692deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5670b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 56712deb8336SPhilipp Reisner } 56722735a594SAndreas Gruenbacher return 0; 5673b411b363SPhilipp Reisner } 5674b411b363SPhilipp Reisner 5675bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5676b411b363SPhilipp Reisner { 56779f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5678b30ab791SAndreas Gruenbacher struct drbd_device *device; 5679e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5680b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5681b411b363SPhilipp Reisner 56829f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56839f4fe9adSAndreas Gruenbacher if (!peer_device) 56842735a594SAndreas Gruenbacher return -EIO; 56859f4fe9adSAndreas Gruenbacher device = peer_device->device; 56861952e916SAndreas Gruenbacher 568769a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 56887be8da07SAndreas Gruenbacher 5689d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5690b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5691b411b363SPhilipp Reisner 5692b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5693b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 56948554df1cSAndreas Gruenbacher NEG_ACKED, false); 5695b411b363SPhilipp Reisner } 5696b411b363SPhilipp Reisner 5697bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5698b411b363SPhilipp Reisner { 56999f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5700b30ab791SAndreas Gruenbacher struct drbd_device *device; 5701b411b363SPhilipp Reisner sector_t sector; 5702b411b363SPhilipp Reisner int size; 5703e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 57041952e916SAndreas Gruenbacher 57059f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 57069f4fe9adSAndreas Gruenbacher if (!peer_device) 57072735a594SAndreas Gruenbacher return -EIO; 57089f4fe9adSAndreas Gruenbacher device = peer_device->device; 5709b411b363SPhilipp Reisner 5710b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5711b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5712b411b363SPhilipp Reisner 571369a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5714b411b363SPhilipp Reisner 5715b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5716b411b363SPhilipp Reisner 5717b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5718b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5719e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5720d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5721b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5722d612d309SPhilipp Reisner case P_RS_CANCEL: 5723d612d309SPhilipp Reisner break; 5724d612d309SPhilipp Reisner default: 57252735a594SAndreas Gruenbacher BUG(); 5726d612d309SPhilipp Reisner } 5727b30ab791SAndreas Gruenbacher put_ldev(device); 5728b411b363SPhilipp Reisner } 5729b411b363SPhilipp Reisner 57302735a594SAndreas Gruenbacher return 0; 5731b411b363SPhilipp Reisner } 5732b411b363SPhilipp Reisner 5733bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5734b411b363SPhilipp Reisner { 5735e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5736c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 57379ed57dcbSLars Ellenberg int vnr; 5738b411b363SPhilipp Reisner 5739bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5740b411b363SPhilipp Reisner 57419ed57dcbSLars Ellenberg rcu_read_lock(); 5742c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5743c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5744c06ece6bSAndreas Gruenbacher 5745b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5746b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5747b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5748b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5749b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5750c4752ef1SPhilipp Reisner } 57519ed57dcbSLars Ellenberg } 57529ed57dcbSLars Ellenberg rcu_read_unlock(); 5753c4752ef1SPhilipp Reisner 57542735a594SAndreas Gruenbacher return 0; 5755b411b363SPhilipp Reisner } 5756b411b363SPhilipp Reisner 5757bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5758b411b363SPhilipp Reisner { 57599f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5760b30ab791SAndreas Gruenbacher struct drbd_device *device; 5761e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 576284b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5763b411b363SPhilipp Reisner sector_t sector; 5764b411b363SPhilipp Reisner int size; 5765b411b363SPhilipp Reisner 57669f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 57679f4fe9adSAndreas Gruenbacher if (!peer_device) 57682735a594SAndreas Gruenbacher return -EIO; 57699f4fe9adSAndreas Gruenbacher device = peer_device->device; 57701952e916SAndreas Gruenbacher 5771b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5772b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5773b411b363SPhilipp Reisner 577469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5775b411b363SPhilipp Reisner 5776b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5777b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5778b411b363SPhilipp Reisner else 5779b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5780b411b363SPhilipp Reisner 5781b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 57822735a594SAndreas Gruenbacher return 0; 57831d53f09eSLars Ellenberg 5784b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5785b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5786b411b363SPhilipp Reisner 5787b30ab791SAndreas Gruenbacher --device->ov_left; 5788ea5442afSLars Ellenberg 5789ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5790b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5791b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5792ea5442afSLars Ellenberg 5793b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 579484b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 579584b8c06bSAndreas Gruenbacher if (dw) { 579684b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 579784b8c06bSAndreas Gruenbacher dw->device = device; 579884b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5799b411b363SPhilipp Reisner } else { 580084b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5801b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5802b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5803b411b363SPhilipp Reisner } 5804b411b363SPhilipp Reisner } 5805b30ab791SAndreas Gruenbacher put_ldev(device); 58062735a594SAndreas Gruenbacher return 0; 5807b411b363SPhilipp Reisner } 5808b411b363SPhilipp Reisner 5809bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 58100ced55a3SPhilipp Reisner { 58112735a594SAndreas Gruenbacher return 0; 58120ced55a3SPhilipp Reisner } 58130ced55a3SPhilipp Reisner 5814668700b4SPhilipp Reisner struct meta_sock_cmd { 5815b411b363SPhilipp Reisner size_t pkt_size; 5816bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5817b411b363SPhilipp Reisner }; 5818b411b363SPhilipp Reisner 5819668700b4SPhilipp Reisner static void set_rcvtimeo(struct drbd_connection *connection, bool ping_timeout) 5820668700b4SPhilipp Reisner { 5821668700b4SPhilipp Reisner long t; 5822668700b4SPhilipp Reisner struct net_conf *nc; 5823668700b4SPhilipp Reisner 5824668700b4SPhilipp Reisner rcu_read_lock(); 5825668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 5826668700b4SPhilipp Reisner t = ping_timeout ? nc->ping_timeo : nc->ping_int; 5827668700b4SPhilipp Reisner rcu_read_unlock(); 5828668700b4SPhilipp Reisner 5829668700b4SPhilipp Reisner t *= HZ; 5830668700b4SPhilipp Reisner if (ping_timeout) 5831668700b4SPhilipp Reisner t /= 10; 5832668700b4SPhilipp Reisner 5833668700b4SPhilipp Reisner connection->meta.socket->sk->sk_rcvtimeo = t; 5834668700b4SPhilipp Reisner } 5835668700b4SPhilipp Reisner 5836668700b4SPhilipp Reisner static void set_ping_timeout(struct drbd_connection *connection) 5837668700b4SPhilipp Reisner { 5838668700b4SPhilipp Reisner set_rcvtimeo(connection, 1); 5839668700b4SPhilipp Reisner } 5840668700b4SPhilipp Reisner 5841668700b4SPhilipp Reisner static void set_idle_timeout(struct drbd_connection *connection) 5842668700b4SPhilipp Reisner { 5843668700b4SPhilipp Reisner set_rcvtimeo(connection, 0); 5844668700b4SPhilipp Reisner } 5845668700b4SPhilipp Reisner 5846668700b4SPhilipp Reisner static struct meta_sock_cmd ack_receiver_tbl[] = { 5847e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5848e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5849b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5850b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5851b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5852d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5853b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5854b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5855b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5856b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5857b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5858b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5859b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 586002918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5861d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 58621952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 58631952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5864b411b363SPhilipp Reisner }; 5865b411b363SPhilipp Reisner 58661c03e520SPhilipp Reisner int drbd_ack_receiver(struct drbd_thread *thi) 5867b411b363SPhilipp Reisner { 5868bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5869668700b4SPhilipp Reisner struct meta_sock_cmd *cmd = NULL; 587077351055SPhilipp Reisner struct packet_info pi; 5871668700b4SPhilipp Reisner unsigned long pre_recv_jif; 5872257d0af6SPhilipp Reisner int rv; 5873bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5874b411b363SPhilipp Reisner int received = 0; 5875bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 587652b061a4SAndreas Gruenbacher int expect = header_size; 587744ed167dSPhilipp Reisner bool ping_timeout_active = false; 58783990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5879b411b363SPhilipp Reisner 58803990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 58813990e04dSPhilipp Reisner if (rv < 0) 5882668700b4SPhilipp Reisner drbd_err(connection, "drbd_ack_receiver: ERROR set priority, ret=%d\n", rv); 5883b411b363SPhilipp Reisner 5884e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 588580822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 588644ed167dSPhilipp Reisner 5887668700b4SPhilipp Reisner conn_reclaim_net_peer_reqs(connection); 588844ed167dSPhilipp Reisner 5889bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5890bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 58911ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5892841ce241SAndreas Gruenbacher goto reconnect; 5893841ce241SAndreas Gruenbacher } 5894668700b4SPhilipp Reisner set_ping_timeout(connection); 589544ed167dSPhilipp Reisner ping_timeout_active = true; 5896b411b363SPhilipp Reisner } 5897b411b363SPhilipp Reisner 5898668700b4SPhilipp Reisner pre_recv_jif = jiffies; 5899bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5900b411b363SPhilipp Reisner 5901b411b363SPhilipp Reisner /* Note: 5902b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5903b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5904b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5905b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5906b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5907b411b363SPhilipp Reisner * rv == expected: full header or command 5908b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5909b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5910b411b363SPhilipp Reisner */ 5911b411b363SPhilipp Reisner if (likely(rv > 0)) { 5912b411b363SPhilipp Reisner received += rv; 5913b411b363SPhilipp Reisner buf += rv; 5914b411b363SPhilipp Reisner } else if (rv == 0) { 5915bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5916b66623e3SPhilipp Reisner long t; 5917b66623e3SPhilipp Reisner rcu_read_lock(); 5918bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5919b66623e3SPhilipp Reisner rcu_read_unlock(); 5920b66623e3SPhilipp Reisner 5921bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5922bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5923b66623e3SPhilipp Reisner t); 5924599377acSPhilipp Reisner if (t) 5925599377acSPhilipp Reisner break; 5926599377acSPhilipp Reisner } 59271ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5928b411b363SPhilipp Reisner goto reconnect; 5929b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5930cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5931cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5932668700b4SPhilipp Reisner if (time_after(connection->last_received, pre_recv_jif)) 5933cb6518cbSLars Ellenberg continue; 5934f36af18cSLars Ellenberg if (ping_timeout_active) { 59351ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5936b411b363SPhilipp Reisner goto reconnect; 5937b411b363SPhilipp Reisner } 5938bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5939b411b363SPhilipp Reisner continue; 5940b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5941668700b4SPhilipp Reisner /* maybe drbd_thread_stop(): the while condition will notice. 5942668700b4SPhilipp Reisner * maybe woken for send_ping: we'll send a ping above, 5943668700b4SPhilipp Reisner * and change the rcvtimeo */ 5944668700b4SPhilipp Reisner flush_signals(current); 5945b411b363SPhilipp Reisner continue; 5946b411b363SPhilipp Reisner } else { 59471ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5948b411b363SPhilipp Reisner goto reconnect; 5949b411b363SPhilipp Reisner } 5950b411b363SPhilipp Reisner 5951b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5952bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5953b411b363SPhilipp Reisner goto reconnect; 5954668700b4SPhilipp Reisner cmd = &ack_receiver_tbl[pi.cmd]; 5955668700b4SPhilipp Reisner if (pi.cmd >= ARRAY_SIZE(ack_receiver_tbl) || !cmd->fn) { 59561ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 59572fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5958b411b363SPhilipp Reisner goto disconnect; 5959b411b363SPhilipp Reisner } 5960e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 596152b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 59621ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 596377351055SPhilipp Reisner pi.cmd, pi.size); 5964b411b363SPhilipp Reisner goto reconnect; 5965b411b363SPhilipp Reisner } 5966257d0af6SPhilipp Reisner } 5967b411b363SPhilipp Reisner if (received == expect) { 59682735a594SAndreas Gruenbacher bool err; 5969a4fbda8eSPhilipp Reisner 5970bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 59712735a594SAndreas Gruenbacher if (err) { 59721ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5973b411b363SPhilipp Reisner goto reconnect; 59741952e916SAndreas Gruenbacher } 5975b411b363SPhilipp Reisner 5976bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5977f36af18cSLars Ellenberg 5978668700b4SPhilipp Reisner if (cmd == &ack_receiver_tbl[P_PING_ACK]) { 5979668700b4SPhilipp Reisner set_idle_timeout(connection); 598044ed167dSPhilipp Reisner ping_timeout_active = false; 598144ed167dSPhilipp Reisner } 5982b411b363SPhilipp Reisner 5983bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5984b411b363SPhilipp Reisner received = 0; 598552b061a4SAndreas Gruenbacher expect = header_size; 5986b411b363SPhilipp Reisner cmd = NULL; 5987b411b363SPhilipp Reisner } 5988b411b363SPhilipp Reisner } 5989b411b363SPhilipp Reisner 5990b411b363SPhilipp Reisner if (0) { 5991b411b363SPhilipp Reisner reconnect: 5992bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5993bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5994b411b363SPhilipp Reisner } 5995b411b363SPhilipp Reisner if (0) { 5996b411b363SPhilipp Reisner disconnect: 5997bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5998b411b363SPhilipp Reisner } 5999b411b363SPhilipp Reisner 6000668700b4SPhilipp Reisner drbd_info(connection, "ack_receiver terminated\n"); 6001b411b363SPhilipp Reisner 6002b411b363SPhilipp Reisner return 0; 6003b411b363SPhilipp Reisner } 6004668700b4SPhilipp Reisner 6005668700b4SPhilipp Reisner void drbd_send_acks_wf(struct work_struct *ws) 6006668700b4SPhilipp Reisner { 6007668700b4SPhilipp Reisner struct drbd_peer_device *peer_device = 6008668700b4SPhilipp Reisner container_of(ws, struct drbd_peer_device, send_acks_work); 6009668700b4SPhilipp Reisner struct drbd_connection *connection = peer_device->connection; 6010668700b4SPhilipp Reisner struct drbd_device *device = peer_device->device; 6011668700b4SPhilipp Reisner struct net_conf *nc; 6012668700b4SPhilipp Reisner int tcp_cork, err; 6013668700b4SPhilipp Reisner 6014668700b4SPhilipp Reisner rcu_read_lock(); 6015668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 6016668700b4SPhilipp Reisner tcp_cork = nc->tcp_cork; 6017668700b4SPhilipp Reisner rcu_read_unlock(); 6018668700b4SPhilipp Reisner 6019668700b4SPhilipp Reisner if (tcp_cork) 6020668700b4SPhilipp Reisner drbd_tcp_cork(connection->meta.socket); 6021668700b4SPhilipp Reisner 6022668700b4SPhilipp Reisner err = drbd_finish_peer_reqs(device); 6023668700b4SPhilipp Reisner kref_put(&device->kref, drbd_destroy_device); 6024668700b4SPhilipp Reisner /* get is in drbd_endio_write_sec_final(). That is necessary to keep the 6025668700b4SPhilipp Reisner struct work_struct send_acks_work alive, which is in the peer_device object */ 6026668700b4SPhilipp Reisner 6027668700b4SPhilipp Reisner if (err) { 6028668700b4SPhilipp Reisner conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 6029668700b4SPhilipp Reisner return; 6030668700b4SPhilipp Reisner } 6031668700b4SPhilipp Reisner 6032668700b4SPhilipp Reisner if (tcp_cork) 6033668700b4SPhilipp Reisner drbd_tcp_uncork(connection->meta.socket); 6034668700b4SPhilipp Reisner 6035668700b4SPhilipp Reisner return; 6036668700b4SPhilipp Reisner } 6037