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> 39b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 40b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 41b411b363SPhilipp Reisner #include <linux/unistd.h> 42b411b363SPhilipp Reisner #include <linux/vmalloc.h> 43b411b363SPhilipp Reisner #include <linux/random.h> 44b411b363SPhilipp Reisner #include <linux/string.h> 45b411b363SPhilipp Reisner #include <linux/scatterlist.h> 46b411b363SPhilipp Reisner #include "drbd_int.h" 47a3603a6eSAndreas Gruenbacher #include "drbd_protocol.h" 48b411b363SPhilipp Reisner #include "drbd_req.h" 49b411b363SPhilipp Reisner #include "drbd_vli.h" 50b411b363SPhilipp Reisner 519104d31aSLars Ellenberg #define PRO_FEATURES (DRBD_FF_TRIM|DRBD_FF_THIN_RESYNC|DRBD_FF_WSAME) 5220c68fdeSLars Ellenberg 5377351055SPhilipp Reisner struct packet_info { 5477351055SPhilipp Reisner enum drbd_packet cmd; 55e2857216SAndreas Gruenbacher unsigned int size; 56e2857216SAndreas Gruenbacher unsigned int vnr; 57e658983aSAndreas Gruenbacher void *data; 5877351055SPhilipp Reisner }; 5977351055SPhilipp Reisner 60b411b363SPhilipp Reisner enum finish_epoch { 61b411b363SPhilipp Reisner FE_STILL_LIVE, 62b411b363SPhilipp Reisner FE_DESTROYED, 63b411b363SPhilipp Reisner FE_RECYCLED, 64b411b363SPhilipp Reisner }; 65b411b363SPhilipp Reisner 66bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection); 67bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection); 6869a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *); 69a0fb3c47SLars Ellenberg static void conn_wait_active_ee_empty(struct drbd_connection *connection); 70bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *, struct drbd_epoch *, enum epoch_event); 7199920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 72b411b363SPhilipp Reisner 73b411b363SPhilipp Reisner 74b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 75b411b363SPhilipp Reisner 7645bb912bSLars Ellenberg /* 7745bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7845bb912bSLars Ellenberg * page->private being our "next" pointer. 7945bb912bSLars Ellenberg */ 8045bb912bSLars Ellenberg 8145bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8245bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8345bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8445bb912bSLars Ellenberg */ 8545bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8645bb912bSLars Ellenberg { 8745bb912bSLars Ellenberg struct page *page; 8845bb912bSLars Ellenberg struct page *tmp; 8945bb912bSLars Ellenberg 9045bb912bSLars Ellenberg BUG_ON(!n); 9145bb912bSLars Ellenberg BUG_ON(!head); 9245bb912bSLars Ellenberg 9345bb912bSLars Ellenberg page = *head; 9423ce4227SPhilipp Reisner 9523ce4227SPhilipp Reisner if (!page) 9623ce4227SPhilipp Reisner return NULL; 9723ce4227SPhilipp Reisner 9845bb912bSLars Ellenberg while (page) { 9945bb912bSLars Ellenberg tmp = page_chain_next(page); 10045bb912bSLars Ellenberg if (--n == 0) 10145bb912bSLars Ellenberg break; /* found sufficient pages */ 10245bb912bSLars Ellenberg if (tmp == NULL) 10345bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10445bb912bSLars Ellenberg return NULL; 10545bb912bSLars Ellenberg page = tmp; 10645bb912bSLars Ellenberg } 10745bb912bSLars Ellenberg 10845bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10945bb912bSLars Ellenberg set_page_private(page, 0); 11045bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11145bb912bSLars Ellenberg page = *head; 11245bb912bSLars Ellenberg *head = tmp; 11345bb912bSLars Ellenberg return page; 11445bb912bSLars Ellenberg } 11545bb912bSLars Ellenberg 11645bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11745bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11845bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11945bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 12045bb912bSLars Ellenberg { 12145bb912bSLars Ellenberg struct page *tmp; 12245bb912bSLars Ellenberg int i = 1; 12345bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12445bb912bSLars Ellenberg ++i, page = tmp; 12545bb912bSLars Ellenberg if (len) 12645bb912bSLars Ellenberg *len = i; 12745bb912bSLars Ellenberg return page; 12845bb912bSLars Ellenberg } 12945bb912bSLars Ellenberg 13045bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13145bb912bSLars Ellenberg { 13245bb912bSLars Ellenberg struct page *tmp; 13345bb912bSLars Ellenberg int i = 0; 13445bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13545bb912bSLars Ellenberg put_page(page); 13645bb912bSLars Ellenberg ++i; 13745bb912bSLars Ellenberg } 13845bb912bSLars Ellenberg return i; 13945bb912bSLars Ellenberg } 14045bb912bSLars Ellenberg 14145bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14245bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14345bb912bSLars Ellenberg { 14445bb912bSLars Ellenberg #if 1 14545bb912bSLars Ellenberg struct page *tmp; 14645bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14745bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14845bb912bSLars Ellenberg #endif 14945bb912bSLars Ellenberg 15045bb912bSLars Ellenberg /* add chain to head */ 15145bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15245bb912bSLars Ellenberg *head = chain_first; 15345bb912bSLars Ellenberg } 15445bb912bSLars Ellenberg 155b30ab791SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_device *device, 15618c2d522SAndreas Gruenbacher unsigned int number) 157b411b363SPhilipp Reisner { 158b411b363SPhilipp Reisner struct page *page = NULL; 15945bb912bSLars Ellenberg struct page *tmp = NULL; 16018c2d522SAndreas Gruenbacher unsigned int i = 0; 161b411b363SPhilipp Reisner 162b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 163b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16445bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 165b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16645bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16745bb912bSLars Ellenberg if (page) 16845bb912bSLars Ellenberg drbd_pp_vacant -= number; 169b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 17045bb912bSLars Ellenberg if (page) 17145bb912bSLars Ellenberg return page; 172b411b363SPhilipp Reisner } 17345bb912bSLars Ellenberg 174b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 175b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 176b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17745bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17845bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17945bb912bSLars Ellenberg if (!tmp) 18045bb912bSLars Ellenberg break; 18145bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18245bb912bSLars Ellenberg page = tmp; 18345bb912bSLars Ellenberg } 18445bb912bSLars Ellenberg 18545bb912bSLars Ellenberg if (i == number) 186b411b363SPhilipp Reisner return page; 18745bb912bSLars Ellenberg 18845bb912bSLars Ellenberg /* Not enough pages immediately available this time. 189c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 19045bb912bSLars Ellenberg * function "soon". */ 19145bb912bSLars Ellenberg if (page) { 19245bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19345bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19445bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19545bb912bSLars Ellenberg drbd_pp_vacant += i; 19645bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19745bb912bSLars Ellenberg } 19845bb912bSLars Ellenberg return NULL; 199b411b363SPhilipp Reisner } 200b411b363SPhilipp Reisner 201b30ab791SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_device *device, 202a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 203b411b363SPhilipp Reisner { 204a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req, *tmp; 205b411b363SPhilipp Reisner 206b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 207b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 208b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 209b411b363SPhilipp Reisner stop to examine the list... */ 210b411b363SPhilipp Reisner 211a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, tmp, &device->net_ee, w.list) { 212045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 213b411b363SPhilipp Reisner break; 214a8cd15baSAndreas Gruenbacher list_move(&peer_req->w.list, to_be_freed); 215b411b363SPhilipp Reisner } 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner 218668700b4SPhilipp Reisner static void drbd_reclaim_net_peer_reqs(struct drbd_device *device) 219b411b363SPhilipp Reisner { 220b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 221db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 222b411b363SPhilipp Reisner 2230500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 224b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 2250500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 226a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 227b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 228b411b363SPhilipp Reisner } 229b411b363SPhilipp Reisner 230668700b4SPhilipp Reisner static void conn_reclaim_net_peer_reqs(struct drbd_connection *connection) 231668700b4SPhilipp Reisner { 232668700b4SPhilipp Reisner struct drbd_peer_device *peer_device; 233668700b4SPhilipp Reisner int vnr; 234668700b4SPhilipp Reisner 235668700b4SPhilipp Reisner rcu_read_lock(); 236668700b4SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 237668700b4SPhilipp Reisner struct drbd_device *device = peer_device->device; 238668700b4SPhilipp Reisner if (!atomic_read(&device->pp_in_use_by_net)) 239668700b4SPhilipp Reisner continue; 240668700b4SPhilipp Reisner 241668700b4SPhilipp Reisner kref_get(&device->kref); 242668700b4SPhilipp Reisner rcu_read_unlock(); 243668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 244668700b4SPhilipp Reisner kref_put(&device->kref, drbd_destroy_device); 245668700b4SPhilipp Reisner rcu_read_lock(); 246668700b4SPhilipp Reisner } 247668700b4SPhilipp Reisner rcu_read_unlock(); 248668700b4SPhilipp Reisner } 249668700b4SPhilipp Reisner 250b411b363SPhilipp Reisner /** 251c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 252b30ab791SAndreas Gruenbacher * @device: DRBD device. 25345bb912bSLars Ellenberg * @number: number of pages requested 25445bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 255b411b363SPhilipp Reisner * 25645bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 2570e49d7b0SLars Ellenberg * the kernel. 25845bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 25945bb912bSLars Ellenberg * 2600e49d7b0SLars Ellenberg * If this allocation would exceed the max_buffers setting, we throttle 2610e49d7b0SLars Ellenberg * allocation (schedule_timeout) to give the system some room to breathe. 2620e49d7b0SLars Ellenberg * 2630e49d7b0SLars Ellenberg * We do not use max-buffers as hard limit, because it could lead to 2640e49d7b0SLars Ellenberg * congestion and further to a distributed deadlock during online-verify or 2650e49d7b0SLars Ellenberg * (checksum based) resync, if the max-buffers, socket buffer sizes and 2660e49d7b0SLars Ellenberg * resync-rate settings are mis-configured. 2670e49d7b0SLars Ellenberg * 26845bb912bSLars Ellenberg * Returns a page chain linked via page->private. 269b411b363SPhilipp Reisner */ 27069a22773SAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_peer_device *peer_device, unsigned int number, 271c37c8ecfSAndreas Gruenbacher bool retry) 272b411b363SPhilipp Reisner { 27369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 274b411b363SPhilipp Reisner struct page *page = NULL; 27544ed167dSPhilipp Reisner struct net_conf *nc; 276b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2770e49d7b0SLars Ellenberg unsigned int mxb; 278b411b363SPhilipp Reisner 27944ed167dSPhilipp Reisner rcu_read_lock(); 28069a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 28144ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 28244ed167dSPhilipp Reisner rcu_read_unlock(); 28344ed167dSPhilipp Reisner 284b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) 285b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 286b411b363SPhilipp Reisner 287668700b4SPhilipp Reisner /* Try to keep the fast path fast, but occasionally we need 288668700b4SPhilipp Reisner * to reclaim the pages we lended to the network stack. */ 289668700b4SPhilipp Reisner if (page && atomic_read(&device->pp_in_use_by_net) > 512) 290668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 291668700b4SPhilipp Reisner 29245bb912bSLars Ellenberg while (page == NULL) { 293b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 294b411b363SPhilipp Reisner 295668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 296b411b363SPhilipp Reisner 297b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) { 298b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 299b411b363SPhilipp Reisner if (page) 300b411b363SPhilipp Reisner break; 301b411b363SPhilipp Reisner } 302b411b363SPhilipp Reisner 303b411b363SPhilipp Reisner if (!retry) 304b411b363SPhilipp Reisner break; 305b411b363SPhilipp Reisner 306b411b363SPhilipp Reisner if (signal_pending(current)) { 307d0180171SAndreas Gruenbacher drbd_warn(device, "drbd_alloc_pages interrupted!\n"); 308b411b363SPhilipp Reisner break; 309b411b363SPhilipp Reisner } 310b411b363SPhilipp Reisner 3110e49d7b0SLars Ellenberg if (schedule_timeout(HZ/10) == 0) 3120e49d7b0SLars Ellenberg mxb = UINT_MAX; 313b411b363SPhilipp Reisner } 314b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 315b411b363SPhilipp Reisner 31645bb912bSLars Ellenberg if (page) 317b30ab791SAndreas Gruenbacher atomic_add(number, &device->pp_in_use); 318b411b363SPhilipp Reisner return page; 319b411b363SPhilipp Reisner } 320b411b363SPhilipp Reisner 321c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 3220500813fSAndreas Gruenbacher * Is also used from inside an other spin_lock_irq(&resource->req_lock); 32345bb912bSLars Ellenberg * Either links the page chain back to the global pool, 32445bb912bSLars Ellenberg * or returns all pages to the system. */ 325b30ab791SAndreas Gruenbacher static void drbd_free_pages(struct drbd_device *device, struct page *page, int is_net) 326b411b363SPhilipp Reisner { 327b30ab791SAndreas Gruenbacher atomic_t *a = is_net ? &device->pp_in_use_by_net : &device->pp_in_use; 328b411b363SPhilipp Reisner int i; 329435f0740SLars Ellenberg 330a73ff323SLars Ellenberg if (page == NULL) 331a73ff323SLars Ellenberg return; 332a73ff323SLars Ellenberg 3331816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 33445bb912bSLars Ellenberg i = page_chain_free(page); 33545bb912bSLars Ellenberg else { 33645bb912bSLars Ellenberg struct page *tmp; 33745bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 338b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 33945bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 34045bb912bSLars Ellenberg drbd_pp_vacant += i; 341b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 342b411b363SPhilipp Reisner } 343435f0740SLars Ellenberg i = atomic_sub_return(i, a); 34445bb912bSLars Ellenberg if (i < 0) 345d0180171SAndreas Gruenbacher drbd_warn(device, "ASSERTION FAILED: %s: %d < 0\n", 346435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 347b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 348b411b363SPhilipp Reisner } 349b411b363SPhilipp Reisner 350b411b363SPhilipp Reisner /* 351b411b363SPhilipp Reisner You need to hold the req_lock: 352b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 353b411b363SPhilipp Reisner 354b411b363SPhilipp Reisner You must not have the req_lock: 3553967deb1SAndreas Gruenbacher drbd_free_peer_req() 3560db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3577721f567SAndreas Gruenbacher drbd_free_peer_reqs() 358b411b363SPhilipp Reisner drbd_ee_fix_bhs() 359a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 360b411b363SPhilipp Reisner drbd_clear_done_ee() 361b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 362b411b363SPhilipp Reisner */ 363b411b363SPhilipp Reisner 3649104d31aSLars Ellenberg /* normal: payload_size == request size (bi_size) 3659104d31aSLars Ellenberg * w_same: payload_size == logical_block_size 3669104d31aSLars Ellenberg * trim: payload_size == 0 */ 367f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 36869a22773SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 3699104d31aSLars Ellenberg unsigned int request_size, unsigned int payload_size, gfp_t gfp_mask) __must_hold(local) 370b411b363SPhilipp Reisner { 37169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 372db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 373a73ff323SLars Ellenberg struct page *page = NULL; 3749104d31aSLars Ellenberg unsigned nr_pages = (payload_size + PAGE_SIZE -1) >> PAGE_SHIFT; 375b411b363SPhilipp Reisner 376b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_AL_EE)) 377b411b363SPhilipp Reisner return NULL; 378b411b363SPhilipp Reisner 379db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 380db830c46SAndreas Gruenbacher if (!peer_req) { 381b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 382d0180171SAndreas Gruenbacher drbd_err(device, "%s: allocation failed\n", __func__); 383b411b363SPhilipp Reisner return NULL; 384b411b363SPhilipp Reisner } 385b411b363SPhilipp Reisner 3869104d31aSLars Ellenberg if (nr_pages) { 387d0164adcSMel Gorman page = drbd_alloc_pages(peer_device, nr_pages, 388d0164adcSMel Gorman gfpflags_allow_blocking(gfp_mask)); 38945bb912bSLars Ellenberg if (!page) 39045bb912bSLars Ellenberg goto fail; 391a73ff323SLars Ellenberg } 392b411b363SPhilipp Reisner 393c5a2c150SLars Ellenberg memset(peer_req, 0, sizeof(*peer_req)); 394c5a2c150SLars Ellenberg INIT_LIST_HEAD(&peer_req->w.list); 395db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 3969104d31aSLars Ellenberg peer_req->i.size = request_size; 397db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 398c5a2c150SLars Ellenberg peer_req->submit_jif = jiffies; 399a8cd15baSAndreas Gruenbacher peer_req->peer_device = peer_device; 400db830c46SAndreas Gruenbacher peer_req->pages = page; 4019a8e7753SAndreas Gruenbacher /* 4029a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 4039a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 4049a8e7753SAndreas Gruenbacher */ 405db830c46SAndreas Gruenbacher peer_req->block_id = id; 406b411b363SPhilipp Reisner 407db830c46SAndreas Gruenbacher return peer_req; 408b411b363SPhilipp Reisner 40945bb912bSLars Ellenberg fail: 410db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 411b411b363SPhilipp Reisner return NULL; 412b411b363SPhilipp Reisner } 413b411b363SPhilipp Reisner 414b30ab791SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_device *device, struct drbd_peer_request *peer_req, 415f6ffca9fSAndreas Gruenbacher int is_net) 416b411b363SPhilipp Reisner { 41721ae5d7fSLars Ellenberg might_sleep(); 418db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 419db830c46SAndreas Gruenbacher kfree(peer_req->digest); 420b30ab791SAndreas Gruenbacher drbd_free_pages(device, peer_req->pages, is_net); 4210b0ba1efSAndreas Gruenbacher D_ASSERT(device, atomic_read(&peer_req->pending_bios) == 0); 4220b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 42321ae5d7fSLars Ellenberg if (!expect(!(peer_req->flags & EE_CALL_AL_COMPLETE_IO))) { 42421ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 42521ae5d7fSLars Ellenberg drbd_al_complete_io(device, &peer_req->i); 42621ae5d7fSLars Ellenberg } 427db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 428b411b363SPhilipp Reisner } 429b411b363SPhilipp Reisner 430b30ab791SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_device *device, struct list_head *list) 431b411b363SPhilipp Reisner { 432b411b363SPhilipp Reisner LIST_HEAD(work_list); 433db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 434b411b363SPhilipp Reisner int count = 0; 435b30ab791SAndreas Gruenbacher int is_net = list == &device->net_ee; 436b411b363SPhilipp Reisner 4370500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 438b411b363SPhilipp Reisner list_splice_init(list, &work_list); 4390500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 440b411b363SPhilipp Reisner 441a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 442b30ab791SAndreas Gruenbacher __drbd_free_peer_req(device, peer_req, is_net); 443b411b363SPhilipp Reisner count++; 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner return count; 446b411b363SPhilipp Reisner } 447b411b363SPhilipp Reisner 448b411b363SPhilipp Reisner /* 449a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 450b411b363SPhilipp Reisner */ 451b30ab791SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_device *device) 452b411b363SPhilipp Reisner { 453b411b363SPhilipp Reisner LIST_HEAD(work_list); 454b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 455db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 456e2b3032bSAndreas Gruenbacher int err = 0; 457b411b363SPhilipp Reisner 4580500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 459b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 460b30ab791SAndreas Gruenbacher list_splice_init(&device->done_ee, &work_list); 4610500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 462b411b363SPhilipp Reisner 463a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 464b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 465b411b363SPhilipp Reisner 466b411b363SPhilipp Reisner /* possible callbacks here: 467d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 468b411b363SPhilipp Reisner * all ignore the last argument. 469b411b363SPhilipp Reisner */ 470a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 471e2b3032bSAndreas Gruenbacher int err2; 472e2b3032bSAndreas Gruenbacher 473b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 474a8cd15baSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 475e2b3032bSAndreas Gruenbacher if (!err) 476e2b3032bSAndreas Gruenbacher err = err2; 477b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 478b411b363SPhilipp Reisner } 479b30ab791SAndreas Gruenbacher wake_up(&device->ee_wait); 480b411b363SPhilipp Reisner 481e2b3032bSAndreas Gruenbacher return err; 482b411b363SPhilipp Reisner } 483b411b363SPhilipp Reisner 484b30ab791SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_device *device, 485d4da1537SAndreas Gruenbacher struct list_head *head) 486b411b363SPhilipp Reisner { 487b411b363SPhilipp Reisner DEFINE_WAIT(wait); 488b411b363SPhilipp Reisner 489b411b363SPhilipp Reisner /* avoids spin_lock/unlock 490b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 491b411b363SPhilipp Reisner while (!list_empty(head)) { 492b30ab791SAndreas Gruenbacher prepare_to_wait(&device->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 4930500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4947eaceaccSJens Axboe io_schedule(); 495b30ab791SAndreas Gruenbacher finish_wait(&device->ee_wait, &wait); 4960500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 497b411b363SPhilipp Reisner } 498b411b363SPhilipp Reisner } 499b411b363SPhilipp Reisner 500b30ab791SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_device *device, 501d4da1537SAndreas Gruenbacher struct list_head *head) 502b411b363SPhilipp Reisner { 5030500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 504b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, head); 5050500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 506b411b363SPhilipp Reisner } 507b411b363SPhilipp Reisner 508dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 509b411b363SPhilipp Reisner { 510b411b363SPhilipp Reisner struct kvec iov = { 511b411b363SPhilipp Reisner .iov_base = buf, 512b411b363SPhilipp Reisner .iov_len = size, 513b411b363SPhilipp Reisner }; 514b411b363SPhilipp Reisner struct msghdr msg = { 515b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 516b411b363SPhilipp Reisner }; 517f730c848SAl Viro return kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); 518b411b363SPhilipp Reisner } 519b411b363SPhilipp Reisner 520bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 521b411b363SPhilipp Reisner { 522b411b363SPhilipp Reisner int rv; 523b411b363SPhilipp Reisner 524bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 525b411b363SPhilipp Reisner 526b411b363SPhilipp Reisner if (rv < 0) { 527b411b363SPhilipp Reisner if (rv == -ECONNRESET) 5281ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 529b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 5301ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 531b411b363SPhilipp Reisner } else if (rv == 0) { 532bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 533b66623e3SPhilipp Reisner long t; 534b66623e3SPhilipp Reisner rcu_read_lock(); 535bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 536b66623e3SPhilipp Reisner rcu_read_unlock(); 537b66623e3SPhilipp Reisner 538bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 539b66623e3SPhilipp Reisner 540599377acSPhilipp Reisner if (t) 541599377acSPhilipp Reisner goto out; 542599377acSPhilipp Reisner } 5431ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 544599377acSPhilipp Reisner } 545599377acSPhilipp Reisner 546b411b363SPhilipp Reisner if (rv != size) 547bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 548b411b363SPhilipp Reisner 549599377acSPhilipp Reisner out: 550b411b363SPhilipp Reisner return rv; 551b411b363SPhilipp Reisner } 552b411b363SPhilipp Reisner 553bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 554c6967746SAndreas Gruenbacher { 555c6967746SAndreas Gruenbacher int err; 556c6967746SAndreas Gruenbacher 557bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 558c6967746SAndreas Gruenbacher if (err != size) { 559c6967746SAndreas Gruenbacher if (err >= 0) 560c6967746SAndreas Gruenbacher err = -EIO; 561c6967746SAndreas Gruenbacher } else 562c6967746SAndreas Gruenbacher err = 0; 563c6967746SAndreas Gruenbacher return err; 564c6967746SAndreas Gruenbacher } 565c6967746SAndreas Gruenbacher 566bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 567a5c31904SAndreas Gruenbacher { 568a5c31904SAndreas Gruenbacher int err; 569a5c31904SAndreas Gruenbacher 570bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 571a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5721ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 573a5c31904SAndreas Gruenbacher return err; 574a5c31904SAndreas Gruenbacher } 575a5c31904SAndreas Gruenbacher 5765dbf1673SLars Ellenberg /* quoting tcp(7): 5775dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5785dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5795dbf1673SLars Ellenberg * This is our wrapper to do so. 5805dbf1673SLars Ellenberg */ 5815dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5825dbf1673SLars Ellenberg unsigned int rcv) 5835dbf1673SLars Ellenberg { 5845dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5855dbf1673SLars Ellenberg if (snd) { 5865dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5875dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5885dbf1673SLars Ellenberg } 5895dbf1673SLars Ellenberg if (rcv) { 5905dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5915dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5925dbf1673SLars Ellenberg } 5935dbf1673SLars Ellenberg } 5945dbf1673SLars Ellenberg 595bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 596b411b363SPhilipp Reisner { 597b411b363SPhilipp Reisner const char *what; 598b411b363SPhilipp Reisner struct socket *sock; 599b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 60044ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 60144ed167dSPhilipp Reisner struct net_conf *nc; 60244ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 60369ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 604b411b363SPhilipp Reisner int disconnect_on_error = 1; 605b411b363SPhilipp Reisner 60644ed167dSPhilipp Reisner rcu_read_lock(); 607bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 60844ed167dSPhilipp Reisner if (!nc) { 60944ed167dSPhilipp Reisner rcu_read_unlock(); 610b411b363SPhilipp Reisner return NULL; 61144ed167dSPhilipp Reisner } 61244ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 61344ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 61469ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 615089c075dSAndreas Gruenbacher rcu_read_unlock(); 61644ed167dSPhilipp Reisner 617bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 618bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 61944ed167dSPhilipp Reisner 620bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 62144ed167dSPhilipp Reisner src_in6.sin6_port = 0; 62244ed167dSPhilipp Reisner else 62344ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 62444ed167dSPhilipp Reisner 625bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 626bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 627b411b363SPhilipp Reisner 628b411b363SPhilipp Reisner what = "sock_create_kern"; 629eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&src_in6)->sa_family, 630b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 631b411b363SPhilipp Reisner if (err < 0) { 632b411b363SPhilipp Reisner sock = NULL; 633b411b363SPhilipp Reisner goto out; 634b411b363SPhilipp Reisner } 635b411b363SPhilipp Reisner 636b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 63769ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 63844ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 639b411b363SPhilipp Reisner 640b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 641b411b363SPhilipp Reisner * for the outgoing connections. 642b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 643b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 644b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 645b411b363SPhilipp Reisner * a free one dynamically. 646b411b363SPhilipp Reisner */ 647b411b363SPhilipp Reisner what = "bind before connect"; 64844ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 649b411b363SPhilipp Reisner if (err < 0) 650b411b363SPhilipp Reisner goto out; 651b411b363SPhilipp Reisner 652b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 653b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 654b411b363SPhilipp Reisner disconnect_on_error = 0; 655b411b363SPhilipp Reisner what = "connect"; 65644ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 657b411b363SPhilipp Reisner 658b411b363SPhilipp Reisner out: 659b411b363SPhilipp Reisner if (err < 0) { 660b411b363SPhilipp Reisner if (sock) { 661b411b363SPhilipp Reisner sock_release(sock); 662b411b363SPhilipp Reisner sock = NULL; 663b411b363SPhilipp Reisner } 664b411b363SPhilipp Reisner switch (-err) { 665b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 666b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 667b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 668b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 669b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 670b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 671b411b363SPhilipp Reisner disconnect_on_error = 0; 672b411b363SPhilipp Reisner break; 673b411b363SPhilipp Reisner default: 6741ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 675b411b363SPhilipp Reisner } 676b411b363SPhilipp Reisner if (disconnect_on_error) 677bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 678b411b363SPhilipp Reisner } 67944ed167dSPhilipp Reisner 680b411b363SPhilipp Reisner return sock; 681b411b363SPhilipp Reisner } 682b411b363SPhilipp Reisner 6837a426fd8SPhilipp Reisner struct accept_wait_data { 684bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6857a426fd8SPhilipp Reisner struct socket *s_listen; 6867a426fd8SPhilipp Reisner struct completion door_bell; 6877a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6887a426fd8SPhilipp Reisner 6897a426fd8SPhilipp Reisner }; 6907a426fd8SPhilipp Reisner 691715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 692b411b363SPhilipp Reisner { 6937a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 694715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6957a426fd8SPhilipp Reisner 696715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 697715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 6987a426fd8SPhilipp Reisner complete(&ad->door_bell); 699715306f6SAndreas Gruenbacher state_change(sk); 7007a426fd8SPhilipp Reisner } 7017a426fd8SPhilipp Reisner 702bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 703b411b363SPhilipp Reisner { 7041f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 70544ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 7061f3e509bSPhilipp Reisner struct socket *s_listen; 70744ed167dSPhilipp Reisner struct net_conf *nc; 708b411b363SPhilipp Reisner const char *what; 709b411b363SPhilipp Reisner 71044ed167dSPhilipp Reisner rcu_read_lock(); 711bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 71244ed167dSPhilipp Reisner if (!nc) { 71344ed167dSPhilipp Reisner rcu_read_unlock(); 7147a426fd8SPhilipp Reisner return -EIO; 71544ed167dSPhilipp Reisner } 71644ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71744ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 71844ed167dSPhilipp Reisner rcu_read_unlock(); 719b411b363SPhilipp Reisner 720bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 721bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 722b411b363SPhilipp Reisner 723b411b363SPhilipp Reisner what = "sock_create_kern"; 724eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&my_addr)->sa_family, 725b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 726b411b363SPhilipp Reisner if (err) { 727b411b363SPhilipp Reisner s_listen = NULL; 728b411b363SPhilipp Reisner goto out; 729b411b363SPhilipp Reisner } 730b411b363SPhilipp Reisner 7314a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 73244ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 733b411b363SPhilipp Reisner 734b411b363SPhilipp Reisner what = "bind before listen"; 73544ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 736b411b363SPhilipp Reisner if (err < 0) 737b411b363SPhilipp Reisner goto out; 738b411b363SPhilipp Reisner 7397a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7407a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7417a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 742715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7437a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7447a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 745b411b363SPhilipp Reisner 7462820fd39SPhilipp Reisner what = "listen"; 7472820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7482820fd39SPhilipp Reisner if (err < 0) 7492820fd39SPhilipp Reisner goto out; 7502820fd39SPhilipp Reisner 7517a426fd8SPhilipp Reisner return 0; 752b411b363SPhilipp Reisner out: 753b411b363SPhilipp Reisner if (s_listen) 754b411b363SPhilipp Reisner sock_release(s_listen); 755b411b363SPhilipp Reisner if (err < 0) { 756b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7571ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 758bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 759b411b363SPhilipp Reisner } 760b411b363SPhilipp Reisner } 7611f3e509bSPhilipp Reisner 7627a426fd8SPhilipp Reisner return -EIO; 7631f3e509bSPhilipp Reisner } 7641f3e509bSPhilipp Reisner 765715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 766715306f6SAndreas Gruenbacher { 767715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 768715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 769715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 770715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 771715306f6SAndreas Gruenbacher } 772715306f6SAndreas Gruenbacher 773bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7741f3e509bSPhilipp Reisner { 7751f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7761f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7771f3e509bSPhilipp Reisner struct net_conf *nc; 7781f3e509bSPhilipp Reisner 7791f3e509bSPhilipp Reisner rcu_read_lock(); 780bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7811f3e509bSPhilipp Reisner if (!nc) { 7821f3e509bSPhilipp Reisner rcu_read_unlock(); 7831f3e509bSPhilipp Reisner return NULL; 7841f3e509bSPhilipp Reisner } 7851f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7861f3e509bSPhilipp Reisner rcu_read_unlock(); 7871f3e509bSPhilipp Reisner 7881f3e509bSPhilipp Reisner timeo = connect_int * HZ; 78938b682b2SAkinobu Mita /* 28.5% random jitter */ 79038b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7911f3e509bSPhilipp Reisner 7927a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7937a426fd8SPhilipp Reisner if (err <= 0) 7947a426fd8SPhilipp Reisner return NULL; 7951f3e509bSPhilipp Reisner 7967a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 797b411b363SPhilipp Reisner if (err < 0) { 798b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7991ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 800bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 801b411b363SPhilipp Reisner } 802b411b363SPhilipp Reisner } 803b411b363SPhilipp Reisner 804715306f6SAndreas Gruenbacher if (s_estab) 805715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 806b411b363SPhilipp Reisner 807b411b363SPhilipp Reisner return s_estab; 808b411b363SPhilipp Reisner } 809b411b363SPhilipp Reisner 810bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 811b411b363SPhilipp Reisner 812bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 8139f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 8149f5bdc33SAndreas Gruenbacher { 815bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 8169f5bdc33SAndreas Gruenbacher return -EIO; 817bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 818b411b363SPhilipp Reisner } 819b411b363SPhilipp Reisner 820bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 821b411b363SPhilipp Reisner { 822bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 8239f5bdc33SAndreas Gruenbacher struct packet_info pi; 8244920e37aSPhilipp Reisner struct net_conf *nc; 8259f5bdc33SAndreas Gruenbacher int err; 826b411b363SPhilipp Reisner 8274920e37aSPhilipp Reisner rcu_read_lock(); 8284920e37aSPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8294920e37aSPhilipp Reisner if (!nc) { 8304920e37aSPhilipp Reisner rcu_read_unlock(); 8314920e37aSPhilipp Reisner return -EIO; 8324920e37aSPhilipp Reisner } 8334920e37aSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo * 4 * HZ / 10; 8344920e37aSPhilipp Reisner rcu_read_unlock(); 8354920e37aSPhilipp Reisner 836bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 8379f5bdc33SAndreas Gruenbacher if (err != header_size) { 8389f5bdc33SAndreas Gruenbacher if (err >= 0) 8399f5bdc33SAndreas Gruenbacher err = -EIO; 8409f5bdc33SAndreas Gruenbacher return err; 8419f5bdc33SAndreas Gruenbacher } 842bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8439f5bdc33SAndreas Gruenbacher if (err) 8449f5bdc33SAndreas Gruenbacher return err; 8459f5bdc33SAndreas Gruenbacher return pi.cmd; 846b411b363SPhilipp Reisner } 847b411b363SPhilipp Reisner 848b411b363SPhilipp Reisner /** 849b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 850b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 851b411b363SPhilipp Reisner */ 8525d0b17f1SPhilipp Reisner static bool drbd_socket_okay(struct socket **sock) 853b411b363SPhilipp Reisner { 854b411b363SPhilipp Reisner int rr; 855b411b363SPhilipp Reisner char tb[4]; 856b411b363SPhilipp Reisner 857b411b363SPhilipp Reisner if (!*sock) 85881e84650SAndreas Gruenbacher return false; 859b411b363SPhilipp Reisner 860dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 861b411b363SPhilipp Reisner 862b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 86381e84650SAndreas Gruenbacher return true; 864b411b363SPhilipp Reisner } else { 865b411b363SPhilipp Reisner sock_release(*sock); 866b411b363SPhilipp Reisner *sock = NULL; 86781e84650SAndreas Gruenbacher return false; 868b411b363SPhilipp Reisner } 869b411b363SPhilipp Reisner } 8705d0b17f1SPhilipp Reisner 8715d0b17f1SPhilipp Reisner static bool connection_established(struct drbd_connection *connection, 8725d0b17f1SPhilipp Reisner struct socket **sock1, 8735d0b17f1SPhilipp Reisner struct socket **sock2) 8745d0b17f1SPhilipp Reisner { 8755d0b17f1SPhilipp Reisner struct net_conf *nc; 8765d0b17f1SPhilipp Reisner int timeout; 8775d0b17f1SPhilipp Reisner bool ok; 8785d0b17f1SPhilipp Reisner 8795d0b17f1SPhilipp Reisner if (!*sock1 || !*sock2) 8805d0b17f1SPhilipp Reisner return false; 8815d0b17f1SPhilipp Reisner 8825d0b17f1SPhilipp Reisner rcu_read_lock(); 8835d0b17f1SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8845d0b17f1SPhilipp Reisner timeout = (nc->sock_check_timeo ?: nc->ping_timeo) * HZ / 10; 8855d0b17f1SPhilipp Reisner rcu_read_unlock(); 8865d0b17f1SPhilipp Reisner schedule_timeout_interruptible(timeout); 8875d0b17f1SPhilipp Reisner 8885d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock1); 8895d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock2) && ok; 8905d0b17f1SPhilipp Reisner 8915d0b17f1SPhilipp Reisner return ok; 8925d0b17f1SPhilipp Reisner } 8935d0b17f1SPhilipp Reisner 8942325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8952325eb66SPhilipp Reisner in a connection */ 89669a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 897907599e0SPhilipp Reisner { 89869a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 8990829f5edSAndreas Gruenbacher int err; 900907599e0SPhilipp Reisner 901b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 902b30ab791SAndreas Gruenbacher device->peer_seq = 0; 903907599e0SPhilipp Reisner 90469a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 90569a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 906b30ab791SAndreas Gruenbacher &device->own_state_mutex; 9078410da8fSPhilipp Reisner 90869a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 9090829f5edSAndreas Gruenbacher if (!err) 91069a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 9110829f5edSAndreas Gruenbacher if (!err) 91269a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 9130829f5edSAndreas Gruenbacher if (!err) 91469a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 915b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 916b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 917b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 918b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 9190829f5edSAndreas Gruenbacher return err; 920907599e0SPhilipp Reisner } 921b411b363SPhilipp Reisner 922b411b363SPhilipp Reisner /* 923b411b363SPhilipp Reisner * return values: 924b411b363SPhilipp Reisner * 1 yes, we have a valid connection 925b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 926b411b363SPhilipp Reisner * -1 peer talks different language, 927b411b363SPhilipp Reisner * no point in trying again, please go standalone. 928b411b363SPhilipp Reisner * -2 We do not have a network config... 929b411b363SPhilipp Reisner */ 930bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 931b411b363SPhilipp Reisner { 9327da35862SPhilipp Reisner struct drbd_socket sock, msock; 933c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 93444ed167dSPhilipp Reisner struct net_conf *nc; 9355d0b17f1SPhilipp Reisner int vnr, timeout, h; 9365d0b17f1SPhilipp Reisner bool discard_my_data, ok; 937197296ffSPhilipp Reisner enum drbd_state_rv rv; 9387a426fd8SPhilipp Reisner struct accept_wait_data ad = { 939bde89a9eSAndreas Gruenbacher .connection = connection, 9407a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 9417a426fd8SPhilipp Reisner }; 942b411b363SPhilipp Reisner 943bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 944bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 945b411b363SPhilipp Reisner return -2; 946b411b363SPhilipp Reisner 9477da35862SPhilipp Reisner mutex_init(&sock.mutex); 948bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 949bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 9507da35862SPhilipp Reisner sock.socket = NULL; 9517da35862SPhilipp Reisner mutex_init(&msock.mutex); 952bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 953bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 9547da35862SPhilipp Reisner msock.socket = NULL; 9557da35862SPhilipp Reisner 9560916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 957bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 958b411b363SPhilipp Reisner 959bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 9607a426fd8SPhilipp Reisner return 0; 961b411b363SPhilipp Reisner 962b411b363SPhilipp Reisner do { 9632bf89621SAndreas Gruenbacher struct socket *s; 964b411b363SPhilipp Reisner 965bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 966b411b363SPhilipp Reisner if (s) { 9677da35862SPhilipp Reisner if (!sock.socket) { 9687da35862SPhilipp Reisner sock.socket = s; 969bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9707da35862SPhilipp Reisner } else if (!msock.socket) { 971bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9727da35862SPhilipp Reisner msock.socket = s; 973bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 974b411b363SPhilipp Reisner } else { 9751ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 976b411b363SPhilipp Reisner goto out_release_sockets; 977b411b363SPhilipp Reisner } 978b411b363SPhilipp Reisner } 979b411b363SPhilipp Reisner 9805d0b17f1SPhilipp Reisner if (connection_established(connection, &sock.socket, &msock.socket)) 981b411b363SPhilipp Reisner break; 982b411b363SPhilipp Reisner 983b411b363SPhilipp Reisner retry: 984bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 985b411b363SPhilipp Reisner if (s) { 986bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9877da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9887da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 98992f14951SPhilipp Reisner switch (fp) { 990e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9917da35862SPhilipp Reisner if (sock.socket) { 9921ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9937da35862SPhilipp Reisner sock_release(sock.socket); 99480c6eed4SPhilipp Reisner sock.socket = s; 99580c6eed4SPhilipp Reisner goto randomize; 996b411b363SPhilipp Reisner } 9977da35862SPhilipp Reisner sock.socket = s; 998b411b363SPhilipp Reisner break; 999e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 1000bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 10017da35862SPhilipp Reisner if (msock.socket) { 10021ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 10037da35862SPhilipp Reisner sock_release(msock.socket); 100480c6eed4SPhilipp Reisner msock.socket = s; 100580c6eed4SPhilipp Reisner goto randomize; 1006b411b363SPhilipp Reisner } 10077da35862SPhilipp Reisner msock.socket = s; 1008b411b363SPhilipp Reisner break; 1009b411b363SPhilipp Reisner default: 10101ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 1011b411b363SPhilipp Reisner sock_release(s); 101280c6eed4SPhilipp Reisner randomize: 101338b682b2SAkinobu Mita if (prandom_u32() & 1) 1014b411b363SPhilipp Reisner goto retry; 1015b411b363SPhilipp Reisner } 1016b411b363SPhilipp Reisner } 1017b411b363SPhilipp Reisner 1018bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 1019b411b363SPhilipp Reisner goto out_release_sockets; 1020b411b363SPhilipp Reisner if (signal_pending(current)) { 1021b411b363SPhilipp Reisner flush_signals(current); 1022b411b363SPhilipp Reisner smp_rmb(); 1023bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 1024b411b363SPhilipp Reisner goto out_release_sockets; 1025b411b363SPhilipp Reisner } 1026b411b363SPhilipp Reisner 10275d0b17f1SPhilipp Reisner ok = connection_established(connection, &sock.socket, &msock.socket); 1028b666dbf8SPhilipp Reisner } while (!ok); 1029b411b363SPhilipp Reisner 10307a426fd8SPhilipp Reisner if (ad.s_listen) 10317a426fd8SPhilipp Reisner sock_release(ad.s_listen); 1032b411b363SPhilipp Reisner 103398683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 103498683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 1035b411b363SPhilipp Reisner 10367da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 10377da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 1038b411b363SPhilipp Reisner 10397da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 10407da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 1041b411b363SPhilipp Reisner 1042b411b363SPhilipp Reisner /* NOT YET ... 1043bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 10447da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10456038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1046b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 104744ed167dSPhilipp Reisner rcu_read_lock(); 1048bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 1049b411b363SPhilipp Reisner 10507da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10517da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 105244ed167dSPhilipp Reisner 10537da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 105444ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 105508b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 105644ed167dSPhilipp Reisner rcu_read_unlock(); 105744ed167dSPhilipp Reisner 10587da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1059b411b363SPhilipp Reisner 1060b411b363SPhilipp Reisner /* we don't want delays. 106125985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10627da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10637da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1064b411b363SPhilipp Reisner 1065bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1066bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1067bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1068b411b363SPhilipp Reisner 1069bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1070b411b363SPhilipp Reisner if (h <= 0) 1071b411b363SPhilipp Reisner return h; 1072b411b363SPhilipp Reisner 1073bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1074b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1075bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1076b10d96cbSJohannes Thoma case -1: 10771ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1078b411b363SPhilipp Reisner return -1; 1079b10d96cbSJohannes Thoma case 0: 10801ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1081b10d96cbSJohannes Thoma return 0; 1082b411b363SPhilipp Reisner } 1083b411b363SPhilipp Reisner } 1084b411b363SPhilipp Reisner 1085bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1086bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1087b411b363SPhilipp Reisner 1088bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10897e2455c1SPhilipp Reisner return -1; 10901e86ac48SPhilipp Reisner 109113c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 109213c76abaSPhilipp Reisner * being promoted to Primary. 109313c76abaSPhilipp Reisner * 109413c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 109513c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 109613c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 109713c76abaSPhilipp Reisner */ 109831007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 109931007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 110031007745SPhilipp Reisner 110131007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 110231007745SPhilipp Reisner 110331007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 110431007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 110531007745SPhilipp Reisner 110631007745SPhilipp Reisner rcu_read_lock(); 110731007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 110831007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 110931007745SPhilipp Reisner kref_get(&device->kref); 111031007745SPhilipp Reisner rcu_read_unlock(); 111113c76abaSPhilipp Reisner 111208b165baSPhilipp Reisner if (discard_my_data) 1113b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 111408b165baSPhilipp Reisner else 1115b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 111608b165baSPhilipp Reisner 111769a22773SAndreas Gruenbacher drbd_connected(peer_device); 111805a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1119c141ebdaSPhilipp Reisner rcu_read_lock(); 1120c141ebdaSPhilipp Reisner } 1121c141ebdaSPhilipp Reisner rcu_read_unlock(); 1122c141ebdaSPhilipp Reisner 1123bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1124bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1125bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 11261e86ac48SPhilipp Reisner return 0; 1127a1096a6eSPhilipp Reisner } 11281e86ac48SPhilipp Reisner 11291c03e520SPhilipp Reisner drbd_thread_start(&connection->ack_receiver); 113039e91a60SLars Ellenberg /* opencoded create_singlethread_workqueue(), 113139e91a60SLars Ellenberg * to be able to use format string arguments */ 113239e91a60SLars Ellenberg connection->ack_sender = 113339e91a60SLars Ellenberg alloc_ordered_workqueue("drbd_as_%s", WQ_MEM_RECLAIM, connection->resource->name); 1134668700b4SPhilipp Reisner if (!connection->ack_sender) { 1135668700b4SPhilipp Reisner drbd_err(connection, "Failed to create workqueue ack_sender\n"); 1136668700b4SPhilipp Reisner return 0; 1137668700b4SPhilipp Reisner } 1138b411b363SPhilipp Reisner 11390500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 114008b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 114108b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 114208b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 114308b165baSPhilipp Reisner * just to clear a single value. */ 1144bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 11450500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 114608b165baSPhilipp Reisner 1147d3fcb490SPhilipp Reisner return h; 1148b411b363SPhilipp Reisner 1149b411b363SPhilipp Reisner out_release_sockets: 11507a426fd8SPhilipp Reisner if (ad.s_listen) 11517a426fd8SPhilipp Reisner sock_release(ad.s_listen); 11527da35862SPhilipp Reisner if (sock.socket) 11537da35862SPhilipp Reisner sock_release(sock.socket); 11547da35862SPhilipp Reisner if (msock.socket) 11557da35862SPhilipp Reisner sock_release(msock.socket); 1156b411b363SPhilipp Reisner return -1; 1157b411b363SPhilipp Reisner } 1158b411b363SPhilipp Reisner 1159bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1160b411b363SPhilipp Reisner { 1161bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1162b411b363SPhilipp Reisner 11630c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11640c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11650c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11660c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11671ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11680c8e36d9SAndreas Gruenbacher return -EINVAL; 116902918be2SPhilipp Reisner } 11700c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11710c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11720c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11730c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1174e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1175e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1176e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1177b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1178eefc2f7dSPhilipp Reisner pi->vnr = 0; 1179e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1180e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1181e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1182e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1183e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 118477351055SPhilipp Reisner pi->vnr = 0; 118502918be2SPhilipp Reisner } else { 11861ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1187e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1188bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11898172f3e9SAndreas Gruenbacher return -EINVAL; 1190b411b363SPhilipp Reisner } 1191e658983aSAndreas Gruenbacher pi->data = header + header_size; 11928172f3e9SAndreas Gruenbacher return 0; 1193b411b363SPhilipp Reisner } 1194b411b363SPhilipp Reisner 1195bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1196257d0af6SPhilipp Reisner { 1197bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 119869bc7bc3SAndreas Gruenbacher int err; 1199257d0af6SPhilipp Reisner 1200bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1201a5c31904SAndreas Gruenbacher if (err) 120269bc7bc3SAndreas Gruenbacher return err; 1203257d0af6SPhilipp Reisner 1204bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1205bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1206b411b363SPhilipp Reisner 120769bc7bc3SAndreas Gruenbacher return err; 1208b411b363SPhilipp Reisner } 1209b411b363SPhilipp Reisner 1210f9ff0da5SLars Ellenberg /* This is blkdev_issue_flush, but asynchronous. 1211f9ff0da5SLars Ellenberg * We want to submit to all component volumes in parallel, 1212f9ff0da5SLars Ellenberg * then wait for all completions. 1213f9ff0da5SLars Ellenberg */ 1214f9ff0da5SLars Ellenberg struct issue_flush_context { 1215f9ff0da5SLars Ellenberg atomic_t pending; 1216f9ff0da5SLars Ellenberg int error; 1217f9ff0da5SLars Ellenberg struct completion done; 1218f9ff0da5SLars Ellenberg }; 1219f9ff0da5SLars Ellenberg struct one_flush_context { 1220f9ff0da5SLars Ellenberg struct drbd_device *device; 1221f9ff0da5SLars Ellenberg struct issue_flush_context *ctx; 1222f9ff0da5SLars Ellenberg }; 1223f9ff0da5SLars Ellenberg 1224f9ff0da5SLars Ellenberg void one_flush_endio(struct bio *bio) 1225f9ff0da5SLars Ellenberg { 1226f9ff0da5SLars Ellenberg struct one_flush_context *octx = bio->bi_private; 1227f9ff0da5SLars Ellenberg struct drbd_device *device = octx->device; 1228f9ff0da5SLars Ellenberg struct issue_flush_context *ctx = octx->ctx; 1229f9ff0da5SLars Ellenberg 1230f9ff0da5SLars Ellenberg if (bio->bi_error) { 1231f9ff0da5SLars Ellenberg ctx->error = bio->bi_error; 1232f9ff0da5SLars Ellenberg drbd_info(device, "local disk FLUSH FAILED with status %d\n", bio->bi_error); 1233f9ff0da5SLars Ellenberg } 1234f9ff0da5SLars Ellenberg kfree(octx); 1235f9ff0da5SLars Ellenberg bio_put(bio); 1236f9ff0da5SLars Ellenberg 1237f9ff0da5SLars Ellenberg clear_bit(FLUSH_PENDING, &device->flags); 1238f9ff0da5SLars Ellenberg put_ldev(device); 1239f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1240f9ff0da5SLars Ellenberg 1241f9ff0da5SLars Ellenberg if (atomic_dec_and_test(&ctx->pending)) 1242f9ff0da5SLars Ellenberg complete(&ctx->done); 1243f9ff0da5SLars Ellenberg } 1244f9ff0da5SLars Ellenberg 1245f9ff0da5SLars Ellenberg static void submit_one_flush(struct drbd_device *device, struct issue_flush_context *ctx) 1246f9ff0da5SLars Ellenberg { 1247f9ff0da5SLars Ellenberg struct bio *bio = bio_alloc(GFP_NOIO, 0); 1248f9ff0da5SLars Ellenberg struct one_flush_context *octx = kmalloc(sizeof(*octx), GFP_NOIO); 1249f9ff0da5SLars Ellenberg if (!bio || !octx) { 1250f9ff0da5SLars Ellenberg drbd_warn(device, "Could not allocate a bio, CANNOT ISSUE FLUSH\n"); 1251f9ff0da5SLars Ellenberg /* FIXME: what else can I do now? disconnecting or detaching 1252f9ff0da5SLars Ellenberg * really does not help to improve the state of the world, either. 1253f9ff0da5SLars Ellenberg */ 1254f9ff0da5SLars Ellenberg kfree(octx); 1255f9ff0da5SLars Ellenberg if (bio) 1256f9ff0da5SLars Ellenberg bio_put(bio); 1257f9ff0da5SLars Ellenberg 1258f9ff0da5SLars Ellenberg ctx->error = -ENOMEM; 1259f9ff0da5SLars Ellenberg put_ldev(device); 1260f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1261f9ff0da5SLars Ellenberg return; 1262f9ff0da5SLars Ellenberg } 1263f9ff0da5SLars Ellenberg 1264f9ff0da5SLars Ellenberg octx->device = device; 1265f9ff0da5SLars Ellenberg octx->ctx = ctx; 1266f9ff0da5SLars Ellenberg bio->bi_bdev = device->ldev->backing_bdev; 1267f9ff0da5SLars Ellenberg bio->bi_private = octx; 1268f9ff0da5SLars Ellenberg bio->bi_end_io = one_flush_endio; 1269f9ff0da5SLars Ellenberg bio_set_op_attrs(bio, REQ_OP_FLUSH, WRITE_FLUSH); 1270f9ff0da5SLars Ellenberg 1271f9ff0da5SLars Ellenberg device->flush_jif = jiffies; 1272f9ff0da5SLars Ellenberg set_bit(FLUSH_PENDING, &device->flags); 1273f9ff0da5SLars Ellenberg atomic_inc(&ctx->pending); 1274f9ff0da5SLars Ellenberg submit_bio(bio); 1275f9ff0da5SLars Ellenberg } 1276f9ff0da5SLars Ellenberg 1277bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1278b411b363SPhilipp Reisner { 1279f9ff0da5SLars Ellenberg if (connection->resource->write_ordering >= WO_BDEV_FLUSH) { 1280c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1281f9ff0da5SLars Ellenberg struct issue_flush_context ctx; 12824b0007c0SPhilipp Reisner int vnr; 1283b411b363SPhilipp Reisner 1284f9ff0da5SLars Ellenberg atomic_set(&ctx.pending, 1); 1285f9ff0da5SLars Ellenberg ctx.error = 0; 1286f9ff0da5SLars Ellenberg init_completion(&ctx.done); 1287f9ff0da5SLars Ellenberg 1288615e087fSLars Ellenberg rcu_read_lock(); 1289c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1290c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1291c06ece6bSAndreas Gruenbacher 1292b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1293615e087fSLars Ellenberg continue; 1294b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1295615e087fSLars Ellenberg rcu_read_unlock(); 12964b0007c0SPhilipp Reisner 1297f9ff0da5SLars Ellenberg submit_one_flush(device, &ctx); 1298f9ff0da5SLars Ellenberg 1299f9ff0da5SLars Ellenberg rcu_read_lock(); 1300f9ff0da5SLars Ellenberg } 1301f9ff0da5SLars Ellenberg rcu_read_unlock(); 1302f9ff0da5SLars Ellenberg 1303f9ff0da5SLars Ellenberg /* Do we want to add a timeout, 1304f9ff0da5SLars Ellenberg * if disk-timeout is set? */ 1305f9ff0da5SLars Ellenberg if (!atomic_dec_and_test(&ctx.pending)) 1306f9ff0da5SLars Ellenberg wait_for_completion(&ctx.done); 1307f9ff0da5SLars Ellenberg 1308f9ff0da5SLars Ellenberg if (ctx.error) { 1309b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1310b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1311b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1312f9ff0da5SLars Ellenberg /* Any error is already reported by bio_endio callback. */ 1313f6ba8636SAndreas Gruenbacher drbd_bump_write_ordering(connection->resource, NULL, WO_DRAIN_IO); 1314b411b363SPhilipp Reisner } 1315b411b363SPhilipp Reisner } 1316b411b363SPhilipp Reisner } 1317b411b363SPhilipp Reisner 1318b411b363SPhilipp Reisner /** 1319b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1320b30ab791SAndreas Gruenbacher * @device: DRBD device. 1321b411b363SPhilipp Reisner * @epoch: Epoch object. 1322b411b363SPhilipp Reisner * @ev: Epoch event. 1323b411b363SPhilipp Reisner */ 1324bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1325b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1326b411b363SPhilipp Reisner enum epoch_event ev) 1327b411b363SPhilipp Reisner { 13282451fc3bSPhilipp Reisner int epoch_size; 1329b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1330b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1331b411b363SPhilipp Reisner 1332bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1333b411b363SPhilipp Reisner do { 1334b411b363SPhilipp Reisner next_epoch = NULL; 1335b411b363SPhilipp Reisner 1336b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1337b411b363SPhilipp Reisner 1338b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1339b411b363SPhilipp Reisner case EV_PUT: 1340b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1341b411b363SPhilipp Reisner break; 1342b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1343b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1344b411b363SPhilipp Reisner break; 1345b411b363SPhilipp Reisner case EV_BECAME_LAST: 1346b411b363SPhilipp Reisner /* nothing to do*/ 1347b411b363SPhilipp Reisner break; 1348b411b363SPhilipp Reisner } 1349b411b363SPhilipp Reisner 1350b411b363SPhilipp Reisner if (epoch_size != 0 && 1351b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 135280f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1353b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1354bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1355bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1356bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1357b411b363SPhilipp Reisner } 13589ed57dcbSLars Ellenberg #if 0 13599ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 13609ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 136180f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1362bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 13639ed57dcbSLars Ellenberg #endif 1364b411b363SPhilipp Reisner 1365bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1366b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1367b411b363SPhilipp Reisner list_del(&epoch->list); 1368b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1369bde89a9eSAndreas Gruenbacher connection->epochs--; 1370b411b363SPhilipp Reisner kfree(epoch); 1371b411b363SPhilipp Reisner 1372b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1373b411b363SPhilipp Reisner rv = FE_DESTROYED; 1374b411b363SPhilipp Reisner } else { 1375b411b363SPhilipp Reisner epoch->flags = 0; 1376b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1377698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1378b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1379b411b363SPhilipp Reisner rv = FE_RECYCLED; 1380b411b363SPhilipp Reisner } 1381b411b363SPhilipp Reisner } 1382b411b363SPhilipp Reisner 1383b411b363SPhilipp Reisner if (!next_epoch) 1384b411b363SPhilipp Reisner break; 1385b411b363SPhilipp Reisner 1386b411b363SPhilipp Reisner epoch = next_epoch; 1387b411b363SPhilipp Reisner } while (1); 1388b411b363SPhilipp Reisner 1389bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1390b411b363SPhilipp Reisner 1391b411b363SPhilipp Reisner return rv; 1392b411b363SPhilipp Reisner } 1393b411b363SPhilipp Reisner 13948fe39aacSPhilipp Reisner static enum write_ordering_e 13958fe39aacSPhilipp Reisner max_allowed_wo(struct drbd_backing_dev *bdev, enum write_ordering_e wo) 13968fe39aacSPhilipp Reisner { 13978fe39aacSPhilipp Reisner struct disk_conf *dc; 13988fe39aacSPhilipp Reisner 13998fe39aacSPhilipp Reisner dc = rcu_dereference(bdev->disk_conf); 14008fe39aacSPhilipp Reisner 1401f6ba8636SAndreas Gruenbacher if (wo == WO_BDEV_FLUSH && !dc->disk_flushes) 1402f6ba8636SAndreas Gruenbacher wo = WO_DRAIN_IO; 1403f6ba8636SAndreas Gruenbacher if (wo == WO_DRAIN_IO && !dc->disk_drain) 1404f6ba8636SAndreas Gruenbacher wo = WO_NONE; 14058fe39aacSPhilipp Reisner 14068fe39aacSPhilipp Reisner return wo; 14078fe39aacSPhilipp Reisner } 14088fe39aacSPhilipp Reisner 1409b411b363SPhilipp Reisner /** 1410b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1411bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1412b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1413b411b363SPhilipp Reisner */ 14148fe39aacSPhilipp Reisner void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, 14158fe39aacSPhilipp Reisner enum write_ordering_e wo) 1416b411b363SPhilipp Reisner { 1417e9526580SPhilipp Reisner struct drbd_device *device; 1418b411b363SPhilipp Reisner enum write_ordering_e pwo; 14194b0007c0SPhilipp Reisner int vnr; 1420b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1421f6ba8636SAndreas Gruenbacher [WO_NONE] = "none", 1422f6ba8636SAndreas Gruenbacher [WO_DRAIN_IO] = "drain", 1423f6ba8636SAndreas Gruenbacher [WO_BDEV_FLUSH] = "flush", 1424b411b363SPhilipp Reisner }; 1425b411b363SPhilipp Reisner 1426e9526580SPhilipp Reisner pwo = resource->write_ordering; 1427f6ba8636SAndreas Gruenbacher if (wo != WO_BDEV_FLUSH) 1428b411b363SPhilipp Reisner wo = min(pwo, wo); 1429daeda1ccSPhilipp Reisner rcu_read_lock(); 1430e9526580SPhilipp Reisner idr_for_each_entry(&resource->devices, device, vnr) { 14318fe39aacSPhilipp Reisner if (get_ldev(device)) { 14328fe39aacSPhilipp Reisner wo = max_allowed_wo(device->ldev, wo); 14338fe39aacSPhilipp Reisner if (device->ldev == bdev) 14348fe39aacSPhilipp Reisner bdev = NULL; 1435b30ab791SAndreas Gruenbacher put_ldev(device); 14364b0007c0SPhilipp Reisner } 14378fe39aacSPhilipp Reisner } 14388fe39aacSPhilipp Reisner 14398fe39aacSPhilipp Reisner if (bdev) 14408fe39aacSPhilipp Reisner wo = max_allowed_wo(bdev, wo); 14418fe39aacSPhilipp Reisner 144270df7092SLars Ellenberg rcu_read_unlock(); 144370df7092SLars Ellenberg 1444e9526580SPhilipp Reisner resource->write_ordering = wo; 1445f6ba8636SAndreas Gruenbacher if (pwo != resource->write_ordering || wo == WO_BDEV_FLUSH) 1446e9526580SPhilipp Reisner drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]); 1447b411b363SPhilipp Reisner } 1448b411b363SPhilipp Reisner 1449dd4f699dSLars Ellenberg /* 1450dd4f699dSLars Ellenberg * We *may* ignore the discard-zeroes-data setting, if so configured. 1451dd4f699dSLars Ellenberg * 1452dd4f699dSLars Ellenberg * Assumption is that it "discard_zeroes_data=0" is only because the backend 1453dd4f699dSLars Ellenberg * may ignore partial unaligned discards. 1454dd4f699dSLars Ellenberg * 1455dd4f699dSLars Ellenberg * LVM/DM thin as of at least 1456dd4f699dSLars Ellenberg * LVM version: 2.02.115(2)-RHEL7 (2015-01-28) 1457dd4f699dSLars Ellenberg * Library version: 1.02.93-RHEL7 (2015-01-28) 1458dd4f699dSLars Ellenberg * Driver version: 4.29.0 1459dd4f699dSLars Ellenberg * still behaves this way. 1460dd4f699dSLars Ellenberg * 1461dd4f699dSLars Ellenberg * For unaligned (wrt. alignment and granularity) or too small discards, 1462dd4f699dSLars Ellenberg * we zero-out the initial (and/or) trailing unaligned partial chunks, 1463dd4f699dSLars Ellenberg * but discard all the aligned full chunks. 1464dd4f699dSLars Ellenberg * 1465dd4f699dSLars Ellenberg * At least for LVM/DM thin, the result is effectively "discard_zeroes_data=1". 1466dd4f699dSLars Ellenberg */ 1467dd4f699dSLars Ellenberg int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, unsigned int nr_sectors, bool discard) 1468dd4f699dSLars Ellenberg { 1469dd4f699dSLars Ellenberg struct block_device *bdev = device->ldev->backing_bdev; 1470dd4f699dSLars Ellenberg struct request_queue *q = bdev_get_queue(bdev); 1471dd4f699dSLars Ellenberg sector_t tmp, nr; 1472dd4f699dSLars Ellenberg unsigned int max_discard_sectors, granularity; 1473dd4f699dSLars Ellenberg int alignment; 1474dd4f699dSLars Ellenberg int err = 0; 1475dd4f699dSLars Ellenberg 1476dd4f699dSLars Ellenberg if (!discard) 1477dd4f699dSLars Ellenberg goto zero_out; 1478dd4f699dSLars Ellenberg 1479dd4f699dSLars Ellenberg /* Zero-sector (unknown) and one-sector granularities are the same. */ 1480dd4f699dSLars Ellenberg granularity = max(q->limits.discard_granularity >> 9, 1U); 1481dd4f699dSLars Ellenberg alignment = (bdev_discard_alignment(bdev) >> 9) % granularity; 1482dd4f699dSLars Ellenberg 1483dd4f699dSLars Ellenberg max_discard_sectors = min(q->limits.max_discard_sectors, (1U << 22)); 1484dd4f699dSLars Ellenberg max_discard_sectors -= max_discard_sectors % granularity; 1485dd4f699dSLars Ellenberg if (unlikely(!max_discard_sectors)) 1486dd4f699dSLars Ellenberg goto zero_out; 1487dd4f699dSLars Ellenberg 1488dd4f699dSLars Ellenberg if (nr_sectors < granularity) 1489dd4f699dSLars Ellenberg goto zero_out; 1490dd4f699dSLars Ellenberg 1491dd4f699dSLars Ellenberg tmp = start; 1492dd4f699dSLars Ellenberg if (sector_div(tmp, granularity) != alignment) { 1493dd4f699dSLars Ellenberg if (nr_sectors < 2*granularity) 1494dd4f699dSLars Ellenberg goto zero_out; 1495dd4f699dSLars Ellenberg /* start + gran - (start + gran - align) % gran */ 1496dd4f699dSLars Ellenberg tmp = start + granularity - alignment; 1497dd4f699dSLars Ellenberg tmp = start + granularity - sector_div(tmp, granularity); 1498dd4f699dSLars Ellenberg 1499dd4f699dSLars Ellenberg nr = tmp - start; 1500dd4f699dSLars Ellenberg err |= blkdev_issue_zeroout(bdev, start, nr, GFP_NOIO, 0); 1501dd4f699dSLars Ellenberg nr_sectors -= nr; 1502dd4f699dSLars Ellenberg start = tmp; 1503dd4f699dSLars Ellenberg } 1504dd4f699dSLars Ellenberg while (nr_sectors >= granularity) { 1505dd4f699dSLars Ellenberg nr = min_t(sector_t, nr_sectors, max_discard_sectors); 1506dd4f699dSLars Ellenberg err |= blkdev_issue_discard(bdev, start, nr, GFP_NOIO, 0); 1507dd4f699dSLars Ellenberg nr_sectors -= nr; 1508dd4f699dSLars Ellenberg start += nr; 1509dd4f699dSLars Ellenberg } 1510dd4f699dSLars Ellenberg zero_out: 1511dd4f699dSLars Ellenberg if (nr_sectors) { 1512dd4f699dSLars Ellenberg err |= blkdev_issue_zeroout(bdev, start, nr_sectors, GFP_NOIO, 0); 1513dd4f699dSLars Ellenberg } 1514dd4f699dSLars Ellenberg return err != 0; 1515dd4f699dSLars Ellenberg } 1516dd4f699dSLars Ellenberg 1517dd4f699dSLars Ellenberg static bool can_do_reliable_discards(struct drbd_device *device) 1518dd4f699dSLars Ellenberg { 1519dd4f699dSLars Ellenberg struct request_queue *q = bdev_get_queue(device->ldev->backing_bdev); 1520dd4f699dSLars Ellenberg struct disk_conf *dc; 1521dd4f699dSLars Ellenberg bool can_do; 1522dd4f699dSLars Ellenberg 1523dd4f699dSLars Ellenberg if (!blk_queue_discard(q)) 1524dd4f699dSLars Ellenberg return false; 1525dd4f699dSLars Ellenberg 1526dd4f699dSLars Ellenberg if (q->limits.discard_zeroes_data) 1527dd4f699dSLars Ellenberg return true; 1528dd4f699dSLars Ellenberg 1529dd4f699dSLars Ellenberg rcu_read_lock(); 1530dd4f699dSLars Ellenberg dc = rcu_dereference(device->ldev->disk_conf); 1531dd4f699dSLars Ellenberg can_do = dc->discard_zeroes_if_aligned; 1532dd4f699dSLars Ellenberg rcu_read_unlock(); 1533dd4f699dSLars Ellenberg return can_do; 1534dd4f699dSLars Ellenberg } 1535dd4f699dSLars Ellenberg 15369104d31aSLars Ellenberg static void drbd_issue_peer_discard(struct drbd_device *device, struct drbd_peer_request *peer_req) 1537dd4f699dSLars Ellenberg { 1538dd4f699dSLars Ellenberg /* If the backend cannot discard, or does not guarantee 1539dd4f699dSLars Ellenberg * read-back zeroes in discarded ranges, we fall back to 1540dd4f699dSLars Ellenberg * zero-out. Unless configuration specifically requested 1541dd4f699dSLars Ellenberg * otherwise. */ 1542dd4f699dSLars Ellenberg if (!can_do_reliable_discards(device)) 1543dd4f699dSLars Ellenberg peer_req->flags |= EE_IS_TRIM_USE_ZEROOUT; 1544dd4f699dSLars Ellenberg 1545dd4f699dSLars Ellenberg if (drbd_issue_discard_or_zero_out(device, peer_req->i.sector, 1546dd4f699dSLars Ellenberg peer_req->i.size >> 9, !(peer_req->flags & EE_IS_TRIM_USE_ZEROOUT))) 1547dd4f699dSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 1548dd4f699dSLars Ellenberg drbd_endio_write_sec_final(peer_req); 1549dd4f699dSLars Ellenberg } 1550dd4f699dSLars Ellenberg 15519104d31aSLars Ellenberg static void drbd_issue_peer_wsame(struct drbd_device *device, 15529104d31aSLars Ellenberg struct drbd_peer_request *peer_req) 15539104d31aSLars Ellenberg { 15549104d31aSLars Ellenberg struct block_device *bdev = device->ldev->backing_bdev; 15559104d31aSLars Ellenberg sector_t s = peer_req->i.sector; 15569104d31aSLars Ellenberg sector_t nr = peer_req->i.size >> 9; 15579104d31aSLars Ellenberg if (blkdev_issue_write_same(bdev, s, nr, GFP_NOIO, peer_req->pages)) 15589104d31aSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 15599104d31aSLars Ellenberg drbd_endio_write_sec_final(peer_req); 15609104d31aSLars Ellenberg } 15619104d31aSLars Ellenberg 15629104d31aSLars Ellenberg 1563b411b363SPhilipp Reisner /** 1564fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1565b30ab791SAndreas Gruenbacher * @device: DRBD device. 1566db830c46SAndreas Gruenbacher * @peer_req: peer request 156745bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 156810f6d992SLars Ellenberg * 156910f6d992SLars Ellenberg * May spread the pages to multiple bios, 157010f6d992SLars Ellenberg * depending on bio_add_page restrictions. 157110f6d992SLars Ellenberg * 157210f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 157310f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 157410f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 157510f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 157610f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 157710f6d992SLars Ellenberg * on certain Xen deployments. 157845bb912bSLars Ellenberg */ 157945bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1580b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1581fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 1582bb3cc85eSMike Christie const unsigned op, const unsigned op_flags, 1583bb3cc85eSMike Christie const int fault_type) 158445bb912bSLars Ellenberg { 158545bb912bSLars Ellenberg struct bio *bios = NULL; 158645bb912bSLars Ellenberg struct bio *bio; 1587db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1588db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 158911f8b2b6SAndreas Gruenbacher unsigned data_size = peer_req->i.size; 159045bb912bSLars Ellenberg unsigned n_bios = 0; 159111f8b2b6SAndreas Gruenbacher unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 159210f6d992SLars Ellenberg int err = -ENOMEM; 159345bb912bSLars Ellenberg 1594dd4f699dSLars Ellenberg /* TRIM/DISCARD: for now, always use the helper function 1595dd4f699dSLars Ellenberg * blkdev_issue_zeroout(..., discard=true). 1596dd4f699dSLars Ellenberg * It's synchronous, but it does the right thing wrt. bio splitting. 1597dd4f699dSLars Ellenberg * Correctness first, performance later. Next step is to code an 1598dd4f699dSLars Ellenberg * asynchronous variant of the same. 1599dd4f699dSLars Ellenberg */ 16009104d31aSLars Ellenberg if (peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) { 1601a0fb3c47SLars Ellenberg /* wait for all pending IO completions, before we start 1602a0fb3c47SLars Ellenberg * zeroing things out. */ 16035dd2ca19SAndreas Gruenbacher conn_wait_active_ee_empty(peer_req->peer_device->connection); 160445d2933cSLars Ellenberg /* add it to the active list now, 160545d2933cSLars Ellenberg * so we can find it to present it in debugfs */ 160621ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 160721ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 1608700ca8c0SPhilipp Reisner 1609700ca8c0SPhilipp Reisner /* If this was a resync request from receive_rs_deallocated(), 1610700ca8c0SPhilipp Reisner * it is already on the sync_ee list */ 1611700ca8c0SPhilipp Reisner if (list_empty(&peer_req->w.list)) { 161245d2933cSLars Ellenberg spin_lock_irq(&device->resource->req_lock); 161345d2933cSLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 161445d2933cSLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 1615700ca8c0SPhilipp Reisner } 1616700ca8c0SPhilipp Reisner 16179104d31aSLars Ellenberg if (peer_req->flags & EE_IS_TRIM) 1618dd4f699dSLars Ellenberg drbd_issue_peer_discard(device, peer_req); 16199104d31aSLars Ellenberg else /* EE_WRITE_SAME */ 16209104d31aSLars Ellenberg drbd_issue_peer_wsame(device, peer_req); 1621a0fb3c47SLars Ellenberg return 0; 1622a0fb3c47SLars Ellenberg } 1623a0fb3c47SLars Ellenberg 162445bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 162545bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 162645bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 16279476f39dSLars Ellenberg * request in more than one bio. 16289476f39dSLars Ellenberg * 16299476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 16309476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 16319476f39dSLars Ellenberg */ 163245bb912bSLars Ellenberg next_bio: 163345bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 163445bb912bSLars Ellenberg if (!bio) { 1635a0fb3c47SLars Ellenberg drbd_err(device, "submit_ee: Allocation of a bio failed (nr_pages=%u)\n", nr_pages); 163645bb912bSLars Ellenberg goto fail; 163745bb912bSLars Ellenberg } 1638db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 16394f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 1640b30ab791SAndreas Gruenbacher bio->bi_bdev = device->ldev->backing_bdev; 1641bb3cc85eSMike Christie bio_set_op_attrs(bio, op, op_flags); 1642db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1643fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 164445bb912bSLars Ellenberg 164545bb912bSLars Ellenberg bio->bi_next = bios; 164645bb912bSLars Ellenberg bios = bio; 164745bb912bSLars Ellenberg ++n_bios; 164845bb912bSLars Ellenberg 164945bb912bSLars Ellenberg page_chain_for_each(page) { 165011f8b2b6SAndreas Gruenbacher unsigned len = min_t(unsigned, data_size, PAGE_SIZE); 165145bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 165210f6d992SLars Ellenberg /* A single page must always be possible! 165310f6d992SLars Ellenberg * But in case it fails anyways, 165410f6d992SLars Ellenberg * we deal with it, and complain (below). */ 165510f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 1656d0180171SAndreas Gruenbacher drbd_err(device, 165710f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 165810f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 16594f024f37SKent Overstreet len, (uint64_t)bio->bi_iter.bi_sector); 166010f6d992SLars Ellenberg err = -ENOSPC; 166110f6d992SLars Ellenberg goto fail; 166210f6d992SLars Ellenberg } 166345bb912bSLars Ellenberg goto next_bio; 166445bb912bSLars Ellenberg } 166511f8b2b6SAndreas Gruenbacher data_size -= len; 166645bb912bSLars Ellenberg sector += len >> 9; 166745bb912bSLars Ellenberg --nr_pages; 166845bb912bSLars Ellenberg } 166911f8b2b6SAndreas Gruenbacher D_ASSERT(device, data_size == 0); 1670a0fb3c47SLars Ellenberg D_ASSERT(device, page == NULL); 167145bb912bSLars Ellenberg 1672db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 167321ae5d7fSLars Ellenberg /* for debugfs: update timestamp, mark as submitted */ 167421ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 167521ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 167645bb912bSLars Ellenberg do { 167745bb912bSLars Ellenberg bio = bios; 167845bb912bSLars Ellenberg bios = bios->bi_next; 167945bb912bSLars Ellenberg bio->bi_next = NULL; 168045bb912bSLars Ellenberg 1681b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 168245bb912bSLars Ellenberg } while (bios); 168345bb912bSLars Ellenberg return 0; 168445bb912bSLars Ellenberg 168545bb912bSLars Ellenberg fail: 168645bb912bSLars Ellenberg while (bios) { 168745bb912bSLars Ellenberg bio = bios; 168845bb912bSLars Ellenberg bios = bios->bi_next; 168945bb912bSLars Ellenberg bio_put(bio); 169045bb912bSLars Ellenberg } 169110f6d992SLars Ellenberg return err; 169245bb912bSLars Ellenberg } 169345bb912bSLars Ellenberg 1694b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1695db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 169653840641SAndreas Gruenbacher { 1697db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 169853840641SAndreas Gruenbacher 1699b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 170053840641SAndreas Gruenbacher drbd_clear_interval(i); 170153840641SAndreas Gruenbacher 17026c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 170353840641SAndreas Gruenbacher if (i->waiting) 1704b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 170553840641SAndreas Gruenbacher } 170653840641SAndreas Gruenbacher 1707bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 170877fede51SPhilipp Reisner { 1709c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 171077fede51SPhilipp Reisner int vnr; 171177fede51SPhilipp Reisner 171277fede51SPhilipp Reisner rcu_read_lock(); 1713c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1714c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1715c06ece6bSAndreas Gruenbacher 1716b30ab791SAndreas Gruenbacher kref_get(&device->kref); 171777fede51SPhilipp Reisner rcu_read_unlock(); 1718b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 171905a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 172077fede51SPhilipp Reisner rcu_read_lock(); 172177fede51SPhilipp Reisner } 172277fede51SPhilipp Reisner rcu_read_unlock(); 172377fede51SPhilipp Reisner } 172477fede51SPhilipp Reisner 1725bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1726b411b363SPhilipp Reisner { 17272451fc3bSPhilipp Reisner int rv; 1728e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1729b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1730b411b363SPhilipp Reisner 17319ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 17329ed57dcbSLars Ellenberg * not a specific (peer)device. 17339ed57dcbSLars Ellenberg */ 1734bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1735bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1736bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1737b411b363SPhilipp Reisner 1738b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1739b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1740b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1741b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1742b411b363SPhilipp Reisner * completed. */ 1743e9526580SPhilipp Reisner switch (connection->resource->write_ordering) { 1744f6ba8636SAndreas Gruenbacher case WO_NONE: 1745b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 174682bc0194SAndreas Gruenbacher return 0; 1747b411b363SPhilipp Reisner 1748b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1749b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1750b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 17512451fc3bSPhilipp Reisner if (epoch) 17522451fc3bSPhilipp Reisner break; 17532451fc3bSPhilipp Reisner else 17541ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 17552451fc3bSPhilipp Reisner /* Fall through */ 17562451fc3bSPhilipp Reisner 1757f6ba8636SAndreas Gruenbacher case WO_BDEV_FLUSH: 1758f6ba8636SAndreas Gruenbacher case WO_DRAIN_IO: 1759bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1760bde89a9eSAndreas Gruenbacher drbd_flush(connection); 17612451fc3bSPhilipp Reisner 1762bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 17632451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 17642451fc3bSPhilipp Reisner if (epoch) 17652451fc3bSPhilipp Reisner break; 1766b411b363SPhilipp Reisner } 1767b411b363SPhilipp Reisner 176882bc0194SAndreas Gruenbacher return 0; 17692451fc3bSPhilipp Reisner default: 1770e9526580SPhilipp Reisner drbd_err(connection, "Strangeness in connection->write_ordering %d\n", 1771e9526580SPhilipp Reisner connection->resource->write_ordering); 177282bc0194SAndreas Gruenbacher return -EIO; 1773b411b363SPhilipp Reisner } 1774b411b363SPhilipp Reisner 1775b411b363SPhilipp Reisner epoch->flags = 0; 1776b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1777b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1778b411b363SPhilipp Reisner 1779bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1780bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1781bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1782bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1783bde89a9eSAndreas Gruenbacher connection->epochs++; 1784b411b363SPhilipp Reisner } else { 1785b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1786b411b363SPhilipp Reisner kfree(epoch); 1787b411b363SPhilipp Reisner } 1788bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1789b411b363SPhilipp Reisner 179082bc0194SAndreas Gruenbacher return 0; 1791b411b363SPhilipp Reisner } 1792b411b363SPhilipp Reisner 17939104d31aSLars Ellenberg /* quick wrapper in case payload size != request_size (write same) */ 17949104d31aSLars Ellenberg static void drbd_csum_ee_size(struct crypto_ahash *h, 17959104d31aSLars Ellenberg struct drbd_peer_request *r, void *d, 17969104d31aSLars Ellenberg unsigned int payload_size) 17979104d31aSLars Ellenberg { 17989104d31aSLars Ellenberg unsigned int tmp = r->i.size; 17999104d31aSLars Ellenberg r->i.size = payload_size; 18009104d31aSLars Ellenberg drbd_csum_ee(h, r, d); 18019104d31aSLars Ellenberg r->i.size = tmp; 18029104d31aSLars Ellenberg } 18039104d31aSLars Ellenberg 1804b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 18059104d31aSLars Ellenberg * and from receive_Data. 18069104d31aSLars Ellenberg * data_size: actual payload ("data in") 18079104d31aSLars Ellenberg * for normal writes that is bi_size. 18089104d31aSLars Ellenberg * for discards, that is zero. 18099104d31aSLars Ellenberg * for write same, it is logical_block_size. 18109104d31aSLars Ellenberg * both trim and write same have the bi_size ("data len to be affected") 18119104d31aSLars Ellenberg * as extra argument in the packet header. 18129104d31aSLars Ellenberg */ 1813f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 181469a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1815a0fb3c47SLars Ellenberg struct packet_info *pi) __must_hold(local) 1816b411b363SPhilipp Reisner { 181769a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1818b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1819db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1820b411b363SPhilipp Reisner struct page *page; 182111f8b2b6SAndreas Gruenbacher int digest_size, err; 182211f8b2b6SAndreas Gruenbacher unsigned int data_size = pi->size, ds; 182369a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 182469a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 18256b4388acSPhilipp Reisner unsigned long *data; 1826a0fb3c47SLars Ellenberg struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; 18279104d31aSLars Ellenberg struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL; 1828b411b363SPhilipp Reisner 182911f8b2b6SAndreas Gruenbacher digest_size = 0; 1830a0fb3c47SLars Ellenberg if (!trim && peer_device->connection->peer_integrity_tfm) { 18319534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 18329f5bdc33SAndreas Gruenbacher /* 18339f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 18349f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 18359f5bdc33SAndreas Gruenbacher */ 183611f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1837a5c31904SAndreas Gruenbacher if (err) 1838b411b363SPhilipp Reisner return NULL; 183911f8b2b6SAndreas Gruenbacher data_size -= digest_size; 184088104ca4SAndreas Gruenbacher } 1841b411b363SPhilipp Reisner 18429104d31aSLars Ellenberg /* assume request_size == data_size, but special case trim and wsame. */ 18439104d31aSLars Ellenberg ds = data_size; 1844a0fb3c47SLars Ellenberg if (trim) { 18459104d31aSLars Ellenberg if (!expect(data_size == 0)) 18469104d31aSLars Ellenberg return NULL; 18479104d31aSLars Ellenberg ds = be32_to_cpu(trim->size); 18489104d31aSLars Ellenberg } else if (wsame) { 18499104d31aSLars Ellenberg if (data_size != queue_logical_block_size(device->rq_queue)) { 18509104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n", 18519104d31aSLars Ellenberg data_size, queue_logical_block_size(device->rq_queue)); 18529104d31aSLars Ellenberg return NULL; 18539104d31aSLars Ellenberg } 18549104d31aSLars Ellenberg if (data_size != bdev_logical_block_size(device->ldev->backing_bdev)) { 18559104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != backend logical block size (%u)\n", 18569104d31aSLars Ellenberg data_size, bdev_logical_block_size(device->ldev->backing_bdev)); 18579104d31aSLars Ellenberg return NULL; 18589104d31aSLars Ellenberg } 18599104d31aSLars Ellenberg ds = be32_to_cpu(wsame->size); 1860a0fb3c47SLars Ellenberg } 1861a0fb3c47SLars Ellenberg 18629104d31aSLars Ellenberg if (!expect(IS_ALIGNED(ds, 512))) 1863841ce241SAndreas Gruenbacher return NULL; 18649104d31aSLars Ellenberg if (trim || wsame) { 18659104d31aSLars Ellenberg if (!expect(ds <= (DRBD_MAX_BBIO_SECTORS << 9))) 18669104d31aSLars Ellenberg return NULL; 18679104d31aSLars Ellenberg } else if (!expect(ds <= DRBD_MAX_BIO_SIZE)) 1868841ce241SAndreas Gruenbacher return NULL; 1869b411b363SPhilipp Reisner 18706666032aSLars Ellenberg /* even though we trust out peer, 18716666032aSLars Ellenberg * we sometimes have to double check. */ 18729104d31aSLars Ellenberg if (sector + (ds>>9) > capacity) { 1873d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1874fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 18756666032aSLars Ellenberg (unsigned long long)capacity, 18769104d31aSLars Ellenberg (unsigned long long)sector, ds); 18776666032aSLars Ellenberg return NULL; 18786666032aSLars Ellenberg } 18796666032aSLars Ellenberg 1880b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1881b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1882b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 18839104d31aSLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, id, sector, ds, data_size, GFP_NOIO); 1884db830c46SAndreas Gruenbacher if (!peer_req) 1885b411b363SPhilipp Reisner return NULL; 188645bb912bSLars Ellenberg 188721ae5d7fSLars Ellenberg peer_req->flags |= EE_WRITE; 18889104d31aSLars Ellenberg if (trim) { 18899104d31aSLars Ellenberg peer_req->flags |= EE_IS_TRIM; 189081a3537aSLars Ellenberg return peer_req; 18919104d31aSLars Ellenberg } 18929104d31aSLars Ellenberg if (wsame) 18939104d31aSLars Ellenberg peer_req->flags |= EE_WRITE_SAME; 1894a73ff323SLars Ellenberg 18959104d31aSLars Ellenberg /* receive payload size bytes into page chain */ 1896b411b363SPhilipp Reisner ds = data_size; 1897db830c46SAndreas Gruenbacher page = peer_req->pages; 189845bb912bSLars Ellenberg page_chain_for_each(page) { 189945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 19006b4388acSPhilipp Reisner data = kmap(page); 190169a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1902b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1903d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 19046b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 19056b4388acSPhilipp Reisner } 1906b411b363SPhilipp Reisner kunmap(page); 1907a5c31904SAndreas Gruenbacher if (err) { 1908b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1909b411b363SPhilipp Reisner return NULL; 1910b411b363SPhilipp Reisner } 1911a5c31904SAndreas Gruenbacher ds -= len; 1912b411b363SPhilipp Reisner } 1913b411b363SPhilipp Reisner 191411f8b2b6SAndreas Gruenbacher if (digest_size) { 19159104d31aSLars Ellenberg drbd_csum_ee_size(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv, data_size); 191611f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 1917d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1918470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1919b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1920b411b363SPhilipp Reisner return NULL; 1921b411b363SPhilipp Reisner } 1922b411b363SPhilipp Reisner } 1923b30ab791SAndreas Gruenbacher device->recv_cnt += data_size >> 9; 1924db830c46SAndreas Gruenbacher return peer_req; 1925b411b363SPhilipp Reisner } 1926b411b363SPhilipp Reisner 1927b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1928b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1929b411b363SPhilipp Reisner */ 193069a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1931b411b363SPhilipp Reisner { 1932b411b363SPhilipp Reisner struct page *page; 1933a5c31904SAndreas Gruenbacher int err = 0; 1934b411b363SPhilipp Reisner void *data; 1935b411b363SPhilipp Reisner 1936c3470cdeSLars Ellenberg if (!data_size) 1937fc5be839SAndreas Gruenbacher return 0; 1938c3470cdeSLars Ellenberg 193969a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1940b411b363SPhilipp Reisner 1941b411b363SPhilipp Reisner data = kmap(page); 1942b411b363SPhilipp Reisner while (data_size) { 1943fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1944fc5be839SAndreas Gruenbacher 194569a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1946a5c31904SAndreas Gruenbacher if (err) 1947b411b363SPhilipp Reisner break; 1948a5c31904SAndreas Gruenbacher data_size -= len; 1949b411b363SPhilipp Reisner } 1950b411b363SPhilipp Reisner kunmap(page); 195169a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1952fc5be839SAndreas Gruenbacher return err; 1953b411b363SPhilipp Reisner } 1954b411b363SPhilipp Reisner 195569a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1956b411b363SPhilipp Reisner sector_t sector, int data_size) 1957b411b363SPhilipp Reisner { 19587988613bSKent Overstreet struct bio_vec bvec; 19597988613bSKent Overstreet struct bvec_iter iter; 1960b411b363SPhilipp Reisner struct bio *bio; 196111f8b2b6SAndreas Gruenbacher int digest_size, err, expect; 196269a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 196369a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1964b411b363SPhilipp Reisner 196511f8b2b6SAndreas Gruenbacher digest_size = 0; 196669a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 19679534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 196811f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1969a5c31904SAndreas Gruenbacher if (err) 1970a5c31904SAndreas Gruenbacher return err; 197111f8b2b6SAndreas Gruenbacher data_size -= digest_size; 197288104ca4SAndreas Gruenbacher } 1973b411b363SPhilipp Reisner 1974b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1975b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 197669a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1977b411b363SPhilipp Reisner 1978b411b363SPhilipp Reisner bio = req->master_bio; 197969a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1980b411b363SPhilipp Reisner 19817988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 19827988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 19837988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 198469a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 19857988613bSKent Overstreet kunmap(bvec.bv_page); 1986a5c31904SAndreas Gruenbacher if (err) 1987a5c31904SAndreas Gruenbacher return err; 1988a5c31904SAndreas Gruenbacher data_size -= expect; 1989b411b363SPhilipp Reisner } 1990b411b363SPhilipp Reisner 199111f8b2b6SAndreas Gruenbacher if (digest_size) { 199269a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 199311f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 199469a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 199528284cefSAndreas Gruenbacher return -EINVAL; 1996b411b363SPhilipp Reisner } 1997b411b363SPhilipp Reisner } 1998b411b363SPhilipp Reisner 199969a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 200028284cefSAndreas Gruenbacher return 0; 2001b411b363SPhilipp Reisner } 2002b411b363SPhilipp Reisner 2003a990be46SAndreas Gruenbacher /* 2004668700b4SPhilipp Reisner * e_end_resync_block() is called in ack_sender context via 2005a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 2006a990be46SAndreas Gruenbacher */ 200799920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 2008b411b363SPhilipp Reisner { 20098050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2010a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2011a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 2012a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2013db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 201499920dc5SAndreas Gruenbacher int err; 2015b411b363SPhilipp Reisner 20160b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 2017b411b363SPhilipp Reisner 2018db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 2019b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 2020a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 2021b411b363SPhilipp Reisner } else { 2022b411b363SPhilipp Reisner /* Record failure to sync */ 2023b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 2024b411b363SPhilipp Reisner 2025a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 2026b411b363SPhilipp Reisner } 2027b30ab791SAndreas Gruenbacher dec_unacked(device); 2028b411b363SPhilipp Reisner 202999920dc5SAndreas Gruenbacher return err; 2030b411b363SPhilipp Reisner } 2031b411b363SPhilipp Reisner 203269a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 2033a0fb3c47SLars Ellenberg struct packet_info *pi) __releases(local) 2034b411b363SPhilipp Reisner { 203569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2036db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2037b411b363SPhilipp Reisner 2038a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi); 2039db830c46SAndreas Gruenbacher if (!peer_req) 204045bb912bSLars Ellenberg goto fail; 2041b411b363SPhilipp Reisner 2042b30ab791SAndreas Gruenbacher dec_rs_pending(device); 2043b411b363SPhilipp Reisner 2044b30ab791SAndreas Gruenbacher inc_unacked(device); 2045b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 2046b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2047b411b363SPhilipp Reisner 2048a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 204921ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 205045bb912bSLars Ellenberg 20510500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2052b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->sync_ee); 20530500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2054b411b363SPhilipp Reisner 2055a0fb3c47SLars Ellenberg atomic_add(pi->size >> 9, &device->rs_sect_ev); 2056bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_WRITE, 0, 2057bb3cc85eSMike Christie DRBD_FAULT_RS_WR) == 0) 2058e1c1b0fcSAndreas Gruenbacher return 0; 205945bb912bSLars Ellenberg 206010f6d992SLars Ellenberg /* don't care for the reason here */ 2061d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 20620500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2063a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 20640500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 206522cc37a9SLars Ellenberg 2066b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 206745bb912bSLars Ellenberg fail: 2068b30ab791SAndreas Gruenbacher put_ldev(device); 2069e1c1b0fcSAndreas Gruenbacher return -EIO; 2070b411b363SPhilipp Reisner } 2071b411b363SPhilipp Reisner 2072668eebc6SAndreas Gruenbacher static struct drbd_request * 2073b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 2074bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 2075b411b363SPhilipp Reisner { 2076b411b363SPhilipp Reisner struct drbd_request *req; 2077668eebc6SAndreas Gruenbacher 2078bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 2079bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 20805e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 2081668eebc6SAndreas Gruenbacher return req; 2082c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 2083d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 2084c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 2085c3afd8f5SAndreas Gruenbacher } 2086668eebc6SAndreas Gruenbacher return NULL; 2087668eebc6SAndreas Gruenbacher } 2088668eebc6SAndreas Gruenbacher 2089bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 2090b411b363SPhilipp Reisner { 20919f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2092b30ab791SAndreas Gruenbacher struct drbd_device *device; 2093b411b363SPhilipp Reisner struct drbd_request *req; 2094b411b363SPhilipp Reisner sector_t sector; 209582bc0194SAndreas Gruenbacher int err; 2096e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20974a76b161SAndreas Gruenbacher 20989f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 20999f4fe9adSAndreas Gruenbacher if (!peer_device) 21004a76b161SAndreas Gruenbacher return -EIO; 21019f4fe9adSAndreas Gruenbacher device = peer_device->device; 2102b411b363SPhilipp Reisner 2103b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2104b411b363SPhilipp Reisner 21050500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2106b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 21070500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2108c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 210982bc0194SAndreas Gruenbacher return -EIO; 2110b411b363SPhilipp Reisner 211124c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 2112b411b363SPhilipp Reisner * special casing it there for the various failure cases. 2113b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 211469a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 211582bc0194SAndreas Gruenbacher if (!err) 21168554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 2117b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 2118b411b363SPhilipp Reisner * I don't think we may complete this just yet 2119b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 2120b411b363SPhilipp Reisner 212182bc0194SAndreas Gruenbacher return err; 2122b411b363SPhilipp Reisner } 2123b411b363SPhilipp Reisner 2124bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 2125b411b363SPhilipp Reisner { 21269f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2127b30ab791SAndreas Gruenbacher struct drbd_device *device; 2128b411b363SPhilipp Reisner sector_t sector; 212982bc0194SAndreas Gruenbacher int err; 2130e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21314a76b161SAndreas Gruenbacher 21329f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 21339f4fe9adSAndreas Gruenbacher if (!peer_device) 21344a76b161SAndreas Gruenbacher return -EIO; 21359f4fe9adSAndreas Gruenbacher device = peer_device->device; 2136b411b363SPhilipp Reisner 2137b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 21380b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 2139b411b363SPhilipp Reisner 2140b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 2141b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 2142b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 2143fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 2144a0fb3c47SLars Ellenberg err = recv_resync_read(peer_device, sector, pi); 2145b411b363SPhilipp Reisner } else { 2146b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 2147d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 2148b411b363SPhilipp Reisner 214969a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 2150b411b363SPhilipp Reisner 215169a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2152b411b363SPhilipp Reisner } 2153b411b363SPhilipp Reisner 2154b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 2155778f271dSPhilipp Reisner 215682bc0194SAndreas Gruenbacher return err; 2157b411b363SPhilipp Reisner } 2158b411b363SPhilipp Reisner 2159b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 21607be8da07SAndreas Gruenbacher sector_t sector, int size) 2161b411b363SPhilipp Reisner { 21627be8da07SAndreas Gruenbacher struct drbd_interval *i; 21637be8da07SAndreas Gruenbacher struct drbd_request *req; 2164b411b363SPhilipp Reisner 2165b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21667be8da07SAndreas Gruenbacher if (!i->local) 21677be8da07SAndreas Gruenbacher continue; 21687be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 21697be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21707be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 21717be8da07SAndreas Gruenbacher continue; 21722312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 21732312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 2174d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 21757be8da07SAndreas Gruenbacher } 21767be8da07SAndreas Gruenbacher } 21777be8da07SAndreas Gruenbacher 2178a990be46SAndreas Gruenbacher /* 2179668700b4SPhilipp Reisner * e_end_block() is called in ack_sender context via drbd_finish_peer_reqs(). 2180b411b363SPhilipp Reisner */ 218199920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 2182b411b363SPhilipp Reisner { 21838050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2184a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2185a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 2186a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2187db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 218899920dc5SAndreas Gruenbacher int err = 0, pcmd; 2189b411b363SPhilipp Reisner 2190303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 2191db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 2192b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 2193b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 2194db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 2195b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 2196a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 2197b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 2198b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 2199b411b363SPhilipp Reisner } else { 2200a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 2201b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 2202b411b363SPhilipp Reisner * maybe assert this? */ 2203b411b363SPhilipp Reisner } 2204b30ab791SAndreas Gruenbacher dec_unacked(device); 2205b411b363SPhilipp Reisner } 220608d0dabfSLars Ellenberg 2207b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 2208b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 2209302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 22100500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 22110b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 2212b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 22137be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 2214b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 22150500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2216bb3bfe96SAndreas Gruenbacher } else 22170b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 2218b411b363SPhilipp Reisner 22195dd2ca19SAndreas Gruenbacher drbd_may_finish_epoch(peer_device->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 2220b411b363SPhilipp Reisner 222199920dc5SAndreas Gruenbacher return err; 2222b411b363SPhilipp Reisner } 2223b411b363SPhilipp Reisner 2224a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 2225b411b363SPhilipp Reisner { 22268050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2227a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2228a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 222999920dc5SAndreas Gruenbacher int err; 2230b411b363SPhilipp Reisner 2231a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 2232a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 2233b411b363SPhilipp Reisner 223499920dc5SAndreas Gruenbacher return err; 2235b411b363SPhilipp Reisner } 2236b411b363SPhilipp Reisner 2237d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 2238b6a370baSPhilipp Reisner { 2239a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 22407be8da07SAndreas Gruenbacher } 2241b6a370baSPhilipp Reisner 224299920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 22437be8da07SAndreas Gruenbacher { 2244a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 2245a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2246a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 22477be8da07SAndreas Gruenbacher 2248a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 2249d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 22507be8da07SAndreas Gruenbacher } 22517be8da07SAndreas Gruenbacher 22523e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 22533e394da1SAndreas Gruenbacher { 22543e394da1SAndreas Gruenbacher /* 22553e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 22563e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 22573e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 22583e394da1SAndreas Gruenbacher */ 22593e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 22603e394da1SAndreas Gruenbacher } 22613e394da1SAndreas Gruenbacher 22623e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 22633e394da1SAndreas Gruenbacher { 22643e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 22653e394da1SAndreas Gruenbacher } 22663e394da1SAndreas Gruenbacher 226769a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 22683e394da1SAndreas Gruenbacher { 226969a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 22703c13b680SLars Ellenberg unsigned int newest_peer_seq; 22713e394da1SAndreas Gruenbacher 227269a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 2273b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2274b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 2275b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 2276b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2277b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 22783c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 2279b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 22803e394da1SAndreas Gruenbacher } 22817be8da07SAndreas Gruenbacher } 22823e394da1SAndreas Gruenbacher 2283d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 2284d93f6302SLars Ellenberg { 2285d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 2286d93f6302SLars Ellenberg } 2287d93f6302SLars Ellenberg 2288d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 2289b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 2290d93f6302SLars Ellenberg { 2291d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 22927e5fec31SFabian Frederick bool rv = false; 2293b6a370baSPhilipp Reisner 22940500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2295a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 2296d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 2297d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 22987e5fec31SFabian Frederick rv = true; 2299b6a370baSPhilipp Reisner break; 2300b6a370baSPhilipp Reisner } 2301b6a370baSPhilipp Reisner } 23020500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2303b6a370baSPhilipp Reisner 2304b6a370baSPhilipp Reisner return rv; 2305b6a370baSPhilipp Reisner } 2306b6a370baSPhilipp Reisner 2307b411b363SPhilipp Reisner /* Called from receive_Data. 2308b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 2309b411b363SPhilipp Reisner * 2310b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 2311b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 2312b411b363SPhilipp Reisner * been sent. 2313b411b363SPhilipp Reisner * 2314b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 2315b411b363SPhilipp Reisner * 2316b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 2317b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 2318b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 2319b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 2320b411b363SPhilipp Reisner * 2321b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 2322b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 2323b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 2324b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 2325b411b363SPhilipp Reisner * 2326b411b363SPhilipp Reisner * returns 0 if we may process the packet, 2327b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 232869a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 2329b411b363SPhilipp Reisner { 233069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2331b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2332b411b363SPhilipp Reisner long timeout; 2333b874d231SPhilipp Reisner int ret = 0, tp; 23347be8da07SAndreas Gruenbacher 233569a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 23367be8da07SAndreas Gruenbacher return 0; 23377be8da07SAndreas Gruenbacher 2338b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2339b411b363SPhilipp Reisner for (;;) { 2340b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 2341b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 2342b411b363SPhilipp Reisner break; 23437be8da07SAndreas Gruenbacher } 2344b874d231SPhilipp Reisner 2345b411b363SPhilipp Reisner if (signal_pending(current)) { 2346b411b363SPhilipp Reisner ret = -ERESTARTSYS; 2347b411b363SPhilipp Reisner break; 2348b411b363SPhilipp Reisner } 2349b874d231SPhilipp Reisner 2350b874d231SPhilipp Reisner rcu_read_lock(); 23515dd2ca19SAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2352b874d231SPhilipp Reisner rcu_read_unlock(); 2353b874d231SPhilipp Reisner 2354b874d231SPhilipp Reisner if (!tp) 2355b874d231SPhilipp Reisner break; 2356b874d231SPhilipp Reisner 2357b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2358b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2359b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 236044ed167dSPhilipp Reisner rcu_read_lock(); 236169a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 236244ed167dSPhilipp Reisner rcu_read_unlock(); 236371b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2364b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 23657be8da07SAndreas Gruenbacher if (!timeout) { 2366b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2367d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2368b411b363SPhilipp Reisner break; 2369b411b363SPhilipp Reisner } 2370b411b363SPhilipp Reisner } 2371b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2372b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2373b411b363SPhilipp Reisner return ret; 2374b411b363SPhilipp Reisner } 2375b411b363SPhilipp Reisner 2376688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2377688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2378688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2379bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_flags(u32 dpf) 238076d2e7ecSPhilipp Reisner { 238176d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 238276d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 238328a8f0d3SMike Christie (dpf & DP_FLUSH ? REQ_PREFLUSH : 0); 2384bb3cc85eSMike Christie } 2385bb3cc85eSMike Christie 2386bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_op(u32 dpf) 2387bb3cc85eSMike Christie { 2388bb3cc85eSMike Christie if (dpf & DP_DISCARD) 2389bb3cc85eSMike Christie return REQ_OP_DISCARD; 2390bb3cc85eSMike Christie else 2391bb3cc85eSMike Christie return REQ_OP_WRITE; 239276d2e7ecSPhilipp Reisner } 239376d2e7ecSPhilipp Reisner 2394b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 23957be8da07SAndreas Gruenbacher unsigned int size) 2396b411b363SPhilipp Reisner { 23977be8da07SAndreas Gruenbacher struct drbd_interval *i; 23987be8da07SAndreas Gruenbacher 23997be8da07SAndreas Gruenbacher repeat: 2400b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 24017be8da07SAndreas Gruenbacher struct drbd_request *req; 24027be8da07SAndreas Gruenbacher struct bio_and_error m; 24037be8da07SAndreas Gruenbacher 24047be8da07SAndreas Gruenbacher if (!i->local) 24057be8da07SAndreas Gruenbacher continue; 24067be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 24077be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 24087be8da07SAndreas Gruenbacher continue; 24097be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 24107be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 24110500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 24127be8da07SAndreas Gruenbacher if (m.bio) 2413b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 24140500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 24157be8da07SAndreas Gruenbacher goto repeat; 24167be8da07SAndreas Gruenbacher } 24177be8da07SAndreas Gruenbacher } 24187be8da07SAndreas Gruenbacher 2419b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 24207be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 24217be8da07SAndreas Gruenbacher { 2422e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2423bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 24247be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 24257be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 24267be8da07SAndreas Gruenbacher struct drbd_interval *i; 24277be8da07SAndreas Gruenbacher bool equal; 24287be8da07SAndreas Gruenbacher int err; 24297be8da07SAndreas Gruenbacher 24307be8da07SAndreas Gruenbacher /* 24317be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 24327be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 24337be8da07SAndreas Gruenbacher */ 2434b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 24357be8da07SAndreas Gruenbacher 24367be8da07SAndreas Gruenbacher repeat: 2437b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 24387be8da07SAndreas Gruenbacher if (i == &peer_req->i) 24397be8da07SAndreas Gruenbacher continue; 244008d0dabfSLars Ellenberg if (i->completed) 244108d0dabfSLars Ellenberg continue; 24427be8da07SAndreas Gruenbacher 24437be8da07SAndreas Gruenbacher if (!i->local) { 24447be8da07SAndreas Gruenbacher /* 24457be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 24467be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 24477be8da07SAndreas Gruenbacher * earlier peer request to complete. 24487be8da07SAndreas Gruenbacher */ 2449b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 24507be8da07SAndreas Gruenbacher if (err) 24517be8da07SAndreas Gruenbacher goto out; 24527be8da07SAndreas Gruenbacher goto repeat; 24537be8da07SAndreas Gruenbacher } 24547be8da07SAndreas Gruenbacher 24557be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 24567be8da07SAndreas Gruenbacher if (resolve_conflicts) { 24577be8da07SAndreas Gruenbacher /* 24587be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2459d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2460d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2461d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 24627be8da07SAndreas Gruenbacher */ 2463d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 24647be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 24657be8da07SAndreas Gruenbacher 24667be8da07SAndreas Gruenbacher if (!equal) 2467d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24687be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 24697be8da07SAndreas Gruenbacher "assuming %s came first\n", 24707be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24717be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2472d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 24737be8da07SAndreas Gruenbacher 2474a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 24757be8da07SAndreas Gruenbacher e_send_retry_write; 2476a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2477668700b4SPhilipp Reisner queue_work(connection->ack_sender, &peer_req->peer_device->send_acks_work); 24787be8da07SAndreas Gruenbacher 24797be8da07SAndreas Gruenbacher err = -ENOENT; 24807be8da07SAndreas Gruenbacher goto out; 24817be8da07SAndreas Gruenbacher } else { 24827be8da07SAndreas Gruenbacher struct drbd_request *req = 24837be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 24847be8da07SAndreas Gruenbacher 24857be8da07SAndreas Gruenbacher if (!equal) 2486d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24877be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 24887be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24897be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 24907be8da07SAndreas Gruenbacher 24917be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 24927be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 24937be8da07SAndreas Gruenbacher /* 24947be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2495d4dabbe2SLars Ellenberg * decide if this request has been superseded 2496d4dabbe2SLars Ellenberg * or needs to be retried. 2497d4dabbe2SLars Ellenberg * Requests that have been superseded will 24987be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 24997be8da07SAndreas Gruenbacher * 25007be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 25017be8da07SAndreas Gruenbacher * request to finish locally before submitting 25027be8da07SAndreas Gruenbacher * the conflicting peer request. 25037be8da07SAndreas Gruenbacher */ 2504b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 25057be8da07SAndreas Gruenbacher if (err) { 2506e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2507b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 25087be8da07SAndreas Gruenbacher goto out; 25097be8da07SAndreas Gruenbacher } 25107be8da07SAndreas Gruenbacher goto repeat; 25117be8da07SAndreas Gruenbacher } 25127be8da07SAndreas Gruenbacher /* 25137be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 25147be8da07SAndreas Gruenbacher * the new peer request has completed. 25157be8da07SAndreas Gruenbacher */ 25167be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 25177be8da07SAndreas Gruenbacher } 25187be8da07SAndreas Gruenbacher } 25197be8da07SAndreas Gruenbacher err = 0; 25207be8da07SAndreas Gruenbacher 25217be8da07SAndreas Gruenbacher out: 25227be8da07SAndreas Gruenbacher if (err) 2523b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 25247be8da07SAndreas Gruenbacher return err; 25257be8da07SAndreas Gruenbacher } 25267be8da07SAndreas Gruenbacher 2527b411b363SPhilipp Reisner /* mirrored write */ 2528bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2529b411b363SPhilipp Reisner { 25309f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2531b30ab791SAndreas Gruenbacher struct drbd_device *device; 253221ae5d7fSLars Ellenberg struct net_conf *nc; 2533b411b363SPhilipp Reisner sector_t sector; 2534db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2535e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 25367be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2537bb3cc85eSMike Christie int op, op_flags; 2538b411b363SPhilipp Reisner u32 dp_flags; 2539302bdeaeSPhilipp Reisner int err, tp; 25407be8da07SAndreas Gruenbacher 25419f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 25429f4fe9adSAndreas Gruenbacher if (!peer_device) 25434a76b161SAndreas Gruenbacher return -EIO; 25449f4fe9adSAndreas Gruenbacher device = peer_device->device; 2545b411b363SPhilipp Reisner 2546b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 254782bc0194SAndreas Gruenbacher int err2; 2548b411b363SPhilipp Reisner 254969a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 255069a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2551bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 255269a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 255382bc0194SAndreas Gruenbacher if (!err) 255482bc0194SAndreas Gruenbacher err = err2; 255582bc0194SAndreas Gruenbacher return err; 2556b411b363SPhilipp Reisner } 2557b411b363SPhilipp Reisner 2558fcefa62eSAndreas Gruenbacher /* 2559fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2560fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2561fcefa62eSAndreas Gruenbacher * end of this function. 2562fcefa62eSAndreas Gruenbacher */ 2563b411b363SPhilipp Reisner 2564b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2565a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, p->block_id, sector, pi); 2566db830c46SAndreas Gruenbacher if (!peer_req) { 2567b30ab791SAndreas Gruenbacher put_ldev(device); 256882bc0194SAndreas Gruenbacher return -EIO; 2569b411b363SPhilipp Reisner } 2570b411b363SPhilipp Reisner 2571a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 257221ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 257321ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 2574b411b363SPhilipp Reisner 2575688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2576bb3cc85eSMike Christie op = wire_flags_to_bio_op(dp_flags); 2577bb3cc85eSMike Christie op_flags = wire_flags_to_bio_flags(dp_flags); 2578a0fb3c47SLars Ellenberg if (pi->cmd == P_TRIM) { 2579a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->i.size > 0); 2580bb3cc85eSMike Christie D_ASSERT(peer_device, op == REQ_OP_DISCARD); 2581a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->pages == NULL); 2582a0fb3c47SLars Ellenberg } else if (peer_req->pages == NULL) { 25830b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 25840b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2585a73ff323SLars Ellenberg } 2586688593c5SLars Ellenberg 2587688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2588db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2589688593c5SLars Ellenberg 2590bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2591bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2592db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2593db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2594bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2595b411b363SPhilipp Reisner 2596302bdeaeSPhilipp Reisner rcu_read_lock(); 259721ae5d7fSLars Ellenberg nc = rcu_dereference(peer_device->connection->net_conf); 259821ae5d7fSLars Ellenberg tp = nc->two_primaries; 259921ae5d7fSLars Ellenberg if (peer_device->connection->agreed_pro_version < 100) { 260021ae5d7fSLars Ellenberg switch (nc->wire_protocol) { 260121ae5d7fSLars Ellenberg case DRBD_PROT_C: 260221ae5d7fSLars Ellenberg dp_flags |= DP_SEND_WRITE_ACK; 260321ae5d7fSLars Ellenberg break; 260421ae5d7fSLars Ellenberg case DRBD_PROT_B: 260521ae5d7fSLars Ellenberg dp_flags |= DP_SEND_RECEIVE_ACK; 260621ae5d7fSLars Ellenberg break; 260721ae5d7fSLars Ellenberg } 260821ae5d7fSLars Ellenberg } 2609302bdeaeSPhilipp Reisner rcu_read_unlock(); 261021ae5d7fSLars Ellenberg 261121ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_WRITE_ACK) { 261221ae5d7fSLars Ellenberg peer_req->flags |= EE_SEND_WRITE_ACK; 261321ae5d7fSLars Ellenberg inc_unacked(device); 261421ae5d7fSLars Ellenberg /* corresponding dec_unacked() in e_end_block() 261521ae5d7fSLars Ellenberg * respective _drbd_clear_done_ee */ 261621ae5d7fSLars Ellenberg } 261721ae5d7fSLars Ellenberg 261821ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_RECEIVE_ACK) { 261921ae5d7fSLars Ellenberg /* I really don't like it that the receiver thread 262021ae5d7fSLars Ellenberg * sends on the msock, but anyways */ 26215dd2ca19SAndreas Gruenbacher drbd_send_ack(peer_device, P_RECV_ACK, peer_req); 262221ae5d7fSLars Ellenberg } 262321ae5d7fSLars Ellenberg 2624302bdeaeSPhilipp Reisner if (tp) { 262521ae5d7fSLars Ellenberg /* two primaries implies protocol C */ 262621ae5d7fSLars Ellenberg D_ASSERT(device, dp_flags & DP_SEND_WRITE_ACK); 2627302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 262869a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 26297be8da07SAndreas Gruenbacher if (err) 2630b411b363SPhilipp Reisner goto out_interrupted; 26310500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2632b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 26337be8da07SAndreas Gruenbacher if (err) { 26340500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 26357be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2636b30ab791SAndreas Gruenbacher put_ldev(device); 263782bc0194SAndreas Gruenbacher return 0; 2638b411b363SPhilipp Reisner } 2639b411b363SPhilipp Reisner goto out_interrupted; 2640b411b363SPhilipp Reisner } 2641b874d231SPhilipp Reisner } else { 264269a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 26430500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2644b874d231SPhilipp Reisner } 26459104d31aSLars Ellenberg /* TRIM and WRITE_SAME are processed synchronously, 26469104d31aSLars Ellenberg * we wait for all pending requests, respectively wait for 2647a0fb3c47SLars Ellenberg * active_ee to become empty in drbd_submit_peer_request(); 2648a0fb3c47SLars Ellenberg * better not add ourselves here. */ 26499104d31aSLars Ellenberg if ((peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) == 0) 2650b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 26510500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2652b411b363SPhilipp Reisner 2653b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2654b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2655b6a370baSPhilipp Reisner 2656b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2657b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2658b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2659db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 26604dd726f0SLars Ellenberg drbd_al_begin_io(device, &peer_req->i); 266121ae5d7fSLars Ellenberg peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2662b411b363SPhilipp Reisner } 2663b411b363SPhilipp Reisner 2664bb3cc85eSMike Christie err = drbd_submit_peer_request(device, peer_req, op, op_flags, 2665bb3cc85eSMike Christie DRBD_FAULT_DT_WR); 266682bc0194SAndreas Gruenbacher if (!err) 266782bc0194SAndreas Gruenbacher return 0; 2668b411b363SPhilipp Reisner 266910f6d992SLars Ellenberg /* don't care for the reason here */ 2670d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 26710500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2672a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2673b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 26740500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 267521ae5d7fSLars Ellenberg if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) { 267621ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 2677b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 267821ae5d7fSLars Ellenberg } 267922cc37a9SLars Ellenberg 2680b411b363SPhilipp Reisner out_interrupted: 26817e5fec31SFabian Frederick drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT | EV_CLEANUP); 2682b30ab791SAndreas Gruenbacher put_ldev(device); 2683b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 268482bc0194SAndreas Gruenbacher return err; 2685b411b363SPhilipp Reisner } 2686b411b363SPhilipp Reisner 26870f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 26880f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 26890f0601f4SLars Ellenberg * 26900f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 26910f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 26920f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 26930f0601f4SLars Ellenberg * activity, it obviously is "busy". 26940f0601f4SLars Ellenberg * 26950f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 26960f0601f4SLars Ellenberg * to have a short time average so we can react faster. 26970f0601f4SLars Ellenberg */ 2698ad3fee79SLars Ellenberg bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector, 2699ad3fee79SLars Ellenberg bool throttle_if_app_is_waiting) 2700e8299874SLars Ellenberg { 2701e8299874SLars Ellenberg struct lc_element *tmp; 2702ad3fee79SLars Ellenberg bool throttle = drbd_rs_c_min_rate_throttle(device); 2703e8299874SLars Ellenberg 2704ad3fee79SLars Ellenberg if (!throttle || throttle_if_app_is_waiting) 2705ad3fee79SLars Ellenberg return throttle; 2706e8299874SLars Ellenberg 2707e8299874SLars Ellenberg spin_lock_irq(&device->al_lock); 2708e8299874SLars Ellenberg tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2709e8299874SLars Ellenberg if (tmp) { 2710e8299874SLars Ellenberg struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2711e8299874SLars Ellenberg if (test_bit(BME_PRIORITY, &bm_ext->flags)) 2712e8299874SLars Ellenberg throttle = false; 2713ad3fee79SLars Ellenberg /* Do not slow down if app IO is already waiting for this extent, 2714ad3fee79SLars Ellenberg * and our progress is necessary for application IO to complete. */ 2715e8299874SLars Ellenberg } 2716e8299874SLars Ellenberg spin_unlock_irq(&device->al_lock); 2717e8299874SLars Ellenberg 2718e8299874SLars Ellenberg return throttle; 2719e8299874SLars Ellenberg } 2720e8299874SLars Ellenberg 2721e8299874SLars Ellenberg bool drbd_rs_c_min_rate_throttle(struct drbd_device *device) 27220f0601f4SLars Ellenberg { 2723b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 27240f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2725daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2726e8299874SLars Ellenberg int curr_events; 2727daeda1ccSPhilipp Reisner 2728daeda1ccSPhilipp Reisner rcu_read_lock(); 2729b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2730daeda1ccSPhilipp Reisner rcu_read_unlock(); 27310f0601f4SLars Ellenberg 27320f0601f4SLars Ellenberg /* feature disabled? */ 2733daeda1ccSPhilipp Reisner if (c_min_rate == 0) 2734e8299874SLars Ellenberg return false; 2735e3555d85SPhilipp Reisner 27360f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 27370f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2738b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2739ad3fee79SLars Ellenberg 2740ad3fee79SLars Ellenberg if (atomic_read(&device->ap_actlog_cnt) 2741ff8bd88bSLars Ellenberg || curr_events - device->rs_last_events > 64) { 27420f0601f4SLars Ellenberg unsigned long rs_left; 27430f0601f4SLars Ellenberg int i; 27440f0601f4SLars Ellenberg 2745b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 27460f0601f4SLars Ellenberg 27470f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 27480f0601f4SLars Ellenberg * approx. */ 2749b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 27502649f080SLars Ellenberg 2751b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2752b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 27532649f080SLars Ellenberg else 2754b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 27550f0601f4SLars Ellenberg 2756b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 27570f0601f4SLars Ellenberg if (!dt) 27580f0601f4SLars Ellenberg dt++; 2759b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 27600f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 27610f0601f4SLars Ellenberg 2762daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 2763e8299874SLars Ellenberg return true; 27640f0601f4SLars Ellenberg } 2765e8299874SLars Ellenberg return false; 27660f0601f4SLars Ellenberg } 27670f0601f4SLars Ellenberg 2768bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2769b411b363SPhilipp Reisner { 27709f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2771b30ab791SAndreas Gruenbacher struct drbd_device *device; 2772b411b363SPhilipp Reisner sector_t sector; 27734a76b161SAndreas Gruenbacher sector_t capacity; 2774db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2775b411b363SPhilipp Reisner struct digest_info *di = NULL; 2776b18b37beSPhilipp Reisner int size, verb; 2777b411b363SPhilipp Reisner unsigned int fault_type; 2778e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 27794a76b161SAndreas Gruenbacher 27809f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 27819f4fe9adSAndreas Gruenbacher if (!peer_device) 27824a76b161SAndreas Gruenbacher return -EIO; 27839f4fe9adSAndreas Gruenbacher device = peer_device->device; 2784b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2785b411b363SPhilipp Reisner 2786b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2787b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2788b411b363SPhilipp Reisner 2789c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2790d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2791b411b363SPhilipp Reisner (unsigned long long)sector, size); 279282bc0194SAndreas Gruenbacher return -EINVAL; 2793b411b363SPhilipp Reisner } 2794b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2795d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2796b411b363SPhilipp Reisner (unsigned long long)sector, size); 279782bc0194SAndreas Gruenbacher return -EINVAL; 2798b411b363SPhilipp Reisner } 2799b411b363SPhilipp Reisner 2800b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2801b18b37beSPhilipp Reisner verb = 1; 2802e2857216SAndreas Gruenbacher switch (pi->cmd) { 2803b18b37beSPhilipp Reisner case P_DATA_REQUEST: 280469a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2805b18b37beSPhilipp Reisner break; 2806700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2807b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2808b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2809b18b37beSPhilipp Reisner case P_OV_REQUEST: 281069a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2811b18b37beSPhilipp Reisner break; 2812b18b37beSPhilipp Reisner case P_OV_REPLY: 2813b18b37beSPhilipp Reisner verb = 0; 2814b30ab791SAndreas Gruenbacher dec_rs_pending(device); 281569a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2816b18b37beSPhilipp Reisner break; 2817b18b37beSPhilipp Reisner default: 281849ba9b1bSAndreas Gruenbacher BUG(); 2819b18b37beSPhilipp Reisner } 2820b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2821d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2822b411b363SPhilipp Reisner "no local data.\n"); 2823b18b37beSPhilipp Reisner 2824a821cc4aSLars Ellenberg /* drain possibly payload */ 282569a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2826b411b363SPhilipp Reisner } 2827b411b363SPhilipp Reisner 2828b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2829b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2830b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2831a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, 28329104d31aSLars Ellenberg size, GFP_NOIO); 2833db830c46SAndreas Gruenbacher if (!peer_req) { 2834b30ab791SAndreas Gruenbacher put_ldev(device); 283582bc0194SAndreas Gruenbacher return -ENOMEM; 2836b411b363SPhilipp Reisner } 2837b411b363SPhilipp Reisner 2838e2857216SAndreas Gruenbacher switch (pi->cmd) { 2839b411b363SPhilipp Reisner case P_DATA_REQUEST: 2840a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2841b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 284280a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 284321ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 284480a40e43SLars Ellenberg goto submit; 284580a40e43SLars Ellenberg 2846700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2847700ca8c0SPhilipp Reisner /* If at some point in the future we have a smart way to 2848700ca8c0SPhilipp Reisner find out if this data block is completely deallocated, 2849700ca8c0SPhilipp Reisner then we would do something smarter here than reading 2850700ca8c0SPhilipp Reisner the block... */ 2851700ca8c0SPhilipp Reisner peer_req->flags |= EE_RS_THIN_REQ; 2852b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2853a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2854b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 28555f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2856b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2857b411b363SPhilipp Reisner break; 2858b411b363SPhilipp Reisner 2859b411b363SPhilipp Reisner case P_OV_REPLY: 2860b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2861b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2862e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2863b411b363SPhilipp Reisner if (!di) 2864b411b363SPhilipp Reisner goto out_free_e; 2865b411b363SPhilipp Reisner 2866e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2867b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2868b411b363SPhilipp Reisner 2869db830c46SAndreas Gruenbacher peer_req->digest = di; 2870db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2871c36c3cedSLars Ellenberg 28729f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2873b411b363SPhilipp Reisner goto out_free_e; 2874b411b363SPhilipp Reisner 2875e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 28769f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2877a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 28785f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2879b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2880aaaba345SLars Ellenberg /* remember to report stats in drbd_resync_finished */ 2881aaaba345SLars Ellenberg device->use_csums = true; 2882e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 28832649f080SLars Ellenberg /* track progress, we may need to throttle */ 2884b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2885a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2886b30ab791SAndreas Gruenbacher dec_rs_pending(device); 28870f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 28880f0601f4SLars Ellenberg * but accounting still needs to be done. */ 28890f0601f4SLars Ellenberg goto submit_for_resync; 2890b411b363SPhilipp Reisner } 2891b411b363SPhilipp Reisner break; 2892b411b363SPhilipp Reisner 2893b411b363SPhilipp Reisner case P_OV_REQUEST: 2894b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 28959f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2896de228bbaSLars Ellenberg unsigned long now = jiffies; 2897de228bbaSLars Ellenberg int i; 2898b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2899b30ab791SAndreas Gruenbacher device->ov_position = sector; 2900b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2901b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2902de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2903b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2904b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2905de228bbaSLars Ellenberg } 2906d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2907b411b363SPhilipp Reisner (unsigned long long)sector); 2908b411b363SPhilipp Reisner } 2909a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2910b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2911b411b363SPhilipp Reisner break; 2912b411b363SPhilipp Reisner 2913b411b363SPhilipp Reisner default: 291449ba9b1bSAndreas Gruenbacher BUG(); 2915b411b363SPhilipp Reisner } 2916b411b363SPhilipp Reisner 29170f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 29180f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 29190f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 29200f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 29210f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 29220f0601f4SLars Ellenberg * 29230f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 29240f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 29250f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 29260f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 29270f0601f4SLars Ellenberg * a while, anyways. 29280f0601f4SLars Ellenberg */ 2929b411b363SPhilipp Reisner 29300f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 29310f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 29320f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 29330f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 29340f0601f4SLars Ellenberg * 29350f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 29360f0601f4SLars Ellenberg * we would also throttle its application reads. 29370f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 29380f0601f4SLars Ellenberg */ 2939c5a2c150SLars Ellenberg 2940c5a2c150SLars Ellenberg /* Even though this may be a resync request, we do add to "read_ee"; 2941c5a2c150SLars Ellenberg * "sync_ee" is only used for resync WRITEs. 2942c5a2c150SLars Ellenberg * Add to list early, so debugfs can find this request 2943c5a2c150SLars Ellenberg * even if we have to sleep below. */ 2944c5a2c150SLars Ellenberg spin_lock_irq(&device->resource->req_lock); 2945c5a2c150SLars Ellenberg list_add_tail(&peer_req->w.list, &device->read_ee); 2946c5a2c150SLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 2947c5a2c150SLars Ellenberg 2948944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_should_slow_down); 2949ad3fee79SLars Ellenberg if (device->state.peer != R_PRIMARY 2950ad3fee79SLars Ellenberg && drbd_rs_should_slow_down(device, sector, false)) 2951e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2952944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_begin_io); 2953b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 295480a40e43SLars Ellenberg goto out_free_e; 2955b411b363SPhilipp Reisner 29560f0601f4SLars Ellenberg submit_for_resync: 2957b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 29580f0601f4SLars Ellenberg 295980a40e43SLars Ellenberg submit: 2960944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_submit_peer_request); 2961b30ab791SAndreas Gruenbacher inc_unacked(device); 2962bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ, 0, 2963bb3cc85eSMike Christie fault_type) == 0) 296482bc0194SAndreas Gruenbacher return 0; 2965b411b363SPhilipp Reisner 296610f6d992SLars Ellenberg /* don't care for the reason here */ 2967d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 2968c5a2c150SLars Ellenberg 2969c5a2c150SLars Ellenberg out_free_e: 29700500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2971a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 29720500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 297322cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 297422cc37a9SLars Ellenberg 2975b30ab791SAndreas Gruenbacher put_ldev(device); 2976b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 297782bc0194SAndreas Gruenbacher return -EIO; 2978b411b363SPhilipp Reisner } 2979b411b363SPhilipp Reisner 298069a22773SAndreas Gruenbacher /** 298169a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 298269a22773SAndreas Gruenbacher */ 298369a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2984b411b363SPhilipp Reisner { 298569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2986b411b363SPhilipp Reisner int self, peer, rv = -100; 2987b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 298844ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2989b411b363SPhilipp Reisner 2990b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2991b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2992b411b363SPhilipp Reisner 2993b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2994b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2995b411b363SPhilipp Reisner 299644ed167dSPhilipp Reisner rcu_read_lock(); 299769a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 299844ed167dSPhilipp Reisner rcu_read_unlock(); 299944ed167dSPhilipp Reisner switch (after_sb_0p) { 3000b411b363SPhilipp Reisner case ASB_CONSENSUS: 3001b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 3002b411b363SPhilipp Reisner case ASB_CALL_HELPER: 300344ed167dSPhilipp Reisner case ASB_VIOLENTLY: 3004d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3005b411b363SPhilipp Reisner break; 3006b411b363SPhilipp Reisner case ASB_DISCONNECT: 3007b411b363SPhilipp Reisner break; 3008b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3009b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 3010b411b363SPhilipp Reisner rv = -1; 3011b411b363SPhilipp Reisner break; 3012b411b363SPhilipp Reisner } 3013b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 3014b411b363SPhilipp Reisner rv = 1; 3015b411b363SPhilipp Reisner break; 3016b411b363SPhilipp Reisner } 3017b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 3018b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3019b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 3020b411b363SPhilipp Reisner rv = 1; 3021b411b363SPhilipp Reisner break; 3022b411b363SPhilipp Reisner } 3023b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 3024b411b363SPhilipp Reisner rv = -1; 3025b411b363SPhilipp Reisner break; 3026b411b363SPhilipp Reisner } 3027b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 3028d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 3029b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 3030b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3031b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 303269a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 3033b411b363SPhilipp Reisner ? -1 : 1; 3034b411b363SPhilipp Reisner break; 3035b411b363SPhilipp Reisner } else { 3036b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 3037b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 3038b411b363SPhilipp Reisner } 303944ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 3040b411b363SPhilipp Reisner break; 3041b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3042b411b363SPhilipp Reisner if (ch_self < ch_peer) 3043b411b363SPhilipp Reisner rv = -1; 3044b411b363SPhilipp Reisner else if (ch_self > ch_peer) 3045b411b363SPhilipp Reisner rv = 1; 3046b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 3047b411b363SPhilipp Reisner /* Well, then use something else. */ 304869a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 3049b411b363SPhilipp Reisner ? -1 : 1; 3050b411b363SPhilipp Reisner break; 3051b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3052b411b363SPhilipp Reisner rv = -1; 3053b411b363SPhilipp Reisner break; 3054b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 3055b411b363SPhilipp Reisner rv = 1; 3056b411b363SPhilipp Reisner } 3057b411b363SPhilipp Reisner 3058b411b363SPhilipp Reisner return rv; 3059b411b363SPhilipp Reisner } 3060b411b363SPhilipp Reisner 306169a22773SAndreas Gruenbacher /** 306269a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 306369a22773SAndreas Gruenbacher */ 306469a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 3065b411b363SPhilipp Reisner { 306669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 30676184ea21SAndreas Gruenbacher int hg, rv = -100; 306844ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 3069b411b363SPhilipp Reisner 307044ed167dSPhilipp Reisner rcu_read_lock(); 307169a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 307244ed167dSPhilipp Reisner rcu_read_unlock(); 307344ed167dSPhilipp Reisner switch (after_sb_1p) { 3074b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3075b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3076b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3077b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3078b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 307944ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3080d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3081b411b363SPhilipp Reisner break; 3082b411b363SPhilipp Reisner case ASB_DISCONNECT: 3083b411b363SPhilipp Reisner break; 3084b411b363SPhilipp Reisner case ASB_CONSENSUS: 308569a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3086b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 3087b411b363SPhilipp Reisner rv = hg; 3088b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 3089b411b363SPhilipp Reisner rv = hg; 3090b411b363SPhilipp Reisner break; 3091b411b363SPhilipp Reisner case ASB_VIOLENTLY: 309269a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3093b411b363SPhilipp Reisner break; 3094b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 3095b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 3096b411b363SPhilipp Reisner case ASB_CALL_HELPER: 309769a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3098b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 3099bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3100bb437946SAndreas Gruenbacher 3101b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3102b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3103b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3104b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3105bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3106b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3107b411b363SPhilipp Reisner } else { 3108d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3109b411b363SPhilipp Reisner rv = hg; 3110b411b363SPhilipp Reisner } 3111b411b363SPhilipp Reisner } else 3112b411b363SPhilipp Reisner rv = hg; 3113b411b363SPhilipp Reisner } 3114b411b363SPhilipp Reisner 3115b411b363SPhilipp Reisner return rv; 3116b411b363SPhilipp Reisner } 3117b411b363SPhilipp Reisner 311869a22773SAndreas Gruenbacher /** 311969a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 312069a22773SAndreas Gruenbacher */ 312169a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 3122b411b363SPhilipp Reisner { 312369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 31246184ea21SAndreas Gruenbacher int hg, rv = -100; 312544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 3126b411b363SPhilipp Reisner 312744ed167dSPhilipp Reisner rcu_read_lock(); 312869a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 312944ed167dSPhilipp Reisner rcu_read_unlock(); 313044ed167dSPhilipp Reisner switch (after_sb_2p) { 3131b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3132b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3133b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3134b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3135b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 3136b411b363SPhilipp Reisner case ASB_CONSENSUS: 3137b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 313844ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3139d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3140b411b363SPhilipp Reisner break; 3141b411b363SPhilipp Reisner case ASB_VIOLENTLY: 314269a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3143b411b363SPhilipp Reisner break; 3144b411b363SPhilipp Reisner case ASB_DISCONNECT: 3145b411b363SPhilipp Reisner break; 3146b411b363SPhilipp Reisner case ASB_CALL_HELPER: 314769a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3148b411b363SPhilipp Reisner if (hg == -1) { 3149bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3150bb437946SAndreas Gruenbacher 3151b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3152b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3153b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3154b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3155bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3156b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3157b411b363SPhilipp Reisner } else { 3158d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3159b411b363SPhilipp Reisner rv = hg; 3160b411b363SPhilipp Reisner } 3161b411b363SPhilipp Reisner } else 3162b411b363SPhilipp Reisner rv = hg; 3163b411b363SPhilipp Reisner } 3164b411b363SPhilipp Reisner 3165b411b363SPhilipp Reisner return rv; 3166b411b363SPhilipp Reisner } 3167b411b363SPhilipp Reisner 3168b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 3169b411b363SPhilipp Reisner u64 bits, u64 flags) 3170b411b363SPhilipp Reisner { 3171b411b363SPhilipp Reisner if (!uuid) { 3172d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 3173b411b363SPhilipp Reisner return; 3174b411b363SPhilipp Reisner } 3175d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 3176b411b363SPhilipp Reisner text, 3177b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 3178b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 3179b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 3180b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 3181b411b363SPhilipp Reisner (unsigned long long)bits, 3182b411b363SPhilipp Reisner (unsigned long long)flags); 3183b411b363SPhilipp Reisner } 3184b411b363SPhilipp Reisner 3185b411b363SPhilipp Reisner /* 3186b411b363SPhilipp Reisner 100 after split brain try auto recover 3187b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 3188b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 3189b411b363SPhilipp Reisner 0 no Sync 3190b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 3191b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 3192b411b363SPhilipp Reisner -100 after split brain, disconnect 3193b411b363SPhilipp Reisner -1000 unrelated data 31944a23f264SPhilipp Reisner -1091 requires proto 91 31954a23f264SPhilipp Reisner -1096 requires proto 96 3196b411b363SPhilipp Reisner */ 3197f2d3d75bSLars Ellenberg 3198f2d3d75bSLars Ellenberg static int drbd_uuid_compare(struct drbd_device *const device, enum drbd_role const peer_role, int *rule_nr) __must_hold(local) 3199b411b363SPhilipp Reisner { 320044a4d551SLars Ellenberg struct drbd_peer_device *const peer_device = first_peer_device(device); 320144a4d551SLars Ellenberg struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; 3202b411b363SPhilipp Reisner u64 self, peer; 3203b411b363SPhilipp Reisner int i, j; 3204b411b363SPhilipp Reisner 3205b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3206b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3207b411b363SPhilipp Reisner 3208b411b363SPhilipp Reisner *rule_nr = 10; 3209b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 3210b411b363SPhilipp Reisner return 0; 3211b411b363SPhilipp Reisner 3212b411b363SPhilipp Reisner *rule_nr = 20; 3213b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 3214b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 3215b411b363SPhilipp Reisner return -2; 3216b411b363SPhilipp Reisner 3217b411b363SPhilipp Reisner *rule_nr = 30; 3218b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 3219b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 3220b411b363SPhilipp Reisner return 2; 3221b411b363SPhilipp Reisner 3222b411b363SPhilipp Reisner if (self == peer) { 3223b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 3224b411b363SPhilipp Reisner 3225b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 3226b411b363SPhilipp Reisner 322744a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 32284a23f264SPhilipp Reisner return -1091; 3229b411b363SPhilipp Reisner 3230b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 3231b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 3232d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 3233b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 3234b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 3235b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 3236b411b363SPhilipp Reisner 3237b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3238b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3239b411b363SPhilipp Reisner *rule_nr = 34; 3240b411b363SPhilipp Reisner } else { 3241d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 3242b411b363SPhilipp Reisner *rule_nr = 36; 3243b411b363SPhilipp Reisner } 3244b411b363SPhilipp Reisner 3245b411b363SPhilipp Reisner return 1; 3246b411b363SPhilipp Reisner } 3247b411b363SPhilipp Reisner 3248b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 3249b411b363SPhilipp Reisner 325044a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 32514a23f264SPhilipp Reisner return -1091; 3252b411b363SPhilipp Reisner 3253b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 3254b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 3255d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 3256b411b363SPhilipp Reisner 3257b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 3258b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 3259b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 3260b411b363SPhilipp Reisner 3261b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3262b411b363SPhilipp Reisner *rule_nr = 35; 3263b411b363SPhilipp Reisner } else { 3264d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 3265b411b363SPhilipp Reisner *rule_nr = 37; 3266b411b363SPhilipp Reisner } 3267b411b363SPhilipp Reisner 3268b411b363SPhilipp Reisner return -1; 3269b411b363SPhilipp Reisner } 3270b411b363SPhilipp Reisner 3271b411b363SPhilipp Reisner /* Common power [off|failure] */ 3272b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 3273b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 3274b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 3275b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 3276b411b363SPhilipp Reisner *rule_nr = 40; 3277b411b363SPhilipp Reisner 3278f2d3d75bSLars Ellenberg /* Neither has the "crashed primary" flag set, 3279f2d3d75bSLars Ellenberg * only a replication link hickup. */ 3280f2d3d75bSLars Ellenberg if (rct == 0) 3281f2d3d75bSLars Ellenberg return 0; 3282f2d3d75bSLars Ellenberg 3283f2d3d75bSLars Ellenberg /* Current UUID equal and no bitmap uuid; does not necessarily 3284f2d3d75bSLars Ellenberg * mean this was a "simultaneous hard crash", maybe IO was 3285f2d3d75bSLars Ellenberg * frozen, so no UUID-bump happened. 3286f2d3d75bSLars Ellenberg * This is a protocol change, overload DRBD_FF_WSAME as flag 3287f2d3d75bSLars Ellenberg * for "new-enough" peer DRBD version. */ 3288f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY || peer_role == R_PRIMARY) { 3289f2d3d75bSLars Ellenberg *rule_nr = 41; 3290f2d3d75bSLars Ellenberg if (!(connection->agreed_features & DRBD_FF_WSAME)) { 3291f2d3d75bSLars Ellenberg drbd_warn(peer_device, "Equivalent unrotated UUIDs, but current primary present.\n"); 3292f2d3d75bSLars Ellenberg return -(0x10000 | PRO_VERSION_MAX | (DRBD_FF_WSAME << 8)); 3293f2d3d75bSLars Ellenberg } 3294f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY && peer_role == R_PRIMARY) { 3295f2d3d75bSLars Ellenberg /* At least one has the "crashed primary" bit set, 3296f2d3d75bSLars Ellenberg * both are primary now, but neither has rotated its UUIDs? 3297f2d3d75bSLars Ellenberg * "Can not happen." */ 3298f2d3d75bSLars Ellenberg drbd_err(peer_device, "Equivalent unrotated UUIDs, but both are primary. Can not resolve this.\n"); 3299f2d3d75bSLars Ellenberg return -100; 3300f2d3d75bSLars Ellenberg } 3301f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY) 3302f2d3d75bSLars Ellenberg return 1; 3303f2d3d75bSLars Ellenberg return -1; 3304f2d3d75bSLars Ellenberg } 3305f2d3d75bSLars Ellenberg 3306f2d3d75bSLars Ellenberg /* Both are secondary. 3307f2d3d75bSLars Ellenberg * Really looks like recovery from simultaneous hard crash. 3308f2d3d75bSLars Ellenberg * Check which had been primary before, and arbitrate. */ 3309b411b363SPhilipp Reisner switch (rct) { 3310f2d3d75bSLars Ellenberg case 0: /* !self_pri && !peer_pri */ return 0; /* already handled */ 3311b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 3312b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 3313b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 331444a4d551SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); 3315b411b363SPhilipp Reisner return dc ? -1 : 1; 3316b411b363SPhilipp Reisner } 3317b411b363SPhilipp Reisner } 3318b411b363SPhilipp Reisner 3319b411b363SPhilipp Reisner *rule_nr = 50; 3320b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3321b411b363SPhilipp Reisner if (self == peer) 3322b411b363SPhilipp Reisner return -1; 3323b411b363SPhilipp Reisner 3324b411b363SPhilipp Reisner *rule_nr = 51; 3325b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 3326b411b363SPhilipp Reisner if (self == peer) { 332744a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3328b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 3329b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 3330b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 3331b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3332b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 3333b411b363SPhilipp Reisner 333444a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 33354a23f264SPhilipp Reisner return -1091; 3336b411b363SPhilipp Reisner 3337b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 3338b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 33394a23f264SPhilipp Reisner 3340d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 3341b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 33424a23f264SPhilipp Reisner 3343b411b363SPhilipp Reisner return -1; 3344b411b363SPhilipp Reisner } 3345b411b363SPhilipp Reisner } 3346b411b363SPhilipp Reisner 3347b411b363SPhilipp Reisner *rule_nr = 60; 3348b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3349b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3350b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 3351b411b363SPhilipp Reisner if (self == peer) 3352b411b363SPhilipp Reisner return -2; 3353b411b363SPhilipp Reisner } 3354b411b363SPhilipp Reisner 3355b411b363SPhilipp Reisner *rule_nr = 70; 3356b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3357b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3358b411b363SPhilipp Reisner if (self == peer) 3359b411b363SPhilipp Reisner return 1; 3360b411b363SPhilipp Reisner 3361b411b363SPhilipp Reisner *rule_nr = 71; 3362b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 3363b411b363SPhilipp Reisner if (self == peer) { 336444a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3365b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 3366b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 3367b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 3368b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3369b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 3370b411b363SPhilipp Reisner 337144a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 33724a23f264SPhilipp Reisner return -1091; 3373b411b363SPhilipp Reisner 3374b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 3375b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 3376b411b363SPhilipp Reisner 3377d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 3378b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3379b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3380b411b363SPhilipp Reisner 3381b411b363SPhilipp Reisner return 1; 3382b411b363SPhilipp Reisner } 3383b411b363SPhilipp Reisner } 3384b411b363SPhilipp Reisner 3385b411b363SPhilipp Reisner 3386b411b363SPhilipp Reisner *rule_nr = 80; 3387b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3388b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3389b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3390b411b363SPhilipp Reisner if (self == peer) 3391b411b363SPhilipp Reisner return 2; 3392b411b363SPhilipp Reisner } 3393b411b363SPhilipp Reisner 3394b411b363SPhilipp Reisner *rule_nr = 90; 3395b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3396b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3397b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 3398b411b363SPhilipp Reisner return 100; 3399b411b363SPhilipp Reisner 3400b411b363SPhilipp Reisner *rule_nr = 100; 3401b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3402b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3403b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 3404b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 3405b411b363SPhilipp Reisner if (self == peer) 3406b411b363SPhilipp Reisner return -100; 3407b411b363SPhilipp Reisner } 3408b411b363SPhilipp Reisner } 3409b411b363SPhilipp Reisner 3410b411b363SPhilipp Reisner return -1000; 3411b411b363SPhilipp Reisner } 3412b411b363SPhilipp Reisner 3413b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 3414b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 3415b411b363SPhilipp Reisner */ 341669a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 341769a22773SAndreas Gruenbacher enum drbd_role peer_role, 3418b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 3419b411b363SPhilipp Reisner { 342069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 3421b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 3422b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 342344ed167dSPhilipp Reisner struct net_conf *nc; 34246dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 3425b411b363SPhilipp Reisner 3426b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 3427b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 3428b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 3429b411b363SPhilipp Reisner 3430d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 34319f2247bbSPhilipp Reisner 3432b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 3433b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 3434b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 3435b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3436b411b363SPhilipp Reisner 3437f2d3d75bSLars Ellenberg hg = drbd_uuid_compare(device, peer_role, &rule_nr); 3438b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 3439b411b363SPhilipp Reisner 3440d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 3441b411b363SPhilipp Reisner 3442b411b363SPhilipp Reisner if (hg == -1000) { 3443d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3444b411b363SPhilipp Reisner return C_MASK; 3445b411b363SPhilipp Reisner } 3446f2d3d75bSLars Ellenberg if (hg < -0x10000) { 3447f2d3d75bSLars Ellenberg int proto, fflags; 3448f2d3d75bSLars Ellenberg hg = -hg; 3449f2d3d75bSLars Ellenberg proto = hg & 0xff; 3450f2d3d75bSLars Ellenberg fflags = (hg >> 8) & 0xff; 3451f2d3d75bSLars Ellenberg drbd_alert(device, "To resolve this both sides have to support at least protocol %d and feature flags 0x%x\n", 3452f2d3d75bSLars Ellenberg proto, fflags); 3453f2d3d75bSLars Ellenberg return C_MASK; 3454f2d3d75bSLars Ellenberg } 34554a23f264SPhilipp Reisner if (hg < -1000) { 3456d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3457b411b363SPhilipp Reisner return C_MASK; 3458b411b363SPhilipp Reisner } 3459b411b363SPhilipp Reisner 3460b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3461b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3462b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3463b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3464b411b363SPhilipp Reisner if (f) 3465b411b363SPhilipp Reisner hg = hg*2; 3466d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3467b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3468b411b363SPhilipp Reisner } 3469b411b363SPhilipp Reisner 34703a11a487SAdam Gandelman if (abs(hg) == 100) 3471b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 34723a11a487SAdam Gandelman 347344ed167dSPhilipp Reisner rcu_read_lock(); 347469a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 347544ed167dSPhilipp Reisner 347644ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3477b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3478b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3479b411b363SPhilipp Reisner int forced = (hg == -100); 3480b411b363SPhilipp Reisner 3481b411b363SPhilipp Reisner switch (pcount) { 3482b411b363SPhilipp Reisner case 0: 348369a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3484b411b363SPhilipp Reisner break; 3485b411b363SPhilipp Reisner case 1: 348669a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3487b411b363SPhilipp Reisner break; 3488b411b363SPhilipp Reisner case 2: 348969a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3490b411b363SPhilipp Reisner break; 3491b411b363SPhilipp Reisner } 3492b411b363SPhilipp Reisner if (abs(hg) < 100) { 3493d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3494b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3495b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3496b411b363SPhilipp Reisner if (forced) { 3497d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3498b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3499b411b363SPhilipp Reisner hg = hg*2; 3500b411b363SPhilipp Reisner } 3501b411b363SPhilipp Reisner } 3502b411b363SPhilipp Reisner } 3503b411b363SPhilipp Reisner 3504b411b363SPhilipp Reisner if (hg == -100) { 3505b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3506b411b363SPhilipp Reisner hg = -1; 3507b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3508b411b363SPhilipp Reisner hg = 1; 3509b411b363SPhilipp Reisner 3510b411b363SPhilipp Reisner if (abs(hg) < 100) 3511d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3512b411b363SPhilipp Reisner "Sync from %s node\n", 3513b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3514b411b363SPhilipp Reisner } 351544ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 35166dff2902SAndreas Gruenbacher tentative = nc->tentative; 351744ed167dSPhilipp Reisner rcu_read_unlock(); 3518b411b363SPhilipp Reisner 3519b411b363SPhilipp Reisner if (hg == -100) { 3520580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3521580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3522580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3523580b9767SLars Ellenberg * to that disk, in a way... */ 3524d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3525b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3526b411b363SPhilipp Reisner return C_MASK; 3527b411b363SPhilipp Reisner } 3528b411b363SPhilipp Reisner 3529b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3530d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3531b411b363SPhilipp Reisner return C_MASK; 3532b411b363SPhilipp Reisner } 3533b411b363SPhilipp Reisner 3534b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3535b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 353644ed167dSPhilipp Reisner switch (rr_conflict) { 3537b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3538b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3539b411b363SPhilipp Reisner /* fall through */ 3540b411b363SPhilipp Reisner case ASB_DISCONNECT: 3541d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3542b411b363SPhilipp Reisner return C_MASK; 3543b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3544d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3545b411b363SPhilipp Reisner "assumption\n"); 3546b411b363SPhilipp Reisner } 3547b411b363SPhilipp Reisner } 3548b411b363SPhilipp Reisner 354969a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3550cf14c2e9SPhilipp Reisner if (hg == 0) 3551d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3552cf14c2e9SPhilipp Reisner else 3553d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3554cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3555cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3556cf14c2e9SPhilipp Reisner return C_MASK; 3557cf14c2e9SPhilipp Reisner } 3558cf14c2e9SPhilipp Reisner 3559b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3560d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3561b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 356220ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3563b411b363SPhilipp Reisner return C_MASK; 3564b411b363SPhilipp Reisner } 3565b411b363SPhilipp Reisner 3566b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3567b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3568b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3569b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3570b411b363SPhilipp Reisner } else { 3571b411b363SPhilipp Reisner rv = C_CONNECTED; 3572b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3573d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3574b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3575b411b363SPhilipp Reisner } 3576b411b363SPhilipp Reisner } 3577b411b363SPhilipp Reisner 3578b411b363SPhilipp Reisner return rv; 3579b411b363SPhilipp Reisner } 3580b411b363SPhilipp Reisner 3581f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3582b411b363SPhilipp Reisner { 3583b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3584f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3585f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3586b411b363SPhilipp Reisner 3587b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3588f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3589f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3590b411b363SPhilipp Reisner 3591b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3592f179d76dSPhilipp Reisner return peer; 3593b411b363SPhilipp Reisner } 3594b411b363SPhilipp Reisner 3595bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3596b411b363SPhilipp Reisner { 3597e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3598036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3599036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3600036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3601036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 36029534d671SHerbert Xu struct crypto_ahash *peer_integrity_tfm = NULL; 36037aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3604b411b363SPhilipp Reisner 3605b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3606b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3607b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3608b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3609b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3610cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 36116139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3612cf14c2e9SPhilipp Reisner 3613bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 361486db0618SAndreas Gruenbacher int err; 361586db0618SAndreas Gruenbacher 361688104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 361786db0618SAndreas Gruenbacher return -EIO; 3618bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 361986db0618SAndreas Gruenbacher if (err) 362086db0618SAndreas Gruenbacher return err; 362188104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3622036b17eaSPhilipp Reisner } 362386db0618SAndreas Gruenbacher 36247d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3625bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3626cf14c2e9SPhilipp Reisner 3627cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3628bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3629b411b363SPhilipp Reisner 363044ed167dSPhilipp Reisner rcu_read_lock(); 3631bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 363244ed167dSPhilipp Reisner 3633036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 36341ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 363544ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3636b411b363SPhilipp Reisner } 3637b411b363SPhilipp Reisner 3638f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 36391ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 364044ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3641b411b363SPhilipp Reisner } 3642b411b363SPhilipp Reisner 3643f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 36441ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 364544ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3646b411b363SPhilipp Reisner } 3647b411b363SPhilipp Reisner 3648f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 36491ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 365044ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3651b411b363SPhilipp Reisner } 3652b411b363SPhilipp Reisner 36536139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 36541ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 365544ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3656b411b363SPhilipp Reisner } 3657b411b363SPhilipp Reisner 365844ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 36591ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 366044ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3661b411b363SPhilipp Reisner } 3662b411b363SPhilipp Reisner 3663036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 36641ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3665036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3666036b17eaSPhilipp Reisner } 3667036b17eaSPhilipp Reisner 366886db0618SAndreas Gruenbacher rcu_read_unlock(); 3669fbc12f45SAndreas Gruenbacher } 36707d4c782cSAndreas Gruenbacher 36717d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 36727d4c782cSAndreas Gruenbacher int hash_size; 36737d4c782cSAndreas Gruenbacher 36747d4c782cSAndreas Gruenbacher /* 36757d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 36767d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 36777d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 36787d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 36797d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 36807d4c782cSAndreas Gruenbacher * change. 36817d4c782cSAndreas Gruenbacher */ 36827d4c782cSAndreas Gruenbacher 36839534d671SHerbert Xu peer_integrity_tfm = crypto_alloc_ahash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 36841b57e663SLars Ellenberg if (IS_ERR(peer_integrity_tfm)) { 36851b57e663SLars Ellenberg peer_integrity_tfm = NULL; 36861ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 36877d4c782cSAndreas Gruenbacher integrity_alg); 3688b411b363SPhilipp Reisner goto disconnect; 3689b411b363SPhilipp Reisner } 3690b411b363SPhilipp Reisner 36919534d671SHerbert Xu hash_size = crypto_ahash_digestsize(peer_integrity_tfm); 36927d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 36937d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 36947d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 36951ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 36967d4c782cSAndreas Gruenbacher goto disconnect; 36977d4c782cSAndreas Gruenbacher } 36987d4c782cSAndreas Gruenbacher } 36997d4c782cSAndreas Gruenbacher 37007d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 37017d4c782cSAndreas Gruenbacher if (!new_net_conf) { 37021ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3703b411b363SPhilipp Reisner goto disconnect; 3704b411b363SPhilipp Reisner } 3705b411b363SPhilipp Reisner 3706bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 37070500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3708bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 37097d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3710b411b363SPhilipp Reisner 37117d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 37127d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 37137d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 37147d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 37157d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3716b411b363SPhilipp Reisner 3717bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 37180500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3719bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3720b411b363SPhilipp Reisner 37219534d671SHerbert Xu crypto_free_ahash(connection->peer_integrity_tfm); 3722bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3723bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3724bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3725bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3726bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3727b411b363SPhilipp Reisner 37287d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 37291ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 37307d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3731b411b363SPhilipp Reisner 37327d4c782cSAndreas Gruenbacher synchronize_rcu(); 37337d4c782cSAndreas Gruenbacher kfree(old_net_conf); 373482bc0194SAndreas Gruenbacher return 0; 3735b411b363SPhilipp Reisner 373644ed167dSPhilipp Reisner disconnect_rcu_unlock: 373744ed167dSPhilipp Reisner rcu_read_unlock(); 3738b411b363SPhilipp Reisner disconnect: 37399534d671SHerbert Xu crypto_free_ahash(peer_integrity_tfm); 3740036b17eaSPhilipp Reisner kfree(int_dig_in); 3741036b17eaSPhilipp Reisner kfree(int_dig_vv); 3742bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 374382bc0194SAndreas Gruenbacher return -EIO; 3744b411b363SPhilipp Reisner } 3745b411b363SPhilipp Reisner 3746b411b363SPhilipp Reisner /* helper function 3747b411b363SPhilipp Reisner * input: alg name, feature name 3748b411b363SPhilipp Reisner * return: NULL (alg name was "") 3749b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3750b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 37519534d671SHerbert Xu static struct crypto_ahash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3752b411b363SPhilipp Reisner const char *alg, const char *name) 3753b411b363SPhilipp Reisner { 37549534d671SHerbert Xu struct crypto_ahash *tfm; 3755b411b363SPhilipp Reisner 3756b411b363SPhilipp Reisner if (!alg[0]) 3757b411b363SPhilipp Reisner return NULL; 3758b411b363SPhilipp Reisner 37599534d671SHerbert Xu tfm = crypto_alloc_ahash(alg, 0, CRYPTO_ALG_ASYNC); 3760b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3761d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3762b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3763b411b363SPhilipp Reisner return tfm; 3764b411b363SPhilipp Reisner } 3765b411b363SPhilipp Reisner return tfm; 3766b411b363SPhilipp Reisner } 3767b411b363SPhilipp Reisner 3768bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3769b411b363SPhilipp Reisner { 3770bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 37714a76b161SAndreas Gruenbacher int size = pi->size; 37724a76b161SAndreas Gruenbacher 37734a76b161SAndreas Gruenbacher while (size) { 37744a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3775bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 37764a76b161SAndreas Gruenbacher if (s <= 0) { 37774a76b161SAndreas Gruenbacher if (s < 0) 37784a76b161SAndreas Gruenbacher return s; 37794a76b161SAndreas Gruenbacher break; 37804a76b161SAndreas Gruenbacher } 37814a76b161SAndreas Gruenbacher size -= s; 37824a76b161SAndreas Gruenbacher } 37834a76b161SAndreas Gruenbacher if (size) 37844a76b161SAndreas Gruenbacher return -EIO; 37854a76b161SAndreas Gruenbacher return 0; 37864a76b161SAndreas Gruenbacher } 37874a76b161SAndreas Gruenbacher 37884a76b161SAndreas Gruenbacher /* 37894a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 37904a76b161SAndreas Gruenbacher * 37914a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 37924a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 37934a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 37944a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 37954a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 37964a76b161SAndreas Gruenbacher * 37974a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 37984a76b161SAndreas Gruenbacher */ 3799bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 38004a76b161SAndreas Gruenbacher { 38011ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 38022fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3803bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 38044a76b161SAndreas Gruenbacher } 38054a76b161SAndreas Gruenbacher 3806bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 38074a76b161SAndreas Gruenbacher { 38089f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3809b30ab791SAndreas Gruenbacher struct drbd_device *device; 3810e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3811b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 38129534d671SHerbert Xu struct crypto_ahash *verify_tfm = NULL; 38139534d671SHerbert Xu struct crypto_ahash *csums_tfm = NULL; 38142ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3815813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3816bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3817813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3818778f271dSPhilipp Reisner int fifo_size = 0; 381982bc0194SAndreas Gruenbacher int err; 3820b411b363SPhilipp Reisner 38219f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 38229f4fe9adSAndreas Gruenbacher if (!peer_device) 3823bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 38249f4fe9adSAndreas Gruenbacher device = peer_device->device; 3825b411b363SPhilipp Reisner 3826b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3827b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3828b411b363SPhilipp Reisner + SHARED_SECRET_MAX 38298e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 38308e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3831b411b363SPhilipp Reisner 3832e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3833d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3834e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 383582bc0194SAndreas Gruenbacher return -EIO; 3836b411b363SPhilipp Reisner } 3837b411b363SPhilipp Reisner 3838b411b363SPhilipp Reisner if (apv <= 88) { 3839e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3840e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 38418e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3842e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3843e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 38440b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 38458e26f9ccSPhilipp Reisner } else { 3846e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3847e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 38480b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3849b411b363SPhilipp Reisner } 3850b411b363SPhilipp Reisner 3851b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3852e658983aSAndreas Gruenbacher p = pi->data; 3853b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3854b411b363SPhilipp Reisner 38559f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 385682bc0194SAndreas Gruenbacher if (err) 385782bc0194SAndreas Gruenbacher return err; 3858b411b363SPhilipp Reisner 38590500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 38609f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3861b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3862daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3863daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3864b30ab791SAndreas Gruenbacher put_ldev(device); 38650500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3866d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3867daeda1ccSPhilipp Reisner return -ENOMEM; 3868f399002eSLars Ellenberg } 3869b411b363SPhilipp Reisner 3870b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3871daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3872daeda1ccSPhilipp Reisner 38736394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3874813472ceSPhilipp Reisner } 3875b411b363SPhilipp Reisner 3876b411b363SPhilipp Reisner if (apv >= 88) { 3877b411b363SPhilipp Reisner if (apv == 88) { 38785de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3879d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 38805de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3881b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3882813472ceSPhilipp Reisner err = -EIO; 3883813472ceSPhilipp Reisner goto reconnect; 3884b411b363SPhilipp Reisner } 3885b411b363SPhilipp Reisner 38869f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3887813472ceSPhilipp Reisner if (err) 3888813472ceSPhilipp Reisner goto reconnect; 3889b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3890b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38910b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3892b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3893b411b363SPhilipp Reisner 3894b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3895b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3896b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38970b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 38980b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3899b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3900b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3901b411b363SPhilipp Reisner } 3902b411b363SPhilipp Reisner 39032ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3904b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3905d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 39062ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3907b411b363SPhilipp Reisner goto disconnect; 3908b411b363SPhilipp Reisner } 3909b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3910b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3911b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3912b411b363SPhilipp Reisner verify_tfm = NULL; 3913b411b363SPhilipp Reisner goto disconnect; 3914b411b363SPhilipp Reisner } 3915b411b363SPhilipp Reisner } 3916b411b363SPhilipp Reisner 39172ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3918b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3919d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 39202ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3921b411b363SPhilipp Reisner goto disconnect; 3922b411b363SPhilipp Reisner } 3923b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3924b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3925b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3926b411b363SPhilipp Reisner csums_tfm = NULL; 3927b411b363SPhilipp Reisner goto disconnect; 3928b411b363SPhilipp Reisner } 3929b411b363SPhilipp Reisner } 3930b411b363SPhilipp Reisner 3931813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3932daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3933daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3934daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3935daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3936778f271dSPhilipp Reisner 3937daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3938b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3939813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3940813472ceSPhilipp Reisner if (!new_plan) { 3941d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3942b30ab791SAndreas Gruenbacher put_ldev(device); 3943778f271dSPhilipp Reisner goto disconnect; 3944778f271dSPhilipp Reisner } 3945778f271dSPhilipp Reisner } 39468e26f9ccSPhilipp Reisner } 3947b411b363SPhilipp Reisner 394891fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 39492ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 39502ec91e0eSPhilipp Reisner if (!new_net_conf) { 3951d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 395291fd4dadSPhilipp Reisner goto disconnect; 395391fd4dadSPhilipp Reisner } 395491fd4dadSPhilipp Reisner 39552ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 395691fd4dadSPhilipp Reisner 3957b411b363SPhilipp Reisner if (verify_tfm) { 39582ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 39592ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 39609534d671SHerbert Xu crypto_free_ahash(peer_device->connection->verify_tfm); 39619f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3962d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3963b411b363SPhilipp Reisner } 3964b411b363SPhilipp Reisner if (csums_tfm) { 39652ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 39662ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 39679534d671SHerbert Xu crypto_free_ahash(peer_device->connection->csums_tfm); 39689f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3969d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3970b411b363SPhilipp Reisner } 3971bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3972778f271dSPhilipp Reisner } 3973b411b363SPhilipp Reisner } 3974b411b363SPhilipp Reisner 3975813472ceSPhilipp Reisner if (new_disk_conf) { 3976b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3977b30ab791SAndreas Gruenbacher put_ldev(device); 3978b411b363SPhilipp Reisner } 3979813472ceSPhilipp Reisner 3980813472ceSPhilipp Reisner if (new_plan) { 3981b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3982b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3983813472ceSPhilipp Reisner } 3984daeda1ccSPhilipp Reisner 39850500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3986daeda1ccSPhilipp Reisner synchronize_rcu(); 3987daeda1ccSPhilipp Reisner if (new_net_conf) 3988daeda1ccSPhilipp Reisner kfree(old_net_conf); 3989daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3990813472ceSPhilipp Reisner kfree(old_plan); 3991daeda1ccSPhilipp Reisner 399282bc0194SAndreas Gruenbacher return 0; 3993b411b363SPhilipp Reisner 3994813472ceSPhilipp Reisner reconnect: 3995813472ceSPhilipp Reisner if (new_disk_conf) { 3996b30ab791SAndreas Gruenbacher put_ldev(device); 3997813472ceSPhilipp Reisner kfree(new_disk_conf); 3998813472ceSPhilipp Reisner } 39990500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 4000813472ceSPhilipp Reisner return -EIO; 4001813472ceSPhilipp Reisner 4002b411b363SPhilipp Reisner disconnect: 4003813472ceSPhilipp Reisner kfree(new_plan); 4004813472ceSPhilipp Reisner if (new_disk_conf) { 4005b30ab791SAndreas Gruenbacher put_ldev(device); 4006813472ceSPhilipp Reisner kfree(new_disk_conf); 4007813472ceSPhilipp Reisner } 40080500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 4009b411b363SPhilipp Reisner /* just for completeness: actually not needed, 4010b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 40119534d671SHerbert Xu crypto_free_ahash(csums_tfm); 4012b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 40139534d671SHerbert Xu crypto_free_ahash(verify_tfm); 40149f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 401582bc0194SAndreas Gruenbacher return -EIO; 4016b411b363SPhilipp Reisner } 4017b411b363SPhilipp Reisner 4018b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 4019b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 4020b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 4021b411b363SPhilipp Reisner { 4022b411b363SPhilipp Reisner sector_t d; 4023b411b363SPhilipp Reisner if (a == 0 || b == 0) 4024b411b363SPhilipp Reisner return; 4025b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 4026b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 4027d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 4028b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 4029b411b363SPhilipp Reisner } 4030b411b363SPhilipp Reisner 4031bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 4032b411b363SPhilipp Reisner { 40339f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4034b30ab791SAndreas Gruenbacher struct drbd_device *device; 4035e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 40369104d31aSLars Ellenberg struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL; 4037e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 40386a8d68b1SLars Ellenberg sector_t p_size, p_usize, p_csize, my_usize; 4039b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 4040e89b591cSPhilipp Reisner enum dds_flags ddsf; 4041b411b363SPhilipp Reisner 40429f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 40439f4fe9adSAndreas Gruenbacher if (!peer_device) 4044bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 40459f4fe9adSAndreas Gruenbacher device = peer_device->device; 40464a76b161SAndreas Gruenbacher 4047b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 4048b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 40496a8d68b1SLars Ellenberg p_csize = be64_to_cpu(p->c_size); 4050b411b363SPhilipp Reisner 4051b411b363SPhilipp Reisner /* just store the peer's disk size for now. 4052b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 4053b30ab791SAndreas Gruenbacher device->p_size = p_size; 4054b411b363SPhilipp Reisner 4055b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 405660bac040SLars Ellenberg sector_t new_size, cur_size; 4057daeda1ccSPhilipp Reisner rcu_read_lock(); 4058b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 4059daeda1ccSPhilipp Reisner rcu_read_unlock(); 4060daeda1ccSPhilipp Reisner 4061b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 4062b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 4063b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 4064daeda1ccSPhilipp Reisner p_usize, my_usize); 4065b411b363SPhilipp Reisner 4066b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 4067b411b363SPhilipp Reisner * param exchange, choose the minimum */ 4068b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 4069daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 4070b411b363SPhilipp Reisner 4071b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 4072b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 407360bac040SLars Ellenberg new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0); 407460bac040SLars Ellenberg cur_size = drbd_get_capacity(device->this_bdev); 407560bac040SLars Ellenberg if (new_size < cur_size && 4076b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 4077b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 407860bac040SLars Ellenberg drbd_err(device, "The peer's disk size is too small! (%llu < %llu sectors)\n", 407960bac040SLars Ellenberg (unsigned long long)new_size, (unsigned long long)cur_size); 40809f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 4081b30ab791SAndreas Gruenbacher put_ldev(device); 408282bc0194SAndreas Gruenbacher return -EIO; 4083b411b363SPhilipp Reisner } 4084daeda1ccSPhilipp Reisner 4085daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 4086daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 4087daeda1ccSPhilipp Reisner 4088daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 4089daeda1ccSPhilipp Reisner if (!new_disk_conf) { 4090d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 4091b30ab791SAndreas Gruenbacher put_ldev(device); 4092daeda1ccSPhilipp Reisner return -ENOMEM; 4093daeda1ccSPhilipp Reisner } 4094daeda1ccSPhilipp Reisner 40950500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 4096b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 4097daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 4098daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 4099daeda1ccSPhilipp Reisner 4100b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 41010500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 4102daeda1ccSPhilipp Reisner synchronize_rcu(); 4103daeda1ccSPhilipp Reisner kfree(old_disk_conf); 4104daeda1ccSPhilipp Reisner 4105d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 4106daeda1ccSPhilipp Reisner (unsigned long)my_usize); 4107daeda1ccSPhilipp Reisner } 4108daeda1ccSPhilipp Reisner 4109b30ab791SAndreas Gruenbacher put_ldev(device); 4110b411b363SPhilipp Reisner } 4111b411b363SPhilipp Reisner 411220c68fdeSLars Ellenberg device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 4113dd4f699dSLars Ellenberg /* Leave drbd_reconsider_queue_parameters() before drbd_determine_dev_size(). 411420c68fdeSLars Ellenberg In case we cleared the QUEUE_FLAG_DISCARD from our queue in 4115dd4f699dSLars Ellenberg drbd_reconsider_queue_parameters(), we can be sure that after 411620c68fdeSLars Ellenberg drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */ 411720c68fdeSLars Ellenberg 4118e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 4119b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 41209104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, device->ldev, o); 4121b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 4122b30ab791SAndreas Gruenbacher put_ldev(device); 4123e96c9633SPhilipp Reisner if (dd == DS_ERROR) 412482bc0194SAndreas Gruenbacher return -EIO; 4125b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4126b411b363SPhilipp Reisner } else { 41276a8d68b1SLars Ellenberg /* 41286a8d68b1SLars Ellenberg * I am diskless, need to accept the peer's *current* size. 41296a8d68b1SLars Ellenberg * I must NOT accept the peers backing disk size, 41306a8d68b1SLars Ellenberg * it may have been larger than mine all along... 41316a8d68b1SLars Ellenberg * 41326a8d68b1SLars Ellenberg * At this point, the peer knows more about my disk, or at 41336a8d68b1SLars Ellenberg * least about what we last agreed upon, than myself. 41346a8d68b1SLars Ellenberg * So if his c_size is less than his d_size, the most likely 41356a8d68b1SLars Ellenberg * reason is that *my* d_size was smaller last time we checked. 41366a8d68b1SLars Ellenberg * 41376a8d68b1SLars Ellenberg * However, if he sends a zero current size, 41386a8d68b1SLars Ellenberg * take his (user-capped or) backing disk size anyways. 41396a8d68b1SLars Ellenberg */ 41409104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, NULL, o); 41416a8d68b1SLars Ellenberg drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); 4142b411b363SPhilipp Reisner } 4143b411b363SPhilipp Reisner 4144b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4145b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 4146b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 4147b411b363SPhilipp Reisner ldsc = 1; 4148b411b363SPhilipp Reisner } 4149b411b363SPhilipp Reisner 4150b30ab791SAndreas Gruenbacher put_ldev(device); 4151b411b363SPhilipp Reisner } 4152b411b363SPhilipp Reisner 4153b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 4154b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 4155b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 4156b411b363SPhilipp Reisner /* we have different sizes, probably peer 4157b411b363SPhilipp Reisner * needs to know my new size... */ 415869a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 4159b411b363SPhilipp Reisner } 4160b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 4161b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 4162b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 4163b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 4164e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 4165d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 4166b411b363SPhilipp Reisner else 4167b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 4168e89b591cSPhilipp Reisner } else 4169b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 4170b411b363SPhilipp Reisner } 4171b411b363SPhilipp Reisner } 4172b411b363SPhilipp Reisner 417382bc0194SAndreas Gruenbacher return 0; 4174b411b363SPhilipp Reisner } 4175b411b363SPhilipp Reisner 4176bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 4177b411b363SPhilipp Reisner { 41789f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4179b30ab791SAndreas Gruenbacher struct drbd_device *device; 4180e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 4181b411b363SPhilipp Reisner u64 *p_uuid; 418262b0da3aSLars Ellenberg int i, updated_uuids = 0; 4183b411b363SPhilipp Reisner 41849f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 41859f4fe9adSAndreas Gruenbacher if (!peer_device) 4186bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 41879f4fe9adSAndreas Gruenbacher device = peer_device->device; 41884a76b161SAndreas Gruenbacher 4189b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 4190063eacf8SJing Wang if (!p_uuid) { 4191d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 4192063eacf8SJing Wang return false; 4193063eacf8SJing Wang } 4194b411b363SPhilipp Reisner 4195b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 4196b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 4197b411b363SPhilipp Reisner 4198b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4199b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 4200b411b363SPhilipp Reisner 4201b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 4202b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 4203b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 4204b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 4205d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 4206b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 42079f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 420882bc0194SAndreas Gruenbacher return -EIO; 4209b411b363SPhilipp Reisner } 4210b411b363SPhilipp Reisner 4211b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4212b411b363SPhilipp Reisner int skip_initial_sync = 4213b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 42149f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 4215b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 4216b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 4217b411b363SPhilipp Reisner if (skip_initial_sync) { 4218d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 4219b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 422020ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 422120ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 4222b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 4223b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 4224b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 4225b411b363SPhilipp Reisner CS_VERBOSE, NULL); 4226b30ab791SAndreas Gruenbacher drbd_md_sync(device); 422762b0da3aSLars Ellenberg updated_uuids = 1; 4228b411b363SPhilipp Reisner } 4229b30ab791SAndreas Gruenbacher put_ldev(device); 4230b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 4231b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 423218a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 423318a50fa2SPhilipp Reisner for me. */ 4234b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 4235b411b363SPhilipp Reisner } 4236b411b363SPhilipp Reisner 4237b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 4238b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 4239b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 4240b411b363SPhilipp Reisner new disk state... */ 4241b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 4242b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 4243b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 4244b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 424562b0da3aSLars Ellenberg 424662b0da3aSLars Ellenberg if (updated_uuids) 4247b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 4248b411b363SPhilipp Reisner 424982bc0194SAndreas Gruenbacher return 0; 4250b411b363SPhilipp Reisner } 4251b411b363SPhilipp Reisner 4252b411b363SPhilipp Reisner /** 4253b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 4254b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 4255b411b363SPhilipp Reisner */ 4256b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 4257b411b363SPhilipp Reisner { 4258b411b363SPhilipp Reisner union drbd_state ms; 4259b411b363SPhilipp Reisner 4260b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 4261369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 4262b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 4263b411b363SPhilipp Reisner 4264b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 4265b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 4266b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 4267b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 4268b411b363SPhilipp Reisner [C_MASK] = C_MASK, 4269b411b363SPhilipp Reisner }; 4270b411b363SPhilipp Reisner 4271b411b363SPhilipp Reisner ms.i = ps.i; 4272b411b363SPhilipp Reisner 4273b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 4274b411b363SPhilipp Reisner ms.peer = ps.role; 4275b411b363SPhilipp Reisner ms.role = ps.peer; 4276b411b363SPhilipp Reisner ms.pdsk = ps.disk; 4277b411b363SPhilipp Reisner ms.disk = ps.pdsk; 4278b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 4279b411b363SPhilipp Reisner 4280b411b363SPhilipp Reisner return ms; 4281b411b363SPhilipp Reisner } 4282b411b363SPhilipp Reisner 4283bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 4284b411b363SPhilipp Reisner { 42859f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4286b30ab791SAndreas Gruenbacher struct drbd_device *device; 4287e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4288b411b363SPhilipp Reisner union drbd_state mask, val; 4289bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 4290b411b363SPhilipp Reisner 42919f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42929f4fe9adSAndreas Gruenbacher if (!peer_device) 42934a76b161SAndreas Gruenbacher return -EIO; 42949f4fe9adSAndreas Gruenbacher device = peer_device->device; 42954a76b161SAndreas Gruenbacher 4296b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4297b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 4298b411b363SPhilipp Reisner 42999f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 4300b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 430169a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 430282bc0194SAndreas Gruenbacher return 0; 4303b411b363SPhilipp Reisner } 4304b411b363SPhilipp Reisner 4305b411b363SPhilipp Reisner mask = convert_state(mask); 4306b411b363SPhilipp Reisner val = convert_state(val); 4307b411b363SPhilipp Reisner 4308b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 430969a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 4310047cd4a6SPhilipp Reisner 4311b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4312b411b363SPhilipp Reisner 431382bc0194SAndreas Gruenbacher return 0; 4314b411b363SPhilipp Reisner } 4315b411b363SPhilipp Reisner 4316bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 4317b411b363SPhilipp Reisner { 4318e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4319dfafcc8aSPhilipp Reisner union drbd_state mask, val; 4320dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 4321dfafcc8aSPhilipp Reisner 4322dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4323dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 4324dfafcc8aSPhilipp Reisner 4325bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 4326bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 4327bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 432882bc0194SAndreas Gruenbacher return 0; 4329dfafcc8aSPhilipp Reisner } 4330dfafcc8aSPhilipp Reisner 4331dfafcc8aSPhilipp Reisner mask = convert_state(mask); 4332dfafcc8aSPhilipp Reisner val = convert_state(val); 4333dfafcc8aSPhilipp Reisner 4334bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 4335bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 4336dfafcc8aSPhilipp Reisner 433782bc0194SAndreas Gruenbacher return 0; 4338dfafcc8aSPhilipp Reisner } 4339dfafcc8aSPhilipp Reisner 4340bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 4341b411b363SPhilipp Reisner { 43429f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4343b30ab791SAndreas Gruenbacher struct drbd_device *device; 4344e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 43454ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 4346b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 434765d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 4348b411b363SPhilipp Reisner int rv; 4349b411b363SPhilipp Reisner 43509f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 43519f4fe9adSAndreas Gruenbacher if (!peer_device) 4352bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 43539f4fe9adSAndreas Gruenbacher device = peer_device->device; 43544a76b161SAndreas Gruenbacher 4355b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 4356b411b363SPhilipp Reisner 4357b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 4358b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 4359b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 4360d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 4361b411b363SPhilipp Reisner } 4362b411b363SPhilipp Reisner 43630500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4364b411b363SPhilipp Reisner retry: 4365b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 43660500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4367b411b363SPhilipp Reisner 4368668700b4SPhilipp Reisner /* If some other part of the code (ack_receiver thread, timeout) 4369545752d5SLars Ellenberg * already decided to close the connection again, 4370545752d5SLars Ellenberg * we must not "re-establish" it here. */ 4371545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 437258ffa580SLars Ellenberg return -ECONNRESET; 4373545752d5SLars Ellenberg 437440424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 437540424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 437640424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 437740424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 437840424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 437940424e4aSLars Ellenberg */ 438040424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 438140424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 4382e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 4383e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 4384e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 4385e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 4386e9ef7bb6SLars Ellenberg * syncing states. 4387e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 4388e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 4389e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 4390e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 4391e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 4392e9ef7bb6SLars Ellenberg 4393e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 4394e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 4395e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 4396e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 4397e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 4398b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 4399b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 440082bc0194SAndreas Gruenbacher return 0; 4401e9ef7bb6SLars Ellenberg } 4402e9ef7bb6SLars Ellenberg } 4403e9ef7bb6SLars Ellenberg 440402b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 440502b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 440602b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 4407b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 4408b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 440958ffa580SLars Ellenberg return 0; 441002b91b55SLars Ellenberg } 441102b91b55SLars Ellenberg 4412e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 4413e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 4414e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 4415e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 4416e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 4417e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 4418e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 4419e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 4420e9ef7bb6SLars Ellenberg 44214ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 44224ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4423b411b363SPhilipp Reisner 442467531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 442567531718SPhilipp Reisner ns.conn = C_BEHIND; 442667531718SPhilipp Reisner 4427b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 4428b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 4429b411b363SPhilipp Reisner int cr; /* consider resync */ 4430b411b363SPhilipp Reisner 4431b411b363SPhilipp Reisner /* if we established a new connection */ 44324ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 4433b411b363SPhilipp Reisner /* if we had an established connection 4434b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 44354ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4436b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 44374ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 4438b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 4439b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 4440b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 4441b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 4442b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 44434ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4444b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 4445b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 4446b411b363SPhilipp Reisner 4447b411b363SPhilipp Reisner if (cr) 444869a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 4449b411b363SPhilipp Reisner 4450b30ab791SAndreas Gruenbacher put_ldev(device); 44514ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 44524ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4453b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 4454b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 4455b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 4456d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 4457b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 4458580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 4459b411b363SPhilipp Reisner } else { 44609f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 446182bc0194SAndreas Gruenbacher return -EIO; 44620b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 44639f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 446482bc0194SAndreas Gruenbacher return -EIO; 4465b411b363SPhilipp Reisner } 4466b411b363SPhilipp Reisner } 4467b411b363SPhilipp Reisner } 4468b411b363SPhilipp Reisner 44690500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4470b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 4471b411b363SPhilipp Reisner goto retry; 4472b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 4473b411b363SPhilipp Reisner ns.peer = peer_state.role; 4474b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4475b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 44764ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4477b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 44784ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4479b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4480b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 44818554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4482481c6f50SPhilipp Reisner for temporal network outages! */ 44830500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4484d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 44859f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4486b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4487b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 44889f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 448982bc0194SAndreas Gruenbacher return -EIO; 4490481c6f50SPhilipp Reisner } 4491b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4492b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 44930500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4494b411b363SPhilipp Reisner 4495b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 44969f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 449782bc0194SAndreas Gruenbacher return -EIO; 4498b411b363SPhilipp Reisner } 4499b411b363SPhilipp Reisner 45004ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 45014ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4502b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4503b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4504b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4505b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 450669a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 450769a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4508b411b363SPhilipp Reisner } 4509b411b363SPhilipp Reisner } 4510b411b363SPhilipp Reisner 4511b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4512b411b363SPhilipp Reisner 4513b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4514b411b363SPhilipp Reisner 451582bc0194SAndreas Gruenbacher return 0; 4516b411b363SPhilipp Reisner } 4517b411b363SPhilipp Reisner 4518bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4519b411b363SPhilipp Reisner { 45209f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4521b30ab791SAndreas Gruenbacher struct drbd_device *device; 4522e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 45234a76b161SAndreas Gruenbacher 45249f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 45259f4fe9adSAndreas Gruenbacher if (!peer_device) 45264a76b161SAndreas Gruenbacher return -EIO; 45279f4fe9adSAndreas Gruenbacher device = peer_device->device; 4528b411b363SPhilipp Reisner 4529b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4530b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4531b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4532b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4533b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4534b411b363SPhilipp Reisner 45350b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4536b411b363SPhilipp Reisner 4537b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4538b411b363SPhilipp Reisner _not_ be rotated into the history */ 4539b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4540b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4541b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4542b411b363SPhilipp Reisner 4543b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4544b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4545b411b363SPhilipp Reisner 4546b30ab791SAndreas Gruenbacher put_ldev(device); 4547b411b363SPhilipp Reisner } else 4548d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4549b411b363SPhilipp Reisner 455082bc0194SAndreas Gruenbacher return 0; 4551b411b363SPhilipp Reisner } 4552b411b363SPhilipp Reisner 45532c46407dSAndreas Gruenbacher /** 45542c46407dSAndreas Gruenbacher * receive_bitmap_plain 45552c46407dSAndreas Gruenbacher * 45562c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 45572c46407dSAndreas Gruenbacher * code upon failure. 45582c46407dSAndreas Gruenbacher */ 45592c46407dSAndreas Gruenbacher static int 456069a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4561e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4562b411b363SPhilipp Reisner { 456350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 456469a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4565e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 456650d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4567e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 45682c46407dSAndreas Gruenbacher int err; 4569b411b363SPhilipp Reisner 457050d0b1adSAndreas Gruenbacher if (want != size) { 457169a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 45722c46407dSAndreas Gruenbacher return -EIO; 4573b411b363SPhilipp Reisner } 4574b411b363SPhilipp Reisner if (want == 0) 45752c46407dSAndreas Gruenbacher return 0; 457669a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 457782bc0194SAndreas Gruenbacher if (err) 45782c46407dSAndreas Gruenbacher return err; 4579b411b363SPhilipp Reisner 458069a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4581b411b363SPhilipp Reisner 4582b411b363SPhilipp Reisner c->word_offset += num_words; 4583b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4584b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4585b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4586b411b363SPhilipp Reisner 45872c46407dSAndreas Gruenbacher return 1; 4588b411b363SPhilipp Reisner } 4589b411b363SPhilipp Reisner 4590a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4591a02d1240SAndreas Gruenbacher { 4592a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4593a02d1240SAndreas Gruenbacher } 4594a02d1240SAndreas Gruenbacher 4595a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4596a02d1240SAndreas Gruenbacher { 4597a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4598a02d1240SAndreas Gruenbacher } 4599a02d1240SAndreas Gruenbacher 4600a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4601a02d1240SAndreas Gruenbacher { 4602a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4603a02d1240SAndreas Gruenbacher } 4604a02d1240SAndreas Gruenbacher 46052c46407dSAndreas Gruenbacher /** 46062c46407dSAndreas Gruenbacher * recv_bm_rle_bits 46072c46407dSAndreas Gruenbacher * 46082c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 46092c46407dSAndreas Gruenbacher * code upon failure. 46102c46407dSAndreas Gruenbacher */ 46112c46407dSAndreas Gruenbacher static int 461269a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4613b411b363SPhilipp Reisner struct p_compressed_bm *p, 4614c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4615c6d25cfeSPhilipp Reisner unsigned int len) 4616b411b363SPhilipp Reisner { 4617b411b363SPhilipp Reisner struct bitstream bs; 4618b411b363SPhilipp Reisner u64 look_ahead; 4619b411b363SPhilipp Reisner u64 rl; 4620b411b363SPhilipp Reisner u64 tmp; 4621b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4622b411b363SPhilipp Reisner unsigned long e; 4623a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4624b411b363SPhilipp Reisner int have; 4625b411b363SPhilipp Reisner int bits; 4626b411b363SPhilipp Reisner 4627a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4628b411b363SPhilipp Reisner 4629b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4630b411b363SPhilipp Reisner if (bits < 0) 46312c46407dSAndreas Gruenbacher return -EIO; 4632b411b363SPhilipp Reisner 4633b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4634b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4635b411b363SPhilipp Reisner if (bits <= 0) 46362c46407dSAndreas Gruenbacher return -EIO; 4637b411b363SPhilipp Reisner 4638b411b363SPhilipp Reisner if (toggle) { 4639b411b363SPhilipp Reisner e = s + rl -1; 4640b411b363SPhilipp Reisner if (e >= c->bm_bits) { 464169a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 46422c46407dSAndreas Gruenbacher return -EIO; 4643b411b363SPhilipp Reisner } 464469a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4645b411b363SPhilipp Reisner } 4646b411b363SPhilipp Reisner 4647b411b363SPhilipp Reisner if (have < bits) { 464869a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4649b411b363SPhilipp Reisner have, bits, look_ahead, 4650b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4651b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 46522c46407dSAndreas Gruenbacher return -EIO; 4653b411b363SPhilipp Reisner } 4654d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4655d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4656b411b363SPhilipp Reisner look_ahead >>= bits; 4657d2da5b0cSLars Ellenberg else 4658d2da5b0cSLars Ellenberg look_ahead = 0; 4659b411b363SPhilipp Reisner have -= bits; 4660b411b363SPhilipp Reisner 4661b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4662b411b363SPhilipp Reisner if (bits < 0) 46632c46407dSAndreas Gruenbacher return -EIO; 4664b411b363SPhilipp Reisner look_ahead |= tmp << have; 4665b411b363SPhilipp Reisner have += bits; 4666b411b363SPhilipp Reisner } 4667b411b363SPhilipp Reisner 4668b411b363SPhilipp Reisner c->bit_offset = s; 4669b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4670b411b363SPhilipp Reisner 46712c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4672b411b363SPhilipp Reisner } 4673b411b363SPhilipp Reisner 46742c46407dSAndreas Gruenbacher /** 46752c46407dSAndreas Gruenbacher * decode_bitmap_c 46762c46407dSAndreas Gruenbacher * 46772c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 46782c46407dSAndreas Gruenbacher * code upon failure. 46792c46407dSAndreas Gruenbacher */ 46802c46407dSAndreas Gruenbacher static int 468169a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4682b411b363SPhilipp Reisner struct p_compressed_bm *p, 4683c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4684c6d25cfeSPhilipp Reisner unsigned int len) 4685b411b363SPhilipp Reisner { 4686a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 468769a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4688b411b363SPhilipp Reisner 4689b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4690b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4691b411b363SPhilipp Reisner * during all our tests. */ 4692b411b363SPhilipp Reisner 469369a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 469469a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 46952c46407dSAndreas Gruenbacher return -EIO; 4696b411b363SPhilipp Reisner } 4697b411b363SPhilipp Reisner 4698b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4699b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4700b411b363SPhilipp Reisner { 4701b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4702a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 470350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 470450d0b1adSAndreas Gruenbacher unsigned int plain = 470550d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 470650d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 470750d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 470850d0b1adSAndreas Gruenbacher unsigned int r; 4709b411b363SPhilipp Reisner 4710b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4711b411b363SPhilipp Reisner if (total == 0) 4712b411b363SPhilipp Reisner return; 4713b411b363SPhilipp Reisner 4714b411b363SPhilipp Reisner /* don't report if not compressed */ 4715b411b363SPhilipp Reisner if (total >= plain) 4716b411b363SPhilipp Reisner return; 4717b411b363SPhilipp Reisner 4718b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4719b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4720b411b363SPhilipp Reisner : (1000 * total / plain); 4721b411b363SPhilipp Reisner 4722b411b363SPhilipp Reisner if (r > 1000) 4723b411b363SPhilipp Reisner r = 1000; 4724b411b363SPhilipp Reisner 4725b411b363SPhilipp Reisner r = 1000 - r; 4726d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4727b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4728b411b363SPhilipp Reisner direction, 4729b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4730b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4731b411b363SPhilipp Reisner total, r/10, r % 10); 4732b411b363SPhilipp Reisner } 4733b411b363SPhilipp Reisner 4734b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4735b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4736b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4737b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4738b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4739b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4740b411b363SPhilipp Reisner 4741b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4742bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4743b411b363SPhilipp Reisner { 47449f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4745b30ab791SAndreas Gruenbacher struct drbd_device *device; 4746b411b363SPhilipp Reisner struct bm_xfer_ctx c; 47472c46407dSAndreas Gruenbacher int err; 47484a76b161SAndreas Gruenbacher 47499f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 47509f4fe9adSAndreas Gruenbacher if (!peer_device) 47514a76b161SAndreas Gruenbacher return -EIO; 47529f4fe9adSAndreas Gruenbacher device = peer_device->device; 4753b411b363SPhilipp Reisner 4754b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 475520ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 475620ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4757b411b363SPhilipp Reisner 4758b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4759b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4760b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4761b411b363SPhilipp Reisner }; 4762b411b363SPhilipp Reisner 47632c46407dSAndreas Gruenbacher for(;;) { 4764e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 476569a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4766e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4767b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4768b411b363SPhilipp Reisner * and the feature is enabled! */ 4769e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4770b411b363SPhilipp Reisner 4771bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4772d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 477382bc0194SAndreas Gruenbacher err = -EIO; 4774b411b363SPhilipp Reisner goto out; 4775b411b363SPhilipp Reisner } 4776e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4777d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 477882bc0194SAndreas Gruenbacher err = -EIO; 477978fcbdaeSAndreas Gruenbacher goto out; 4780b411b363SPhilipp Reisner } 47819f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4782e658983aSAndreas Gruenbacher if (err) 4783e658983aSAndreas Gruenbacher goto out; 478469a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4785b411b363SPhilipp Reisner } else { 4786d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 478782bc0194SAndreas Gruenbacher err = -EIO; 4788b411b363SPhilipp Reisner goto out; 4789b411b363SPhilipp Reisner } 4790b411b363SPhilipp Reisner 4791e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4792bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4793b411b363SPhilipp Reisner 47942c46407dSAndreas Gruenbacher if (err <= 0) { 47952c46407dSAndreas Gruenbacher if (err < 0) 47962c46407dSAndreas Gruenbacher goto out; 4797b411b363SPhilipp Reisner break; 47982c46407dSAndreas Gruenbacher } 47999f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 480082bc0194SAndreas Gruenbacher if (err) 4801b411b363SPhilipp Reisner goto out; 48022c46407dSAndreas Gruenbacher } 4803b411b363SPhilipp Reisner 4804b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4805b411b363SPhilipp Reisner 4806b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4807de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4808de1f8e4aSAndreas Gruenbacher 4809b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 481082bc0194SAndreas Gruenbacher if (err) 4811b411b363SPhilipp Reisner goto out; 4812b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4813b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 48140b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4815b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4816b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4817b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4818d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4819b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4820b411b363SPhilipp Reisner } 482182bc0194SAndreas Gruenbacher err = 0; 4822b411b363SPhilipp Reisner 4823b411b363SPhilipp Reisner out: 4824b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4825b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4826b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 482782bc0194SAndreas Gruenbacher return err; 4828b411b363SPhilipp Reisner } 4829b411b363SPhilipp Reisner 4830bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4831b411b363SPhilipp Reisner { 48321ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4833e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4834b411b363SPhilipp Reisner 4835bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4836b411b363SPhilipp Reisner } 4837b411b363SPhilipp Reisner 4838bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4839b411b363SPhilipp Reisner { 4840b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4841b411b363SPhilipp Reisner * with the data requests being unplugged */ 4842bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4843b411b363SPhilipp Reisner 484482bc0194SAndreas Gruenbacher return 0; 4845b411b363SPhilipp Reisner } 4846b411b363SPhilipp Reisner 4847bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 484873a01a18SPhilipp Reisner { 48499f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4850b30ab791SAndreas Gruenbacher struct drbd_device *device; 4851e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 48524a76b161SAndreas Gruenbacher 48539f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 48549f4fe9adSAndreas Gruenbacher if (!peer_device) 48554a76b161SAndreas Gruenbacher return -EIO; 48569f4fe9adSAndreas Gruenbacher device = peer_device->device; 485773a01a18SPhilipp Reisner 4858b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4859f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4860f735e363SLars Ellenberg case C_WF_BITMAP_T: 4861f735e363SLars Ellenberg case C_BEHIND: 4862f735e363SLars Ellenberg break; 4863f735e363SLars Ellenberg default: 4864d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4865b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4866f735e363SLars Ellenberg } 4867f735e363SLars Ellenberg 4868b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 486973a01a18SPhilipp Reisner 487082bc0194SAndreas Gruenbacher return 0; 487173a01a18SPhilipp Reisner } 487273a01a18SPhilipp Reisner 4873700ca8c0SPhilipp Reisner static int receive_rs_deallocated(struct drbd_connection *connection, struct packet_info *pi) 4874700ca8c0SPhilipp Reisner { 4875700ca8c0SPhilipp Reisner struct drbd_peer_device *peer_device; 4876700ca8c0SPhilipp Reisner struct p_block_desc *p = pi->data; 4877700ca8c0SPhilipp Reisner struct drbd_device *device; 4878700ca8c0SPhilipp Reisner sector_t sector; 4879700ca8c0SPhilipp Reisner int size, err = 0; 4880700ca8c0SPhilipp Reisner 4881700ca8c0SPhilipp Reisner peer_device = conn_peer_device(connection, pi->vnr); 4882700ca8c0SPhilipp Reisner if (!peer_device) 4883700ca8c0SPhilipp Reisner return -EIO; 4884700ca8c0SPhilipp Reisner device = peer_device->device; 4885700ca8c0SPhilipp Reisner 4886700ca8c0SPhilipp Reisner sector = be64_to_cpu(p->sector); 4887700ca8c0SPhilipp Reisner size = be32_to_cpu(p->blksize); 4888700ca8c0SPhilipp Reisner 4889700ca8c0SPhilipp Reisner dec_rs_pending(device); 4890700ca8c0SPhilipp Reisner 4891700ca8c0SPhilipp Reisner if (get_ldev(device)) { 4892700ca8c0SPhilipp Reisner struct drbd_peer_request *peer_req; 4893700ca8c0SPhilipp Reisner const int op = REQ_OP_DISCARD; 4894700ca8c0SPhilipp Reisner 4895700ca8c0SPhilipp Reisner peer_req = drbd_alloc_peer_req(peer_device, ID_SYNCER, sector, 48969104d31aSLars Ellenberg size, 0, GFP_NOIO); 4897700ca8c0SPhilipp Reisner if (!peer_req) { 4898700ca8c0SPhilipp Reisner put_ldev(device); 4899700ca8c0SPhilipp Reisner return -ENOMEM; 4900700ca8c0SPhilipp Reisner } 4901700ca8c0SPhilipp Reisner 4902700ca8c0SPhilipp Reisner peer_req->w.cb = e_end_resync_block; 4903700ca8c0SPhilipp Reisner peer_req->submit_jif = jiffies; 4904700ca8c0SPhilipp Reisner peer_req->flags |= EE_IS_TRIM; 4905700ca8c0SPhilipp Reisner 4906700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4907700ca8c0SPhilipp Reisner list_add_tail(&peer_req->w.list, &device->sync_ee); 4908700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4909700ca8c0SPhilipp Reisner 4910700ca8c0SPhilipp Reisner atomic_add(pi->size >> 9, &device->rs_sect_ev); 4911700ca8c0SPhilipp Reisner err = drbd_submit_peer_request(device, peer_req, op, 0, DRBD_FAULT_RS_WR); 4912700ca8c0SPhilipp Reisner 4913700ca8c0SPhilipp Reisner if (err) { 4914700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4915700ca8c0SPhilipp Reisner list_del(&peer_req->w.list); 4916700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4917700ca8c0SPhilipp Reisner 4918700ca8c0SPhilipp Reisner drbd_free_peer_req(device, peer_req); 4919700ca8c0SPhilipp Reisner put_ldev(device); 4920700ca8c0SPhilipp Reisner err = 0; 4921700ca8c0SPhilipp Reisner goto fail; 4922700ca8c0SPhilipp Reisner } 4923700ca8c0SPhilipp Reisner 4924700ca8c0SPhilipp Reisner inc_unacked(device); 4925700ca8c0SPhilipp Reisner 4926700ca8c0SPhilipp Reisner /* No put_ldev() here. Gets called in drbd_endio_write_sec_final(), 4927700ca8c0SPhilipp Reisner as well as drbd_rs_complete_io() */ 4928700ca8c0SPhilipp Reisner } else { 4929700ca8c0SPhilipp Reisner fail: 4930700ca8c0SPhilipp Reisner drbd_rs_complete_io(device, sector); 4931700ca8c0SPhilipp Reisner drbd_send_ack_ex(peer_device, P_NEG_ACK, sector, size, ID_SYNCER); 4932700ca8c0SPhilipp Reisner } 4933700ca8c0SPhilipp Reisner 4934700ca8c0SPhilipp Reisner atomic_add(size >> 9, &device->rs_sect_in); 4935700ca8c0SPhilipp Reisner 4936700ca8c0SPhilipp Reisner return err; 4937700ca8c0SPhilipp Reisner } 4938700ca8c0SPhilipp Reisner 493902918be2SPhilipp Reisner struct data_cmd { 494002918be2SPhilipp Reisner int expect_payload; 49419104d31aSLars Ellenberg unsigned int pkt_size; 4942bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4943b411b363SPhilipp Reisner }; 4944b411b363SPhilipp Reisner 494502918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 494602918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 494702918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 494802918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 494902918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4950e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4951e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4952e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 495302918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 495402918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4955e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4956e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 495702918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 495802918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 495902918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 496002918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 496102918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 496202918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 496302918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 496402918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 496502918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 4966700ca8c0SPhilipp Reisner [P_RS_THIN_REQ] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 496702918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 496873a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 49694a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4970036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 4971a0fb3c47SLars Ellenberg [P_TRIM] = { 0, sizeof(struct p_trim), receive_Data }, 4972700ca8c0SPhilipp Reisner [P_RS_DEALLOCATED] = { 0, sizeof(struct p_block_desc), receive_rs_deallocated }, 49739104d31aSLars Ellenberg [P_WSAME] = { 1, sizeof(struct p_wsame), receive_Data }, 497402918be2SPhilipp Reisner }; 497502918be2SPhilipp Reisner 4976bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4977b411b363SPhilipp Reisner { 497877351055SPhilipp Reisner struct packet_info pi; 497902918be2SPhilipp Reisner size_t shs; /* sub header size */ 498082bc0194SAndreas Gruenbacher int err; 4981b411b363SPhilipp Reisner 4982bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 49839104d31aSLars Ellenberg struct data_cmd const *cmd; 4984deebe195SAndreas Gruenbacher 4985bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4986944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_header); 4987bde89a9eSAndreas Gruenbacher if (drbd_recv_header(connection, &pi)) 498802918be2SPhilipp Reisner goto err_out; 498902918be2SPhilipp Reisner 4990deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 49914a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 49921ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 49932fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 499402918be2SPhilipp Reisner goto err_out; 49950b33a916SLars Ellenberg } 4996b411b363SPhilipp Reisner 4997e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 49989104d31aSLars Ellenberg if (pi.cmd == P_SIZES && connection->agreed_features & DRBD_FF_WSAME) 49999104d31aSLars Ellenberg shs += sizeof(struct o_qlim); 5000e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 50011ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 50022fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 5003c13f7e1aSLars Ellenberg goto err_out; 5004c13f7e1aSLars Ellenberg } 50059104d31aSLars Ellenberg if (pi.size < shs) { 50069104d31aSLars Ellenberg drbd_err(connection, "%s: unexpected packet size, expected:%d received:%d\n", 50079104d31aSLars Ellenberg cmdname(pi.cmd), (int)shs, pi.size); 50089104d31aSLars Ellenberg goto err_out; 50099104d31aSLars Ellenberg } 5010c13f7e1aSLars Ellenberg 5011c13f7e1aSLars Ellenberg if (shs) { 5012944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_all_warn); 5013bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 5014a5c31904SAndreas Gruenbacher if (err) 501502918be2SPhilipp Reisner goto err_out; 5016e2857216SAndreas Gruenbacher pi.size -= shs; 5017b411b363SPhilipp Reisner } 501802918be2SPhilipp Reisner 5019944410e9SLars Ellenberg update_receiver_timing_details(connection, cmd->fn); 5020bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 50214a76b161SAndreas Gruenbacher if (err) { 50221ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 50239f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 502402918be2SPhilipp Reisner goto err_out; 502502918be2SPhilipp Reisner } 502602918be2SPhilipp Reisner } 502782bc0194SAndreas Gruenbacher return; 502802918be2SPhilipp Reisner 502902918be2SPhilipp Reisner err_out: 5030bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 5031b411b363SPhilipp Reisner } 5032b411b363SPhilipp Reisner 5033bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 5034f70b3511SPhilipp Reisner { 5035c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5036bbeb641cSPhilipp Reisner enum drbd_conns oc; 5037376694a0SPhilipp Reisner int vnr; 5038f70b3511SPhilipp Reisner 5039bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 5040b411b363SPhilipp Reisner return; 5041b411b363SPhilipp Reisner 5042545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 5043545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 5044545752d5SLars Ellenberg * Usually we should be in some network failure state already, 5045545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 5046545752d5SLars Ellenberg */ 5047bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5048545752d5SLars Ellenberg 5049668700b4SPhilipp Reisner /* ack_receiver does not clean up anything. it must not interfere, either */ 50501c03e520SPhilipp Reisner drbd_thread_stop(&connection->ack_receiver); 5051668700b4SPhilipp Reisner if (connection->ack_sender) { 5052668700b4SPhilipp Reisner destroy_workqueue(connection->ack_sender); 5053668700b4SPhilipp Reisner connection->ack_sender = NULL; 5054668700b4SPhilipp Reisner } 5055bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 5056360cc740SPhilipp Reisner 5057c141ebdaSPhilipp Reisner rcu_read_lock(); 5058c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5059c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5060b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5061c141ebdaSPhilipp Reisner rcu_read_unlock(); 506269a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 5063c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5064c141ebdaSPhilipp Reisner rcu_read_lock(); 5065c141ebdaSPhilipp Reisner } 5066c141ebdaSPhilipp Reisner rcu_read_unlock(); 5067c141ebdaSPhilipp Reisner 5068bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 50691ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 507012038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 5071bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 5072bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 507312038a3aSPhilipp Reisner 50741ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 5075360cc740SPhilipp Reisner 5076bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 5077bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 5078cb703454SPhilipp Reisner 50790500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5080bde89a9eSAndreas Gruenbacher oc = connection->cstate; 5081bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 5082bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 5083bbeb641cSPhilipp Reisner 50840500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5085360cc740SPhilipp Reisner 5086f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 5087bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 5088360cc740SPhilipp Reisner } 5089360cc740SPhilipp Reisner 509069a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 5091360cc740SPhilipp Reisner { 509269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5093360cc740SPhilipp Reisner unsigned int i; 5094b411b363SPhilipp Reisner 509585719573SPhilipp Reisner /* wait for current activity to cease. */ 50960500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5097b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 5098b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 5099b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 51000500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5101b411b363SPhilipp Reisner 5102b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 5103b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 5104b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 5105b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 5106b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 5107b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 5108b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 5109b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 5110b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 5111b411b363SPhilipp Reisner * on the fly. */ 5112b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5113b30ab791SAndreas Gruenbacher device->rs_total = 0; 5114b30ab791SAndreas Gruenbacher device->rs_failed = 0; 5115b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 5116b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 5117b411b363SPhilipp Reisner 5118b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 5119b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 5120b411b363SPhilipp Reisner 5121b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 5122b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 5123b411b363SPhilipp Reisner * to be "canceled" */ 5124b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5125b411b363SPhilipp Reisner 5126b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 5127b411b363SPhilipp Reisner 5128d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 5129d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 5130d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 5131b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5132d10b4ea3SPhilipp Reisner 513308332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 513408332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 5135b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5136b411b363SPhilipp Reisner 5137b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 5138b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 5139b411b363SPhilipp Reisner 5140b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 514169a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 5142b411b363SPhilipp Reisner 5143b30ab791SAndreas Gruenbacher drbd_md_sync(device); 5144b411b363SPhilipp Reisner 5145be115b69SLars Ellenberg if (get_ldev(device)) { 5146be115b69SLars Ellenberg drbd_bitmap_io(device, &drbd_bm_write_copy_pages, 5147be115b69SLars Ellenberg "write from disconnected", BM_LOCKED_CHANGE_ALLOWED); 5148be115b69SLars Ellenberg put_ldev(device); 5149be115b69SLars Ellenberg } 515020ceb2b2SLars Ellenberg 5151b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 5152b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 5153b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 5154b411b363SPhilipp Reisner * 5155b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 5156b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 5157b411b363SPhilipp Reisner */ 5158b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 5159b411b363SPhilipp Reisner if (i) 5160d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 5161b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 5162435f0740SLars Ellenberg if (i) 5163d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 5164b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 5165b411b363SPhilipp Reisner if (i) 5166d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 5167b411b363SPhilipp Reisner 51680b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 51690b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 51700b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 51710b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 5172b411b363SPhilipp Reisner 5173360cc740SPhilipp Reisner return 0; 5174b411b363SPhilipp Reisner } 5175b411b363SPhilipp Reisner 5176b411b363SPhilipp Reisner /* 5177b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 5178b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 5179b411b363SPhilipp Reisner * 5180b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 5181b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 5182b411b363SPhilipp Reisner * 5183b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 5184b411b363SPhilipp Reisner */ 5185bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 5186b411b363SPhilipp Reisner { 51879f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 51889f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 5189b411b363SPhilipp Reisner 5190bde89a9eSAndreas Gruenbacher sock = &connection->data; 5191bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 51929f5bdc33SAndreas Gruenbacher if (!p) 5193e8d17b01SAndreas Gruenbacher return -EIO; 5194b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 5195b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 5196b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 519720c68fdeSLars Ellenberg p->feature_flags = cpu_to_be32(PRO_FEATURES); 5198bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 5199b411b363SPhilipp Reisner } 5200b411b363SPhilipp Reisner 5201b411b363SPhilipp Reisner /* 5202b411b363SPhilipp Reisner * return values: 5203b411b363SPhilipp Reisner * 1 yes, we have a valid connection 5204b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 5205b411b363SPhilipp Reisner * -1 peer talks different language, 5206b411b363SPhilipp Reisner * no point in trying again, please go standalone. 5207b411b363SPhilipp Reisner */ 5208bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 5209b411b363SPhilipp Reisner { 5210bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 5211e658983aSAndreas Gruenbacher struct p_connection_features *p; 5212e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 521377351055SPhilipp Reisner struct packet_info pi; 5214a5c31904SAndreas Gruenbacher int err; 5215b411b363SPhilipp Reisner 5216bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 5217e8d17b01SAndreas Gruenbacher if (err) 5218b411b363SPhilipp Reisner return 0; 5219b411b363SPhilipp Reisner 5220bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 522169bc7bc3SAndreas Gruenbacher if (err) 5222b411b363SPhilipp Reisner return 0; 5223b411b363SPhilipp Reisner 52246038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 52251ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 522677351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5227b411b363SPhilipp Reisner return -1; 5228b411b363SPhilipp Reisner } 5229b411b363SPhilipp Reisner 523077351055SPhilipp Reisner if (pi.size != expect) { 52311ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 523277351055SPhilipp Reisner expect, pi.size); 5233b411b363SPhilipp Reisner return -1; 5234b411b363SPhilipp Reisner } 5235b411b363SPhilipp Reisner 5236e658983aSAndreas Gruenbacher p = pi.data; 5237bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 5238a5c31904SAndreas Gruenbacher if (err) 5239b411b363SPhilipp Reisner return 0; 5240b411b363SPhilipp Reisner 5241b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 5242b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 5243b411b363SPhilipp Reisner if (p->protocol_max == 0) 5244b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 5245b411b363SPhilipp Reisner 5246b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 5247b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 5248b411b363SPhilipp Reisner goto incompat; 5249b411b363SPhilipp Reisner 5250bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 525120c68fdeSLars Ellenberg connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); 5252b411b363SPhilipp Reisner 52531ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 5254bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 5255b411b363SPhilipp Reisner 52569104d31aSLars Ellenberg drbd_info(connection, "Feature flags enabled on protocol level: 0x%x%s%s%s.\n", 52579104d31aSLars Ellenberg connection->agreed_features, 52589104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "", 52599104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "", 52609104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" : 52619104d31aSLars Ellenberg connection->agreed_features ? "" : " none"); 526292d94ae6SPhilipp Reisner 5263b411b363SPhilipp Reisner return 1; 5264b411b363SPhilipp Reisner 5265b411b363SPhilipp Reisner incompat: 52661ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 5267b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 5268b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 5269b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 5270b411b363SPhilipp Reisner return -1; 5271b411b363SPhilipp Reisner } 5272b411b363SPhilipp Reisner 5273b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 5274bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5275b411b363SPhilipp Reisner { 52761ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 52771ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 5278b10d96cbSJohannes Thoma return -1; 5279b411b363SPhilipp Reisner } 5280b411b363SPhilipp Reisner #else 5281b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 5282b10d96cbSJohannes Thoma 5283b10d96cbSJohannes Thoma /* Return value: 5284b10d96cbSJohannes Thoma 1 - auth succeeded, 5285b10d96cbSJohannes Thoma 0 - failed, try again (network error), 5286b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 5287b10d96cbSJohannes Thoma */ 5288b10d96cbSJohannes Thoma 5289bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5290b411b363SPhilipp Reisner { 52919f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 5292b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 5293b411b363SPhilipp Reisner char *response = NULL; 5294b411b363SPhilipp Reisner char *right_response = NULL; 5295b411b363SPhilipp Reisner char *peers_ch = NULL; 529644ed167dSPhilipp Reisner unsigned int key_len; 529744ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 5298b411b363SPhilipp Reisner unsigned int resp_size; 52999534d671SHerbert Xu SHASH_DESC_ON_STACK(desc, connection->cram_hmac_tfm); 530077351055SPhilipp Reisner struct packet_info pi; 530144ed167dSPhilipp Reisner struct net_conf *nc; 530269bc7bc3SAndreas Gruenbacher int err, rv; 5303b411b363SPhilipp Reisner 53049f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 53059f5bdc33SAndreas Gruenbacher 530644ed167dSPhilipp Reisner rcu_read_lock(); 5307bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 530844ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 530944ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 531044ed167dSPhilipp Reisner rcu_read_unlock(); 531144ed167dSPhilipp Reisner 53129534d671SHerbert Xu desc->tfm = connection->cram_hmac_tfm; 53139534d671SHerbert Xu desc->flags = 0; 5314b411b363SPhilipp Reisner 53159534d671SHerbert Xu rv = crypto_shash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 5316b411b363SPhilipp Reisner if (rv) { 53179534d671SHerbert Xu drbd_err(connection, "crypto_shash_setkey() failed with %d\n", rv); 5318b10d96cbSJohannes Thoma rv = -1; 5319b411b363SPhilipp Reisner goto fail; 5320b411b363SPhilipp Reisner } 5321b411b363SPhilipp Reisner 5322b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 5323b411b363SPhilipp Reisner 5324bde89a9eSAndreas Gruenbacher sock = &connection->data; 5325bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 53269f5bdc33SAndreas Gruenbacher rv = 0; 53279f5bdc33SAndreas Gruenbacher goto fail; 53289f5bdc33SAndreas Gruenbacher } 5329bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 53309f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 5331b411b363SPhilipp Reisner if (!rv) 5332b411b363SPhilipp Reisner goto fail; 5333b411b363SPhilipp Reisner 5334bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 533569bc7bc3SAndreas Gruenbacher if (err) { 5336b411b363SPhilipp Reisner rv = 0; 5337b411b363SPhilipp Reisner goto fail; 5338b411b363SPhilipp Reisner } 5339b411b363SPhilipp Reisner 534077351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 53411ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 534277351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5343b411b363SPhilipp Reisner rv = 0; 5344b411b363SPhilipp Reisner goto fail; 5345b411b363SPhilipp Reisner } 5346b411b363SPhilipp Reisner 534777351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 53481ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 5349b10d96cbSJohannes Thoma rv = -1; 5350b411b363SPhilipp Reisner goto fail; 5351b411b363SPhilipp Reisner } 5352b411b363SPhilipp Reisner 535367cca286SPhilipp Reisner if (pi.size < CHALLENGE_LEN) { 535467cca286SPhilipp Reisner drbd_err(connection, "AuthChallenge payload too small.\n"); 535567cca286SPhilipp Reisner rv = -1; 535667cca286SPhilipp Reisner goto fail; 535767cca286SPhilipp Reisner } 535867cca286SPhilipp Reisner 535977351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 5360b411b363SPhilipp Reisner if (peers_ch == NULL) { 53611ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 5362b10d96cbSJohannes Thoma rv = -1; 5363b411b363SPhilipp Reisner goto fail; 5364b411b363SPhilipp Reisner } 5365b411b363SPhilipp Reisner 5366bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 5367a5c31904SAndreas Gruenbacher if (err) { 5368b411b363SPhilipp Reisner rv = 0; 5369b411b363SPhilipp Reisner goto fail; 5370b411b363SPhilipp Reisner } 5371b411b363SPhilipp Reisner 537267cca286SPhilipp Reisner if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) { 537367cca286SPhilipp Reisner drbd_err(connection, "Peer presented the same challenge!\n"); 537467cca286SPhilipp Reisner rv = -1; 537567cca286SPhilipp Reisner goto fail; 537667cca286SPhilipp Reisner } 537767cca286SPhilipp Reisner 53789534d671SHerbert Xu resp_size = crypto_shash_digestsize(connection->cram_hmac_tfm); 5379b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 5380b411b363SPhilipp Reisner if (response == NULL) { 53811ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 5382b10d96cbSJohannes Thoma rv = -1; 5383b411b363SPhilipp Reisner goto fail; 5384b411b363SPhilipp Reisner } 5385b411b363SPhilipp Reisner 53869534d671SHerbert Xu rv = crypto_shash_digest(desc, peers_ch, pi.size, response); 5387b411b363SPhilipp Reisner if (rv) { 53881ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5389b10d96cbSJohannes Thoma rv = -1; 5390b411b363SPhilipp Reisner goto fail; 5391b411b363SPhilipp Reisner } 5392b411b363SPhilipp Reisner 5393bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 53949f5bdc33SAndreas Gruenbacher rv = 0; 53959f5bdc33SAndreas Gruenbacher goto fail; 53969f5bdc33SAndreas Gruenbacher } 5397bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 53989f5bdc33SAndreas Gruenbacher response, resp_size); 5399b411b363SPhilipp Reisner if (!rv) 5400b411b363SPhilipp Reisner goto fail; 5401b411b363SPhilipp Reisner 5402bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 540369bc7bc3SAndreas Gruenbacher if (err) { 5404b411b363SPhilipp Reisner rv = 0; 5405b411b363SPhilipp Reisner goto fail; 5406b411b363SPhilipp Reisner } 5407b411b363SPhilipp Reisner 540877351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 54091ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 541077351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5411b411b363SPhilipp Reisner rv = 0; 5412b411b363SPhilipp Reisner goto fail; 5413b411b363SPhilipp Reisner } 5414b411b363SPhilipp Reisner 541577351055SPhilipp Reisner if (pi.size != resp_size) { 54161ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 5417b411b363SPhilipp Reisner rv = 0; 5418b411b363SPhilipp Reisner goto fail; 5419b411b363SPhilipp Reisner } 5420b411b363SPhilipp Reisner 5421bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 5422a5c31904SAndreas Gruenbacher if (err) { 5423b411b363SPhilipp Reisner rv = 0; 5424b411b363SPhilipp Reisner goto fail; 5425b411b363SPhilipp Reisner } 5426b411b363SPhilipp Reisner 5427b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 54282d1ee87dSJulia Lawall if (right_response == NULL) { 54291ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 5430b10d96cbSJohannes Thoma rv = -1; 5431b411b363SPhilipp Reisner goto fail; 5432b411b363SPhilipp Reisner } 5433b411b363SPhilipp Reisner 54349534d671SHerbert Xu rv = crypto_shash_digest(desc, my_challenge, CHALLENGE_LEN, 54359534d671SHerbert Xu right_response); 5436b411b363SPhilipp Reisner if (rv) { 54371ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5438b10d96cbSJohannes Thoma rv = -1; 5439b411b363SPhilipp Reisner goto fail; 5440b411b363SPhilipp Reisner } 5441b411b363SPhilipp Reisner 5442b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 5443b411b363SPhilipp Reisner 5444b411b363SPhilipp Reisner if (rv) 54451ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 544644ed167dSPhilipp Reisner resp_size); 5447b10d96cbSJohannes Thoma else 5448b10d96cbSJohannes Thoma rv = -1; 5449b411b363SPhilipp Reisner 5450b411b363SPhilipp Reisner fail: 5451b411b363SPhilipp Reisner kfree(peers_ch); 5452b411b363SPhilipp Reisner kfree(response); 5453b411b363SPhilipp Reisner kfree(right_response); 54549534d671SHerbert Xu shash_desc_zero(desc); 5455b411b363SPhilipp Reisner 5456b411b363SPhilipp Reisner return rv; 5457b411b363SPhilipp Reisner } 5458b411b363SPhilipp Reisner #endif 5459b411b363SPhilipp Reisner 54608fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 5461b411b363SPhilipp Reisner { 5462bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5463b411b363SPhilipp Reisner int h; 5464b411b363SPhilipp Reisner 54651ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 5466b411b363SPhilipp Reisner 5467b411b363SPhilipp Reisner do { 5468bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 5469b411b363SPhilipp Reisner if (h == 0) { 5470bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 547120ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 5472b411b363SPhilipp Reisner } 5473b411b363SPhilipp Reisner if (h == -1) { 54741ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 5475bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5476b411b363SPhilipp Reisner } 5477b411b363SPhilipp Reisner } while (h == 0); 5478b411b363SPhilipp Reisner 547991fd4dadSPhilipp Reisner if (h > 0) 5480bde89a9eSAndreas Gruenbacher drbdd(connection); 5481b411b363SPhilipp Reisner 5482bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 5483b411b363SPhilipp Reisner 54841ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 5485b411b363SPhilipp Reisner return 0; 5486b411b363SPhilipp Reisner } 5487b411b363SPhilipp Reisner 5488b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 5489b411b363SPhilipp Reisner 5490bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5491b411b363SPhilipp Reisner { 5492e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5493b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5494b411b363SPhilipp Reisner 5495b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 5496bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 5497b411b363SPhilipp Reisner } else { 5498bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 54991ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 5500fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5501fc3b10a4SPhilipp Reisner } 5502bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5503e4f78edeSPhilipp Reisner 55042735a594SAndreas Gruenbacher return 0; 5505fc3b10a4SPhilipp Reisner } 5506e4f78edeSPhilipp Reisner 5507bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5508e4f78edeSPhilipp Reisner { 55099f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5510b30ab791SAndreas Gruenbacher struct drbd_device *device; 5511e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5512e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5513e4f78edeSPhilipp Reisner 55149f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55159f4fe9adSAndreas Gruenbacher if (!peer_device) 55162735a594SAndreas Gruenbacher return -EIO; 55179f4fe9adSAndreas Gruenbacher device = peer_device->device; 55181952e916SAndreas Gruenbacher 5519bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 55200b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 5521bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 55224d0fc3fdSPhilipp Reisner } 55234d0fc3fdSPhilipp Reisner 5524e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 5525b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 5526e4f78edeSPhilipp Reisner } else { 5527b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 5528d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 5529b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5530b411b363SPhilipp Reisner } 5531b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 5532b411b363SPhilipp Reisner 55332735a594SAndreas Gruenbacher return 0; 5534b411b363SPhilipp Reisner } 5535b411b363SPhilipp Reisner 5536bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 5537b411b363SPhilipp Reisner { 5538bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 5539b411b363SPhilipp Reisner 5540b411b363SPhilipp Reisner } 5541b411b363SPhilipp Reisner 5542bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 5543b411b363SPhilipp Reisner { 5544b411b363SPhilipp Reisner /* restore idle timeout */ 5545bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 5546bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 5547bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5548b411b363SPhilipp Reisner 55492735a594SAndreas Gruenbacher return 0; 5550b411b363SPhilipp Reisner } 5551b411b363SPhilipp Reisner 5552bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 5553b411b363SPhilipp Reisner { 55549f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5555b30ab791SAndreas Gruenbacher struct drbd_device *device; 5556e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5557b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5558b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5559b411b363SPhilipp Reisner 55609f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55619f4fe9adSAndreas Gruenbacher if (!peer_device) 55622735a594SAndreas Gruenbacher return -EIO; 55639f4fe9adSAndreas Gruenbacher device = peer_device->device; 55641952e916SAndreas Gruenbacher 55659f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 5566b411b363SPhilipp Reisner 556769a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5568b411b363SPhilipp Reisner 5569b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 5570b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5571b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5572b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 5573b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 5574b30ab791SAndreas Gruenbacher put_ldev(device); 55751d53f09eSLars Ellenberg } 5576b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5577b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5578b411b363SPhilipp Reisner 55792735a594SAndreas Gruenbacher return 0; 5580b411b363SPhilipp Reisner } 5581b411b363SPhilipp Reisner 5582bc9c5c41SAndreas Gruenbacher static int 5583b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5584bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5585bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5586b411b363SPhilipp Reisner { 5587b411b363SPhilipp Reisner struct drbd_request *req; 5588b411b363SPhilipp Reisner struct bio_and_error m; 5589b411b363SPhilipp Reisner 55900500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5591b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5592b411b363SPhilipp Reisner if (unlikely(!req)) { 55930500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 559485997675SAndreas Gruenbacher return -EIO; 5595b411b363SPhilipp Reisner } 5596b411b363SPhilipp Reisner __req_mod(req, what, &m); 55970500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5598b411b363SPhilipp Reisner 5599b411b363SPhilipp Reisner if (m.bio) 5600b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 560185997675SAndreas Gruenbacher return 0; 5602b411b363SPhilipp Reisner } 5603b411b363SPhilipp Reisner 5604bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5605b411b363SPhilipp Reisner { 56069f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5607b30ab791SAndreas Gruenbacher struct drbd_device *device; 5608e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5609b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5610b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5611b411b363SPhilipp Reisner enum drbd_req_event what; 5612b411b363SPhilipp Reisner 56139f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56149f4fe9adSAndreas Gruenbacher if (!peer_device) 56152735a594SAndreas Gruenbacher return -EIO; 56169f4fe9adSAndreas Gruenbacher device = peer_device->device; 56171952e916SAndreas Gruenbacher 561869a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5619b411b363SPhilipp Reisner 5620579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5621b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5622b30ab791SAndreas Gruenbacher dec_rs_pending(device); 56232735a594SAndreas Gruenbacher return 0; 5624b411b363SPhilipp Reisner } 5625e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5626b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 56278554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5628b411b363SPhilipp Reisner break; 5629b411b363SPhilipp Reisner case P_WRITE_ACK: 56308554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5631b411b363SPhilipp Reisner break; 5632b411b363SPhilipp Reisner case P_RECV_ACK: 56338554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5634b411b363SPhilipp Reisner break; 5635d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5636d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 56377be8da07SAndreas Gruenbacher break; 56387be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 56397be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5640b411b363SPhilipp Reisner break; 5641b411b363SPhilipp Reisner default: 56422735a594SAndreas Gruenbacher BUG(); 5643b411b363SPhilipp Reisner } 5644b411b363SPhilipp Reisner 5645b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5646b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5647bc9c5c41SAndreas Gruenbacher what, false); 5648b411b363SPhilipp Reisner } 5649b411b363SPhilipp Reisner 5650bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5651b411b363SPhilipp Reisner { 56529f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5653b30ab791SAndreas Gruenbacher struct drbd_device *device; 5654e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5655b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 56562deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 565785997675SAndreas Gruenbacher int err; 5658b411b363SPhilipp Reisner 56599f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56609f4fe9adSAndreas Gruenbacher if (!peer_device) 56612735a594SAndreas Gruenbacher return -EIO; 56629f4fe9adSAndreas Gruenbacher device = peer_device->device; 5663b411b363SPhilipp Reisner 566469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5665b411b363SPhilipp Reisner 5666579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5667b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5668b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 56692735a594SAndreas Gruenbacher return 0; 5670b411b363SPhilipp Reisner } 56712deb8336SPhilipp Reisner 5672b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5673b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5674303d1448SPhilipp Reisner NEG_ACKED, true); 567585997675SAndreas Gruenbacher if (err) { 56762deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 56772deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5678c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 56792deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 56802deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5681b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 56822deb8336SPhilipp Reisner } 56832735a594SAndreas Gruenbacher return 0; 5684b411b363SPhilipp Reisner } 5685b411b363SPhilipp Reisner 5686bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5687b411b363SPhilipp Reisner { 56889f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5689b30ab791SAndreas Gruenbacher struct drbd_device *device; 5690e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5691b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5692b411b363SPhilipp Reisner 56939f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56949f4fe9adSAndreas Gruenbacher if (!peer_device) 56952735a594SAndreas Gruenbacher return -EIO; 56969f4fe9adSAndreas Gruenbacher device = peer_device->device; 56971952e916SAndreas Gruenbacher 569869a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 56997be8da07SAndreas Gruenbacher 5700d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5701b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5702b411b363SPhilipp Reisner 5703b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5704b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 57058554df1cSAndreas Gruenbacher NEG_ACKED, false); 5706b411b363SPhilipp Reisner } 5707b411b363SPhilipp Reisner 5708bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5709b411b363SPhilipp Reisner { 57109f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5711b30ab791SAndreas Gruenbacher struct drbd_device *device; 5712b411b363SPhilipp Reisner sector_t sector; 5713b411b363SPhilipp Reisner int size; 5714e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 57151952e916SAndreas Gruenbacher 57169f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 57179f4fe9adSAndreas Gruenbacher if (!peer_device) 57182735a594SAndreas Gruenbacher return -EIO; 57199f4fe9adSAndreas Gruenbacher device = peer_device->device; 5720b411b363SPhilipp Reisner 5721b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5722b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5723b411b363SPhilipp Reisner 572469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5725b411b363SPhilipp Reisner 5726b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5727b411b363SPhilipp Reisner 5728b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5729b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5730e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5731d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5732b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5733d612d309SPhilipp Reisner case P_RS_CANCEL: 5734d612d309SPhilipp Reisner break; 5735d612d309SPhilipp Reisner default: 57362735a594SAndreas Gruenbacher BUG(); 5737d612d309SPhilipp Reisner } 5738b30ab791SAndreas Gruenbacher put_ldev(device); 5739b411b363SPhilipp Reisner } 5740b411b363SPhilipp Reisner 57412735a594SAndreas Gruenbacher return 0; 5742b411b363SPhilipp Reisner } 5743b411b363SPhilipp Reisner 5744bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5745b411b363SPhilipp Reisner { 5746e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5747c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 57489ed57dcbSLars Ellenberg int vnr; 5749b411b363SPhilipp Reisner 5750bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5751b411b363SPhilipp Reisner 57529ed57dcbSLars Ellenberg rcu_read_lock(); 5753c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5754c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5755c06ece6bSAndreas Gruenbacher 5756b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5757b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5758b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5759b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5760b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5761c4752ef1SPhilipp Reisner } 57629ed57dcbSLars Ellenberg } 57639ed57dcbSLars Ellenberg rcu_read_unlock(); 5764c4752ef1SPhilipp Reisner 57652735a594SAndreas Gruenbacher return 0; 5766b411b363SPhilipp Reisner } 5767b411b363SPhilipp Reisner 5768bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5769b411b363SPhilipp Reisner { 57709f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5771b30ab791SAndreas Gruenbacher struct drbd_device *device; 5772e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 577384b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5774b411b363SPhilipp Reisner sector_t sector; 5775b411b363SPhilipp Reisner int size; 5776b411b363SPhilipp Reisner 57779f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 57789f4fe9adSAndreas Gruenbacher if (!peer_device) 57792735a594SAndreas Gruenbacher return -EIO; 57809f4fe9adSAndreas Gruenbacher device = peer_device->device; 57811952e916SAndreas Gruenbacher 5782b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5783b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5784b411b363SPhilipp Reisner 578569a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5786b411b363SPhilipp Reisner 5787b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5788b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5789b411b363SPhilipp Reisner else 5790b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5791b411b363SPhilipp Reisner 5792b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 57932735a594SAndreas Gruenbacher return 0; 57941d53f09eSLars Ellenberg 5795b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5796b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5797b411b363SPhilipp Reisner 5798b30ab791SAndreas Gruenbacher --device->ov_left; 5799ea5442afSLars Ellenberg 5800ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5801b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5802b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5803ea5442afSLars Ellenberg 5804b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 580584b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 580684b8c06bSAndreas Gruenbacher if (dw) { 580784b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 580884b8c06bSAndreas Gruenbacher dw->device = device; 580984b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5810b411b363SPhilipp Reisner } else { 581184b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5812b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5813b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5814b411b363SPhilipp Reisner } 5815b411b363SPhilipp Reisner } 5816b30ab791SAndreas Gruenbacher put_ldev(device); 58172735a594SAndreas Gruenbacher return 0; 5818b411b363SPhilipp Reisner } 5819b411b363SPhilipp Reisner 5820bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 58210ced55a3SPhilipp Reisner { 58222735a594SAndreas Gruenbacher return 0; 58230ced55a3SPhilipp Reisner } 58240ced55a3SPhilipp Reisner 5825668700b4SPhilipp Reisner struct meta_sock_cmd { 5826b411b363SPhilipp Reisner size_t pkt_size; 5827bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5828b411b363SPhilipp Reisner }; 5829b411b363SPhilipp Reisner 5830668700b4SPhilipp Reisner static void set_rcvtimeo(struct drbd_connection *connection, bool ping_timeout) 5831668700b4SPhilipp Reisner { 5832668700b4SPhilipp Reisner long t; 5833668700b4SPhilipp Reisner struct net_conf *nc; 5834668700b4SPhilipp Reisner 5835668700b4SPhilipp Reisner rcu_read_lock(); 5836668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 5837668700b4SPhilipp Reisner t = ping_timeout ? nc->ping_timeo : nc->ping_int; 5838668700b4SPhilipp Reisner rcu_read_unlock(); 5839668700b4SPhilipp Reisner 5840668700b4SPhilipp Reisner t *= HZ; 5841668700b4SPhilipp Reisner if (ping_timeout) 5842668700b4SPhilipp Reisner t /= 10; 5843668700b4SPhilipp Reisner 5844668700b4SPhilipp Reisner connection->meta.socket->sk->sk_rcvtimeo = t; 5845668700b4SPhilipp Reisner } 5846668700b4SPhilipp Reisner 5847668700b4SPhilipp Reisner static void set_ping_timeout(struct drbd_connection *connection) 5848668700b4SPhilipp Reisner { 5849668700b4SPhilipp Reisner set_rcvtimeo(connection, 1); 5850668700b4SPhilipp Reisner } 5851668700b4SPhilipp Reisner 5852668700b4SPhilipp Reisner static void set_idle_timeout(struct drbd_connection *connection) 5853668700b4SPhilipp Reisner { 5854668700b4SPhilipp Reisner set_rcvtimeo(connection, 0); 5855668700b4SPhilipp Reisner } 5856668700b4SPhilipp Reisner 5857668700b4SPhilipp Reisner static struct meta_sock_cmd ack_receiver_tbl[] = { 5858e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5859e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5860b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5861b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5862b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5863d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5864b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5865b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5866b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5867b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5868b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5869b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5870b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 587102918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5872d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 58731952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 58741952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5875b411b363SPhilipp Reisner }; 5876b411b363SPhilipp Reisner 58771c03e520SPhilipp Reisner int drbd_ack_receiver(struct drbd_thread *thi) 5878b411b363SPhilipp Reisner { 5879bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5880668700b4SPhilipp Reisner struct meta_sock_cmd *cmd = NULL; 588177351055SPhilipp Reisner struct packet_info pi; 5882668700b4SPhilipp Reisner unsigned long pre_recv_jif; 5883257d0af6SPhilipp Reisner int rv; 5884bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5885b411b363SPhilipp Reisner int received = 0; 5886bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 588752b061a4SAndreas Gruenbacher int expect = header_size; 588844ed167dSPhilipp Reisner bool ping_timeout_active = false; 58893990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5890b411b363SPhilipp Reisner 58913990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 58923990e04dSPhilipp Reisner if (rv < 0) 5893668700b4SPhilipp Reisner drbd_err(connection, "drbd_ack_receiver: ERROR set priority, ret=%d\n", rv); 5894b411b363SPhilipp Reisner 5895e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 589680822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 589744ed167dSPhilipp Reisner 5898668700b4SPhilipp Reisner conn_reclaim_net_peer_reqs(connection); 589944ed167dSPhilipp Reisner 5900bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5901bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 59021ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5903841ce241SAndreas Gruenbacher goto reconnect; 5904841ce241SAndreas Gruenbacher } 5905668700b4SPhilipp Reisner set_ping_timeout(connection); 590644ed167dSPhilipp Reisner ping_timeout_active = true; 5907b411b363SPhilipp Reisner } 5908b411b363SPhilipp Reisner 5909668700b4SPhilipp Reisner pre_recv_jif = jiffies; 5910bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5911b411b363SPhilipp Reisner 5912b411b363SPhilipp Reisner /* Note: 5913b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5914b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5915b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5916b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5917b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5918b411b363SPhilipp Reisner * rv == expected: full header or command 5919b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5920b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5921b411b363SPhilipp Reisner */ 5922b411b363SPhilipp Reisner if (likely(rv > 0)) { 5923b411b363SPhilipp Reisner received += rv; 5924b411b363SPhilipp Reisner buf += rv; 5925b411b363SPhilipp Reisner } else if (rv == 0) { 5926bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5927b66623e3SPhilipp Reisner long t; 5928b66623e3SPhilipp Reisner rcu_read_lock(); 5929bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5930b66623e3SPhilipp Reisner rcu_read_unlock(); 5931b66623e3SPhilipp Reisner 5932bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5933bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5934b66623e3SPhilipp Reisner t); 5935599377acSPhilipp Reisner if (t) 5936599377acSPhilipp Reisner break; 5937599377acSPhilipp Reisner } 59381ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5939b411b363SPhilipp Reisner goto reconnect; 5940b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5941cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5942cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5943668700b4SPhilipp Reisner if (time_after(connection->last_received, pre_recv_jif)) 5944cb6518cbSLars Ellenberg continue; 5945f36af18cSLars Ellenberg if (ping_timeout_active) { 59461ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5947b411b363SPhilipp Reisner goto reconnect; 5948b411b363SPhilipp Reisner } 5949bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5950b411b363SPhilipp Reisner continue; 5951b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5952668700b4SPhilipp Reisner /* maybe drbd_thread_stop(): the while condition will notice. 5953668700b4SPhilipp Reisner * maybe woken for send_ping: we'll send a ping above, 5954668700b4SPhilipp Reisner * and change the rcvtimeo */ 5955668700b4SPhilipp Reisner flush_signals(current); 5956b411b363SPhilipp Reisner continue; 5957b411b363SPhilipp Reisner } else { 59581ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5959b411b363SPhilipp Reisner goto reconnect; 5960b411b363SPhilipp Reisner } 5961b411b363SPhilipp Reisner 5962b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5963bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5964b411b363SPhilipp Reisner goto reconnect; 5965668700b4SPhilipp Reisner cmd = &ack_receiver_tbl[pi.cmd]; 5966668700b4SPhilipp Reisner if (pi.cmd >= ARRAY_SIZE(ack_receiver_tbl) || !cmd->fn) { 59671ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 59682fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5969b411b363SPhilipp Reisner goto disconnect; 5970b411b363SPhilipp Reisner } 5971e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 597252b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 59731ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 597477351055SPhilipp Reisner pi.cmd, pi.size); 5975b411b363SPhilipp Reisner goto reconnect; 5976b411b363SPhilipp Reisner } 5977257d0af6SPhilipp Reisner } 5978b411b363SPhilipp Reisner if (received == expect) { 59792735a594SAndreas Gruenbacher bool err; 5980a4fbda8eSPhilipp Reisner 5981bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 59822735a594SAndreas Gruenbacher if (err) { 59831ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5984b411b363SPhilipp Reisner goto reconnect; 59851952e916SAndreas Gruenbacher } 5986b411b363SPhilipp Reisner 5987bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5988f36af18cSLars Ellenberg 5989668700b4SPhilipp Reisner if (cmd == &ack_receiver_tbl[P_PING_ACK]) { 5990668700b4SPhilipp Reisner set_idle_timeout(connection); 599144ed167dSPhilipp Reisner ping_timeout_active = false; 599244ed167dSPhilipp Reisner } 5993b411b363SPhilipp Reisner 5994bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5995b411b363SPhilipp Reisner received = 0; 599652b061a4SAndreas Gruenbacher expect = header_size; 5997b411b363SPhilipp Reisner cmd = NULL; 5998b411b363SPhilipp Reisner } 5999b411b363SPhilipp Reisner } 6000b411b363SPhilipp Reisner 6001b411b363SPhilipp Reisner if (0) { 6002b411b363SPhilipp Reisner reconnect: 6003bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 6004bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 6005b411b363SPhilipp Reisner } 6006b411b363SPhilipp Reisner if (0) { 6007b411b363SPhilipp Reisner disconnect: 6008bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 6009b411b363SPhilipp Reisner } 6010b411b363SPhilipp Reisner 6011668700b4SPhilipp Reisner drbd_info(connection, "ack_receiver terminated\n"); 6012b411b363SPhilipp Reisner 6013b411b363SPhilipp Reisner return 0; 6014b411b363SPhilipp Reisner } 6015668700b4SPhilipp Reisner 6016668700b4SPhilipp Reisner void drbd_send_acks_wf(struct work_struct *ws) 6017668700b4SPhilipp Reisner { 6018668700b4SPhilipp Reisner struct drbd_peer_device *peer_device = 6019668700b4SPhilipp Reisner container_of(ws, struct drbd_peer_device, send_acks_work); 6020668700b4SPhilipp Reisner struct drbd_connection *connection = peer_device->connection; 6021668700b4SPhilipp Reisner struct drbd_device *device = peer_device->device; 6022668700b4SPhilipp Reisner struct net_conf *nc; 6023668700b4SPhilipp Reisner int tcp_cork, err; 6024668700b4SPhilipp Reisner 6025668700b4SPhilipp Reisner rcu_read_lock(); 6026668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 6027668700b4SPhilipp Reisner tcp_cork = nc->tcp_cork; 6028668700b4SPhilipp Reisner rcu_read_unlock(); 6029668700b4SPhilipp Reisner 6030668700b4SPhilipp Reisner if (tcp_cork) 6031668700b4SPhilipp Reisner drbd_tcp_cork(connection->meta.socket); 6032668700b4SPhilipp Reisner 6033668700b4SPhilipp Reisner err = drbd_finish_peer_reqs(device); 6034668700b4SPhilipp Reisner kref_put(&device->kref, drbd_destroy_device); 6035668700b4SPhilipp Reisner /* get is in drbd_endio_write_sec_final(). That is necessary to keep the 6036668700b4SPhilipp Reisner struct work_struct send_acks_work alive, which is in the peer_device object */ 6037668700b4SPhilipp Reisner 6038668700b4SPhilipp Reisner if (err) { 6039668700b4SPhilipp Reisner conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 6040668700b4SPhilipp Reisner return; 6041668700b4SPhilipp Reisner } 6042668700b4SPhilipp Reisner 6043668700b4SPhilipp Reisner if (tcp_cork) 6044668700b4SPhilipp Reisner drbd_tcp_uncork(connection->meta.socket); 6045668700b4SPhilipp Reisner 6046668700b4SPhilipp Reisner return; 6047668700b4SPhilipp Reisner } 6048