1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_receiver.c 3b411b363SPhilipp Reisner 4b411b363SPhilipp Reisner This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5b411b363SPhilipp Reisner 6b411b363SPhilipp Reisner Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7b411b363SPhilipp Reisner Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8b411b363SPhilipp Reisner Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9b411b363SPhilipp Reisner 10b411b363SPhilipp Reisner drbd is free software; you can redistribute it and/or modify 11b411b363SPhilipp Reisner it under the terms of the GNU General Public License as published by 12b411b363SPhilipp Reisner the Free Software Foundation; either version 2, or (at your option) 13b411b363SPhilipp Reisner any later version. 14b411b363SPhilipp Reisner 15b411b363SPhilipp Reisner drbd is distributed in the hope that it will be useful, 16b411b363SPhilipp Reisner but WITHOUT ANY WARRANTY; without even the implied warranty of 17b411b363SPhilipp Reisner MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18b411b363SPhilipp Reisner GNU General Public License for more details. 19b411b363SPhilipp Reisner 20b411b363SPhilipp Reisner You should have received a copy of the GNU General Public License 21b411b363SPhilipp Reisner along with drbd; see the file COPYING. If not, write to 22b411b363SPhilipp Reisner the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23b411b363SPhilipp Reisner */ 24b411b363SPhilipp Reisner 25b411b363SPhilipp Reisner 26b411b363SPhilipp Reisner #include <linux/module.h> 27b411b363SPhilipp Reisner 287e5fec31SFabian Frederick #include <linux/uaccess.h> 29b411b363SPhilipp Reisner #include <net/sock.h> 30b411b363SPhilipp Reisner 31b411b363SPhilipp Reisner #include <linux/drbd.h> 32b411b363SPhilipp Reisner #include <linux/fs.h> 33b411b363SPhilipp Reisner #include <linux/file.h> 34b411b363SPhilipp Reisner #include <linux/in.h> 35b411b363SPhilipp Reisner #include <linux/mm.h> 36b411b363SPhilipp Reisner #include <linux/memcontrol.h> 37b411b363SPhilipp Reisner #include <linux/mm_inline.h> 38b411b363SPhilipp Reisner #include <linux/slab.h> 39ae7e81c0SIngo Molnar #include <uapi/linux/sched/types.h> 40174cd4b1SIngo Molnar #include <linux/sched/signal.h> 41b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 42b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 43b411b363SPhilipp Reisner #include <linux/unistd.h> 44b411b363SPhilipp Reisner #include <linux/vmalloc.h> 45b411b363SPhilipp Reisner #include <linux/random.h> 46b411b363SPhilipp Reisner #include <linux/string.h> 47b411b363SPhilipp Reisner #include <linux/scatterlist.h> 48b411b363SPhilipp Reisner #include "drbd_int.h" 49a3603a6eSAndreas Gruenbacher #include "drbd_protocol.h" 50b411b363SPhilipp Reisner #include "drbd_req.h" 51b411b363SPhilipp Reisner #include "drbd_vli.h" 52b411b363SPhilipp Reisner 539104d31aSLars Ellenberg #define PRO_FEATURES (DRBD_FF_TRIM|DRBD_FF_THIN_RESYNC|DRBD_FF_WSAME) 5420c68fdeSLars Ellenberg 5577351055SPhilipp Reisner struct packet_info { 5677351055SPhilipp Reisner enum drbd_packet cmd; 57e2857216SAndreas Gruenbacher unsigned int size; 58e2857216SAndreas Gruenbacher unsigned int vnr; 59e658983aSAndreas Gruenbacher void *data; 6077351055SPhilipp Reisner }; 6177351055SPhilipp Reisner 62b411b363SPhilipp Reisner enum finish_epoch { 63b411b363SPhilipp Reisner FE_STILL_LIVE, 64b411b363SPhilipp Reisner FE_DESTROYED, 65b411b363SPhilipp Reisner FE_RECYCLED, 66b411b363SPhilipp Reisner }; 67b411b363SPhilipp Reisner 68bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection); 69bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection); 7069a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *); 71a0fb3c47SLars Ellenberg static void conn_wait_active_ee_empty(struct drbd_connection *connection); 72bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *, struct drbd_epoch *, enum epoch_event); 7399920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 74b411b363SPhilipp Reisner 75b411b363SPhilipp Reisner 76b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 77b411b363SPhilipp Reisner 7845bb912bSLars Ellenberg /* 7945bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 8045bb912bSLars Ellenberg * page->private being our "next" pointer. 8145bb912bSLars Ellenberg */ 8245bb912bSLars Ellenberg 8345bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8445bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8545bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8645bb912bSLars Ellenberg */ 8745bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8845bb912bSLars Ellenberg { 8945bb912bSLars Ellenberg struct page *page; 9045bb912bSLars Ellenberg struct page *tmp; 9145bb912bSLars Ellenberg 9245bb912bSLars Ellenberg BUG_ON(!n); 9345bb912bSLars Ellenberg BUG_ON(!head); 9445bb912bSLars Ellenberg 9545bb912bSLars Ellenberg page = *head; 9623ce4227SPhilipp Reisner 9723ce4227SPhilipp Reisner if (!page) 9823ce4227SPhilipp Reisner return NULL; 9923ce4227SPhilipp Reisner 10045bb912bSLars Ellenberg while (page) { 10145bb912bSLars Ellenberg tmp = page_chain_next(page); 10245bb912bSLars Ellenberg if (--n == 0) 10345bb912bSLars Ellenberg break; /* found sufficient pages */ 10445bb912bSLars Ellenberg if (tmp == NULL) 10545bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10645bb912bSLars Ellenberg return NULL; 10745bb912bSLars Ellenberg page = tmp; 10845bb912bSLars Ellenberg } 10945bb912bSLars Ellenberg 11045bb912bSLars Ellenberg /* add end of list marker for the returned list */ 11145bb912bSLars Ellenberg set_page_private(page, 0); 11245bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11345bb912bSLars Ellenberg page = *head; 11445bb912bSLars Ellenberg *head = tmp; 11545bb912bSLars Ellenberg return page; 11645bb912bSLars Ellenberg } 11745bb912bSLars Ellenberg 11845bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11945bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 12045bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 12145bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 12245bb912bSLars Ellenberg { 12345bb912bSLars Ellenberg struct page *tmp; 12445bb912bSLars Ellenberg int i = 1; 12545bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12645bb912bSLars Ellenberg ++i, page = tmp; 12745bb912bSLars Ellenberg if (len) 12845bb912bSLars Ellenberg *len = i; 12945bb912bSLars Ellenberg return page; 13045bb912bSLars Ellenberg } 13145bb912bSLars Ellenberg 13245bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13345bb912bSLars Ellenberg { 13445bb912bSLars Ellenberg struct page *tmp; 13545bb912bSLars Ellenberg int i = 0; 13645bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13745bb912bSLars Ellenberg put_page(page); 13845bb912bSLars Ellenberg ++i; 13945bb912bSLars Ellenberg } 14045bb912bSLars Ellenberg return i; 14145bb912bSLars Ellenberg } 14245bb912bSLars Ellenberg 14345bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14445bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14545bb912bSLars Ellenberg { 14645bb912bSLars Ellenberg #if 1 14745bb912bSLars Ellenberg struct page *tmp; 14845bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14945bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 15045bb912bSLars Ellenberg #endif 15145bb912bSLars Ellenberg 15245bb912bSLars Ellenberg /* add chain to head */ 15345bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15445bb912bSLars Ellenberg *head = chain_first; 15545bb912bSLars Ellenberg } 15645bb912bSLars Ellenberg 157b30ab791SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_device *device, 15818c2d522SAndreas Gruenbacher unsigned int number) 159b411b363SPhilipp Reisner { 160b411b363SPhilipp Reisner struct page *page = NULL; 16145bb912bSLars Ellenberg struct page *tmp = NULL; 16218c2d522SAndreas Gruenbacher unsigned int i = 0; 163b411b363SPhilipp Reisner 164b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 165b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16645bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 167b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16845bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16945bb912bSLars Ellenberg if (page) 17045bb912bSLars Ellenberg drbd_pp_vacant -= number; 171b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 17245bb912bSLars Ellenberg if (page) 17345bb912bSLars Ellenberg return page; 174b411b363SPhilipp Reisner } 17545bb912bSLars Ellenberg 176b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 177b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 178b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17945bb912bSLars Ellenberg for (i = 0; i < number; i++) { 18045bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 18145bb912bSLars Ellenberg if (!tmp) 18245bb912bSLars Ellenberg break; 18345bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18445bb912bSLars Ellenberg page = tmp; 18545bb912bSLars Ellenberg } 18645bb912bSLars Ellenberg 18745bb912bSLars Ellenberg if (i == number) 188b411b363SPhilipp Reisner return page; 18945bb912bSLars Ellenberg 19045bb912bSLars Ellenberg /* Not enough pages immediately available this time. 191c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 19245bb912bSLars Ellenberg * function "soon". */ 19345bb912bSLars Ellenberg if (page) { 19445bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19545bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19645bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19745bb912bSLars Ellenberg drbd_pp_vacant += i; 19845bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19945bb912bSLars Ellenberg } 20045bb912bSLars Ellenberg return NULL; 201b411b363SPhilipp Reisner } 202b411b363SPhilipp Reisner 203b30ab791SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_device *device, 204a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 205b411b363SPhilipp Reisner { 206a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req, *tmp; 207b411b363SPhilipp Reisner 208b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 209b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 210b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 211b411b363SPhilipp Reisner stop to examine the list... */ 212b411b363SPhilipp Reisner 213a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, tmp, &device->net_ee, w.list) { 214045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 215b411b363SPhilipp Reisner break; 216a8cd15baSAndreas Gruenbacher list_move(&peer_req->w.list, to_be_freed); 217b411b363SPhilipp Reisner } 218b411b363SPhilipp Reisner } 219b411b363SPhilipp Reisner 220668700b4SPhilipp Reisner static void drbd_reclaim_net_peer_reqs(struct drbd_device *device) 221b411b363SPhilipp Reisner { 222b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 223db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 224b411b363SPhilipp Reisner 2250500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 226b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 2270500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 228a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 229b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 230b411b363SPhilipp Reisner } 231b411b363SPhilipp Reisner 232668700b4SPhilipp Reisner static void conn_reclaim_net_peer_reqs(struct drbd_connection *connection) 233668700b4SPhilipp Reisner { 234668700b4SPhilipp Reisner struct drbd_peer_device *peer_device; 235668700b4SPhilipp Reisner int vnr; 236668700b4SPhilipp Reisner 237668700b4SPhilipp Reisner rcu_read_lock(); 238668700b4SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 239668700b4SPhilipp Reisner struct drbd_device *device = peer_device->device; 240668700b4SPhilipp Reisner if (!atomic_read(&device->pp_in_use_by_net)) 241668700b4SPhilipp Reisner continue; 242668700b4SPhilipp Reisner 243668700b4SPhilipp Reisner kref_get(&device->kref); 244668700b4SPhilipp Reisner rcu_read_unlock(); 245668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 246668700b4SPhilipp Reisner kref_put(&device->kref, drbd_destroy_device); 247668700b4SPhilipp Reisner rcu_read_lock(); 248668700b4SPhilipp Reisner } 249668700b4SPhilipp Reisner rcu_read_unlock(); 250668700b4SPhilipp Reisner } 251668700b4SPhilipp Reisner 252b411b363SPhilipp Reisner /** 253c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 254b30ab791SAndreas Gruenbacher * @device: DRBD device. 25545bb912bSLars Ellenberg * @number: number of pages requested 25645bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 257b411b363SPhilipp Reisner * 25845bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 2590e49d7b0SLars Ellenberg * the kernel. 26045bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 26145bb912bSLars Ellenberg * 2620e49d7b0SLars Ellenberg * If this allocation would exceed the max_buffers setting, we throttle 2630e49d7b0SLars Ellenberg * allocation (schedule_timeout) to give the system some room to breathe. 2640e49d7b0SLars Ellenberg * 2650e49d7b0SLars Ellenberg * We do not use max-buffers as hard limit, because it could lead to 2660e49d7b0SLars Ellenberg * congestion and further to a distributed deadlock during online-verify or 2670e49d7b0SLars Ellenberg * (checksum based) resync, if the max-buffers, socket buffer sizes and 2680e49d7b0SLars Ellenberg * resync-rate settings are mis-configured. 2690e49d7b0SLars Ellenberg * 27045bb912bSLars Ellenberg * Returns a page chain linked via page->private. 271b411b363SPhilipp Reisner */ 27269a22773SAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_peer_device *peer_device, unsigned int number, 273c37c8ecfSAndreas Gruenbacher bool retry) 274b411b363SPhilipp Reisner { 27569a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 276b411b363SPhilipp Reisner struct page *page = NULL; 27744ed167dSPhilipp Reisner struct net_conf *nc; 278b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2790e49d7b0SLars Ellenberg unsigned int mxb; 280b411b363SPhilipp Reisner 28144ed167dSPhilipp Reisner rcu_read_lock(); 28269a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 28344ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 28444ed167dSPhilipp Reisner rcu_read_unlock(); 28544ed167dSPhilipp Reisner 286b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) 287b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 288b411b363SPhilipp Reisner 289668700b4SPhilipp Reisner /* Try to keep the fast path fast, but occasionally we need 290668700b4SPhilipp Reisner * to reclaim the pages we lended to the network stack. */ 291668700b4SPhilipp Reisner if (page && atomic_read(&device->pp_in_use_by_net) > 512) 292668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 293668700b4SPhilipp Reisner 29445bb912bSLars Ellenberg while (page == NULL) { 295b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 296b411b363SPhilipp Reisner 297668700b4SPhilipp Reisner drbd_reclaim_net_peer_reqs(device); 298b411b363SPhilipp Reisner 299b30ab791SAndreas Gruenbacher if (atomic_read(&device->pp_in_use) < mxb) { 300b30ab791SAndreas Gruenbacher page = __drbd_alloc_pages(device, number); 301b411b363SPhilipp Reisner if (page) 302b411b363SPhilipp Reisner break; 303b411b363SPhilipp Reisner } 304b411b363SPhilipp Reisner 305b411b363SPhilipp Reisner if (!retry) 306b411b363SPhilipp Reisner break; 307b411b363SPhilipp Reisner 308b411b363SPhilipp Reisner if (signal_pending(current)) { 309d0180171SAndreas Gruenbacher drbd_warn(device, "drbd_alloc_pages interrupted!\n"); 310b411b363SPhilipp Reisner break; 311b411b363SPhilipp Reisner } 312b411b363SPhilipp Reisner 3130e49d7b0SLars Ellenberg if (schedule_timeout(HZ/10) == 0) 3140e49d7b0SLars Ellenberg mxb = UINT_MAX; 315b411b363SPhilipp Reisner } 316b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 317b411b363SPhilipp Reisner 31845bb912bSLars Ellenberg if (page) 319b30ab791SAndreas Gruenbacher atomic_add(number, &device->pp_in_use); 320b411b363SPhilipp Reisner return page; 321b411b363SPhilipp Reisner } 322b411b363SPhilipp Reisner 323c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 3240500813fSAndreas Gruenbacher * Is also used from inside an other spin_lock_irq(&resource->req_lock); 32545bb912bSLars Ellenberg * Either links the page chain back to the global pool, 32645bb912bSLars Ellenberg * or returns all pages to the system. */ 327b30ab791SAndreas Gruenbacher static void drbd_free_pages(struct drbd_device *device, struct page *page, int is_net) 328b411b363SPhilipp Reisner { 329b30ab791SAndreas Gruenbacher atomic_t *a = is_net ? &device->pp_in_use_by_net : &device->pp_in_use; 330b411b363SPhilipp Reisner int i; 331435f0740SLars Ellenberg 332a73ff323SLars Ellenberg if (page == NULL) 333a73ff323SLars Ellenberg return; 334a73ff323SLars Ellenberg 335183ece30SRoland Kammerer if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * drbd_minor_count) 33645bb912bSLars Ellenberg i = page_chain_free(page); 33745bb912bSLars Ellenberg else { 33845bb912bSLars Ellenberg struct page *tmp; 33945bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 340b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 34145bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 34245bb912bSLars Ellenberg drbd_pp_vacant += i; 343b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 344b411b363SPhilipp Reisner } 345435f0740SLars Ellenberg i = atomic_sub_return(i, a); 34645bb912bSLars Ellenberg if (i < 0) 347d0180171SAndreas Gruenbacher drbd_warn(device, "ASSERTION FAILED: %s: %d < 0\n", 348435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 349b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 350b411b363SPhilipp Reisner } 351b411b363SPhilipp Reisner 352b411b363SPhilipp Reisner /* 353b411b363SPhilipp Reisner You need to hold the req_lock: 354b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 355b411b363SPhilipp Reisner 356b411b363SPhilipp Reisner You must not have the req_lock: 3573967deb1SAndreas Gruenbacher drbd_free_peer_req() 3580db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3597721f567SAndreas Gruenbacher drbd_free_peer_reqs() 360b411b363SPhilipp Reisner drbd_ee_fix_bhs() 361a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 362b411b363SPhilipp Reisner drbd_clear_done_ee() 363b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 364b411b363SPhilipp Reisner */ 365b411b363SPhilipp Reisner 3669104d31aSLars Ellenberg /* normal: payload_size == request size (bi_size) 3679104d31aSLars Ellenberg * w_same: payload_size == logical_block_size 3689104d31aSLars Ellenberg * trim: payload_size == 0 */ 369f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 37069a22773SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 3719104d31aSLars Ellenberg unsigned int request_size, unsigned int payload_size, gfp_t gfp_mask) __must_hold(local) 372b411b363SPhilipp Reisner { 37369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 374db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 375a73ff323SLars Ellenberg struct page *page = NULL; 3769104d31aSLars Ellenberg unsigned nr_pages = (payload_size + PAGE_SIZE -1) >> PAGE_SHIFT; 377b411b363SPhilipp Reisner 378b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_AL_EE)) 379b411b363SPhilipp Reisner return NULL; 380b411b363SPhilipp Reisner 3810892fac8SKent Overstreet peer_req = mempool_alloc(&drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 382db830c46SAndreas Gruenbacher if (!peer_req) { 383b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 384d0180171SAndreas Gruenbacher drbd_err(device, "%s: allocation failed\n", __func__); 385b411b363SPhilipp Reisner return NULL; 386b411b363SPhilipp Reisner } 387b411b363SPhilipp Reisner 3889104d31aSLars Ellenberg if (nr_pages) { 389d0164adcSMel Gorman page = drbd_alloc_pages(peer_device, nr_pages, 390d0164adcSMel Gorman gfpflags_allow_blocking(gfp_mask)); 39145bb912bSLars Ellenberg if (!page) 39245bb912bSLars Ellenberg goto fail; 393a73ff323SLars Ellenberg } 394b411b363SPhilipp Reisner 395c5a2c150SLars Ellenberg memset(peer_req, 0, sizeof(*peer_req)); 396c5a2c150SLars Ellenberg INIT_LIST_HEAD(&peer_req->w.list); 397db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 3989104d31aSLars Ellenberg peer_req->i.size = request_size; 399db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 400c5a2c150SLars Ellenberg peer_req->submit_jif = jiffies; 401a8cd15baSAndreas Gruenbacher peer_req->peer_device = peer_device; 402db830c46SAndreas Gruenbacher peer_req->pages = page; 4039a8e7753SAndreas Gruenbacher /* 4049a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 4059a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 4069a8e7753SAndreas Gruenbacher */ 407db830c46SAndreas Gruenbacher peer_req->block_id = id; 408b411b363SPhilipp Reisner 409db830c46SAndreas Gruenbacher return peer_req; 410b411b363SPhilipp Reisner 41145bb912bSLars Ellenberg fail: 4120892fac8SKent Overstreet mempool_free(peer_req, &drbd_ee_mempool); 413b411b363SPhilipp Reisner return NULL; 414b411b363SPhilipp Reisner } 415b411b363SPhilipp Reisner 416b30ab791SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_device *device, struct drbd_peer_request *peer_req, 417f6ffca9fSAndreas Gruenbacher int is_net) 418b411b363SPhilipp Reisner { 41921ae5d7fSLars Ellenberg might_sleep(); 420db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 421db830c46SAndreas Gruenbacher kfree(peer_req->digest); 422b30ab791SAndreas Gruenbacher drbd_free_pages(device, peer_req->pages, is_net); 4230b0ba1efSAndreas Gruenbacher D_ASSERT(device, atomic_read(&peer_req->pending_bios) == 0); 4240b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 42521ae5d7fSLars Ellenberg if (!expect(!(peer_req->flags & EE_CALL_AL_COMPLETE_IO))) { 42621ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 42721ae5d7fSLars Ellenberg drbd_al_complete_io(device, &peer_req->i); 42821ae5d7fSLars Ellenberg } 4290892fac8SKent Overstreet mempool_free(peer_req, &drbd_ee_mempool); 430b411b363SPhilipp Reisner } 431b411b363SPhilipp Reisner 432b30ab791SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_device *device, struct list_head *list) 433b411b363SPhilipp Reisner { 434b411b363SPhilipp Reisner LIST_HEAD(work_list); 435db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 436b411b363SPhilipp Reisner int count = 0; 437b30ab791SAndreas Gruenbacher int is_net = list == &device->net_ee; 438b411b363SPhilipp Reisner 4390500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 440b411b363SPhilipp Reisner list_splice_init(list, &work_list); 4410500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 442b411b363SPhilipp Reisner 443a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 444b30ab791SAndreas Gruenbacher __drbd_free_peer_req(device, peer_req, is_net); 445b411b363SPhilipp Reisner count++; 446b411b363SPhilipp Reisner } 447b411b363SPhilipp Reisner return count; 448b411b363SPhilipp Reisner } 449b411b363SPhilipp Reisner 450b411b363SPhilipp Reisner /* 451a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 452b411b363SPhilipp Reisner */ 453b30ab791SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_device *device) 454b411b363SPhilipp Reisner { 455b411b363SPhilipp Reisner LIST_HEAD(work_list); 456b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 457db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 458e2b3032bSAndreas Gruenbacher int err = 0; 459b411b363SPhilipp Reisner 4600500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 461b30ab791SAndreas Gruenbacher reclaim_finished_net_peer_reqs(device, &reclaimed); 462b30ab791SAndreas Gruenbacher list_splice_init(&device->done_ee, &work_list); 4630500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 464b411b363SPhilipp Reisner 465a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 466b30ab791SAndreas Gruenbacher drbd_free_net_peer_req(device, peer_req); 467b411b363SPhilipp Reisner 468b411b363SPhilipp Reisner /* possible callbacks here: 469d4dabbe2SLars Ellenberg * e_end_block, and e_end_resync_block, e_send_superseded. 470b411b363SPhilipp Reisner * all ignore the last argument. 471b411b363SPhilipp Reisner */ 472a8cd15baSAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 473e2b3032bSAndreas Gruenbacher int err2; 474e2b3032bSAndreas Gruenbacher 475b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 476a8cd15baSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 477e2b3032bSAndreas Gruenbacher if (!err) 478e2b3032bSAndreas Gruenbacher err = err2; 479b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 480b411b363SPhilipp Reisner } 481b30ab791SAndreas Gruenbacher wake_up(&device->ee_wait); 482b411b363SPhilipp Reisner 483e2b3032bSAndreas Gruenbacher return err; 484b411b363SPhilipp Reisner } 485b411b363SPhilipp Reisner 486b30ab791SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_device *device, 487d4da1537SAndreas Gruenbacher struct list_head *head) 488b411b363SPhilipp Reisner { 489b411b363SPhilipp Reisner DEFINE_WAIT(wait); 490b411b363SPhilipp Reisner 491b411b363SPhilipp Reisner /* avoids spin_lock/unlock 492b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 493b411b363SPhilipp Reisner while (!list_empty(head)) { 494b30ab791SAndreas Gruenbacher prepare_to_wait(&device->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 4950500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4967eaceaccSJens Axboe io_schedule(); 497b30ab791SAndreas Gruenbacher finish_wait(&device->ee_wait, &wait); 4980500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 499b411b363SPhilipp Reisner } 500b411b363SPhilipp Reisner } 501b411b363SPhilipp Reisner 502b30ab791SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_device *device, 503d4da1537SAndreas Gruenbacher struct list_head *head) 504b411b363SPhilipp Reisner { 5050500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 506b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, head); 5070500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 508b411b363SPhilipp Reisner } 509b411b363SPhilipp Reisner 510dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 511b411b363SPhilipp Reisner { 512b411b363SPhilipp Reisner struct kvec iov = { 513b411b363SPhilipp Reisner .iov_base = buf, 514b411b363SPhilipp Reisner .iov_len = size, 515b411b363SPhilipp Reisner }; 516b411b363SPhilipp Reisner struct msghdr msg = { 517b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 518b411b363SPhilipp Reisner }; 519f7765c36SAl Viro iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, &iov, 1, size); 520f7765c36SAl Viro return sock_recvmsg(sock, &msg, msg.msg_flags); 521b411b363SPhilipp Reisner } 522b411b363SPhilipp Reisner 523bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 524b411b363SPhilipp Reisner { 525b411b363SPhilipp Reisner int rv; 526b411b363SPhilipp Reisner 527bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 528b411b363SPhilipp Reisner 529b411b363SPhilipp Reisner if (rv < 0) { 530b411b363SPhilipp Reisner if (rv == -ECONNRESET) 5311ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 532b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 5331ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 534b411b363SPhilipp Reisner } else if (rv == 0) { 535bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 536b66623e3SPhilipp Reisner long t; 537b66623e3SPhilipp Reisner rcu_read_lock(); 538bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 539b66623e3SPhilipp Reisner rcu_read_unlock(); 540b66623e3SPhilipp Reisner 541bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 542b66623e3SPhilipp Reisner 543599377acSPhilipp Reisner if (t) 544599377acSPhilipp Reisner goto out; 545599377acSPhilipp Reisner } 5461ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 547599377acSPhilipp Reisner } 548599377acSPhilipp Reisner 549b411b363SPhilipp Reisner if (rv != size) 550bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 551b411b363SPhilipp Reisner 552599377acSPhilipp Reisner out: 553b411b363SPhilipp Reisner return rv; 554b411b363SPhilipp Reisner } 555b411b363SPhilipp Reisner 556bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 557c6967746SAndreas Gruenbacher { 558c6967746SAndreas Gruenbacher int err; 559c6967746SAndreas Gruenbacher 560bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 561c6967746SAndreas Gruenbacher if (err != size) { 562c6967746SAndreas Gruenbacher if (err >= 0) 563c6967746SAndreas Gruenbacher err = -EIO; 564c6967746SAndreas Gruenbacher } else 565c6967746SAndreas Gruenbacher err = 0; 566c6967746SAndreas Gruenbacher return err; 567c6967746SAndreas Gruenbacher } 568c6967746SAndreas Gruenbacher 569bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 570a5c31904SAndreas Gruenbacher { 571a5c31904SAndreas Gruenbacher int err; 572a5c31904SAndreas Gruenbacher 573bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 574a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5751ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 576a5c31904SAndreas Gruenbacher return err; 577a5c31904SAndreas Gruenbacher } 578a5c31904SAndreas Gruenbacher 5795dbf1673SLars Ellenberg /* quoting tcp(7): 5805dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5815dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5825dbf1673SLars Ellenberg * This is our wrapper to do so. 5835dbf1673SLars Ellenberg */ 5845dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5855dbf1673SLars Ellenberg unsigned int rcv) 5865dbf1673SLars Ellenberg { 5875dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5885dbf1673SLars Ellenberg if (snd) { 5895dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5905dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5915dbf1673SLars Ellenberg } 5925dbf1673SLars Ellenberg if (rcv) { 5935dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5945dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5955dbf1673SLars Ellenberg } 5965dbf1673SLars Ellenberg } 5975dbf1673SLars Ellenberg 598bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 599b411b363SPhilipp Reisner { 600b411b363SPhilipp Reisner const char *what; 601b411b363SPhilipp Reisner struct socket *sock; 602b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 60344ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 60444ed167dSPhilipp Reisner struct net_conf *nc; 60544ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 60669ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 607b411b363SPhilipp Reisner int disconnect_on_error = 1; 608b411b363SPhilipp Reisner 60944ed167dSPhilipp Reisner rcu_read_lock(); 610bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 61144ed167dSPhilipp Reisner if (!nc) { 61244ed167dSPhilipp Reisner rcu_read_unlock(); 613b411b363SPhilipp Reisner return NULL; 61444ed167dSPhilipp Reisner } 61544ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 61644ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 61769ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 618089c075dSAndreas Gruenbacher rcu_read_unlock(); 61944ed167dSPhilipp Reisner 620bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 621bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 62244ed167dSPhilipp Reisner 623bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 62444ed167dSPhilipp Reisner src_in6.sin6_port = 0; 62544ed167dSPhilipp Reisner else 62644ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 62744ed167dSPhilipp Reisner 628bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 629bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 630b411b363SPhilipp Reisner 631b411b363SPhilipp Reisner what = "sock_create_kern"; 632eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&src_in6)->sa_family, 633b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 634b411b363SPhilipp Reisner if (err < 0) { 635b411b363SPhilipp Reisner sock = NULL; 636b411b363SPhilipp Reisner goto out; 637b411b363SPhilipp Reisner } 638b411b363SPhilipp Reisner 639b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 64069ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 64144ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 642b411b363SPhilipp Reisner 643b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 644b411b363SPhilipp Reisner * for the outgoing connections. 645b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 646b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 647b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 648b411b363SPhilipp Reisner * a free one dynamically. 649b411b363SPhilipp Reisner */ 650b411b363SPhilipp Reisner what = "bind before connect"; 65144ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 652b411b363SPhilipp Reisner if (err < 0) 653b411b363SPhilipp Reisner goto out; 654b411b363SPhilipp Reisner 655b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 656b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 657b411b363SPhilipp Reisner disconnect_on_error = 0; 658b411b363SPhilipp Reisner what = "connect"; 65944ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 660b411b363SPhilipp Reisner 661b411b363SPhilipp Reisner out: 662b411b363SPhilipp Reisner if (err < 0) { 663b411b363SPhilipp Reisner if (sock) { 664b411b363SPhilipp Reisner sock_release(sock); 665b411b363SPhilipp Reisner sock = NULL; 666b411b363SPhilipp Reisner } 667b411b363SPhilipp Reisner switch (-err) { 668b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 669b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 670b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 671b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 672b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 673b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 674b411b363SPhilipp Reisner disconnect_on_error = 0; 675b411b363SPhilipp Reisner break; 676b411b363SPhilipp Reisner default: 6771ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 678b411b363SPhilipp Reisner } 679b411b363SPhilipp Reisner if (disconnect_on_error) 680bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 681b411b363SPhilipp Reisner } 68244ed167dSPhilipp Reisner 683b411b363SPhilipp Reisner return sock; 684b411b363SPhilipp Reisner } 685b411b363SPhilipp Reisner 6867a426fd8SPhilipp Reisner struct accept_wait_data { 687bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6887a426fd8SPhilipp Reisner struct socket *s_listen; 6897a426fd8SPhilipp Reisner struct completion door_bell; 6907a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6917a426fd8SPhilipp Reisner 6927a426fd8SPhilipp Reisner }; 6937a426fd8SPhilipp Reisner 694715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 695b411b363SPhilipp Reisner { 6967a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 697715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6987a426fd8SPhilipp Reisner 699715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 700715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 7017a426fd8SPhilipp Reisner complete(&ad->door_bell); 702715306f6SAndreas Gruenbacher state_change(sk); 7037a426fd8SPhilipp Reisner } 7047a426fd8SPhilipp Reisner 705bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 706b411b363SPhilipp Reisner { 7071f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 70844ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 7091f3e509bSPhilipp Reisner struct socket *s_listen; 71044ed167dSPhilipp Reisner struct net_conf *nc; 711b411b363SPhilipp Reisner const char *what; 712b411b363SPhilipp Reisner 71344ed167dSPhilipp Reisner rcu_read_lock(); 714bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 71544ed167dSPhilipp Reisner if (!nc) { 71644ed167dSPhilipp Reisner rcu_read_unlock(); 7177a426fd8SPhilipp Reisner return -EIO; 71844ed167dSPhilipp Reisner } 71944ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 72044ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 72144ed167dSPhilipp Reisner rcu_read_unlock(); 722b411b363SPhilipp Reisner 723bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 724bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 725b411b363SPhilipp Reisner 726b411b363SPhilipp Reisner what = "sock_create_kern"; 727eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&my_addr)->sa_family, 728b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 729b411b363SPhilipp Reisner if (err) { 730b411b363SPhilipp Reisner s_listen = NULL; 731b411b363SPhilipp Reisner goto out; 732b411b363SPhilipp Reisner } 733b411b363SPhilipp Reisner 7344a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 73544ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 736b411b363SPhilipp Reisner 737b411b363SPhilipp Reisner what = "bind before listen"; 73844ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 739b411b363SPhilipp Reisner if (err < 0) 740b411b363SPhilipp Reisner goto out; 741b411b363SPhilipp Reisner 7427a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7437a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7447a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 745715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7467a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7477a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 748b411b363SPhilipp Reisner 7492820fd39SPhilipp Reisner what = "listen"; 7502820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7512820fd39SPhilipp Reisner if (err < 0) 7522820fd39SPhilipp Reisner goto out; 7532820fd39SPhilipp Reisner 7547a426fd8SPhilipp Reisner return 0; 755b411b363SPhilipp Reisner out: 756b411b363SPhilipp Reisner if (s_listen) 757b411b363SPhilipp Reisner sock_release(s_listen); 758b411b363SPhilipp Reisner if (err < 0) { 759b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7601ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 761bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 762b411b363SPhilipp Reisner } 763b411b363SPhilipp Reisner } 7641f3e509bSPhilipp Reisner 7657a426fd8SPhilipp Reisner return -EIO; 7661f3e509bSPhilipp Reisner } 7671f3e509bSPhilipp Reisner 768715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 769715306f6SAndreas Gruenbacher { 770715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 771715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 772715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 773715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 774715306f6SAndreas Gruenbacher } 775715306f6SAndreas Gruenbacher 776bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7771f3e509bSPhilipp Reisner { 7781f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7791f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7801f3e509bSPhilipp Reisner struct net_conf *nc; 7811f3e509bSPhilipp Reisner 7821f3e509bSPhilipp Reisner rcu_read_lock(); 783bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7841f3e509bSPhilipp Reisner if (!nc) { 7851f3e509bSPhilipp Reisner rcu_read_unlock(); 7861f3e509bSPhilipp Reisner return NULL; 7871f3e509bSPhilipp Reisner } 7881f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7891f3e509bSPhilipp Reisner rcu_read_unlock(); 7901f3e509bSPhilipp Reisner 7911f3e509bSPhilipp Reisner timeo = connect_int * HZ; 79238b682b2SAkinobu Mita /* 28.5% random jitter */ 79338b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7941f3e509bSPhilipp Reisner 7957a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7967a426fd8SPhilipp Reisner if (err <= 0) 7977a426fd8SPhilipp Reisner return NULL; 7981f3e509bSPhilipp Reisner 7997a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 800b411b363SPhilipp Reisner if (err < 0) { 801b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 8021ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 803bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 804b411b363SPhilipp Reisner } 805b411b363SPhilipp Reisner } 806b411b363SPhilipp Reisner 807715306f6SAndreas Gruenbacher if (s_estab) 808715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 809b411b363SPhilipp Reisner 810b411b363SPhilipp Reisner return s_estab; 811b411b363SPhilipp Reisner } 812b411b363SPhilipp Reisner 813bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 814b411b363SPhilipp Reisner 815bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 8169f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 8179f5bdc33SAndreas Gruenbacher { 818bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 8199f5bdc33SAndreas Gruenbacher return -EIO; 820bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 821b411b363SPhilipp Reisner } 822b411b363SPhilipp Reisner 823bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 824b411b363SPhilipp Reisner { 825bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 8269f5bdc33SAndreas Gruenbacher struct packet_info pi; 8274920e37aSPhilipp Reisner struct net_conf *nc; 8289f5bdc33SAndreas Gruenbacher int err; 829b411b363SPhilipp Reisner 8304920e37aSPhilipp Reisner rcu_read_lock(); 8314920e37aSPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8324920e37aSPhilipp Reisner if (!nc) { 8334920e37aSPhilipp Reisner rcu_read_unlock(); 8344920e37aSPhilipp Reisner return -EIO; 8354920e37aSPhilipp Reisner } 8364920e37aSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo * 4 * HZ / 10; 8374920e37aSPhilipp Reisner rcu_read_unlock(); 8384920e37aSPhilipp Reisner 839bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 8409f5bdc33SAndreas Gruenbacher if (err != header_size) { 8419f5bdc33SAndreas Gruenbacher if (err >= 0) 8429f5bdc33SAndreas Gruenbacher err = -EIO; 8439f5bdc33SAndreas Gruenbacher return err; 8449f5bdc33SAndreas Gruenbacher } 845bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8469f5bdc33SAndreas Gruenbacher if (err) 8479f5bdc33SAndreas Gruenbacher return err; 8489f5bdc33SAndreas Gruenbacher return pi.cmd; 849b411b363SPhilipp Reisner } 850b411b363SPhilipp Reisner 851b411b363SPhilipp Reisner /** 852b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 853b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 854b411b363SPhilipp Reisner */ 8555d0b17f1SPhilipp Reisner static bool drbd_socket_okay(struct socket **sock) 856b411b363SPhilipp Reisner { 857b411b363SPhilipp Reisner int rr; 858b411b363SPhilipp Reisner char tb[4]; 859b411b363SPhilipp Reisner 860b411b363SPhilipp Reisner if (!*sock) 86181e84650SAndreas Gruenbacher return false; 862b411b363SPhilipp Reisner 863dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 864b411b363SPhilipp Reisner 865b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 86681e84650SAndreas Gruenbacher return true; 867b411b363SPhilipp Reisner } else { 868b411b363SPhilipp Reisner sock_release(*sock); 869b411b363SPhilipp Reisner *sock = NULL; 87081e84650SAndreas Gruenbacher return false; 871b411b363SPhilipp Reisner } 872b411b363SPhilipp Reisner } 8735d0b17f1SPhilipp Reisner 8745d0b17f1SPhilipp Reisner static bool connection_established(struct drbd_connection *connection, 8755d0b17f1SPhilipp Reisner struct socket **sock1, 8765d0b17f1SPhilipp Reisner struct socket **sock2) 8775d0b17f1SPhilipp Reisner { 8785d0b17f1SPhilipp Reisner struct net_conf *nc; 8795d0b17f1SPhilipp Reisner int timeout; 8805d0b17f1SPhilipp Reisner bool ok; 8815d0b17f1SPhilipp Reisner 8825d0b17f1SPhilipp Reisner if (!*sock1 || !*sock2) 8835d0b17f1SPhilipp Reisner return false; 8845d0b17f1SPhilipp Reisner 8855d0b17f1SPhilipp Reisner rcu_read_lock(); 8865d0b17f1SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8875d0b17f1SPhilipp Reisner timeout = (nc->sock_check_timeo ?: nc->ping_timeo) * HZ / 10; 8885d0b17f1SPhilipp Reisner rcu_read_unlock(); 8895d0b17f1SPhilipp Reisner schedule_timeout_interruptible(timeout); 8905d0b17f1SPhilipp Reisner 8915d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock1); 8925d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock2) && ok; 8935d0b17f1SPhilipp Reisner 8945d0b17f1SPhilipp Reisner return ok; 8955d0b17f1SPhilipp Reisner } 8965d0b17f1SPhilipp Reisner 8972325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8982325eb66SPhilipp Reisner in a connection */ 89969a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 900907599e0SPhilipp Reisner { 90169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 9020829f5edSAndreas Gruenbacher int err; 903907599e0SPhilipp Reisner 904b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 905b30ab791SAndreas Gruenbacher device->peer_seq = 0; 906907599e0SPhilipp Reisner 90769a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 90869a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 909b30ab791SAndreas Gruenbacher &device->own_state_mutex; 9108410da8fSPhilipp Reisner 91169a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 9120829f5edSAndreas Gruenbacher if (!err) 91369a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 9140829f5edSAndreas Gruenbacher if (!err) 91569a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 9160829f5edSAndreas Gruenbacher if (!err) 91769a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 918b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 919b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 920b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 921b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 9220829f5edSAndreas Gruenbacher return err; 923907599e0SPhilipp Reisner } 924b411b363SPhilipp Reisner 925b411b363SPhilipp Reisner /* 926b411b363SPhilipp Reisner * return values: 927b411b363SPhilipp Reisner * 1 yes, we have a valid connection 928b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 929b411b363SPhilipp Reisner * -1 peer talks different language, 930b411b363SPhilipp Reisner * no point in trying again, please go standalone. 931b411b363SPhilipp Reisner * -2 We do not have a network config... 932b411b363SPhilipp Reisner */ 933bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 934b411b363SPhilipp Reisner { 9357da35862SPhilipp Reisner struct drbd_socket sock, msock; 936c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 93744ed167dSPhilipp Reisner struct net_conf *nc; 9385d0b17f1SPhilipp Reisner int vnr, timeout, h; 9395d0b17f1SPhilipp Reisner bool discard_my_data, ok; 940197296ffSPhilipp Reisner enum drbd_state_rv rv; 9417a426fd8SPhilipp Reisner struct accept_wait_data ad = { 942bde89a9eSAndreas Gruenbacher .connection = connection, 9437a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 9447a426fd8SPhilipp Reisner }; 945b411b363SPhilipp Reisner 946bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 947bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 948b411b363SPhilipp Reisner return -2; 949b411b363SPhilipp Reisner 9507da35862SPhilipp Reisner mutex_init(&sock.mutex); 951bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 952bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 9537da35862SPhilipp Reisner sock.socket = NULL; 9547da35862SPhilipp Reisner mutex_init(&msock.mutex); 955bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 956bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 9577da35862SPhilipp Reisner msock.socket = NULL; 9587da35862SPhilipp Reisner 9590916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 960bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 961b411b363SPhilipp Reisner 962bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 9637a426fd8SPhilipp Reisner return 0; 964b411b363SPhilipp Reisner 965b411b363SPhilipp Reisner do { 9662bf89621SAndreas Gruenbacher struct socket *s; 967b411b363SPhilipp Reisner 968bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 969b411b363SPhilipp Reisner if (s) { 9707da35862SPhilipp Reisner if (!sock.socket) { 9717da35862SPhilipp Reisner sock.socket = s; 972bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9737da35862SPhilipp Reisner } else if (!msock.socket) { 974bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9757da35862SPhilipp Reisner msock.socket = s; 976bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 977b411b363SPhilipp Reisner } else { 9781ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 979b411b363SPhilipp Reisner goto out_release_sockets; 980b411b363SPhilipp Reisner } 981b411b363SPhilipp Reisner } 982b411b363SPhilipp Reisner 9835d0b17f1SPhilipp Reisner if (connection_established(connection, &sock.socket, &msock.socket)) 984b411b363SPhilipp Reisner break; 985b411b363SPhilipp Reisner 986b411b363SPhilipp Reisner retry: 987bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 988b411b363SPhilipp Reisner if (s) { 989bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9907da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9917da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 99292f14951SPhilipp Reisner switch (fp) { 993e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9947da35862SPhilipp Reisner if (sock.socket) { 9951ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9967da35862SPhilipp Reisner sock_release(sock.socket); 99780c6eed4SPhilipp Reisner sock.socket = s; 99880c6eed4SPhilipp Reisner goto randomize; 999b411b363SPhilipp Reisner } 10007da35862SPhilipp Reisner sock.socket = s; 1001b411b363SPhilipp Reisner break; 1002e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 1003bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 10047da35862SPhilipp Reisner if (msock.socket) { 10051ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 10067da35862SPhilipp Reisner sock_release(msock.socket); 100780c6eed4SPhilipp Reisner msock.socket = s; 100880c6eed4SPhilipp Reisner goto randomize; 1009b411b363SPhilipp Reisner } 10107da35862SPhilipp Reisner msock.socket = s; 1011b411b363SPhilipp Reisner break; 1012b411b363SPhilipp Reisner default: 10131ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 1014b411b363SPhilipp Reisner sock_release(s); 101580c6eed4SPhilipp Reisner randomize: 101638b682b2SAkinobu Mita if (prandom_u32() & 1) 1017b411b363SPhilipp Reisner goto retry; 1018b411b363SPhilipp Reisner } 1019b411b363SPhilipp Reisner } 1020b411b363SPhilipp Reisner 1021bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 1022b411b363SPhilipp Reisner goto out_release_sockets; 1023b411b363SPhilipp Reisner if (signal_pending(current)) { 1024b411b363SPhilipp Reisner flush_signals(current); 1025b411b363SPhilipp Reisner smp_rmb(); 1026bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 1027b411b363SPhilipp Reisner goto out_release_sockets; 1028b411b363SPhilipp Reisner } 1029b411b363SPhilipp Reisner 10305d0b17f1SPhilipp Reisner ok = connection_established(connection, &sock.socket, &msock.socket); 1031b666dbf8SPhilipp Reisner } while (!ok); 1032b411b363SPhilipp Reisner 10337a426fd8SPhilipp Reisner if (ad.s_listen) 10347a426fd8SPhilipp Reisner sock_release(ad.s_listen); 1035b411b363SPhilipp Reisner 103698683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 103798683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 1038b411b363SPhilipp Reisner 10397da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 10407da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 1041b411b363SPhilipp Reisner 10427da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 10437da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 1044b411b363SPhilipp Reisner 1045b411b363SPhilipp Reisner /* NOT YET ... 1046bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 10477da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10486038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1049b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 105044ed167dSPhilipp Reisner rcu_read_lock(); 1051bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 1052b411b363SPhilipp Reisner 10537da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10547da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 105544ed167dSPhilipp Reisner 10567da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 105744ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 105808b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 105944ed167dSPhilipp Reisner rcu_read_unlock(); 106044ed167dSPhilipp Reisner 10617da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1062b411b363SPhilipp Reisner 1063b411b363SPhilipp Reisner /* we don't want delays. 106425985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10657da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10667da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1067b411b363SPhilipp Reisner 1068bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1069bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1070bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1071b411b363SPhilipp Reisner 1072bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1073b411b363SPhilipp Reisner if (h <= 0) 1074b411b363SPhilipp Reisner return h; 1075b411b363SPhilipp Reisner 1076bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1077b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1078bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1079b10d96cbSJohannes Thoma case -1: 10801ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1081b411b363SPhilipp Reisner return -1; 1082b10d96cbSJohannes Thoma case 0: 10831ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1084b10d96cbSJohannes Thoma return 0; 1085b411b363SPhilipp Reisner } 1086b411b363SPhilipp Reisner } 1087b411b363SPhilipp Reisner 1088bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1089bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1090b411b363SPhilipp Reisner 1091bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10927e2455c1SPhilipp Reisner return -1; 10931e86ac48SPhilipp Reisner 109413c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 109513c76abaSPhilipp Reisner * being promoted to Primary. 109613c76abaSPhilipp Reisner * 109713c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 109813c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 109913c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 110013c76abaSPhilipp Reisner */ 110131007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 110231007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 110331007745SPhilipp Reisner 1104cde81d99SLars Ellenberg /* avoid a race with conn_request_state( C_DISCONNECTING ) */ 1105cde81d99SLars Ellenberg spin_lock_irq(&connection->resource->req_lock); 110631007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 1107cde81d99SLars Ellenberg spin_unlock_irq(&connection->resource->req_lock); 110831007745SPhilipp Reisner 110931007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 111031007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 111131007745SPhilipp Reisner 111231007745SPhilipp Reisner rcu_read_lock(); 111331007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 111431007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 111531007745SPhilipp Reisner kref_get(&device->kref); 111631007745SPhilipp Reisner rcu_read_unlock(); 111713c76abaSPhilipp Reisner 111808b165baSPhilipp Reisner if (discard_my_data) 1119b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 112008b165baSPhilipp Reisner else 1121b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 112208b165baSPhilipp Reisner 112369a22773SAndreas Gruenbacher drbd_connected(peer_device); 112405a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1125c141ebdaSPhilipp Reisner rcu_read_lock(); 1126c141ebdaSPhilipp Reisner } 1127c141ebdaSPhilipp Reisner rcu_read_unlock(); 1128c141ebdaSPhilipp Reisner 1129bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1130bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1131bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 11321e86ac48SPhilipp Reisner return 0; 1133a1096a6eSPhilipp Reisner } 11341e86ac48SPhilipp Reisner 11351c03e520SPhilipp Reisner drbd_thread_start(&connection->ack_receiver); 113639e91a60SLars Ellenberg /* opencoded create_singlethread_workqueue(), 113739e91a60SLars Ellenberg * to be able to use format string arguments */ 113839e91a60SLars Ellenberg connection->ack_sender = 113939e91a60SLars Ellenberg alloc_ordered_workqueue("drbd_as_%s", WQ_MEM_RECLAIM, connection->resource->name); 1140668700b4SPhilipp Reisner if (!connection->ack_sender) { 1141668700b4SPhilipp Reisner drbd_err(connection, "Failed to create workqueue ack_sender\n"); 1142668700b4SPhilipp Reisner return 0; 1143668700b4SPhilipp Reisner } 1144b411b363SPhilipp Reisner 11450500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 114608b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 114708b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 114808b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 114908b165baSPhilipp Reisner * just to clear a single value. */ 1150bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 11510500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 115208b165baSPhilipp Reisner 1153d3fcb490SPhilipp Reisner return h; 1154b411b363SPhilipp Reisner 1155b411b363SPhilipp Reisner out_release_sockets: 11567a426fd8SPhilipp Reisner if (ad.s_listen) 11577a426fd8SPhilipp Reisner sock_release(ad.s_listen); 11587da35862SPhilipp Reisner if (sock.socket) 11597da35862SPhilipp Reisner sock_release(sock.socket); 11607da35862SPhilipp Reisner if (msock.socket) 11617da35862SPhilipp Reisner sock_release(msock.socket); 1162b411b363SPhilipp Reisner return -1; 1163b411b363SPhilipp Reisner } 1164b411b363SPhilipp Reisner 1165bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1166b411b363SPhilipp Reisner { 1167bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1168b411b363SPhilipp Reisner 11690c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11700c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11710c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11720c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11731ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11740c8e36d9SAndreas Gruenbacher return -EINVAL; 117502918be2SPhilipp Reisner } 11760c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11770c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11780c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11790c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1180e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1181e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1182e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1183b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1184eefc2f7dSPhilipp Reisner pi->vnr = 0; 1185e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1186e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1187e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1188e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1189e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 119077351055SPhilipp Reisner pi->vnr = 0; 119102918be2SPhilipp Reisner } else { 11921ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1193e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1194bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11958172f3e9SAndreas Gruenbacher return -EINVAL; 1196b411b363SPhilipp Reisner } 1197e658983aSAndreas Gruenbacher pi->data = header + header_size; 11988172f3e9SAndreas Gruenbacher return 0; 1199b411b363SPhilipp Reisner } 1200b411b363SPhilipp Reisner 1201c51a0ef3SLars Ellenberg static void drbd_unplug_all_devices(struct drbd_connection *connection) 1202c51a0ef3SLars Ellenberg { 1203c51a0ef3SLars Ellenberg if (current->plug == &connection->receiver_plug) { 1204c51a0ef3SLars Ellenberg blk_finish_plug(&connection->receiver_plug); 1205c51a0ef3SLars Ellenberg blk_start_plug(&connection->receiver_plug); 1206c51a0ef3SLars Ellenberg } /* else: maybe just schedule() ?? */ 1207c51a0ef3SLars Ellenberg } 1208c51a0ef3SLars Ellenberg 1209bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1210257d0af6SPhilipp Reisner { 1211bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 121269bc7bc3SAndreas Gruenbacher int err; 1213257d0af6SPhilipp Reisner 1214bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1215a5c31904SAndreas Gruenbacher if (err) 121669bc7bc3SAndreas Gruenbacher return err; 1217257d0af6SPhilipp Reisner 1218bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1219bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1220b411b363SPhilipp Reisner 122169bc7bc3SAndreas Gruenbacher return err; 1222b411b363SPhilipp Reisner } 1223b411b363SPhilipp Reisner 1224c51a0ef3SLars Ellenberg static int drbd_recv_header_maybe_unplug(struct drbd_connection *connection, struct packet_info *pi) 1225c51a0ef3SLars Ellenberg { 1226c51a0ef3SLars Ellenberg void *buffer = connection->data.rbuf; 1227c51a0ef3SLars Ellenberg unsigned int size = drbd_header_size(connection); 1228c51a0ef3SLars Ellenberg int err; 1229c51a0ef3SLars Ellenberg 1230c51a0ef3SLars Ellenberg err = drbd_recv_short(connection->data.socket, buffer, size, MSG_NOSIGNAL|MSG_DONTWAIT); 1231c51a0ef3SLars Ellenberg if (err != size) { 1232c51a0ef3SLars Ellenberg /* If we have nothing in the receive buffer now, to reduce 1233c51a0ef3SLars Ellenberg * application latency, try to drain the backend queues as 1234c51a0ef3SLars Ellenberg * quickly as possible, and let remote TCP know what we have 1235c51a0ef3SLars Ellenberg * received so far. */ 1236c51a0ef3SLars Ellenberg if (err == -EAGAIN) { 1237c51a0ef3SLars Ellenberg drbd_tcp_quickack(connection->data.socket); 1238c51a0ef3SLars Ellenberg drbd_unplug_all_devices(connection); 1239c51a0ef3SLars Ellenberg } 1240c51a0ef3SLars Ellenberg if (err > 0) { 1241c51a0ef3SLars Ellenberg buffer += err; 1242c51a0ef3SLars Ellenberg size -= err; 1243c51a0ef3SLars Ellenberg } 1244c51a0ef3SLars Ellenberg err = drbd_recv_all_warn(connection, buffer, size); 1245c51a0ef3SLars Ellenberg if (err) 1246c51a0ef3SLars Ellenberg return err; 1247c51a0ef3SLars Ellenberg } 1248c51a0ef3SLars Ellenberg 1249c51a0ef3SLars Ellenberg err = decode_header(connection, connection->data.rbuf, pi); 1250c51a0ef3SLars Ellenberg connection->last_received = jiffies; 1251c51a0ef3SLars Ellenberg 1252c51a0ef3SLars Ellenberg return err; 1253c51a0ef3SLars Ellenberg } 1254f9ff0da5SLars Ellenberg /* This is blkdev_issue_flush, but asynchronous. 1255f9ff0da5SLars Ellenberg * We want to submit to all component volumes in parallel, 1256f9ff0da5SLars Ellenberg * then wait for all completions. 1257f9ff0da5SLars Ellenberg */ 1258f9ff0da5SLars Ellenberg struct issue_flush_context { 1259f9ff0da5SLars Ellenberg atomic_t pending; 1260f9ff0da5SLars Ellenberg int error; 1261f9ff0da5SLars Ellenberg struct completion done; 1262f9ff0da5SLars Ellenberg }; 1263f9ff0da5SLars Ellenberg struct one_flush_context { 1264f9ff0da5SLars Ellenberg struct drbd_device *device; 1265f9ff0da5SLars Ellenberg struct issue_flush_context *ctx; 1266f9ff0da5SLars Ellenberg }; 1267f9ff0da5SLars Ellenberg 12681ffa7bfaSBaoyou Xie static void one_flush_endio(struct bio *bio) 1269f9ff0da5SLars Ellenberg { 1270f9ff0da5SLars Ellenberg struct one_flush_context *octx = bio->bi_private; 1271f9ff0da5SLars Ellenberg struct drbd_device *device = octx->device; 1272f9ff0da5SLars Ellenberg struct issue_flush_context *ctx = octx->ctx; 1273f9ff0da5SLars Ellenberg 12744e4cbee9SChristoph Hellwig if (bio->bi_status) { 12754e4cbee9SChristoph Hellwig ctx->error = blk_status_to_errno(bio->bi_status); 12764e4cbee9SChristoph Hellwig drbd_info(device, "local disk FLUSH FAILED with status %d\n", bio->bi_status); 1277f9ff0da5SLars Ellenberg } 1278f9ff0da5SLars Ellenberg kfree(octx); 1279f9ff0da5SLars Ellenberg bio_put(bio); 1280f9ff0da5SLars Ellenberg 1281f9ff0da5SLars Ellenberg clear_bit(FLUSH_PENDING, &device->flags); 1282f9ff0da5SLars Ellenberg put_ldev(device); 1283f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1284f9ff0da5SLars Ellenberg 1285f9ff0da5SLars Ellenberg if (atomic_dec_and_test(&ctx->pending)) 1286f9ff0da5SLars Ellenberg complete(&ctx->done); 1287f9ff0da5SLars Ellenberg } 1288f9ff0da5SLars Ellenberg 1289f9ff0da5SLars Ellenberg static void submit_one_flush(struct drbd_device *device, struct issue_flush_context *ctx) 1290f9ff0da5SLars Ellenberg { 1291f9ff0da5SLars Ellenberg struct bio *bio = bio_alloc(GFP_NOIO, 0); 1292f9ff0da5SLars Ellenberg struct one_flush_context *octx = kmalloc(sizeof(*octx), GFP_NOIO); 1293f9ff0da5SLars Ellenberg if (!bio || !octx) { 1294f9ff0da5SLars Ellenberg drbd_warn(device, "Could not allocate a bio, CANNOT ISSUE FLUSH\n"); 1295f9ff0da5SLars Ellenberg /* FIXME: what else can I do now? disconnecting or detaching 1296f9ff0da5SLars Ellenberg * really does not help to improve the state of the world, either. 1297f9ff0da5SLars Ellenberg */ 1298f9ff0da5SLars Ellenberg kfree(octx); 1299f9ff0da5SLars Ellenberg if (bio) 1300f9ff0da5SLars Ellenberg bio_put(bio); 1301f9ff0da5SLars Ellenberg 1302f9ff0da5SLars Ellenberg ctx->error = -ENOMEM; 1303f9ff0da5SLars Ellenberg put_ldev(device); 1304f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1305f9ff0da5SLars Ellenberg return; 1306f9ff0da5SLars Ellenberg } 1307f9ff0da5SLars Ellenberg 1308f9ff0da5SLars Ellenberg octx->device = device; 1309f9ff0da5SLars Ellenberg octx->ctx = ctx; 131074d46992SChristoph Hellwig bio_set_dev(bio, device->ldev->backing_bdev); 1311f9ff0da5SLars Ellenberg bio->bi_private = octx; 1312f9ff0da5SLars Ellenberg bio->bi_end_io = one_flush_endio; 131370fd7614SChristoph Hellwig bio->bi_opf = REQ_OP_FLUSH | REQ_PREFLUSH; 1314f9ff0da5SLars Ellenberg 1315f9ff0da5SLars Ellenberg device->flush_jif = jiffies; 1316f9ff0da5SLars Ellenberg set_bit(FLUSH_PENDING, &device->flags); 1317f9ff0da5SLars Ellenberg atomic_inc(&ctx->pending); 1318f9ff0da5SLars Ellenberg submit_bio(bio); 1319f9ff0da5SLars Ellenberg } 1320f9ff0da5SLars Ellenberg 1321bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1322b411b363SPhilipp Reisner { 1323f9ff0da5SLars Ellenberg if (connection->resource->write_ordering >= WO_BDEV_FLUSH) { 1324c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1325f9ff0da5SLars Ellenberg struct issue_flush_context ctx; 13264b0007c0SPhilipp Reisner int vnr; 1327b411b363SPhilipp Reisner 1328f9ff0da5SLars Ellenberg atomic_set(&ctx.pending, 1); 1329f9ff0da5SLars Ellenberg ctx.error = 0; 1330f9ff0da5SLars Ellenberg init_completion(&ctx.done); 1331f9ff0da5SLars Ellenberg 1332615e087fSLars Ellenberg rcu_read_lock(); 1333c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1334c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1335c06ece6bSAndreas Gruenbacher 1336b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1337615e087fSLars Ellenberg continue; 1338b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1339615e087fSLars Ellenberg rcu_read_unlock(); 13404b0007c0SPhilipp Reisner 1341f9ff0da5SLars Ellenberg submit_one_flush(device, &ctx); 1342f9ff0da5SLars Ellenberg 1343f9ff0da5SLars Ellenberg rcu_read_lock(); 1344f9ff0da5SLars Ellenberg } 1345f9ff0da5SLars Ellenberg rcu_read_unlock(); 1346f9ff0da5SLars Ellenberg 1347f9ff0da5SLars Ellenberg /* Do we want to add a timeout, 1348f9ff0da5SLars Ellenberg * if disk-timeout is set? */ 1349f9ff0da5SLars Ellenberg if (!atomic_dec_and_test(&ctx.pending)) 1350f9ff0da5SLars Ellenberg wait_for_completion(&ctx.done); 1351f9ff0da5SLars Ellenberg 1352f9ff0da5SLars Ellenberg if (ctx.error) { 1353b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1354b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1355b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1356f9ff0da5SLars Ellenberg /* Any error is already reported by bio_endio callback. */ 1357f6ba8636SAndreas Gruenbacher drbd_bump_write_ordering(connection->resource, NULL, WO_DRAIN_IO); 1358b411b363SPhilipp Reisner } 1359b411b363SPhilipp Reisner } 1360b411b363SPhilipp Reisner } 1361b411b363SPhilipp Reisner 1362b411b363SPhilipp Reisner /** 1363b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1364b30ab791SAndreas Gruenbacher * @device: DRBD device. 1365b411b363SPhilipp Reisner * @epoch: Epoch object. 1366b411b363SPhilipp Reisner * @ev: Epoch event. 1367b411b363SPhilipp Reisner */ 1368bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1369b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1370b411b363SPhilipp Reisner enum epoch_event ev) 1371b411b363SPhilipp Reisner { 13722451fc3bSPhilipp Reisner int epoch_size; 1373b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1374b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1375b411b363SPhilipp Reisner 1376bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1377b411b363SPhilipp Reisner do { 1378b411b363SPhilipp Reisner next_epoch = NULL; 1379b411b363SPhilipp Reisner 1380b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1381b411b363SPhilipp Reisner 1382b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1383b411b363SPhilipp Reisner case EV_PUT: 1384b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1385b411b363SPhilipp Reisner break; 1386b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1387b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1388b411b363SPhilipp Reisner break; 1389b411b363SPhilipp Reisner case EV_BECAME_LAST: 1390b411b363SPhilipp Reisner /* nothing to do*/ 1391b411b363SPhilipp Reisner break; 1392b411b363SPhilipp Reisner } 1393b411b363SPhilipp Reisner 1394b411b363SPhilipp Reisner if (epoch_size != 0 && 1395b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 139680f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1397b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1398bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1399bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1400bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1401b411b363SPhilipp Reisner } 14029ed57dcbSLars Ellenberg #if 0 14039ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 14049ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 140580f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1406bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 14079ed57dcbSLars Ellenberg #endif 1408b411b363SPhilipp Reisner 1409bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1410b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1411b411b363SPhilipp Reisner list_del(&epoch->list); 1412b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1413bde89a9eSAndreas Gruenbacher connection->epochs--; 1414b411b363SPhilipp Reisner kfree(epoch); 1415b411b363SPhilipp Reisner 1416b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1417b411b363SPhilipp Reisner rv = FE_DESTROYED; 1418b411b363SPhilipp Reisner } else { 1419b411b363SPhilipp Reisner epoch->flags = 0; 1420b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1421698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1422b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1423b411b363SPhilipp Reisner rv = FE_RECYCLED; 1424b411b363SPhilipp Reisner } 1425b411b363SPhilipp Reisner } 1426b411b363SPhilipp Reisner 1427b411b363SPhilipp Reisner if (!next_epoch) 1428b411b363SPhilipp Reisner break; 1429b411b363SPhilipp Reisner 1430b411b363SPhilipp Reisner epoch = next_epoch; 1431b411b363SPhilipp Reisner } while (1); 1432b411b363SPhilipp Reisner 1433bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1434b411b363SPhilipp Reisner 1435b411b363SPhilipp Reisner return rv; 1436b411b363SPhilipp Reisner } 1437b411b363SPhilipp Reisner 14388fe39aacSPhilipp Reisner static enum write_ordering_e 14398fe39aacSPhilipp Reisner max_allowed_wo(struct drbd_backing_dev *bdev, enum write_ordering_e wo) 14408fe39aacSPhilipp Reisner { 14418fe39aacSPhilipp Reisner struct disk_conf *dc; 14428fe39aacSPhilipp Reisner 14438fe39aacSPhilipp Reisner dc = rcu_dereference(bdev->disk_conf); 14448fe39aacSPhilipp Reisner 1445f6ba8636SAndreas Gruenbacher if (wo == WO_BDEV_FLUSH && !dc->disk_flushes) 1446f6ba8636SAndreas Gruenbacher wo = WO_DRAIN_IO; 1447f6ba8636SAndreas Gruenbacher if (wo == WO_DRAIN_IO && !dc->disk_drain) 1448f6ba8636SAndreas Gruenbacher wo = WO_NONE; 14498fe39aacSPhilipp Reisner 14508fe39aacSPhilipp Reisner return wo; 14518fe39aacSPhilipp Reisner } 14528fe39aacSPhilipp Reisner 1453b411b363SPhilipp Reisner /** 1454b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1455bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1456b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1457b411b363SPhilipp Reisner */ 14588fe39aacSPhilipp Reisner void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, 14598fe39aacSPhilipp Reisner enum write_ordering_e wo) 1460b411b363SPhilipp Reisner { 1461e9526580SPhilipp Reisner struct drbd_device *device; 1462b411b363SPhilipp Reisner enum write_ordering_e pwo; 14634b0007c0SPhilipp Reisner int vnr; 1464b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1465f6ba8636SAndreas Gruenbacher [WO_NONE] = "none", 1466f6ba8636SAndreas Gruenbacher [WO_DRAIN_IO] = "drain", 1467f6ba8636SAndreas Gruenbacher [WO_BDEV_FLUSH] = "flush", 1468b411b363SPhilipp Reisner }; 1469b411b363SPhilipp Reisner 1470e9526580SPhilipp Reisner pwo = resource->write_ordering; 1471f6ba8636SAndreas Gruenbacher if (wo != WO_BDEV_FLUSH) 1472b411b363SPhilipp Reisner wo = min(pwo, wo); 1473daeda1ccSPhilipp Reisner rcu_read_lock(); 1474e9526580SPhilipp Reisner idr_for_each_entry(&resource->devices, device, vnr) { 14758fe39aacSPhilipp Reisner if (get_ldev(device)) { 14768fe39aacSPhilipp Reisner wo = max_allowed_wo(device->ldev, wo); 14778fe39aacSPhilipp Reisner if (device->ldev == bdev) 14788fe39aacSPhilipp Reisner bdev = NULL; 1479b30ab791SAndreas Gruenbacher put_ldev(device); 14804b0007c0SPhilipp Reisner } 14818fe39aacSPhilipp Reisner } 14828fe39aacSPhilipp Reisner 14838fe39aacSPhilipp Reisner if (bdev) 14848fe39aacSPhilipp Reisner wo = max_allowed_wo(bdev, wo); 14858fe39aacSPhilipp Reisner 148670df7092SLars Ellenberg rcu_read_unlock(); 148770df7092SLars Ellenberg 1488e9526580SPhilipp Reisner resource->write_ordering = wo; 1489f6ba8636SAndreas Gruenbacher if (pwo != resource->write_ordering || wo == WO_BDEV_FLUSH) 1490e9526580SPhilipp Reisner drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]); 1491b411b363SPhilipp Reisner } 1492b411b363SPhilipp Reisner 14939104d31aSLars Ellenberg static void drbd_issue_peer_discard(struct drbd_device *device, struct drbd_peer_request *peer_req) 1494dd4f699dSLars Ellenberg { 14950dbed96aSChristoph Hellwig struct block_device *bdev = device->ldev->backing_bdev; 1496dd4f699dSLars Ellenberg 14970dbed96aSChristoph Hellwig if (blkdev_issue_zeroout(bdev, peer_req->i.sector, peer_req->i.size >> 9, 14980dbed96aSChristoph Hellwig GFP_NOIO, 0)) 1499dd4f699dSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 15000dbed96aSChristoph Hellwig 1501dd4f699dSLars Ellenberg drbd_endio_write_sec_final(peer_req); 1502dd4f699dSLars Ellenberg } 1503dd4f699dSLars Ellenberg 15049104d31aSLars Ellenberg static void drbd_issue_peer_wsame(struct drbd_device *device, 15059104d31aSLars Ellenberg struct drbd_peer_request *peer_req) 15069104d31aSLars Ellenberg { 15079104d31aSLars Ellenberg struct block_device *bdev = device->ldev->backing_bdev; 15089104d31aSLars Ellenberg sector_t s = peer_req->i.sector; 15099104d31aSLars Ellenberg sector_t nr = peer_req->i.size >> 9; 15109104d31aSLars Ellenberg if (blkdev_issue_write_same(bdev, s, nr, GFP_NOIO, peer_req->pages)) 15119104d31aSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 15129104d31aSLars Ellenberg drbd_endio_write_sec_final(peer_req); 15139104d31aSLars Ellenberg } 15149104d31aSLars Ellenberg 15159104d31aSLars Ellenberg 1516b411b363SPhilipp Reisner /** 1517fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1518b30ab791SAndreas Gruenbacher * @device: DRBD device. 1519db830c46SAndreas Gruenbacher * @peer_req: peer request 15201eff9d32SJens Axboe * @rw: flag field, see bio->bi_opf 152110f6d992SLars Ellenberg * 152210f6d992SLars Ellenberg * May spread the pages to multiple bios, 152310f6d992SLars Ellenberg * depending on bio_add_page restrictions. 152410f6d992SLars Ellenberg * 152510f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 152610f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 152710f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 152810f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 152910f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 153010f6d992SLars Ellenberg * on certain Xen deployments. 153145bb912bSLars Ellenberg */ 153245bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1533b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1534fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 1535bb3cc85eSMike Christie const unsigned op, const unsigned op_flags, 1536bb3cc85eSMike Christie const int fault_type) 153745bb912bSLars Ellenberg { 153845bb912bSLars Ellenberg struct bio *bios = NULL; 153945bb912bSLars Ellenberg struct bio *bio; 1540db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1541db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 154211f8b2b6SAndreas Gruenbacher unsigned data_size = peer_req->i.size; 154345bb912bSLars Ellenberg unsigned n_bios = 0; 154411f8b2b6SAndreas Gruenbacher unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 154510f6d992SLars Ellenberg int err = -ENOMEM; 154645bb912bSLars Ellenberg 1547dd4f699dSLars Ellenberg /* TRIM/DISCARD: for now, always use the helper function 1548dd4f699dSLars Ellenberg * blkdev_issue_zeroout(..., discard=true). 1549dd4f699dSLars Ellenberg * It's synchronous, but it does the right thing wrt. bio splitting. 1550dd4f699dSLars Ellenberg * Correctness first, performance later. Next step is to code an 1551dd4f699dSLars Ellenberg * asynchronous variant of the same. 1552dd4f699dSLars Ellenberg */ 15539104d31aSLars Ellenberg if (peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) { 1554a0fb3c47SLars Ellenberg /* wait for all pending IO completions, before we start 1555a0fb3c47SLars Ellenberg * zeroing things out. */ 15565dd2ca19SAndreas Gruenbacher conn_wait_active_ee_empty(peer_req->peer_device->connection); 155745d2933cSLars Ellenberg /* add it to the active list now, 155845d2933cSLars Ellenberg * so we can find it to present it in debugfs */ 155921ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 156021ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 1561700ca8c0SPhilipp Reisner 1562700ca8c0SPhilipp Reisner /* If this was a resync request from receive_rs_deallocated(), 1563700ca8c0SPhilipp Reisner * it is already on the sync_ee list */ 1564700ca8c0SPhilipp Reisner if (list_empty(&peer_req->w.list)) { 156545d2933cSLars Ellenberg spin_lock_irq(&device->resource->req_lock); 156645d2933cSLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 156745d2933cSLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 1568700ca8c0SPhilipp Reisner } 1569700ca8c0SPhilipp Reisner 15709104d31aSLars Ellenberg if (peer_req->flags & EE_IS_TRIM) 1571dd4f699dSLars Ellenberg drbd_issue_peer_discard(device, peer_req); 15729104d31aSLars Ellenberg else /* EE_WRITE_SAME */ 15739104d31aSLars Ellenberg drbd_issue_peer_wsame(device, peer_req); 1574a0fb3c47SLars Ellenberg return 0; 1575a0fb3c47SLars Ellenberg } 1576a0fb3c47SLars Ellenberg 157745bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 157845bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 157945bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 15809476f39dSLars Ellenberg * request in more than one bio. 15819476f39dSLars Ellenberg * 15829476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 15839476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 15849476f39dSLars Ellenberg */ 158545bb912bSLars Ellenberg next_bio: 158645bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 158745bb912bSLars Ellenberg if (!bio) { 1588a0fb3c47SLars Ellenberg drbd_err(device, "submit_ee: Allocation of a bio failed (nr_pages=%u)\n", nr_pages); 158945bb912bSLars Ellenberg goto fail; 159045bb912bSLars Ellenberg } 1591db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 15924f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 159374d46992SChristoph Hellwig bio_set_dev(bio, device->ldev->backing_bdev); 1594bb3cc85eSMike Christie bio_set_op_attrs(bio, op, op_flags); 1595db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1596fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 159745bb912bSLars Ellenberg 159845bb912bSLars Ellenberg bio->bi_next = bios; 159945bb912bSLars Ellenberg bios = bio; 160045bb912bSLars Ellenberg ++n_bios; 160145bb912bSLars Ellenberg 160245bb912bSLars Ellenberg page_chain_for_each(page) { 160311f8b2b6SAndreas Gruenbacher unsigned len = min_t(unsigned, data_size, PAGE_SIZE); 160406efffdaSMing Lei if (!bio_add_page(bio, page, len, 0)) 160545bb912bSLars Ellenberg goto next_bio; 160611f8b2b6SAndreas Gruenbacher data_size -= len; 160745bb912bSLars Ellenberg sector += len >> 9; 160845bb912bSLars Ellenberg --nr_pages; 160945bb912bSLars Ellenberg } 161011f8b2b6SAndreas Gruenbacher D_ASSERT(device, data_size == 0); 1611a0fb3c47SLars Ellenberg D_ASSERT(device, page == NULL); 161245bb912bSLars Ellenberg 1613db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 161421ae5d7fSLars Ellenberg /* for debugfs: update timestamp, mark as submitted */ 161521ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 161621ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 161745bb912bSLars Ellenberg do { 161845bb912bSLars Ellenberg bio = bios; 161945bb912bSLars Ellenberg bios = bios->bi_next; 162045bb912bSLars Ellenberg bio->bi_next = NULL; 162145bb912bSLars Ellenberg 1622b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 162345bb912bSLars Ellenberg } while (bios); 162445bb912bSLars Ellenberg return 0; 162545bb912bSLars Ellenberg 162645bb912bSLars Ellenberg fail: 162745bb912bSLars Ellenberg while (bios) { 162845bb912bSLars Ellenberg bio = bios; 162945bb912bSLars Ellenberg bios = bios->bi_next; 163045bb912bSLars Ellenberg bio_put(bio); 163145bb912bSLars Ellenberg } 163210f6d992SLars Ellenberg return err; 163345bb912bSLars Ellenberg } 163445bb912bSLars Ellenberg 1635b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1636db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 163753840641SAndreas Gruenbacher { 1638db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 163953840641SAndreas Gruenbacher 1640b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 164153840641SAndreas Gruenbacher drbd_clear_interval(i); 164253840641SAndreas Gruenbacher 16436c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 164453840641SAndreas Gruenbacher if (i->waiting) 1645b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 164653840641SAndreas Gruenbacher } 164753840641SAndreas Gruenbacher 1648bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 164977fede51SPhilipp Reisner { 1650c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 165177fede51SPhilipp Reisner int vnr; 165277fede51SPhilipp Reisner 165377fede51SPhilipp Reisner rcu_read_lock(); 1654c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1655c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1656c06ece6bSAndreas Gruenbacher 1657b30ab791SAndreas Gruenbacher kref_get(&device->kref); 165877fede51SPhilipp Reisner rcu_read_unlock(); 1659b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 166005a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 166177fede51SPhilipp Reisner rcu_read_lock(); 166277fede51SPhilipp Reisner } 166377fede51SPhilipp Reisner rcu_read_unlock(); 166477fede51SPhilipp Reisner } 166577fede51SPhilipp Reisner 1666bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1667b411b363SPhilipp Reisner { 16682451fc3bSPhilipp Reisner int rv; 1669e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1670b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1671b411b363SPhilipp Reisner 16729ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 16739ed57dcbSLars Ellenberg * not a specific (peer)device. 16749ed57dcbSLars Ellenberg */ 1675bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1676bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1677bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1678b411b363SPhilipp Reisner 1679b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1680b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1681b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1682b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1683b411b363SPhilipp Reisner * completed. */ 1684e9526580SPhilipp Reisner switch (connection->resource->write_ordering) { 1685f6ba8636SAndreas Gruenbacher case WO_NONE: 1686b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 168782bc0194SAndreas Gruenbacher return 0; 1688b411b363SPhilipp Reisner 1689b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1690b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1691b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 16922451fc3bSPhilipp Reisner if (epoch) 16932451fc3bSPhilipp Reisner break; 16942451fc3bSPhilipp Reisner else 16951ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 16962451fc3bSPhilipp Reisner /* Fall through */ 16972451fc3bSPhilipp Reisner 1698f6ba8636SAndreas Gruenbacher case WO_BDEV_FLUSH: 1699f6ba8636SAndreas Gruenbacher case WO_DRAIN_IO: 1700bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1701bde89a9eSAndreas Gruenbacher drbd_flush(connection); 17022451fc3bSPhilipp Reisner 1703bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 17042451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 17052451fc3bSPhilipp Reisner if (epoch) 17062451fc3bSPhilipp Reisner break; 1707b411b363SPhilipp Reisner } 1708b411b363SPhilipp Reisner 170982bc0194SAndreas Gruenbacher return 0; 17102451fc3bSPhilipp Reisner default: 1711e9526580SPhilipp Reisner drbd_err(connection, "Strangeness in connection->write_ordering %d\n", 1712e9526580SPhilipp Reisner connection->resource->write_ordering); 171382bc0194SAndreas Gruenbacher return -EIO; 1714b411b363SPhilipp Reisner } 1715b411b363SPhilipp Reisner 1716b411b363SPhilipp Reisner epoch->flags = 0; 1717b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1718b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1719b411b363SPhilipp Reisner 1720bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1721bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1722bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1723bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1724bde89a9eSAndreas Gruenbacher connection->epochs++; 1725b411b363SPhilipp Reisner } else { 1726b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1727b411b363SPhilipp Reisner kfree(epoch); 1728b411b363SPhilipp Reisner } 1729bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1730b411b363SPhilipp Reisner 173182bc0194SAndreas Gruenbacher return 0; 1732b411b363SPhilipp Reisner } 1733b411b363SPhilipp Reisner 17349104d31aSLars Ellenberg /* quick wrapper in case payload size != request_size (write same) */ 17359104d31aSLars Ellenberg static void drbd_csum_ee_size(struct crypto_ahash *h, 17369104d31aSLars Ellenberg struct drbd_peer_request *r, void *d, 17379104d31aSLars Ellenberg unsigned int payload_size) 17389104d31aSLars Ellenberg { 17399104d31aSLars Ellenberg unsigned int tmp = r->i.size; 17409104d31aSLars Ellenberg r->i.size = payload_size; 17419104d31aSLars Ellenberg drbd_csum_ee(h, r, d); 17429104d31aSLars Ellenberg r->i.size = tmp; 17439104d31aSLars Ellenberg } 17449104d31aSLars Ellenberg 1745b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 17469104d31aSLars Ellenberg * and from receive_Data. 17479104d31aSLars Ellenberg * data_size: actual payload ("data in") 17489104d31aSLars Ellenberg * for normal writes that is bi_size. 17499104d31aSLars Ellenberg * for discards, that is zero. 17509104d31aSLars Ellenberg * for write same, it is logical_block_size. 17519104d31aSLars Ellenberg * both trim and write same have the bi_size ("data len to be affected") 17529104d31aSLars Ellenberg * as extra argument in the packet header. 17539104d31aSLars Ellenberg */ 1754f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 175569a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1756a0fb3c47SLars Ellenberg struct packet_info *pi) __must_hold(local) 1757b411b363SPhilipp Reisner { 175869a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1759b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1760db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1761b411b363SPhilipp Reisner struct page *page; 176211f8b2b6SAndreas Gruenbacher int digest_size, err; 176311f8b2b6SAndreas Gruenbacher unsigned int data_size = pi->size, ds; 176469a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 176569a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 17666b4388acSPhilipp Reisner unsigned long *data; 1767a0fb3c47SLars Ellenberg struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; 17689104d31aSLars Ellenberg struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL; 1769b411b363SPhilipp Reisner 177011f8b2b6SAndreas Gruenbacher digest_size = 0; 1771a0fb3c47SLars Ellenberg if (!trim && peer_device->connection->peer_integrity_tfm) { 17729534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 17739f5bdc33SAndreas Gruenbacher /* 17749f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 17759f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 17769f5bdc33SAndreas Gruenbacher */ 177711f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1778a5c31904SAndreas Gruenbacher if (err) 1779b411b363SPhilipp Reisner return NULL; 178011f8b2b6SAndreas Gruenbacher data_size -= digest_size; 178188104ca4SAndreas Gruenbacher } 1782b411b363SPhilipp Reisner 17839104d31aSLars Ellenberg /* assume request_size == data_size, but special case trim and wsame. */ 17849104d31aSLars Ellenberg ds = data_size; 1785a0fb3c47SLars Ellenberg if (trim) { 17869104d31aSLars Ellenberg if (!expect(data_size == 0)) 17879104d31aSLars Ellenberg return NULL; 17889104d31aSLars Ellenberg ds = be32_to_cpu(trim->size); 17899104d31aSLars Ellenberg } else if (wsame) { 17909104d31aSLars Ellenberg if (data_size != queue_logical_block_size(device->rq_queue)) { 17919104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n", 17929104d31aSLars Ellenberg data_size, queue_logical_block_size(device->rq_queue)); 17939104d31aSLars Ellenberg return NULL; 17949104d31aSLars Ellenberg } 17959104d31aSLars Ellenberg if (data_size != bdev_logical_block_size(device->ldev->backing_bdev)) { 17969104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != backend logical block size (%u)\n", 17979104d31aSLars Ellenberg data_size, bdev_logical_block_size(device->ldev->backing_bdev)); 17989104d31aSLars Ellenberg return NULL; 17999104d31aSLars Ellenberg } 18009104d31aSLars Ellenberg ds = be32_to_cpu(wsame->size); 1801a0fb3c47SLars Ellenberg } 1802a0fb3c47SLars Ellenberg 18039104d31aSLars Ellenberg if (!expect(IS_ALIGNED(ds, 512))) 1804841ce241SAndreas Gruenbacher return NULL; 18059104d31aSLars Ellenberg if (trim || wsame) { 18069104d31aSLars Ellenberg if (!expect(ds <= (DRBD_MAX_BBIO_SECTORS << 9))) 18079104d31aSLars Ellenberg return NULL; 18089104d31aSLars Ellenberg } else if (!expect(ds <= DRBD_MAX_BIO_SIZE)) 1809841ce241SAndreas Gruenbacher return NULL; 1810b411b363SPhilipp Reisner 18116666032aSLars Ellenberg /* even though we trust out peer, 18126666032aSLars Ellenberg * we sometimes have to double check. */ 18139104d31aSLars Ellenberg if (sector + (ds>>9) > capacity) { 1814d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1815fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 18166666032aSLars Ellenberg (unsigned long long)capacity, 18179104d31aSLars Ellenberg (unsigned long long)sector, ds); 18186666032aSLars Ellenberg return NULL; 18196666032aSLars Ellenberg } 18206666032aSLars Ellenberg 1821b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1822b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1823b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 18249104d31aSLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, id, sector, ds, data_size, GFP_NOIO); 1825db830c46SAndreas Gruenbacher if (!peer_req) 1826b411b363SPhilipp Reisner return NULL; 182745bb912bSLars Ellenberg 182821ae5d7fSLars Ellenberg peer_req->flags |= EE_WRITE; 18299104d31aSLars Ellenberg if (trim) { 18309104d31aSLars Ellenberg peer_req->flags |= EE_IS_TRIM; 183181a3537aSLars Ellenberg return peer_req; 18329104d31aSLars Ellenberg } 18339104d31aSLars Ellenberg if (wsame) 18349104d31aSLars Ellenberg peer_req->flags |= EE_WRITE_SAME; 1835a73ff323SLars Ellenberg 18369104d31aSLars Ellenberg /* receive payload size bytes into page chain */ 1837b411b363SPhilipp Reisner ds = data_size; 1838db830c46SAndreas Gruenbacher page = peer_req->pages; 183945bb912bSLars Ellenberg page_chain_for_each(page) { 184045bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 18416b4388acSPhilipp Reisner data = kmap(page); 184269a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1843b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1844d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 18456b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 18466b4388acSPhilipp Reisner } 1847b411b363SPhilipp Reisner kunmap(page); 1848a5c31904SAndreas Gruenbacher if (err) { 1849b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1850b411b363SPhilipp Reisner return NULL; 1851b411b363SPhilipp Reisner } 1852a5c31904SAndreas Gruenbacher ds -= len; 1853b411b363SPhilipp Reisner } 1854b411b363SPhilipp Reisner 185511f8b2b6SAndreas Gruenbacher if (digest_size) { 18569104d31aSLars Ellenberg drbd_csum_ee_size(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv, data_size); 185711f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 1858d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1859470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1860b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1861b411b363SPhilipp Reisner return NULL; 1862b411b363SPhilipp Reisner } 1863b411b363SPhilipp Reisner } 1864b30ab791SAndreas Gruenbacher device->recv_cnt += data_size >> 9; 1865db830c46SAndreas Gruenbacher return peer_req; 1866b411b363SPhilipp Reisner } 1867b411b363SPhilipp Reisner 1868b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1869b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1870b411b363SPhilipp Reisner */ 187169a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1872b411b363SPhilipp Reisner { 1873b411b363SPhilipp Reisner struct page *page; 1874a5c31904SAndreas Gruenbacher int err = 0; 1875b411b363SPhilipp Reisner void *data; 1876b411b363SPhilipp Reisner 1877c3470cdeSLars Ellenberg if (!data_size) 1878fc5be839SAndreas Gruenbacher return 0; 1879c3470cdeSLars Ellenberg 188069a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1881b411b363SPhilipp Reisner 1882b411b363SPhilipp Reisner data = kmap(page); 1883b411b363SPhilipp Reisner while (data_size) { 1884fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1885fc5be839SAndreas Gruenbacher 188669a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1887a5c31904SAndreas Gruenbacher if (err) 1888b411b363SPhilipp Reisner break; 1889a5c31904SAndreas Gruenbacher data_size -= len; 1890b411b363SPhilipp Reisner } 1891b411b363SPhilipp Reisner kunmap(page); 189269a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1893fc5be839SAndreas Gruenbacher return err; 1894b411b363SPhilipp Reisner } 1895b411b363SPhilipp Reisner 189669a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1897b411b363SPhilipp Reisner sector_t sector, int data_size) 1898b411b363SPhilipp Reisner { 18997988613bSKent Overstreet struct bio_vec bvec; 19007988613bSKent Overstreet struct bvec_iter iter; 1901b411b363SPhilipp Reisner struct bio *bio; 190211f8b2b6SAndreas Gruenbacher int digest_size, err, expect; 190369a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 190469a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1905b411b363SPhilipp Reisner 190611f8b2b6SAndreas Gruenbacher digest_size = 0; 190769a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 19089534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 190911f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1910a5c31904SAndreas Gruenbacher if (err) 1911a5c31904SAndreas Gruenbacher return err; 191211f8b2b6SAndreas Gruenbacher data_size -= digest_size; 191388104ca4SAndreas Gruenbacher } 1914b411b363SPhilipp Reisner 1915b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1916b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 191769a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1918b411b363SPhilipp Reisner 1919b411b363SPhilipp Reisner bio = req->master_bio; 192069a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1921b411b363SPhilipp Reisner 19227988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 19237988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 19247988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 192569a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 19267988613bSKent Overstreet kunmap(bvec.bv_page); 1927a5c31904SAndreas Gruenbacher if (err) 1928a5c31904SAndreas Gruenbacher return err; 1929a5c31904SAndreas Gruenbacher data_size -= expect; 1930b411b363SPhilipp Reisner } 1931b411b363SPhilipp Reisner 193211f8b2b6SAndreas Gruenbacher if (digest_size) { 193369a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 193411f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 193569a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 193628284cefSAndreas Gruenbacher return -EINVAL; 1937b411b363SPhilipp Reisner } 1938b411b363SPhilipp Reisner } 1939b411b363SPhilipp Reisner 194069a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 194128284cefSAndreas Gruenbacher return 0; 1942b411b363SPhilipp Reisner } 1943b411b363SPhilipp Reisner 1944a990be46SAndreas Gruenbacher /* 1945668700b4SPhilipp Reisner * e_end_resync_block() is called in ack_sender context via 1946a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1947a990be46SAndreas Gruenbacher */ 194899920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1949b411b363SPhilipp Reisner { 19508050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1951a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1952a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1953a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1954db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 195599920dc5SAndreas Gruenbacher int err; 1956b411b363SPhilipp Reisner 19570b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1958b411b363SPhilipp Reisner 1959db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1960b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1961a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 1962b411b363SPhilipp Reisner } else { 1963b411b363SPhilipp Reisner /* Record failure to sync */ 1964b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 1965b411b363SPhilipp Reisner 1966a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1967b411b363SPhilipp Reisner } 1968b30ab791SAndreas Gruenbacher dec_unacked(device); 1969b411b363SPhilipp Reisner 197099920dc5SAndreas Gruenbacher return err; 1971b411b363SPhilipp Reisner } 1972b411b363SPhilipp Reisner 197369a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 1974a0fb3c47SLars Ellenberg struct packet_info *pi) __releases(local) 1975b411b363SPhilipp Reisner { 197669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1977db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1978b411b363SPhilipp Reisner 1979a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi); 1980db830c46SAndreas Gruenbacher if (!peer_req) 198145bb912bSLars Ellenberg goto fail; 1982b411b363SPhilipp Reisner 1983b30ab791SAndreas Gruenbacher dec_rs_pending(device); 1984b411b363SPhilipp Reisner 1985b30ab791SAndreas Gruenbacher inc_unacked(device); 1986b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1987b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1988b411b363SPhilipp Reisner 1989a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 199021ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 199145bb912bSLars Ellenberg 19920500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1993b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->sync_ee); 19940500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1995b411b363SPhilipp Reisner 1996a0fb3c47SLars Ellenberg atomic_add(pi->size >> 9, &device->rs_sect_ev); 1997bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_WRITE, 0, 1998bb3cc85eSMike Christie DRBD_FAULT_RS_WR) == 0) 1999e1c1b0fcSAndreas Gruenbacher return 0; 200045bb912bSLars Ellenberg 200110f6d992SLars Ellenberg /* don't care for the reason here */ 2002d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 20030500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2004a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 20050500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 200622cc37a9SLars Ellenberg 2007b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 200845bb912bSLars Ellenberg fail: 2009b30ab791SAndreas Gruenbacher put_ldev(device); 2010e1c1b0fcSAndreas Gruenbacher return -EIO; 2011b411b363SPhilipp Reisner } 2012b411b363SPhilipp Reisner 2013668eebc6SAndreas Gruenbacher static struct drbd_request * 2014b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 2015bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 2016b411b363SPhilipp Reisner { 2017b411b363SPhilipp Reisner struct drbd_request *req; 2018668eebc6SAndreas Gruenbacher 2019bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 2020bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 20215e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 2022668eebc6SAndreas Gruenbacher return req; 2023c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 2024d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 2025c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 2026c3afd8f5SAndreas Gruenbacher } 2027668eebc6SAndreas Gruenbacher return NULL; 2028668eebc6SAndreas Gruenbacher } 2029668eebc6SAndreas Gruenbacher 2030bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 2031b411b363SPhilipp Reisner { 20329f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2033b30ab791SAndreas Gruenbacher struct drbd_device *device; 2034b411b363SPhilipp Reisner struct drbd_request *req; 2035b411b363SPhilipp Reisner sector_t sector; 203682bc0194SAndreas Gruenbacher int err; 2037e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20384a76b161SAndreas Gruenbacher 20399f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 20409f4fe9adSAndreas Gruenbacher if (!peer_device) 20414a76b161SAndreas Gruenbacher return -EIO; 20429f4fe9adSAndreas Gruenbacher device = peer_device->device; 2043b411b363SPhilipp Reisner 2044b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2045b411b363SPhilipp Reisner 20460500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2047b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 20480500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2049c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 205082bc0194SAndreas Gruenbacher return -EIO; 2051b411b363SPhilipp Reisner 205224c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 2053b411b363SPhilipp Reisner * special casing it there for the various failure cases. 2054b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 205569a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 205682bc0194SAndreas Gruenbacher if (!err) 20578554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 2058b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 2059b411b363SPhilipp Reisner * I don't think we may complete this just yet 2060b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 2061b411b363SPhilipp Reisner 206282bc0194SAndreas Gruenbacher return err; 2063b411b363SPhilipp Reisner } 2064b411b363SPhilipp Reisner 2065bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 2066b411b363SPhilipp Reisner { 20679f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2068b30ab791SAndreas Gruenbacher struct drbd_device *device; 2069b411b363SPhilipp Reisner sector_t sector; 207082bc0194SAndreas Gruenbacher int err; 2071e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20724a76b161SAndreas Gruenbacher 20739f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 20749f4fe9adSAndreas Gruenbacher if (!peer_device) 20754a76b161SAndreas Gruenbacher return -EIO; 20769f4fe9adSAndreas Gruenbacher device = peer_device->device; 2077b411b363SPhilipp Reisner 2078b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 20790b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 2080b411b363SPhilipp Reisner 2081b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 2082b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 2083b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 2084fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 2085a0fb3c47SLars Ellenberg err = recv_resync_read(peer_device, sector, pi); 2086b411b363SPhilipp Reisner } else { 2087b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 2088d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 2089b411b363SPhilipp Reisner 209069a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 2091b411b363SPhilipp Reisner 209269a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2093b411b363SPhilipp Reisner } 2094b411b363SPhilipp Reisner 2095b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 2096778f271dSPhilipp Reisner 209782bc0194SAndreas Gruenbacher return err; 2098b411b363SPhilipp Reisner } 2099b411b363SPhilipp Reisner 2100b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 21017be8da07SAndreas Gruenbacher sector_t sector, int size) 2102b411b363SPhilipp Reisner { 21037be8da07SAndreas Gruenbacher struct drbd_interval *i; 21047be8da07SAndreas Gruenbacher struct drbd_request *req; 2105b411b363SPhilipp Reisner 2106b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21077be8da07SAndreas Gruenbacher if (!i->local) 21087be8da07SAndreas Gruenbacher continue; 21097be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 21107be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21117be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 21127be8da07SAndreas Gruenbacher continue; 21132312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 21142312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 2115d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 21167be8da07SAndreas Gruenbacher } 21177be8da07SAndreas Gruenbacher } 21187be8da07SAndreas Gruenbacher 2119a990be46SAndreas Gruenbacher /* 2120668700b4SPhilipp Reisner * e_end_block() is called in ack_sender context via drbd_finish_peer_reqs(). 2121b411b363SPhilipp Reisner */ 212299920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 2123b411b363SPhilipp Reisner { 21248050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2125a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2126a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 2127a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2128db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 212999920dc5SAndreas Gruenbacher int err = 0, pcmd; 2130b411b363SPhilipp Reisner 2131303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 2132db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 2133b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 2134b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 2135db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 2136b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 2137a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 2138b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 2139b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 2140b411b363SPhilipp Reisner } else { 2141a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 2142b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 2143b411b363SPhilipp Reisner * maybe assert this? */ 2144b411b363SPhilipp Reisner } 2145b30ab791SAndreas Gruenbacher dec_unacked(device); 2146b411b363SPhilipp Reisner } 214708d0dabfSLars Ellenberg 2148b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 2149b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 2150302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 21510500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 21520b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 2153b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 21547be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 2155b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 21560500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2157bb3bfe96SAndreas Gruenbacher } else 21580b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 2159b411b363SPhilipp Reisner 21605dd2ca19SAndreas Gruenbacher drbd_may_finish_epoch(peer_device->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 2161b411b363SPhilipp Reisner 216299920dc5SAndreas Gruenbacher return err; 2163b411b363SPhilipp Reisner } 2164b411b363SPhilipp Reisner 2165a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 2166b411b363SPhilipp Reisner { 21678050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2168a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2169a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 217099920dc5SAndreas Gruenbacher int err; 2171b411b363SPhilipp Reisner 2172a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 2173a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 2174b411b363SPhilipp Reisner 217599920dc5SAndreas Gruenbacher return err; 2176b411b363SPhilipp Reisner } 2177b411b363SPhilipp Reisner 2178d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 2179b6a370baSPhilipp Reisner { 2180a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 21817be8da07SAndreas Gruenbacher } 2182b6a370baSPhilipp Reisner 218399920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 21847be8da07SAndreas Gruenbacher { 2185a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 2186a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2187a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 21887be8da07SAndreas Gruenbacher 2189a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 2190d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 21917be8da07SAndreas Gruenbacher } 21927be8da07SAndreas Gruenbacher 21933e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 21943e394da1SAndreas Gruenbacher { 21953e394da1SAndreas Gruenbacher /* 21963e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 21973e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 21983e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 21993e394da1SAndreas Gruenbacher */ 22003e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 22013e394da1SAndreas Gruenbacher } 22023e394da1SAndreas Gruenbacher 22033e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 22043e394da1SAndreas Gruenbacher { 22053e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 22063e394da1SAndreas Gruenbacher } 22073e394da1SAndreas Gruenbacher 220869a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 22093e394da1SAndreas Gruenbacher { 221069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 22113c13b680SLars Ellenberg unsigned int newest_peer_seq; 22123e394da1SAndreas Gruenbacher 221369a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 2214b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2215b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 2216b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 2217b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2218b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 22193c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 2220b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 22213e394da1SAndreas Gruenbacher } 22227be8da07SAndreas Gruenbacher } 22233e394da1SAndreas Gruenbacher 2224d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 2225d93f6302SLars Ellenberg { 2226d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 2227d93f6302SLars Ellenberg } 2228d93f6302SLars Ellenberg 2229d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 2230b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 2231d93f6302SLars Ellenberg { 2232d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 22337e5fec31SFabian Frederick bool rv = false; 2234b6a370baSPhilipp Reisner 22350500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2236a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 2237d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 2238d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 22397e5fec31SFabian Frederick rv = true; 2240b6a370baSPhilipp Reisner break; 2241b6a370baSPhilipp Reisner } 2242b6a370baSPhilipp Reisner } 22430500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2244b6a370baSPhilipp Reisner 2245b6a370baSPhilipp Reisner return rv; 2246b6a370baSPhilipp Reisner } 2247b6a370baSPhilipp Reisner 2248b411b363SPhilipp Reisner /* Called from receive_Data. 2249b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 2250b411b363SPhilipp Reisner * 2251b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 2252b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 2253b411b363SPhilipp Reisner * been sent. 2254b411b363SPhilipp Reisner * 2255b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 2256b411b363SPhilipp Reisner * 2257b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 2258b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 2259b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 2260b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 2261b411b363SPhilipp Reisner * 2262b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 2263b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 2264b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 2265b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 2266b411b363SPhilipp Reisner * 2267b411b363SPhilipp Reisner * returns 0 if we may process the packet, 2268b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 226969a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 2270b411b363SPhilipp Reisner { 227169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2272b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2273b411b363SPhilipp Reisner long timeout; 2274b874d231SPhilipp Reisner int ret = 0, tp; 22757be8da07SAndreas Gruenbacher 227669a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 22777be8da07SAndreas Gruenbacher return 0; 22787be8da07SAndreas Gruenbacher 2279b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2280b411b363SPhilipp Reisner for (;;) { 2281b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 2282b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 2283b411b363SPhilipp Reisner break; 22847be8da07SAndreas Gruenbacher } 2285b874d231SPhilipp Reisner 2286b411b363SPhilipp Reisner if (signal_pending(current)) { 2287b411b363SPhilipp Reisner ret = -ERESTARTSYS; 2288b411b363SPhilipp Reisner break; 2289b411b363SPhilipp Reisner } 2290b874d231SPhilipp Reisner 2291b874d231SPhilipp Reisner rcu_read_lock(); 22925dd2ca19SAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2293b874d231SPhilipp Reisner rcu_read_unlock(); 2294b874d231SPhilipp Reisner 2295b874d231SPhilipp Reisner if (!tp) 2296b874d231SPhilipp Reisner break; 2297b874d231SPhilipp Reisner 2298b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2299b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2300b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 230144ed167dSPhilipp Reisner rcu_read_lock(); 230269a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 230344ed167dSPhilipp Reisner rcu_read_unlock(); 230471b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2305b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 23067be8da07SAndreas Gruenbacher if (!timeout) { 2307b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2308d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2309b411b363SPhilipp Reisner break; 2310b411b363SPhilipp Reisner } 2311b411b363SPhilipp Reisner } 2312b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2313b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2314b411b363SPhilipp Reisner return ret; 2315b411b363SPhilipp Reisner } 2316b411b363SPhilipp Reisner 2317688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2318688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2319688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2320bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_flags(u32 dpf) 232176d2e7ecSPhilipp Reisner { 232276d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 232376d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 232428a8f0d3SMike Christie (dpf & DP_FLUSH ? REQ_PREFLUSH : 0); 2325bb3cc85eSMike Christie } 2326bb3cc85eSMike Christie 2327bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_op(u32 dpf) 2328bb3cc85eSMike Christie { 2329bb3cc85eSMike Christie if (dpf & DP_DISCARD) 233045c21793SChristoph Hellwig return REQ_OP_WRITE_ZEROES; 2331bb3cc85eSMike Christie else 2332bb3cc85eSMike Christie return REQ_OP_WRITE; 233376d2e7ecSPhilipp Reisner } 233476d2e7ecSPhilipp Reisner 2335b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 23367be8da07SAndreas Gruenbacher unsigned int size) 2337b411b363SPhilipp Reisner { 23387be8da07SAndreas Gruenbacher struct drbd_interval *i; 23397be8da07SAndreas Gruenbacher 23407be8da07SAndreas Gruenbacher repeat: 2341b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 23427be8da07SAndreas Gruenbacher struct drbd_request *req; 23437be8da07SAndreas Gruenbacher struct bio_and_error m; 23447be8da07SAndreas Gruenbacher 23457be8da07SAndreas Gruenbacher if (!i->local) 23467be8da07SAndreas Gruenbacher continue; 23477be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 23487be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 23497be8da07SAndreas Gruenbacher continue; 23507be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 23517be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 23520500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 23537be8da07SAndreas Gruenbacher if (m.bio) 2354b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 23550500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 23567be8da07SAndreas Gruenbacher goto repeat; 23577be8da07SAndreas Gruenbacher } 23587be8da07SAndreas Gruenbacher } 23597be8da07SAndreas Gruenbacher 2360b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 23617be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 23627be8da07SAndreas Gruenbacher { 2363e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2364bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 23657be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 23667be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 23677be8da07SAndreas Gruenbacher struct drbd_interval *i; 23687be8da07SAndreas Gruenbacher bool equal; 23697be8da07SAndreas Gruenbacher int err; 23707be8da07SAndreas Gruenbacher 23717be8da07SAndreas Gruenbacher /* 23727be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 23737be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 23747be8da07SAndreas Gruenbacher */ 2375b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 23767be8da07SAndreas Gruenbacher 23777be8da07SAndreas Gruenbacher repeat: 2378b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 23797be8da07SAndreas Gruenbacher if (i == &peer_req->i) 23807be8da07SAndreas Gruenbacher continue; 238108d0dabfSLars Ellenberg if (i->completed) 238208d0dabfSLars Ellenberg continue; 23837be8da07SAndreas Gruenbacher 23847be8da07SAndreas Gruenbacher if (!i->local) { 23857be8da07SAndreas Gruenbacher /* 23867be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 23877be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 23887be8da07SAndreas Gruenbacher * earlier peer request to complete. 23897be8da07SAndreas Gruenbacher */ 2390b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 23917be8da07SAndreas Gruenbacher if (err) 23927be8da07SAndreas Gruenbacher goto out; 23937be8da07SAndreas Gruenbacher goto repeat; 23947be8da07SAndreas Gruenbacher } 23957be8da07SAndreas Gruenbacher 23967be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 23977be8da07SAndreas Gruenbacher if (resolve_conflicts) { 23987be8da07SAndreas Gruenbacher /* 23997be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2400d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2401d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2402d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 24037be8da07SAndreas Gruenbacher */ 2404d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 24057be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 24067be8da07SAndreas Gruenbacher 24077be8da07SAndreas Gruenbacher if (!equal) 2408d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24097be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 24107be8da07SAndreas Gruenbacher "assuming %s came first\n", 24117be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24127be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2413d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 24147be8da07SAndreas Gruenbacher 2415a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 24167be8da07SAndreas Gruenbacher e_send_retry_write; 2417a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2418668700b4SPhilipp Reisner queue_work(connection->ack_sender, &peer_req->peer_device->send_acks_work); 24197be8da07SAndreas Gruenbacher 24207be8da07SAndreas Gruenbacher err = -ENOENT; 24217be8da07SAndreas Gruenbacher goto out; 24227be8da07SAndreas Gruenbacher } else { 24237be8da07SAndreas Gruenbacher struct drbd_request *req = 24247be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 24257be8da07SAndreas Gruenbacher 24267be8da07SAndreas Gruenbacher if (!equal) 2427d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24287be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 24297be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24307be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 24317be8da07SAndreas Gruenbacher 24327be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 24337be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 24347be8da07SAndreas Gruenbacher /* 24357be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2436d4dabbe2SLars Ellenberg * decide if this request has been superseded 2437d4dabbe2SLars Ellenberg * or needs to be retried. 2438d4dabbe2SLars Ellenberg * Requests that have been superseded will 24397be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 24407be8da07SAndreas Gruenbacher * 24417be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 24427be8da07SAndreas Gruenbacher * request to finish locally before submitting 24437be8da07SAndreas Gruenbacher * the conflicting peer request. 24447be8da07SAndreas Gruenbacher */ 2445b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 24467be8da07SAndreas Gruenbacher if (err) { 2447e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2448b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 24497be8da07SAndreas Gruenbacher goto out; 24507be8da07SAndreas Gruenbacher } 24517be8da07SAndreas Gruenbacher goto repeat; 24527be8da07SAndreas Gruenbacher } 24537be8da07SAndreas Gruenbacher /* 24547be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 24557be8da07SAndreas Gruenbacher * the new peer request has completed. 24567be8da07SAndreas Gruenbacher */ 24577be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 24587be8da07SAndreas Gruenbacher } 24597be8da07SAndreas Gruenbacher } 24607be8da07SAndreas Gruenbacher err = 0; 24617be8da07SAndreas Gruenbacher 24627be8da07SAndreas Gruenbacher out: 24637be8da07SAndreas Gruenbacher if (err) 2464b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 24657be8da07SAndreas Gruenbacher return err; 24667be8da07SAndreas Gruenbacher } 24677be8da07SAndreas Gruenbacher 2468b411b363SPhilipp Reisner /* mirrored write */ 2469bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2470b411b363SPhilipp Reisner { 24719f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2472b30ab791SAndreas Gruenbacher struct drbd_device *device; 247321ae5d7fSLars Ellenberg struct net_conf *nc; 2474b411b363SPhilipp Reisner sector_t sector; 2475db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2476e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 24777be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2478bb3cc85eSMike Christie int op, op_flags; 2479b411b363SPhilipp Reisner u32 dp_flags; 2480302bdeaeSPhilipp Reisner int err, tp; 24817be8da07SAndreas Gruenbacher 24829f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 24839f4fe9adSAndreas Gruenbacher if (!peer_device) 24844a76b161SAndreas Gruenbacher return -EIO; 24859f4fe9adSAndreas Gruenbacher device = peer_device->device; 2486b411b363SPhilipp Reisner 2487b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 248882bc0194SAndreas Gruenbacher int err2; 2489b411b363SPhilipp Reisner 249069a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 249169a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2492bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 249369a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 249482bc0194SAndreas Gruenbacher if (!err) 249582bc0194SAndreas Gruenbacher err = err2; 249682bc0194SAndreas Gruenbacher return err; 2497b411b363SPhilipp Reisner } 2498b411b363SPhilipp Reisner 2499fcefa62eSAndreas Gruenbacher /* 2500fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2501fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2502fcefa62eSAndreas Gruenbacher * end of this function. 2503fcefa62eSAndreas Gruenbacher */ 2504b411b363SPhilipp Reisner 2505b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2506a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, p->block_id, sector, pi); 2507db830c46SAndreas Gruenbacher if (!peer_req) { 2508b30ab791SAndreas Gruenbacher put_ldev(device); 250982bc0194SAndreas Gruenbacher return -EIO; 2510b411b363SPhilipp Reisner } 2511b411b363SPhilipp Reisner 2512a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 251321ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 251421ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 2515b411b363SPhilipp Reisner 2516688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2517bb3cc85eSMike Christie op = wire_flags_to_bio_op(dp_flags); 2518bb3cc85eSMike Christie op_flags = wire_flags_to_bio_flags(dp_flags); 2519a0fb3c47SLars Ellenberg if (pi->cmd == P_TRIM) { 2520a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->i.size > 0); 252145c21793SChristoph Hellwig D_ASSERT(peer_device, op == REQ_OP_WRITE_ZEROES); 2522a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->pages == NULL); 2523a0fb3c47SLars Ellenberg } else if (peer_req->pages == NULL) { 25240b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 25250b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2526a73ff323SLars Ellenberg } 2527688593c5SLars Ellenberg 2528688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2529db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2530688593c5SLars Ellenberg 2531bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2532bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2533db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2534db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2535bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2536b411b363SPhilipp Reisner 2537302bdeaeSPhilipp Reisner rcu_read_lock(); 253821ae5d7fSLars Ellenberg nc = rcu_dereference(peer_device->connection->net_conf); 253921ae5d7fSLars Ellenberg tp = nc->two_primaries; 254021ae5d7fSLars Ellenberg if (peer_device->connection->agreed_pro_version < 100) { 254121ae5d7fSLars Ellenberg switch (nc->wire_protocol) { 254221ae5d7fSLars Ellenberg case DRBD_PROT_C: 254321ae5d7fSLars Ellenberg dp_flags |= DP_SEND_WRITE_ACK; 254421ae5d7fSLars Ellenberg break; 254521ae5d7fSLars Ellenberg case DRBD_PROT_B: 254621ae5d7fSLars Ellenberg dp_flags |= DP_SEND_RECEIVE_ACK; 254721ae5d7fSLars Ellenberg break; 254821ae5d7fSLars Ellenberg } 254921ae5d7fSLars Ellenberg } 2550302bdeaeSPhilipp Reisner rcu_read_unlock(); 255121ae5d7fSLars Ellenberg 255221ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_WRITE_ACK) { 255321ae5d7fSLars Ellenberg peer_req->flags |= EE_SEND_WRITE_ACK; 255421ae5d7fSLars Ellenberg inc_unacked(device); 255521ae5d7fSLars Ellenberg /* corresponding dec_unacked() in e_end_block() 255621ae5d7fSLars Ellenberg * respective _drbd_clear_done_ee */ 255721ae5d7fSLars Ellenberg } 255821ae5d7fSLars Ellenberg 255921ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_RECEIVE_ACK) { 256021ae5d7fSLars Ellenberg /* I really don't like it that the receiver thread 256121ae5d7fSLars Ellenberg * sends on the msock, but anyways */ 25625dd2ca19SAndreas Gruenbacher drbd_send_ack(peer_device, P_RECV_ACK, peer_req); 256321ae5d7fSLars Ellenberg } 256421ae5d7fSLars Ellenberg 2565302bdeaeSPhilipp Reisner if (tp) { 256621ae5d7fSLars Ellenberg /* two primaries implies protocol C */ 256721ae5d7fSLars Ellenberg D_ASSERT(device, dp_flags & DP_SEND_WRITE_ACK); 2568302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 256969a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 25707be8da07SAndreas Gruenbacher if (err) 2571b411b363SPhilipp Reisner goto out_interrupted; 25720500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2573b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 25747be8da07SAndreas Gruenbacher if (err) { 25750500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 25767be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2577b30ab791SAndreas Gruenbacher put_ldev(device); 257882bc0194SAndreas Gruenbacher return 0; 2579b411b363SPhilipp Reisner } 2580b411b363SPhilipp Reisner goto out_interrupted; 2581b411b363SPhilipp Reisner } 2582b874d231SPhilipp Reisner } else { 258369a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 25840500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2585b874d231SPhilipp Reisner } 25869104d31aSLars Ellenberg /* TRIM and WRITE_SAME are processed synchronously, 25879104d31aSLars Ellenberg * we wait for all pending requests, respectively wait for 2588a0fb3c47SLars Ellenberg * active_ee to become empty in drbd_submit_peer_request(); 2589a0fb3c47SLars Ellenberg * better not add ourselves here. */ 25909104d31aSLars Ellenberg if ((peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) == 0) 2591b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 25920500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2593b411b363SPhilipp Reisner 2594b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2595b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2596b6a370baSPhilipp Reisner 2597b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2598b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2599b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2600db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 26014dd726f0SLars Ellenberg drbd_al_begin_io(device, &peer_req->i); 260221ae5d7fSLars Ellenberg peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2603b411b363SPhilipp Reisner } 2604b411b363SPhilipp Reisner 2605bb3cc85eSMike Christie err = drbd_submit_peer_request(device, peer_req, op, op_flags, 2606bb3cc85eSMike Christie DRBD_FAULT_DT_WR); 260782bc0194SAndreas Gruenbacher if (!err) 260882bc0194SAndreas Gruenbacher return 0; 2609b411b363SPhilipp Reisner 261010f6d992SLars Ellenberg /* don't care for the reason here */ 2611d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 26120500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2613a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2614b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 26150500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 261621ae5d7fSLars Ellenberg if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) { 261721ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 2618b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 261921ae5d7fSLars Ellenberg } 262022cc37a9SLars Ellenberg 2621b411b363SPhilipp Reisner out_interrupted: 26227e5fec31SFabian Frederick drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT | EV_CLEANUP); 2623b30ab791SAndreas Gruenbacher put_ldev(device); 2624b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 262582bc0194SAndreas Gruenbacher return err; 2626b411b363SPhilipp Reisner } 2627b411b363SPhilipp Reisner 26280f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 26290f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 26300f0601f4SLars Ellenberg * 26310f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 26320f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 26330f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 26340f0601f4SLars Ellenberg * activity, it obviously is "busy". 26350f0601f4SLars Ellenberg * 26360f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 26370f0601f4SLars Ellenberg * to have a short time average so we can react faster. 26380f0601f4SLars Ellenberg */ 2639ad3fee79SLars Ellenberg bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector, 2640ad3fee79SLars Ellenberg bool throttle_if_app_is_waiting) 2641e8299874SLars Ellenberg { 2642e8299874SLars Ellenberg struct lc_element *tmp; 2643ad3fee79SLars Ellenberg bool throttle = drbd_rs_c_min_rate_throttle(device); 2644e8299874SLars Ellenberg 2645ad3fee79SLars Ellenberg if (!throttle || throttle_if_app_is_waiting) 2646ad3fee79SLars Ellenberg return throttle; 2647e8299874SLars Ellenberg 2648e8299874SLars Ellenberg spin_lock_irq(&device->al_lock); 2649e8299874SLars Ellenberg tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2650e8299874SLars Ellenberg if (tmp) { 2651e8299874SLars Ellenberg struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2652e8299874SLars Ellenberg if (test_bit(BME_PRIORITY, &bm_ext->flags)) 2653e8299874SLars Ellenberg throttle = false; 2654ad3fee79SLars Ellenberg /* Do not slow down if app IO is already waiting for this extent, 2655ad3fee79SLars Ellenberg * and our progress is necessary for application IO to complete. */ 2656e8299874SLars Ellenberg } 2657e8299874SLars Ellenberg spin_unlock_irq(&device->al_lock); 2658e8299874SLars Ellenberg 2659e8299874SLars Ellenberg return throttle; 2660e8299874SLars Ellenberg } 2661e8299874SLars Ellenberg 2662e8299874SLars Ellenberg bool drbd_rs_c_min_rate_throttle(struct drbd_device *device) 26630f0601f4SLars Ellenberg { 2664b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 26650f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2666daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2667e8299874SLars Ellenberg int curr_events; 2668daeda1ccSPhilipp Reisner 2669daeda1ccSPhilipp Reisner rcu_read_lock(); 2670b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2671daeda1ccSPhilipp Reisner rcu_read_unlock(); 26720f0601f4SLars Ellenberg 26730f0601f4SLars Ellenberg /* feature disabled? */ 2674daeda1ccSPhilipp Reisner if (c_min_rate == 0) 2675e8299874SLars Ellenberg return false; 2676e3555d85SPhilipp Reisner 26770f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 26780f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2679b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2680ad3fee79SLars Ellenberg 2681ad3fee79SLars Ellenberg if (atomic_read(&device->ap_actlog_cnt) 2682ff8bd88bSLars Ellenberg || curr_events - device->rs_last_events > 64) { 26830f0601f4SLars Ellenberg unsigned long rs_left; 26840f0601f4SLars Ellenberg int i; 26850f0601f4SLars Ellenberg 2686b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 26870f0601f4SLars Ellenberg 26880f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 26890f0601f4SLars Ellenberg * approx. */ 2690b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 26912649f080SLars Ellenberg 2692b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2693b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 26942649f080SLars Ellenberg else 2695b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 26960f0601f4SLars Ellenberg 2697b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 26980f0601f4SLars Ellenberg if (!dt) 26990f0601f4SLars Ellenberg dt++; 2700b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 27010f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 27020f0601f4SLars Ellenberg 2703daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 2704e8299874SLars Ellenberg return true; 27050f0601f4SLars Ellenberg } 2706e8299874SLars Ellenberg return false; 27070f0601f4SLars Ellenberg } 27080f0601f4SLars Ellenberg 2709bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2710b411b363SPhilipp Reisner { 27119f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2712b30ab791SAndreas Gruenbacher struct drbd_device *device; 2713b411b363SPhilipp Reisner sector_t sector; 27144a76b161SAndreas Gruenbacher sector_t capacity; 2715db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2716b411b363SPhilipp Reisner struct digest_info *di = NULL; 2717b18b37beSPhilipp Reisner int size, verb; 2718b411b363SPhilipp Reisner unsigned int fault_type; 2719e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 27204a76b161SAndreas Gruenbacher 27219f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 27229f4fe9adSAndreas Gruenbacher if (!peer_device) 27234a76b161SAndreas Gruenbacher return -EIO; 27249f4fe9adSAndreas Gruenbacher device = peer_device->device; 2725b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2726b411b363SPhilipp Reisner 2727b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2728b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2729b411b363SPhilipp Reisner 2730c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2731d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2732b411b363SPhilipp Reisner (unsigned long long)sector, size); 273382bc0194SAndreas Gruenbacher return -EINVAL; 2734b411b363SPhilipp Reisner } 2735b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2736d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2737b411b363SPhilipp Reisner (unsigned long long)sector, size); 273882bc0194SAndreas Gruenbacher return -EINVAL; 2739b411b363SPhilipp Reisner } 2740b411b363SPhilipp Reisner 2741b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2742b18b37beSPhilipp Reisner verb = 1; 2743e2857216SAndreas Gruenbacher switch (pi->cmd) { 2744b18b37beSPhilipp Reisner case P_DATA_REQUEST: 274569a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2746b18b37beSPhilipp Reisner break; 2747700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2748b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2749b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2750b18b37beSPhilipp Reisner case P_OV_REQUEST: 275169a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2752b18b37beSPhilipp Reisner break; 2753b18b37beSPhilipp Reisner case P_OV_REPLY: 2754b18b37beSPhilipp Reisner verb = 0; 2755b30ab791SAndreas Gruenbacher dec_rs_pending(device); 275669a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2757b18b37beSPhilipp Reisner break; 2758b18b37beSPhilipp Reisner default: 275949ba9b1bSAndreas Gruenbacher BUG(); 2760b18b37beSPhilipp Reisner } 2761b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2762d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2763b411b363SPhilipp Reisner "no local data.\n"); 2764b18b37beSPhilipp Reisner 2765a821cc4aSLars Ellenberg /* drain possibly payload */ 276669a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2767b411b363SPhilipp Reisner } 2768b411b363SPhilipp Reisner 2769b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2770b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2771b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2772a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, 27739104d31aSLars Ellenberg size, GFP_NOIO); 2774db830c46SAndreas Gruenbacher if (!peer_req) { 2775b30ab791SAndreas Gruenbacher put_ldev(device); 277682bc0194SAndreas Gruenbacher return -ENOMEM; 2777b411b363SPhilipp Reisner } 2778b411b363SPhilipp Reisner 2779e2857216SAndreas Gruenbacher switch (pi->cmd) { 2780b411b363SPhilipp Reisner case P_DATA_REQUEST: 2781a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2782b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 278380a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 278421ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 278580a40e43SLars Ellenberg goto submit; 278680a40e43SLars Ellenberg 2787700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2788700ca8c0SPhilipp Reisner /* If at some point in the future we have a smart way to 2789700ca8c0SPhilipp Reisner find out if this data block is completely deallocated, 2790700ca8c0SPhilipp Reisner then we would do something smarter here than reading 2791700ca8c0SPhilipp Reisner the block... */ 2792700ca8c0SPhilipp Reisner peer_req->flags |= EE_RS_THIN_REQ; 2793b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2794a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2795b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 27965f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2797b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2798b411b363SPhilipp Reisner break; 2799b411b363SPhilipp Reisner 2800b411b363SPhilipp Reisner case P_OV_REPLY: 2801b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2802b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2803e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2804b411b363SPhilipp Reisner if (!di) 2805b411b363SPhilipp Reisner goto out_free_e; 2806b411b363SPhilipp Reisner 2807e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2808b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2809b411b363SPhilipp Reisner 2810db830c46SAndreas Gruenbacher peer_req->digest = di; 2811db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2812c36c3cedSLars Ellenberg 28139f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2814b411b363SPhilipp Reisner goto out_free_e; 2815b411b363SPhilipp Reisner 2816e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 28179f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2818a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 28195f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2820b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2821aaaba345SLars Ellenberg /* remember to report stats in drbd_resync_finished */ 2822aaaba345SLars Ellenberg device->use_csums = true; 2823e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 28242649f080SLars Ellenberg /* track progress, we may need to throttle */ 2825b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2826a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2827b30ab791SAndreas Gruenbacher dec_rs_pending(device); 28280f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 28290f0601f4SLars Ellenberg * but accounting still needs to be done. */ 28300f0601f4SLars Ellenberg goto submit_for_resync; 2831b411b363SPhilipp Reisner } 2832b411b363SPhilipp Reisner break; 2833b411b363SPhilipp Reisner 2834b411b363SPhilipp Reisner case P_OV_REQUEST: 2835b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 28369f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2837de228bbaSLars Ellenberg unsigned long now = jiffies; 2838de228bbaSLars Ellenberg int i; 2839b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2840b30ab791SAndreas Gruenbacher device->ov_position = sector; 2841b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2842b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2843de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2844b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2845b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2846de228bbaSLars Ellenberg } 2847d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2848b411b363SPhilipp Reisner (unsigned long long)sector); 2849b411b363SPhilipp Reisner } 2850a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2851b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2852b411b363SPhilipp Reisner break; 2853b411b363SPhilipp Reisner 2854b411b363SPhilipp Reisner default: 285549ba9b1bSAndreas Gruenbacher BUG(); 2856b411b363SPhilipp Reisner } 2857b411b363SPhilipp Reisner 28580f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 28590f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 28600f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 28610f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 28620f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 28630f0601f4SLars Ellenberg * 28640f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 28650f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 28660f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 28670f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 28680f0601f4SLars Ellenberg * a while, anyways. 28690f0601f4SLars Ellenberg */ 2870b411b363SPhilipp Reisner 28710f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 28720f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 28730f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 28740f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 28750f0601f4SLars Ellenberg * 28760f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 28770f0601f4SLars Ellenberg * we would also throttle its application reads. 28780f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 28790f0601f4SLars Ellenberg */ 2880c5a2c150SLars Ellenberg 2881c5a2c150SLars Ellenberg /* Even though this may be a resync request, we do add to "read_ee"; 2882c5a2c150SLars Ellenberg * "sync_ee" is only used for resync WRITEs. 2883c5a2c150SLars Ellenberg * Add to list early, so debugfs can find this request 2884c5a2c150SLars Ellenberg * even if we have to sleep below. */ 2885c5a2c150SLars Ellenberg spin_lock_irq(&device->resource->req_lock); 2886c5a2c150SLars Ellenberg list_add_tail(&peer_req->w.list, &device->read_ee); 2887c5a2c150SLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 2888c5a2c150SLars Ellenberg 2889944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_should_slow_down); 2890ad3fee79SLars Ellenberg if (device->state.peer != R_PRIMARY 2891ad3fee79SLars Ellenberg && drbd_rs_should_slow_down(device, sector, false)) 2892e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2893944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_begin_io); 2894b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 289580a40e43SLars Ellenberg goto out_free_e; 2896b411b363SPhilipp Reisner 28970f0601f4SLars Ellenberg submit_for_resync: 2898b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 28990f0601f4SLars Ellenberg 290080a40e43SLars Ellenberg submit: 2901944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_submit_peer_request); 2902b30ab791SAndreas Gruenbacher inc_unacked(device); 2903bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ, 0, 2904bb3cc85eSMike Christie fault_type) == 0) 290582bc0194SAndreas Gruenbacher return 0; 2906b411b363SPhilipp Reisner 290710f6d992SLars Ellenberg /* don't care for the reason here */ 2908d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 2909c5a2c150SLars Ellenberg 2910c5a2c150SLars Ellenberg out_free_e: 29110500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2912a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 29130500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 291422cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 291522cc37a9SLars Ellenberg 2916b30ab791SAndreas Gruenbacher put_ldev(device); 2917b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 291882bc0194SAndreas Gruenbacher return -EIO; 2919b411b363SPhilipp Reisner } 2920b411b363SPhilipp Reisner 292169a22773SAndreas Gruenbacher /** 292269a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 292369a22773SAndreas Gruenbacher */ 292469a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2925b411b363SPhilipp Reisner { 292669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2927b411b363SPhilipp Reisner int self, peer, rv = -100; 2928b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 292944ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2930b411b363SPhilipp Reisner 2931b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2932b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2933b411b363SPhilipp Reisner 2934b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2935b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2936b411b363SPhilipp Reisner 293744ed167dSPhilipp Reisner rcu_read_lock(); 293869a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 293944ed167dSPhilipp Reisner rcu_read_unlock(); 294044ed167dSPhilipp Reisner switch (after_sb_0p) { 2941b411b363SPhilipp Reisner case ASB_CONSENSUS: 2942b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2943b411b363SPhilipp Reisner case ASB_CALL_HELPER: 294444ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2945d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2946b411b363SPhilipp Reisner break; 2947b411b363SPhilipp Reisner case ASB_DISCONNECT: 2948b411b363SPhilipp Reisner break; 2949b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2950b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2951b411b363SPhilipp Reisner rv = -1; 2952b411b363SPhilipp Reisner break; 2953b411b363SPhilipp Reisner } 2954b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2955b411b363SPhilipp Reisner rv = 1; 2956b411b363SPhilipp Reisner break; 2957b411b363SPhilipp Reisner } 2958b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2959b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2960b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2961b411b363SPhilipp Reisner rv = 1; 2962b411b363SPhilipp Reisner break; 2963b411b363SPhilipp Reisner } 2964b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2965b411b363SPhilipp Reisner rv = -1; 2966b411b363SPhilipp Reisner break; 2967b411b363SPhilipp Reisner } 2968b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2969d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 2970b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2971b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2972b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 297369a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2974b411b363SPhilipp Reisner ? -1 : 1; 2975b411b363SPhilipp Reisner break; 2976b411b363SPhilipp Reisner } else { 2977b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2978b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2979b411b363SPhilipp Reisner } 298044ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2981b411b363SPhilipp Reisner break; 2982b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2983b411b363SPhilipp Reisner if (ch_self < ch_peer) 2984b411b363SPhilipp Reisner rv = -1; 2985b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2986b411b363SPhilipp Reisner rv = 1; 2987b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2988b411b363SPhilipp Reisner /* Well, then use something else. */ 298969a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2990b411b363SPhilipp Reisner ? -1 : 1; 2991b411b363SPhilipp Reisner break; 2992b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2993b411b363SPhilipp Reisner rv = -1; 2994b411b363SPhilipp Reisner break; 2995b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2996b411b363SPhilipp Reisner rv = 1; 2997b411b363SPhilipp Reisner } 2998b411b363SPhilipp Reisner 2999b411b363SPhilipp Reisner return rv; 3000b411b363SPhilipp Reisner } 3001b411b363SPhilipp Reisner 300269a22773SAndreas Gruenbacher /** 300369a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 300469a22773SAndreas Gruenbacher */ 300569a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 3006b411b363SPhilipp Reisner { 300769a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 30086184ea21SAndreas Gruenbacher int hg, rv = -100; 300944ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 3010b411b363SPhilipp Reisner 301144ed167dSPhilipp Reisner rcu_read_lock(); 301269a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 301344ed167dSPhilipp Reisner rcu_read_unlock(); 301444ed167dSPhilipp Reisner switch (after_sb_1p) { 3015b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3016b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3017b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3018b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3019b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 302044ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3021d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3022b411b363SPhilipp Reisner break; 3023b411b363SPhilipp Reisner case ASB_DISCONNECT: 3024b411b363SPhilipp Reisner break; 3025b411b363SPhilipp Reisner case ASB_CONSENSUS: 302669a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3027b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 3028b411b363SPhilipp Reisner rv = hg; 3029b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 3030b411b363SPhilipp Reisner rv = hg; 3031b411b363SPhilipp Reisner break; 3032b411b363SPhilipp Reisner case ASB_VIOLENTLY: 303369a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3034b411b363SPhilipp Reisner break; 3035b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 3036b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 3037b411b363SPhilipp Reisner case ASB_CALL_HELPER: 303869a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3039b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 3040bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3041bb437946SAndreas Gruenbacher 3042b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3043b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3044b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3045b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3046bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3047b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3048b411b363SPhilipp Reisner } else { 3049d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3050b411b363SPhilipp Reisner rv = hg; 3051b411b363SPhilipp Reisner } 3052b411b363SPhilipp Reisner } else 3053b411b363SPhilipp Reisner rv = hg; 3054b411b363SPhilipp Reisner } 3055b411b363SPhilipp Reisner 3056b411b363SPhilipp Reisner return rv; 3057b411b363SPhilipp Reisner } 3058b411b363SPhilipp Reisner 305969a22773SAndreas Gruenbacher /** 306069a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 306169a22773SAndreas Gruenbacher */ 306269a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 3063b411b363SPhilipp Reisner { 306469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 30656184ea21SAndreas Gruenbacher int hg, rv = -100; 306644ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 3067b411b363SPhilipp Reisner 306844ed167dSPhilipp Reisner rcu_read_lock(); 306969a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 307044ed167dSPhilipp Reisner rcu_read_unlock(); 307144ed167dSPhilipp Reisner switch (after_sb_2p) { 3072b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3073b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3074b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3075b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3076b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 3077b411b363SPhilipp Reisner case ASB_CONSENSUS: 3078b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 307944ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3080d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3081b411b363SPhilipp Reisner break; 3082b411b363SPhilipp Reisner case ASB_VIOLENTLY: 308369a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3084b411b363SPhilipp Reisner break; 3085b411b363SPhilipp Reisner case ASB_DISCONNECT: 3086b411b363SPhilipp Reisner break; 3087b411b363SPhilipp Reisner case ASB_CALL_HELPER: 308869a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3089b411b363SPhilipp Reisner if (hg == -1) { 3090bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3091bb437946SAndreas Gruenbacher 3092b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3093b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3094b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3095b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3096bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3097b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3098b411b363SPhilipp Reisner } else { 3099d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3100b411b363SPhilipp Reisner rv = hg; 3101b411b363SPhilipp Reisner } 3102b411b363SPhilipp Reisner } else 3103b411b363SPhilipp Reisner rv = hg; 3104b411b363SPhilipp Reisner } 3105b411b363SPhilipp Reisner 3106b411b363SPhilipp Reisner return rv; 3107b411b363SPhilipp Reisner } 3108b411b363SPhilipp Reisner 3109b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 3110b411b363SPhilipp Reisner u64 bits, u64 flags) 3111b411b363SPhilipp Reisner { 3112b411b363SPhilipp Reisner if (!uuid) { 3113d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 3114b411b363SPhilipp Reisner return; 3115b411b363SPhilipp Reisner } 3116d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 3117b411b363SPhilipp Reisner text, 3118b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 3119b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 3120b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 3121b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 3122b411b363SPhilipp Reisner (unsigned long long)bits, 3123b411b363SPhilipp Reisner (unsigned long long)flags); 3124b411b363SPhilipp Reisner } 3125b411b363SPhilipp Reisner 3126b411b363SPhilipp Reisner /* 3127b411b363SPhilipp Reisner 100 after split brain try auto recover 3128b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 3129b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 3130b411b363SPhilipp Reisner 0 no Sync 3131b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 3132b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 3133b411b363SPhilipp Reisner -100 after split brain, disconnect 3134b411b363SPhilipp Reisner -1000 unrelated data 31354a23f264SPhilipp Reisner -1091 requires proto 91 31364a23f264SPhilipp Reisner -1096 requires proto 96 3137b411b363SPhilipp Reisner */ 3138f2d3d75bSLars Ellenberg 3139f2d3d75bSLars Ellenberg static int drbd_uuid_compare(struct drbd_device *const device, enum drbd_role const peer_role, int *rule_nr) __must_hold(local) 3140b411b363SPhilipp Reisner { 314144a4d551SLars Ellenberg struct drbd_peer_device *const peer_device = first_peer_device(device); 314244a4d551SLars Ellenberg struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; 3143b411b363SPhilipp Reisner u64 self, peer; 3144b411b363SPhilipp Reisner int i, j; 3145b411b363SPhilipp Reisner 3146b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3147b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3148b411b363SPhilipp Reisner 3149b411b363SPhilipp Reisner *rule_nr = 10; 3150b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 3151b411b363SPhilipp Reisner return 0; 3152b411b363SPhilipp Reisner 3153b411b363SPhilipp Reisner *rule_nr = 20; 3154b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 3155b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 3156b411b363SPhilipp Reisner return -2; 3157b411b363SPhilipp Reisner 3158b411b363SPhilipp Reisner *rule_nr = 30; 3159b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 3160b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 3161b411b363SPhilipp Reisner return 2; 3162b411b363SPhilipp Reisner 3163b411b363SPhilipp Reisner if (self == peer) { 3164b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 3165b411b363SPhilipp Reisner 3166b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 3167b411b363SPhilipp Reisner 316844a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 31694a23f264SPhilipp Reisner return -1091; 3170b411b363SPhilipp Reisner 3171b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 3172b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 3173d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 3174b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 3175b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 3176b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 3177b411b363SPhilipp Reisner 3178b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3179b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3180b411b363SPhilipp Reisner *rule_nr = 34; 3181b411b363SPhilipp Reisner } else { 3182d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 3183b411b363SPhilipp Reisner *rule_nr = 36; 3184b411b363SPhilipp Reisner } 3185b411b363SPhilipp Reisner 3186b411b363SPhilipp Reisner return 1; 3187b411b363SPhilipp Reisner } 3188b411b363SPhilipp Reisner 3189b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 3190b411b363SPhilipp Reisner 319144a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 31924a23f264SPhilipp Reisner return -1091; 3193b411b363SPhilipp Reisner 3194b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 3195b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 3196d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 3197b411b363SPhilipp Reisner 3198b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 3199b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 3200b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 3201b411b363SPhilipp Reisner 3202b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3203b411b363SPhilipp Reisner *rule_nr = 35; 3204b411b363SPhilipp Reisner } else { 3205d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 3206b411b363SPhilipp Reisner *rule_nr = 37; 3207b411b363SPhilipp Reisner } 3208b411b363SPhilipp Reisner 3209b411b363SPhilipp Reisner return -1; 3210b411b363SPhilipp Reisner } 3211b411b363SPhilipp Reisner 3212b411b363SPhilipp Reisner /* Common power [off|failure] */ 3213b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 3214b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 3215b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 3216b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 3217b411b363SPhilipp Reisner *rule_nr = 40; 3218b411b363SPhilipp Reisner 3219f2d3d75bSLars Ellenberg /* Neither has the "crashed primary" flag set, 3220f2d3d75bSLars Ellenberg * only a replication link hickup. */ 3221f2d3d75bSLars Ellenberg if (rct == 0) 3222f2d3d75bSLars Ellenberg return 0; 3223f2d3d75bSLars Ellenberg 3224f2d3d75bSLars Ellenberg /* Current UUID equal and no bitmap uuid; does not necessarily 3225f2d3d75bSLars Ellenberg * mean this was a "simultaneous hard crash", maybe IO was 3226f2d3d75bSLars Ellenberg * frozen, so no UUID-bump happened. 3227f2d3d75bSLars Ellenberg * This is a protocol change, overload DRBD_FF_WSAME as flag 3228f2d3d75bSLars Ellenberg * for "new-enough" peer DRBD version. */ 3229f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY || peer_role == R_PRIMARY) { 3230f2d3d75bSLars Ellenberg *rule_nr = 41; 3231f2d3d75bSLars Ellenberg if (!(connection->agreed_features & DRBD_FF_WSAME)) { 3232f2d3d75bSLars Ellenberg drbd_warn(peer_device, "Equivalent unrotated UUIDs, but current primary present.\n"); 3233f2d3d75bSLars Ellenberg return -(0x10000 | PRO_VERSION_MAX | (DRBD_FF_WSAME << 8)); 3234f2d3d75bSLars Ellenberg } 3235f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY && peer_role == R_PRIMARY) { 3236f2d3d75bSLars Ellenberg /* At least one has the "crashed primary" bit set, 3237f2d3d75bSLars Ellenberg * both are primary now, but neither has rotated its UUIDs? 3238f2d3d75bSLars Ellenberg * "Can not happen." */ 3239f2d3d75bSLars Ellenberg drbd_err(peer_device, "Equivalent unrotated UUIDs, but both are primary. Can not resolve this.\n"); 3240f2d3d75bSLars Ellenberg return -100; 3241f2d3d75bSLars Ellenberg } 3242f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY) 3243f2d3d75bSLars Ellenberg return 1; 3244f2d3d75bSLars Ellenberg return -1; 3245f2d3d75bSLars Ellenberg } 3246f2d3d75bSLars Ellenberg 3247f2d3d75bSLars Ellenberg /* Both are secondary. 3248f2d3d75bSLars Ellenberg * Really looks like recovery from simultaneous hard crash. 3249f2d3d75bSLars Ellenberg * Check which had been primary before, and arbitrate. */ 3250b411b363SPhilipp Reisner switch (rct) { 3251f2d3d75bSLars Ellenberg case 0: /* !self_pri && !peer_pri */ return 0; /* already handled */ 3252b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 3253b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 3254b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 325544a4d551SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); 3256b411b363SPhilipp Reisner return dc ? -1 : 1; 3257b411b363SPhilipp Reisner } 3258b411b363SPhilipp Reisner } 3259b411b363SPhilipp Reisner 3260b411b363SPhilipp Reisner *rule_nr = 50; 3261b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3262b411b363SPhilipp Reisner if (self == peer) 3263b411b363SPhilipp Reisner return -1; 3264b411b363SPhilipp Reisner 3265b411b363SPhilipp Reisner *rule_nr = 51; 3266b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 3267b411b363SPhilipp Reisner if (self == peer) { 326844a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3269b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 3270b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 3271b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 3272b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3273b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 3274b411b363SPhilipp Reisner 327544a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 32764a23f264SPhilipp Reisner return -1091; 3277b411b363SPhilipp Reisner 3278b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 3279b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 32804a23f264SPhilipp Reisner 3281d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 3282b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 32834a23f264SPhilipp Reisner 3284b411b363SPhilipp Reisner return -1; 3285b411b363SPhilipp Reisner } 3286b411b363SPhilipp Reisner } 3287b411b363SPhilipp Reisner 3288b411b363SPhilipp Reisner *rule_nr = 60; 3289b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3290b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3291b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 3292b411b363SPhilipp Reisner if (self == peer) 3293b411b363SPhilipp Reisner return -2; 3294b411b363SPhilipp Reisner } 3295b411b363SPhilipp Reisner 3296b411b363SPhilipp Reisner *rule_nr = 70; 3297b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3298b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3299b411b363SPhilipp Reisner if (self == peer) 3300b411b363SPhilipp Reisner return 1; 3301b411b363SPhilipp Reisner 3302b411b363SPhilipp Reisner *rule_nr = 71; 3303b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 3304b411b363SPhilipp Reisner if (self == peer) { 330544a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3306b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 3307b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 3308b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 3309b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3310b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 3311b411b363SPhilipp Reisner 331244a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 33134a23f264SPhilipp Reisner return -1091; 3314b411b363SPhilipp Reisner 3315b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 3316b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 3317b411b363SPhilipp Reisner 3318d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 3319b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3320b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3321b411b363SPhilipp Reisner 3322b411b363SPhilipp Reisner return 1; 3323b411b363SPhilipp Reisner } 3324b411b363SPhilipp Reisner } 3325b411b363SPhilipp Reisner 3326b411b363SPhilipp Reisner 3327b411b363SPhilipp Reisner *rule_nr = 80; 3328b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3329b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3330b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3331b411b363SPhilipp Reisner if (self == peer) 3332b411b363SPhilipp Reisner return 2; 3333b411b363SPhilipp Reisner } 3334b411b363SPhilipp Reisner 3335b411b363SPhilipp Reisner *rule_nr = 90; 3336b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3337b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3338b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 3339b411b363SPhilipp Reisner return 100; 3340b411b363SPhilipp Reisner 3341b411b363SPhilipp Reisner *rule_nr = 100; 3342b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3343b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3344b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 3345b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 3346b411b363SPhilipp Reisner if (self == peer) 3347b411b363SPhilipp Reisner return -100; 3348b411b363SPhilipp Reisner } 3349b411b363SPhilipp Reisner } 3350b411b363SPhilipp Reisner 3351b411b363SPhilipp Reisner return -1000; 3352b411b363SPhilipp Reisner } 3353b411b363SPhilipp Reisner 3354b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 3355b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 3356b411b363SPhilipp Reisner */ 335769a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 335869a22773SAndreas Gruenbacher enum drbd_role peer_role, 3359b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 3360b411b363SPhilipp Reisner { 336169a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 3362b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 3363b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 336444ed167dSPhilipp Reisner struct net_conf *nc; 33656dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 3366b411b363SPhilipp Reisner 3367b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 3368b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 3369b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 3370b411b363SPhilipp Reisner 3371d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 33729f2247bbSPhilipp Reisner 3373b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 3374b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 3375b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 3376b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3377b411b363SPhilipp Reisner 3378f2d3d75bSLars Ellenberg hg = drbd_uuid_compare(device, peer_role, &rule_nr); 3379b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 3380b411b363SPhilipp Reisner 3381d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 3382b411b363SPhilipp Reisner 3383b411b363SPhilipp Reisner if (hg == -1000) { 3384d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3385b411b363SPhilipp Reisner return C_MASK; 3386b411b363SPhilipp Reisner } 3387f2d3d75bSLars Ellenberg if (hg < -0x10000) { 3388f2d3d75bSLars Ellenberg int proto, fflags; 3389f2d3d75bSLars Ellenberg hg = -hg; 3390f2d3d75bSLars Ellenberg proto = hg & 0xff; 3391f2d3d75bSLars Ellenberg fflags = (hg >> 8) & 0xff; 3392f2d3d75bSLars Ellenberg drbd_alert(device, "To resolve this both sides have to support at least protocol %d and feature flags 0x%x\n", 3393f2d3d75bSLars Ellenberg proto, fflags); 3394f2d3d75bSLars Ellenberg return C_MASK; 3395f2d3d75bSLars Ellenberg } 33964a23f264SPhilipp Reisner if (hg < -1000) { 3397d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3398b411b363SPhilipp Reisner return C_MASK; 3399b411b363SPhilipp Reisner } 3400b411b363SPhilipp Reisner 3401b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3402b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3403b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3404b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3405b411b363SPhilipp Reisner if (f) 3406b411b363SPhilipp Reisner hg = hg*2; 3407d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3408b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3409b411b363SPhilipp Reisner } 3410b411b363SPhilipp Reisner 34113a11a487SAdam Gandelman if (abs(hg) == 100) 3412b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 34133a11a487SAdam Gandelman 341444ed167dSPhilipp Reisner rcu_read_lock(); 341569a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 341644ed167dSPhilipp Reisner 341744ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3418b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3419b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3420b411b363SPhilipp Reisner int forced = (hg == -100); 3421b411b363SPhilipp Reisner 3422b411b363SPhilipp Reisner switch (pcount) { 3423b411b363SPhilipp Reisner case 0: 342469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3425b411b363SPhilipp Reisner break; 3426b411b363SPhilipp Reisner case 1: 342769a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3428b411b363SPhilipp Reisner break; 3429b411b363SPhilipp Reisner case 2: 343069a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3431b411b363SPhilipp Reisner break; 3432b411b363SPhilipp Reisner } 3433b411b363SPhilipp Reisner if (abs(hg) < 100) { 3434d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3435b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3436b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3437b411b363SPhilipp Reisner if (forced) { 3438d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3439b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3440b411b363SPhilipp Reisner hg = hg*2; 3441b411b363SPhilipp Reisner } 3442b411b363SPhilipp Reisner } 3443b411b363SPhilipp Reisner } 3444b411b363SPhilipp Reisner 3445b411b363SPhilipp Reisner if (hg == -100) { 3446b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3447b411b363SPhilipp Reisner hg = -1; 3448b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3449b411b363SPhilipp Reisner hg = 1; 3450b411b363SPhilipp Reisner 3451b411b363SPhilipp Reisner if (abs(hg) < 100) 3452d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3453b411b363SPhilipp Reisner "Sync from %s node\n", 3454b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3455b411b363SPhilipp Reisner } 345644ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 34576dff2902SAndreas Gruenbacher tentative = nc->tentative; 345844ed167dSPhilipp Reisner rcu_read_unlock(); 3459b411b363SPhilipp Reisner 3460b411b363SPhilipp Reisner if (hg == -100) { 3461580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3462580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3463580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3464580b9767SLars Ellenberg * to that disk, in a way... */ 3465d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3466b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3467b411b363SPhilipp Reisner return C_MASK; 3468b411b363SPhilipp Reisner } 3469b411b363SPhilipp Reisner 3470b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3471d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3472b411b363SPhilipp Reisner return C_MASK; 3473b411b363SPhilipp Reisner } 3474b411b363SPhilipp Reisner 3475b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3476b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 347744ed167dSPhilipp Reisner switch (rr_conflict) { 3478b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3479b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3480b411b363SPhilipp Reisner /* fall through */ 3481b411b363SPhilipp Reisner case ASB_DISCONNECT: 3482d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3483b411b363SPhilipp Reisner return C_MASK; 3484b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3485d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3486b411b363SPhilipp Reisner "assumption\n"); 3487b411b363SPhilipp Reisner } 3488b411b363SPhilipp Reisner } 3489b411b363SPhilipp Reisner 349069a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3491cf14c2e9SPhilipp Reisner if (hg == 0) 3492d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3493cf14c2e9SPhilipp Reisner else 3494d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3495cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3496cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3497cf14c2e9SPhilipp Reisner return C_MASK; 3498cf14c2e9SPhilipp Reisner } 3499cf14c2e9SPhilipp Reisner 3500b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3501d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3502b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 350320ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3504b411b363SPhilipp Reisner return C_MASK; 3505b411b363SPhilipp Reisner } 3506b411b363SPhilipp Reisner 3507b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3508b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3509b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3510b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3511b411b363SPhilipp Reisner } else { 3512b411b363SPhilipp Reisner rv = C_CONNECTED; 3513b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3514d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3515b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3516b411b363SPhilipp Reisner } 3517b411b363SPhilipp Reisner } 3518b411b363SPhilipp Reisner 3519b411b363SPhilipp Reisner return rv; 3520b411b363SPhilipp Reisner } 3521b411b363SPhilipp Reisner 3522f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3523b411b363SPhilipp Reisner { 3524b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3525f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3526f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3527b411b363SPhilipp Reisner 3528b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3529f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3530f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3531b411b363SPhilipp Reisner 3532b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3533f179d76dSPhilipp Reisner return peer; 3534b411b363SPhilipp Reisner } 3535b411b363SPhilipp Reisner 3536bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3537b411b363SPhilipp Reisner { 3538e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3539036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3540036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3541036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3542036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 35439534d671SHerbert Xu struct crypto_ahash *peer_integrity_tfm = NULL; 35447aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3545b411b363SPhilipp Reisner 3546b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3547b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3548b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3549b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3550b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3551cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 35526139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3553cf14c2e9SPhilipp Reisner 3554bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 355586db0618SAndreas Gruenbacher int err; 355686db0618SAndreas Gruenbacher 355788104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 355886db0618SAndreas Gruenbacher return -EIO; 3559bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 356086db0618SAndreas Gruenbacher if (err) 356186db0618SAndreas Gruenbacher return err; 356288104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3563036b17eaSPhilipp Reisner } 356486db0618SAndreas Gruenbacher 35657d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3566bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3567cf14c2e9SPhilipp Reisner 3568cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3569bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3570b411b363SPhilipp Reisner 357144ed167dSPhilipp Reisner rcu_read_lock(); 3572bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 357344ed167dSPhilipp Reisner 3574036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 35751ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 357644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3577b411b363SPhilipp Reisner } 3578b411b363SPhilipp Reisner 3579f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 35801ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 358144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3582b411b363SPhilipp Reisner } 3583b411b363SPhilipp Reisner 3584f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 35851ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 358644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3587b411b363SPhilipp Reisner } 3588b411b363SPhilipp Reisner 3589f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 35901ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 359144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3592b411b363SPhilipp Reisner } 3593b411b363SPhilipp Reisner 35946139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 35951ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 359644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3597b411b363SPhilipp Reisner } 3598b411b363SPhilipp Reisner 359944ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 36001ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 360144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3602b411b363SPhilipp Reisner } 3603b411b363SPhilipp Reisner 3604036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 36051ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3606036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3607036b17eaSPhilipp Reisner } 3608036b17eaSPhilipp Reisner 360986db0618SAndreas Gruenbacher rcu_read_unlock(); 3610fbc12f45SAndreas Gruenbacher } 36117d4c782cSAndreas Gruenbacher 36127d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 36137d4c782cSAndreas Gruenbacher int hash_size; 36147d4c782cSAndreas Gruenbacher 36157d4c782cSAndreas Gruenbacher /* 36167d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 36177d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 36187d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 36197d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 36207d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 36217d4c782cSAndreas Gruenbacher * change. 36227d4c782cSAndreas Gruenbacher */ 36237d4c782cSAndreas Gruenbacher 36249534d671SHerbert Xu peer_integrity_tfm = crypto_alloc_ahash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 36251b57e663SLars Ellenberg if (IS_ERR(peer_integrity_tfm)) { 36261b57e663SLars Ellenberg peer_integrity_tfm = NULL; 36271ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 36287d4c782cSAndreas Gruenbacher integrity_alg); 3629b411b363SPhilipp Reisner goto disconnect; 3630b411b363SPhilipp Reisner } 3631b411b363SPhilipp Reisner 36329534d671SHerbert Xu hash_size = crypto_ahash_digestsize(peer_integrity_tfm); 36337d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 36347d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 36357d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 36361ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 36377d4c782cSAndreas Gruenbacher goto disconnect; 36387d4c782cSAndreas Gruenbacher } 36397d4c782cSAndreas Gruenbacher } 36407d4c782cSAndreas Gruenbacher 36417d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 36427d4c782cSAndreas Gruenbacher if (!new_net_conf) { 36431ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3644b411b363SPhilipp Reisner goto disconnect; 3645b411b363SPhilipp Reisner } 3646b411b363SPhilipp Reisner 3647bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 36480500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3649bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 36507d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3651b411b363SPhilipp Reisner 36527d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 36537d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 36547d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 36557d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 36567d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3657b411b363SPhilipp Reisner 3658bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 36590500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3660bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3661b411b363SPhilipp Reisner 36629534d671SHerbert Xu crypto_free_ahash(connection->peer_integrity_tfm); 3663bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3664bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3665bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3666bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3667bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3668b411b363SPhilipp Reisner 36697d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 36701ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 36717d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3672b411b363SPhilipp Reisner 36737d4c782cSAndreas Gruenbacher synchronize_rcu(); 36747d4c782cSAndreas Gruenbacher kfree(old_net_conf); 367582bc0194SAndreas Gruenbacher return 0; 3676b411b363SPhilipp Reisner 367744ed167dSPhilipp Reisner disconnect_rcu_unlock: 367844ed167dSPhilipp Reisner rcu_read_unlock(); 3679b411b363SPhilipp Reisner disconnect: 36809534d671SHerbert Xu crypto_free_ahash(peer_integrity_tfm); 3681036b17eaSPhilipp Reisner kfree(int_dig_in); 3682036b17eaSPhilipp Reisner kfree(int_dig_vv); 3683bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 368482bc0194SAndreas Gruenbacher return -EIO; 3685b411b363SPhilipp Reisner } 3686b411b363SPhilipp Reisner 3687b411b363SPhilipp Reisner /* helper function 3688b411b363SPhilipp Reisner * input: alg name, feature name 3689b411b363SPhilipp Reisner * return: NULL (alg name was "") 3690b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3691b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 36929534d671SHerbert Xu static struct crypto_ahash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3693b411b363SPhilipp Reisner const char *alg, const char *name) 3694b411b363SPhilipp Reisner { 36959534d671SHerbert Xu struct crypto_ahash *tfm; 3696b411b363SPhilipp Reisner 3697b411b363SPhilipp Reisner if (!alg[0]) 3698b411b363SPhilipp Reisner return NULL; 3699b411b363SPhilipp Reisner 37009534d671SHerbert Xu tfm = crypto_alloc_ahash(alg, 0, CRYPTO_ALG_ASYNC); 3701b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3702d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3703b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3704b411b363SPhilipp Reisner return tfm; 3705b411b363SPhilipp Reisner } 3706b411b363SPhilipp Reisner return tfm; 3707b411b363SPhilipp Reisner } 3708b411b363SPhilipp Reisner 3709bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3710b411b363SPhilipp Reisner { 3711bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 37124a76b161SAndreas Gruenbacher int size = pi->size; 37134a76b161SAndreas Gruenbacher 37144a76b161SAndreas Gruenbacher while (size) { 37154a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3716bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 37174a76b161SAndreas Gruenbacher if (s <= 0) { 37184a76b161SAndreas Gruenbacher if (s < 0) 37194a76b161SAndreas Gruenbacher return s; 37204a76b161SAndreas Gruenbacher break; 37214a76b161SAndreas Gruenbacher } 37224a76b161SAndreas Gruenbacher size -= s; 37234a76b161SAndreas Gruenbacher } 37244a76b161SAndreas Gruenbacher if (size) 37254a76b161SAndreas Gruenbacher return -EIO; 37264a76b161SAndreas Gruenbacher return 0; 37274a76b161SAndreas Gruenbacher } 37284a76b161SAndreas Gruenbacher 37294a76b161SAndreas Gruenbacher /* 37304a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 37314a76b161SAndreas Gruenbacher * 37324a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 37334a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 37344a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 37354a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 37364a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 37374a76b161SAndreas Gruenbacher * 37384a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 37394a76b161SAndreas Gruenbacher */ 3740bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 37414a76b161SAndreas Gruenbacher { 37421ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 37432fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3744bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 37454a76b161SAndreas Gruenbacher } 37464a76b161SAndreas Gruenbacher 3747bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 37484a76b161SAndreas Gruenbacher { 37499f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3750b30ab791SAndreas Gruenbacher struct drbd_device *device; 3751e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3752b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 37539534d671SHerbert Xu struct crypto_ahash *verify_tfm = NULL; 37549534d671SHerbert Xu struct crypto_ahash *csums_tfm = NULL; 37552ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3756813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3757bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3758813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3759778f271dSPhilipp Reisner int fifo_size = 0; 376082bc0194SAndreas Gruenbacher int err; 3761b411b363SPhilipp Reisner 37629f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 37639f4fe9adSAndreas Gruenbacher if (!peer_device) 3764bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 37659f4fe9adSAndreas Gruenbacher device = peer_device->device; 3766b411b363SPhilipp Reisner 3767b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3768b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3769b411b363SPhilipp Reisner + SHARED_SECRET_MAX 37708e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 37718e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3772b411b363SPhilipp Reisner 3773e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3774d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3775e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 377682bc0194SAndreas Gruenbacher return -EIO; 3777b411b363SPhilipp Reisner } 3778b411b363SPhilipp Reisner 3779b411b363SPhilipp Reisner if (apv <= 88) { 3780e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3781e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 37828e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3783e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3784e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 37850b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 37868e26f9ccSPhilipp Reisner } else { 3787e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3788e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 37890b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3790b411b363SPhilipp Reisner } 3791b411b363SPhilipp Reisner 3792b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3793e658983aSAndreas Gruenbacher p = pi->data; 3794b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3795b411b363SPhilipp Reisner 37969f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 379782bc0194SAndreas Gruenbacher if (err) 379882bc0194SAndreas Gruenbacher return err; 3799b411b363SPhilipp Reisner 38000500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 38019f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3802b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3803daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3804daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3805b30ab791SAndreas Gruenbacher put_ldev(device); 38060500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3807d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3808daeda1ccSPhilipp Reisner return -ENOMEM; 3809f399002eSLars Ellenberg } 3810b411b363SPhilipp Reisner 3811b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3812daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3813daeda1ccSPhilipp Reisner 38146394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3815813472ceSPhilipp Reisner } 3816b411b363SPhilipp Reisner 3817b411b363SPhilipp Reisner if (apv >= 88) { 3818b411b363SPhilipp Reisner if (apv == 88) { 38195de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3820d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 38215de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3822b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3823813472ceSPhilipp Reisner err = -EIO; 3824813472ceSPhilipp Reisner goto reconnect; 3825b411b363SPhilipp Reisner } 3826b411b363SPhilipp Reisner 38279f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3828813472ceSPhilipp Reisner if (err) 3829813472ceSPhilipp Reisner goto reconnect; 3830b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3831b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38320b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3833b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3834b411b363SPhilipp Reisner 3835b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3836b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3837b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38380b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 38390b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3840b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3841b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3842b411b363SPhilipp Reisner } 3843b411b363SPhilipp Reisner 38442ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3845b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3846d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 38472ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3848b411b363SPhilipp Reisner goto disconnect; 3849b411b363SPhilipp Reisner } 3850b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3851b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3852b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3853b411b363SPhilipp Reisner verify_tfm = NULL; 3854b411b363SPhilipp Reisner goto disconnect; 3855b411b363SPhilipp Reisner } 3856b411b363SPhilipp Reisner } 3857b411b363SPhilipp Reisner 38582ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3859b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3860d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 38612ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3862b411b363SPhilipp Reisner goto disconnect; 3863b411b363SPhilipp Reisner } 3864b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3865b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3866b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3867b411b363SPhilipp Reisner csums_tfm = NULL; 3868b411b363SPhilipp Reisner goto disconnect; 3869b411b363SPhilipp Reisner } 3870b411b363SPhilipp Reisner } 3871b411b363SPhilipp Reisner 3872813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3873daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3874daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3875daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3876daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3877778f271dSPhilipp Reisner 3878daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3879b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3880813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3881813472ceSPhilipp Reisner if (!new_plan) { 3882d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3883b30ab791SAndreas Gruenbacher put_ldev(device); 3884778f271dSPhilipp Reisner goto disconnect; 3885778f271dSPhilipp Reisner } 3886778f271dSPhilipp Reisner } 38878e26f9ccSPhilipp Reisner } 3888b411b363SPhilipp Reisner 388991fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 38902ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 38912ec91e0eSPhilipp Reisner if (!new_net_conf) { 3892d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 389391fd4dadSPhilipp Reisner goto disconnect; 389491fd4dadSPhilipp Reisner } 389591fd4dadSPhilipp Reisner 38962ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 389791fd4dadSPhilipp Reisner 3898b411b363SPhilipp Reisner if (verify_tfm) { 38992ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 39002ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 39019534d671SHerbert Xu crypto_free_ahash(peer_device->connection->verify_tfm); 39029f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3903d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3904b411b363SPhilipp Reisner } 3905b411b363SPhilipp Reisner if (csums_tfm) { 39062ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 39072ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 39089534d671SHerbert Xu crypto_free_ahash(peer_device->connection->csums_tfm); 39099f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3910d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3911b411b363SPhilipp Reisner } 3912bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3913778f271dSPhilipp Reisner } 3914b411b363SPhilipp Reisner } 3915b411b363SPhilipp Reisner 3916813472ceSPhilipp Reisner if (new_disk_conf) { 3917b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3918b30ab791SAndreas Gruenbacher put_ldev(device); 3919b411b363SPhilipp Reisner } 3920813472ceSPhilipp Reisner 3921813472ceSPhilipp Reisner if (new_plan) { 3922b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3923b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3924813472ceSPhilipp Reisner } 3925daeda1ccSPhilipp Reisner 39260500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3927daeda1ccSPhilipp Reisner synchronize_rcu(); 3928daeda1ccSPhilipp Reisner if (new_net_conf) 3929daeda1ccSPhilipp Reisner kfree(old_net_conf); 3930daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3931813472ceSPhilipp Reisner kfree(old_plan); 3932daeda1ccSPhilipp Reisner 393382bc0194SAndreas Gruenbacher return 0; 3934b411b363SPhilipp Reisner 3935813472ceSPhilipp Reisner reconnect: 3936813472ceSPhilipp Reisner if (new_disk_conf) { 3937b30ab791SAndreas Gruenbacher put_ldev(device); 3938813472ceSPhilipp Reisner kfree(new_disk_conf); 3939813472ceSPhilipp Reisner } 39400500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3941813472ceSPhilipp Reisner return -EIO; 3942813472ceSPhilipp Reisner 3943b411b363SPhilipp Reisner disconnect: 3944813472ceSPhilipp Reisner kfree(new_plan); 3945813472ceSPhilipp Reisner if (new_disk_conf) { 3946b30ab791SAndreas Gruenbacher put_ldev(device); 3947813472ceSPhilipp Reisner kfree(new_disk_conf); 3948813472ceSPhilipp Reisner } 39490500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3950b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3951b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 39529534d671SHerbert Xu crypto_free_ahash(csums_tfm); 3953b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 39549534d671SHerbert Xu crypto_free_ahash(verify_tfm); 39559f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 395682bc0194SAndreas Gruenbacher return -EIO; 3957b411b363SPhilipp Reisner } 3958b411b363SPhilipp Reisner 3959b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3960b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 3961b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3962b411b363SPhilipp Reisner { 3963b411b363SPhilipp Reisner sector_t d; 3964b411b363SPhilipp Reisner if (a == 0 || b == 0) 3965b411b363SPhilipp Reisner return; 3966b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3967b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3968d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 3969b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3970b411b363SPhilipp Reisner } 3971b411b363SPhilipp Reisner 3972bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 3973b411b363SPhilipp Reisner { 39749f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3975b30ab791SAndreas Gruenbacher struct drbd_device *device; 3976e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 39779104d31aSLars Ellenberg struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL; 3978e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 39796a8d68b1SLars Ellenberg sector_t p_size, p_usize, p_csize, my_usize; 3980b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3981e89b591cSPhilipp Reisner enum dds_flags ddsf; 3982b411b363SPhilipp Reisner 39839f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 39849f4fe9adSAndreas Gruenbacher if (!peer_device) 3985bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 39869f4fe9adSAndreas Gruenbacher device = peer_device->device; 39874a76b161SAndreas Gruenbacher 3988b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3989b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 39906a8d68b1SLars Ellenberg p_csize = be64_to_cpu(p->c_size); 3991b411b363SPhilipp Reisner 3992b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3993b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3994b30ab791SAndreas Gruenbacher device->p_size = p_size; 3995b411b363SPhilipp Reisner 3996b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 399760bac040SLars Ellenberg sector_t new_size, cur_size; 3998daeda1ccSPhilipp Reisner rcu_read_lock(); 3999b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 4000daeda1ccSPhilipp Reisner rcu_read_unlock(); 4001daeda1ccSPhilipp Reisner 4002b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 4003b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 4004b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 4005daeda1ccSPhilipp Reisner p_usize, my_usize); 4006b411b363SPhilipp Reisner 4007b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 4008b411b363SPhilipp Reisner * param exchange, choose the minimum */ 4009b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 4010daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 4011b411b363SPhilipp Reisner 4012b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 4013b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 401460bac040SLars Ellenberg new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0); 401560bac040SLars Ellenberg cur_size = drbd_get_capacity(device->this_bdev); 401660bac040SLars Ellenberg if (new_size < cur_size && 4017b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 4018b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 401960bac040SLars Ellenberg drbd_err(device, "The peer's disk size is too small! (%llu < %llu sectors)\n", 402060bac040SLars Ellenberg (unsigned long long)new_size, (unsigned long long)cur_size); 40219f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 4022b30ab791SAndreas Gruenbacher put_ldev(device); 402382bc0194SAndreas Gruenbacher return -EIO; 4024b411b363SPhilipp Reisner } 4025daeda1ccSPhilipp Reisner 4026daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 4027daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 4028daeda1ccSPhilipp Reisner 4029daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 4030daeda1ccSPhilipp Reisner if (!new_disk_conf) { 4031d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 4032b30ab791SAndreas Gruenbacher put_ldev(device); 4033daeda1ccSPhilipp Reisner return -ENOMEM; 4034daeda1ccSPhilipp Reisner } 4035daeda1ccSPhilipp Reisner 40360500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 4037b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 4038daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 4039daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 4040daeda1ccSPhilipp Reisner 4041b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 40420500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 4043daeda1ccSPhilipp Reisner synchronize_rcu(); 4044daeda1ccSPhilipp Reisner kfree(old_disk_conf); 4045daeda1ccSPhilipp Reisner 4046d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 4047daeda1ccSPhilipp Reisner (unsigned long)my_usize); 4048daeda1ccSPhilipp Reisner } 4049daeda1ccSPhilipp Reisner 4050b30ab791SAndreas Gruenbacher put_ldev(device); 4051b411b363SPhilipp Reisner } 4052b411b363SPhilipp Reisner 405320c68fdeSLars Ellenberg device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 4054dd4f699dSLars Ellenberg /* Leave drbd_reconsider_queue_parameters() before drbd_determine_dev_size(). 405520c68fdeSLars Ellenberg In case we cleared the QUEUE_FLAG_DISCARD from our queue in 4056dd4f699dSLars Ellenberg drbd_reconsider_queue_parameters(), we can be sure that after 405720c68fdeSLars Ellenberg drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */ 405820c68fdeSLars Ellenberg 4059e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 4060b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 40619104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, device->ldev, o); 4062b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 4063b30ab791SAndreas Gruenbacher put_ldev(device); 4064e96c9633SPhilipp Reisner if (dd == DS_ERROR) 406582bc0194SAndreas Gruenbacher return -EIO; 4066b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4067b411b363SPhilipp Reisner } else { 40686a8d68b1SLars Ellenberg /* 40696a8d68b1SLars Ellenberg * I am diskless, need to accept the peer's *current* size. 40706a8d68b1SLars Ellenberg * I must NOT accept the peers backing disk size, 40716a8d68b1SLars Ellenberg * it may have been larger than mine all along... 40726a8d68b1SLars Ellenberg * 40736a8d68b1SLars Ellenberg * At this point, the peer knows more about my disk, or at 40746a8d68b1SLars Ellenberg * least about what we last agreed upon, than myself. 40756a8d68b1SLars Ellenberg * So if his c_size is less than his d_size, the most likely 40766a8d68b1SLars Ellenberg * reason is that *my* d_size was smaller last time we checked. 40776a8d68b1SLars Ellenberg * 40786a8d68b1SLars Ellenberg * However, if he sends a zero current size, 40796a8d68b1SLars Ellenberg * take his (user-capped or) backing disk size anyways. 40806a8d68b1SLars Ellenberg */ 40819104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, NULL, o); 40826a8d68b1SLars Ellenberg drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); 4083b411b363SPhilipp Reisner } 4084b411b363SPhilipp Reisner 4085b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4086b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 4087b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 4088b411b363SPhilipp Reisner ldsc = 1; 4089b411b363SPhilipp Reisner } 4090b411b363SPhilipp Reisner 4091b30ab791SAndreas Gruenbacher put_ldev(device); 4092b411b363SPhilipp Reisner } 4093b411b363SPhilipp Reisner 4094b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 4095b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 4096b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 4097b411b363SPhilipp Reisner /* we have different sizes, probably peer 4098b411b363SPhilipp Reisner * needs to know my new size... */ 409969a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 4100b411b363SPhilipp Reisner } 4101b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 4102b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 4103b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 4104b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 4105e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 4106d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 4107b411b363SPhilipp Reisner else 4108b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 4109e89b591cSPhilipp Reisner } else 4110b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 4111b411b363SPhilipp Reisner } 4112b411b363SPhilipp Reisner } 4113b411b363SPhilipp Reisner 411482bc0194SAndreas Gruenbacher return 0; 4115b411b363SPhilipp Reisner } 4116b411b363SPhilipp Reisner 4117bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 4118b411b363SPhilipp Reisner { 41199f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4120b30ab791SAndreas Gruenbacher struct drbd_device *device; 4121e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 4122b411b363SPhilipp Reisner u64 *p_uuid; 412362b0da3aSLars Ellenberg int i, updated_uuids = 0; 4124b411b363SPhilipp Reisner 41259f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 41269f4fe9adSAndreas Gruenbacher if (!peer_device) 4127bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 41289f4fe9adSAndreas Gruenbacher device = peer_device->device; 41294a76b161SAndreas Gruenbacher 4130365cf663SRoland Kammerer p_uuid = kmalloc_array(UI_EXTENDED_SIZE, sizeof(*p_uuid), GFP_NOIO); 4131063eacf8SJing Wang if (!p_uuid) { 4132d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 4133063eacf8SJing Wang return false; 4134063eacf8SJing Wang } 4135b411b363SPhilipp Reisner 4136b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 4137b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 4138b411b363SPhilipp Reisner 4139b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4140b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 4141b411b363SPhilipp Reisner 4142b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 4143b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 4144b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 4145b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 4146d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 4147b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 41489f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 414982bc0194SAndreas Gruenbacher return -EIO; 4150b411b363SPhilipp Reisner } 4151b411b363SPhilipp Reisner 4152b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4153b411b363SPhilipp Reisner int skip_initial_sync = 4154b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 41559f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 4156b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 4157b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 4158b411b363SPhilipp Reisner if (skip_initial_sync) { 4159d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 4160b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 416120ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 416220ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 4163b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 4164b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 4165b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 4166b411b363SPhilipp Reisner CS_VERBOSE, NULL); 4167b30ab791SAndreas Gruenbacher drbd_md_sync(device); 416862b0da3aSLars Ellenberg updated_uuids = 1; 4169b411b363SPhilipp Reisner } 4170b30ab791SAndreas Gruenbacher put_ldev(device); 4171b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 4172b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 417318a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 417418a50fa2SPhilipp Reisner for me. */ 4175b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 4176b411b363SPhilipp Reisner } 4177b411b363SPhilipp Reisner 4178b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 4179b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 4180b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 4181b411b363SPhilipp Reisner new disk state... */ 4182b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 4183b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 4184b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 4185b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 418662b0da3aSLars Ellenberg 418762b0da3aSLars Ellenberg if (updated_uuids) 4188b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 4189b411b363SPhilipp Reisner 419082bc0194SAndreas Gruenbacher return 0; 4191b411b363SPhilipp Reisner } 4192b411b363SPhilipp Reisner 4193b411b363SPhilipp Reisner /** 4194b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 4195b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 4196b411b363SPhilipp Reisner */ 4197b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 4198b411b363SPhilipp Reisner { 4199b411b363SPhilipp Reisner union drbd_state ms; 4200b411b363SPhilipp Reisner 4201b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 4202369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 4203b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 4204b411b363SPhilipp Reisner 4205b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 4206b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 4207b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 4208b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 4209b411b363SPhilipp Reisner [C_MASK] = C_MASK, 4210b411b363SPhilipp Reisner }; 4211b411b363SPhilipp Reisner 4212b411b363SPhilipp Reisner ms.i = ps.i; 4213b411b363SPhilipp Reisner 4214b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 4215b411b363SPhilipp Reisner ms.peer = ps.role; 4216b411b363SPhilipp Reisner ms.role = ps.peer; 4217b411b363SPhilipp Reisner ms.pdsk = ps.disk; 4218b411b363SPhilipp Reisner ms.disk = ps.pdsk; 4219b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 4220b411b363SPhilipp Reisner 4221b411b363SPhilipp Reisner return ms; 4222b411b363SPhilipp Reisner } 4223b411b363SPhilipp Reisner 4224bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 4225b411b363SPhilipp Reisner { 42269f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4227b30ab791SAndreas Gruenbacher struct drbd_device *device; 4228e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4229b411b363SPhilipp Reisner union drbd_state mask, val; 4230bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 4231b411b363SPhilipp Reisner 42329f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42339f4fe9adSAndreas Gruenbacher if (!peer_device) 42344a76b161SAndreas Gruenbacher return -EIO; 42359f4fe9adSAndreas Gruenbacher device = peer_device->device; 42364a76b161SAndreas Gruenbacher 4237b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4238b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 4239b411b363SPhilipp Reisner 42409f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 4241b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 424269a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 424382bc0194SAndreas Gruenbacher return 0; 4244b411b363SPhilipp Reisner } 4245b411b363SPhilipp Reisner 4246b411b363SPhilipp Reisner mask = convert_state(mask); 4247b411b363SPhilipp Reisner val = convert_state(val); 4248b411b363SPhilipp Reisner 4249b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 425069a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 4251047cd4a6SPhilipp Reisner 4252b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4253b411b363SPhilipp Reisner 425482bc0194SAndreas Gruenbacher return 0; 4255b411b363SPhilipp Reisner } 4256b411b363SPhilipp Reisner 4257bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 4258b411b363SPhilipp Reisner { 4259e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4260dfafcc8aSPhilipp Reisner union drbd_state mask, val; 4261dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 4262dfafcc8aSPhilipp Reisner 4263dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4264dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 4265dfafcc8aSPhilipp Reisner 4266bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 4267bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 4268bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 426982bc0194SAndreas Gruenbacher return 0; 4270dfafcc8aSPhilipp Reisner } 4271dfafcc8aSPhilipp Reisner 4272dfafcc8aSPhilipp Reisner mask = convert_state(mask); 4273dfafcc8aSPhilipp Reisner val = convert_state(val); 4274dfafcc8aSPhilipp Reisner 4275bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 4276bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 4277dfafcc8aSPhilipp Reisner 427882bc0194SAndreas Gruenbacher return 0; 4279dfafcc8aSPhilipp Reisner } 4280dfafcc8aSPhilipp Reisner 4281bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 4282b411b363SPhilipp Reisner { 42839f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4284b30ab791SAndreas Gruenbacher struct drbd_device *device; 4285e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 42864ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 4287b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 428865d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 4289b411b363SPhilipp Reisner int rv; 4290b411b363SPhilipp Reisner 42919f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42929f4fe9adSAndreas Gruenbacher if (!peer_device) 4293bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 42949f4fe9adSAndreas Gruenbacher device = peer_device->device; 42954a76b161SAndreas Gruenbacher 4296b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 4297b411b363SPhilipp Reisner 4298b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 4299b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 4300b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 4301d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 4302b411b363SPhilipp Reisner } 4303b411b363SPhilipp Reisner 43040500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4305b411b363SPhilipp Reisner retry: 4306b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 43070500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4308b411b363SPhilipp Reisner 4309668700b4SPhilipp Reisner /* If some other part of the code (ack_receiver thread, timeout) 4310545752d5SLars Ellenberg * already decided to close the connection again, 4311545752d5SLars Ellenberg * we must not "re-establish" it here. */ 4312545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 431358ffa580SLars Ellenberg return -ECONNRESET; 4314545752d5SLars Ellenberg 431540424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 431640424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 431740424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 431840424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 431940424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 432040424e4aSLars Ellenberg */ 432140424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 432240424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 4323e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 4324e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 4325e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 4326e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 4327e9ef7bb6SLars Ellenberg * syncing states. 4328e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 4329e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 4330e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 4331e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 4332e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 4333e9ef7bb6SLars Ellenberg 4334e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 4335e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 4336e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 4337e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 4338e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 4339b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 4340b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 434182bc0194SAndreas Gruenbacher return 0; 4342e9ef7bb6SLars Ellenberg } 4343e9ef7bb6SLars Ellenberg } 4344e9ef7bb6SLars Ellenberg 434502b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 434602b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 434702b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 4348b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 4349b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 435058ffa580SLars Ellenberg return 0; 435102b91b55SLars Ellenberg } 435202b91b55SLars Ellenberg 4353e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 4354e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 4355e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 4356e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 4357e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 4358e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 4359e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 4360e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 4361e9ef7bb6SLars Ellenberg 43624ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 43634ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4364b411b363SPhilipp Reisner 436567531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 436667531718SPhilipp Reisner ns.conn = C_BEHIND; 436767531718SPhilipp Reisner 4368b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 4369b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 4370b411b363SPhilipp Reisner int cr; /* consider resync */ 4371b411b363SPhilipp Reisner 4372b411b363SPhilipp Reisner /* if we established a new connection */ 43734ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 4374b411b363SPhilipp Reisner /* if we had an established connection 4375b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 43764ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4377b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 43784ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 4379b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 4380b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 4381b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 4382b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 4383b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 43844ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4385b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 4386b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 4387b411b363SPhilipp Reisner 4388b411b363SPhilipp Reisner if (cr) 438969a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 4390b411b363SPhilipp Reisner 4391b30ab791SAndreas Gruenbacher put_ldev(device); 43924ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 43934ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4394b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 4395b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 4396b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 4397d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 4398b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 4399580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 4400b411b363SPhilipp Reisner } else { 44019f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 440282bc0194SAndreas Gruenbacher return -EIO; 44030b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 44049f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 440582bc0194SAndreas Gruenbacher return -EIO; 4406b411b363SPhilipp Reisner } 4407b411b363SPhilipp Reisner } 4408b411b363SPhilipp Reisner } 4409b411b363SPhilipp Reisner 44100500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4411b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 4412b411b363SPhilipp Reisner goto retry; 4413b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 4414b411b363SPhilipp Reisner ns.peer = peer_state.role; 4415b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4416b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 44174ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4418b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 44194ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4420b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4421b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 44228554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4423481c6f50SPhilipp Reisner for temporal network outages! */ 44240500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4425d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 44269f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4427b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4428b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 44299f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 443082bc0194SAndreas Gruenbacher return -EIO; 4431481c6f50SPhilipp Reisner } 4432b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4433b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 44340500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4435b411b363SPhilipp Reisner 4436b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 44379f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 443882bc0194SAndreas Gruenbacher return -EIO; 4439b411b363SPhilipp Reisner } 4440b411b363SPhilipp Reisner 44414ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 44424ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4443b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4444b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4445b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4446b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 444769a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 444869a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4449b411b363SPhilipp Reisner } 4450b411b363SPhilipp Reisner } 4451b411b363SPhilipp Reisner 4452b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4453b411b363SPhilipp Reisner 4454b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4455b411b363SPhilipp Reisner 445682bc0194SAndreas Gruenbacher return 0; 4457b411b363SPhilipp Reisner } 4458b411b363SPhilipp Reisner 4459bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4460b411b363SPhilipp Reisner { 44619f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4462b30ab791SAndreas Gruenbacher struct drbd_device *device; 4463e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 44644a76b161SAndreas Gruenbacher 44659f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 44669f4fe9adSAndreas Gruenbacher if (!peer_device) 44674a76b161SAndreas Gruenbacher return -EIO; 44689f4fe9adSAndreas Gruenbacher device = peer_device->device; 4469b411b363SPhilipp Reisner 4470b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4471b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4472b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4473b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4474b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4475b411b363SPhilipp Reisner 44760b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4477b411b363SPhilipp Reisner 4478b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4479b411b363SPhilipp Reisner _not_ be rotated into the history */ 4480b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4481b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4482b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4483b411b363SPhilipp Reisner 4484b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4485b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4486b411b363SPhilipp Reisner 4487b30ab791SAndreas Gruenbacher put_ldev(device); 4488b411b363SPhilipp Reisner } else 4489d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4490b411b363SPhilipp Reisner 449182bc0194SAndreas Gruenbacher return 0; 4492b411b363SPhilipp Reisner } 4493b411b363SPhilipp Reisner 44942c46407dSAndreas Gruenbacher /** 44952c46407dSAndreas Gruenbacher * receive_bitmap_plain 44962c46407dSAndreas Gruenbacher * 44972c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 44982c46407dSAndreas Gruenbacher * code upon failure. 44992c46407dSAndreas Gruenbacher */ 45002c46407dSAndreas Gruenbacher static int 450169a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4502e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4503b411b363SPhilipp Reisner { 450450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 450569a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4506e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 450750d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4508e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 45092c46407dSAndreas Gruenbacher int err; 4510b411b363SPhilipp Reisner 451150d0b1adSAndreas Gruenbacher if (want != size) { 451269a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 45132c46407dSAndreas Gruenbacher return -EIO; 4514b411b363SPhilipp Reisner } 4515b411b363SPhilipp Reisner if (want == 0) 45162c46407dSAndreas Gruenbacher return 0; 451769a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 451882bc0194SAndreas Gruenbacher if (err) 45192c46407dSAndreas Gruenbacher return err; 4520b411b363SPhilipp Reisner 452169a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4522b411b363SPhilipp Reisner 4523b411b363SPhilipp Reisner c->word_offset += num_words; 4524b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4525b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4526b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4527b411b363SPhilipp Reisner 45282c46407dSAndreas Gruenbacher return 1; 4529b411b363SPhilipp Reisner } 4530b411b363SPhilipp Reisner 4531a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4532a02d1240SAndreas Gruenbacher { 4533a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4534a02d1240SAndreas Gruenbacher } 4535a02d1240SAndreas Gruenbacher 4536a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4537a02d1240SAndreas Gruenbacher { 4538a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4539a02d1240SAndreas Gruenbacher } 4540a02d1240SAndreas Gruenbacher 4541a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4542a02d1240SAndreas Gruenbacher { 4543a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4544a02d1240SAndreas Gruenbacher } 4545a02d1240SAndreas Gruenbacher 45462c46407dSAndreas Gruenbacher /** 45472c46407dSAndreas Gruenbacher * recv_bm_rle_bits 45482c46407dSAndreas Gruenbacher * 45492c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 45502c46407dSAndreas Gruenbacher * code upon failure. 45512c46407dSAndreas Gruenbacher */ 45522c46407dSAndreas Gruenbacher static int 455369a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4554b411b363SPhilipp Reisner struct p_compressed_bm *p, 4555c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4556c6d25cfeSPhilipp Reisner unsigned int len) 4557b411b363SPhilipp Reisner { 4558b411b363SPhilipp Reisner struct bitstream bs; 4559b411b363SPhilipp Reisner u64 look_ahead; 4560b411b363SPhilipp Reisner u64 rl; 4561b411b363SPhilipp Reisner u64 tmp; 4562b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4563b411b363SPhilipp Reisner unsigned long e; 4564a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4565b411b363SPhilipp Reisner int have; 4566b411b363SPhilipp Reisner int bits; 4567b411b363SPhilipp Reisner 4568a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4569b411b363SPhilipp Reisner 4570b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4571b411b363SPhilipp Reisner if (bits < 0) 45722c46407dSAndreas Gruenbacher return -EIO; 4573b411b363SPhilipp Reisner 4574b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4575b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4576b411b363SPhilipp Reisner if (bits <= 0) 45772c46407dSAndreas Gruenbacher return -EIO; 4578b411b363SPhilipp Reisner 4579b411b363SPhilipp Reisner if (toggle) { 4580b411b363SPhilipp Reisner e = s + rl -1; 4581b411b363SPhilipp Reisner if (e >= c->bm_bits) { 458269a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 45832c46407dSAndreas Gruenbacher return -EIO; 4584b411b363SPhilipp Reisner } 458569a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4586b411b363SPhilipp Reisner } 4587b411b363SPhilipp Reisner 4588b411b363SPhilipp Reisner if (have < bits) { 458969a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4590b411b363SPhilipp Reisner have, bits, look_ahead, 4591b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4592b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 45932c46407dSAndreas Gruenbacher return -EIO; 4594b411b363SPhilipp Reisner } 4595d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4596d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4597b411b363SPhilipp Reisner look_ahead >>= bits; 4598d2da5b0cSLars Ellenberg else 4599d2da5b0cSLars Ellenberg look_ahead = 0; 4600b411b363SPhilipp Reisner have -= bits; 4601b411b363SPhilipp Reisner 4602b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4603b411b363SPhilipp Reisner if (bits < 0) 46042c46407dSAndreas Gruenbacher return -EIO; 4605b411b363SPhilipp Reisner look_ahead |= tmp << have; 4606b411b363SPhilipp Reisner have += bits; 4607b411b363SPhilipp Reisner } 4608b411b363SPhilipp Reisner 4609b411b363SPhilipp Reisner c->bit_offset = s; 4610b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4611b411b363SPhilipp Reisner 46122c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4613b411b363SPhilipp Reisner } 4614b411b363SPhilipp Reisner 46152c46407dSAndreas Gruenbacher /** 46162c46407dSAndreas Gruenbacher * decode_bitmap_c 46172c46407dSAndreas Gruenbacher * 46182c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 46192c46407dSAndreas Gruenbacher * code upon failure. 46202c46407dSAndreas Gruenbacher */ 46212c46407dSAndreas Gruenbacher static int 462269a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4623b411b363SPhilipp Reisner struct p_compressed_bm *p, 4624c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4625c6d25cfeSPhilipp Reisner unsigned int len) 4626b411b363SPhilipp Reisner { 4627a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 462869a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4629b411b363SPhilipp Reisner 4630b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4631b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4632b411b363SPhilipp Reisner * during all our tests. */ 4633b411b363SPhilipp Reisner 463469a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 463569a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 46362c46407dSAndreas Gruenbacher return -EIO; 4637b411b363SPhilipp Reisner } 4638b411b363SPhilipp Reisner 4639b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4640b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4641b411b363SPhilipp Reisner { 4642b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4643a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 464450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 464550d0b1adSAndreas Gruenbacher unsigned int plain = 464650d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 464750d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 464850d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 464950d0b1adSAndreas Gruenbacher unsigned int r; 4650b411b363SPhilipp Reisner 4651b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4652b411b363SPhilipp Reisner if (total == 0) 4653b411b363SPhilipp Reisner return; 4654b411b363SPhilipp Reisner 4655b411b363SPhilipp Reisner /* don't report if not compressed */ 4656b411b363SPhilipp Reisner if (total >= plain) 4657b411b363SPhilipp Reisner return; 4658b411b363SPhilipp Reisner 4659b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4660b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4661b411b363SPhilipp Reisner : (1000 * total / plain); 4662b411b363SPhilipp Reisner 4663b411b363SPhilipp Reisner if (r > 1000) 4664b411b363SPhilipp Reisner r = 1000; 4665b411b363SPhilipp Reisner 4666b411b363SPhilipp Reisner r = 1000 - r; 4667d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4668b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4669b411b363SPhilipp Reisner direction, 4670b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4671b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4672b411b363SPhilipp Reisner total, r/10, r % 10); 4673b411b363SPhilipp Reisner } 4674b411b363SPhilipp Reisner 4675b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4676b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4677b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4678b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4679b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4680b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4681b411b363SPhilipp Reisner 4682b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4683bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4684b411b363SPhilipp Reisner { 46859f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4686b30ab791SAndreas Gruenbacher struct drbd_device *device; 4687b411b363SPhilipp Reisner struct bm_xfer_ctx c; 46882c46407dSAndreas Gruenbacher int err; 46894a76b161SAndreas Gruenbacher 46909f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 46919f4fe9adSAndreas Gruenbacher if (!peer_device) 46924a76b161SAndreas Gruenbacher return -EIO; 46939f4fe9adSAndreas Gruenbacher device = peer_device->device; 4694b411b363SPhilipp Reisner 4695b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 469620ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 469720ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4698b411b363SPhilipp Reisner 4699b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4700b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4701b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4702b411b363SPhilipp Reisner }; 4703b411b363SPhilipp Reisner 47042c46407dSAndreas Gruenbacher for(;;) { 4705e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 470669a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4707e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4708b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4709b411b363SPhilipp Reisner * and the feature is enabled! */ 4710e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4711b411b363SPhilipp Reisner 4712bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4713d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 471482bc0194SAndreas Gruenbacher err = -EIO; 4715b411b363SPhilipp Reisner goto out; 4716b411b363SPhilipp Reisner } 4717e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4718d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 471982bc0194SAndreas Gruenbacher err = -EIO; 472078fcbdaeSAndreas Gruenbacher goto out; 4721b411b363SPhilipp Reisner } 47229f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4723e658983aSAndreas Gruenbacher if (err) 4724e658983aSAndreas Gruenbacher goto out; 472569a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4726b411b363SPhilipp Reisner } else { 4727d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 472882bc0194SAndreas Gruenbacher err = -EIO; 4729b411b363SPhilipp Reisner goto out; 4730b411b363SPhilipp Reisner } 4731b411b363SPhilipp Reisner 4732e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4733bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4734b411b363SPhilipp Reisner 47352c46407dSAndreas Gruenbacher if (err <= 0) { 47362c46407dSAndreas Gruenbacher if (err < 0) 47372c46407dSAndreas Gruenbacher goto out; 4738b411b363SPhilipp Reisner break; 47392c46407dSAndreas Gruenbacher } 47409f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 474182bc0194SAndreas Gruenbacher if (err) 4742b411b363SPhilipp Reisner goto out; 47432c46407dSAndreas Gruenbacher } 4744b411b363SPhilipp Reisner 4745b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4746b411b363SPhilipp Reisner 4747b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4748de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4749de1f8e4aSAndreas Gruenbacher 4750b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 475182bc0194SAndreas Gruenbacher if (err) 4752b411b363SPhilipp Reisner goto out; 4753b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4754b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 47550b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4756b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4757b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4758b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4759d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4760b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4761b411b363SPhilipp Reisner } 476282bc0194SAndreas Gruenbacher err = 0; 4763b411b363SPhilipp Reisner 4764b411b363SPhilipp Reisner out: 4765b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4766b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4767b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 476882bc0194SAndreas Gruenbacher return err; 4769b411b363SPhilipp Reisner } 4770b411b363SPhilipp Reisner 4771bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4772b411b363SPhilipp Reisner { 47731ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4774e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4775b411b363SPhilipp Reisner 4776bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4777b411b363SPhilipp Reisner } 4778b411b363SPhilipp Reisner 4779bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4780b411b363SPhilipp Reisner { 4781b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4782b411b363SPhilipp Reisner * with the data requests being unplugged */ 4783bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4784b411b363SPhilipp Reisner 478582bc0194SAndreas Gruenbacher return 0; 4786b411b363SPhilipp Reisner } 4787b411b363SPhilipp Reisner 4788bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 478973a01a18SPhilipp Reisner { 47909f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4791b30ab791SAndreas Gruenbacher struct drbd_device *device; 4792e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 47934a76b161SAndreas Gruenbacher 47949f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 47959f4fe9adSAndreas Gruenbacher if (!peer_device) 47964a76b161SAndreas Gruenbacher return -EIO; 47979f4fe9adSAndreas Gruenbacher device = peer_device->device; 479873a01a18SPhilipp Reisner 4799b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4800f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4801f735e363SLars Ellenberg case C_WF_BITMAP_T: 4802f735e363SLars Ellenberg case C_BEHIND: 4803f735e363SLars Ellenberg break; 4804f735e363SLars Ellenberg default: 4805d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4806b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4807f735e363SLars Ellenberg } 4808f735e363SLars Ellenberg 4809b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 481073a01a18SPhilipp Reisner 481182bc0194SAndreas Gruenbacher return 0; 481273a01a18SPhilipp Reisner } 481373a01a18SPhilipp Reisner 4814700ca8c0SPhilipp Reisner static int receive_rs_deallocated(struct drbd_connection *connection, struct packet_info *pi) 4815700ca8c0SPhilipp Reisner { 4816700ca8c0SPhilipp Reisner struct drbd_peer_device *peer_device; 4817700ca8c0SPhilipp Reisner struct p_block_desc *p = pi->data; 4818700ca8c0SPhilipp Reisner struct drbd_device *device; 4819700ca8c0SPhilipp Reisner sector_t sector; 4820700ca8c0SPhilipp Reisner int size, err = 0; 4821700ca8c0SPhilipp Reisner 4822700ca8c0SPhilipp Reisner peer_device = conn_peer_device(connection, pi->vnr); 4823700ca8c0SPhilipp Reisner if (!peer_device) 4824700ca8c0SPhilipp Reisner return -EIO; 4825700ca8c0SPhilipp Reisner device = peer_device->device; 4826700ca8c0SPhilipp Reisner 4827700ca8c0SPhilipp Reisner sector = be64_to_cpu(p->sector); 4828700ca8c0SPhilipp Reisner size = be32_to_cpu(p->blksize); 4829700ca8c0SPhilipp Reisner 4830700ca8c0SPhilipp Reisner dec_rs_pending(device); 4831700ca8c0SPhilipp Reisner 4832700ca8c0SPhilipp Reisner if (get_ldev(device)) { 4833700ca8c0SPhilipp Reisner struct drbd_peer_request *peer_req; 483445c21793SChristoph Hellwig const int op = REQ_OP_WRITE_ZEROES; 4835700ca8c0SPhilipp Reisner 4836700ca8c0SPhilipp Reisner peer_req = drbd_alloc_peer_req(peer_device, ID_SYNCER, sector, 48379104d31aSLars Ellenberg size, 0, GFP_NOIO); 4838700ca8c0SPhilipp Reisner if (!peer_req) { 4839700ca8c0SPhilipp Reisner put_ldev(device); 4840700ca8c0SPhilipp Reisner return -ENOMEM; 4841700ca8c0SPhilipp Reisner } 4842700ca8c0SPhilipp Reisner 4843700ca8c0SPhilipp Reisner peer_req->w.cb = e_end_resync_block; 4844700ca8c0SPhilipp Reisner peer_req->submit_jif = jiffies; 4845700ca8c0SPhilipp Reisner peer_req->flags |= EE_IS_TRIM; 4846700ca8c0SPhilipp Reisner 4847700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4848700ca8c0SPhilipp Reisner list_add_tail(&peer_req->w.list, &device->sync_ee); 4849700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4850700ca8c0SPhilipp Reisner 4851700ca8c0SPhilipp Reisner atomic_add(pi->size >> 9, &device->rs_sect_ev); 4852700ca8c0SPhilipp Reisner err = drbd_submit_peer_request(device, peer_req, op, 0, DRBD_FAULT_RS_WR); 4853700ca8c0SPhilipp Reisner 4854700ca8c0SPhilipp Reisner if (err) { 4855700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4856700ca8c0SPhilipp Reisner list_del(&peer_req->w.list); 4857700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4858700ca8c0SPhilipp Reisner 4859700ca8c0SPhilipp Reisner drbd_free_peer_req(device, peer_req); 4860700ca8c0SPhilipp Reisner put_ldev(device); 4861700ca8c0SPhilipp Reisner err = 0; 4862700ca8c0SPhilipp Reisner goto fail; 4863700ca8c0SPhilipp Reisner } 4864700ca8c0SPhilipp Reisner 4865700ca8c0SPhilipp Reisner inc_unacked(device); 4866700ca8c0SPhilipp Reisner 4867700ca8c0SPhilipp Reisner /* No put_ldev() here. Gets called in drbd_endio_write_sec_final(), 4868700ca8c0SPhilipp Reisner as well as drbd_rs_complete_io() */ 4869700ca8c0SPhilipp Reisner } else { 4870700ca8c0SPhilipp Reisner fail: 4871700ca8c0SPhilipp Reisner drbd_rs_complete_io(device, sector); 4872700ca8c0SPhilipp Reisner drbd_send_ack_ex(peer_device, P_NEG_ACK, sector, size, ID_SYNCER); 4873700ca8c0SPhilipp Reisner } 4874700ca8c0SPhilipp Reisner 4875700ca8c0SPhilipp Reisner atomic_add(size >> 9, &device->rs_sect_in); 4876700ca8c0SPhilipp Reisner 4877700ca8c0SPhilipp Reisner return err; 4878700ca8c0SPhilipp Reisner } 4879700ca8c0SPhilipp Reisner 488002918be2SPhilipp Reisner struct data_cmd { 488102918be2SPhilipp Reisner int expect_payload; 48829104d31aSLars Ellenberg unsigned int pkt_size; 4883bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4884b411b363SPhilipp Reisner }; 4885b411b363SPhilipp Reisner 488602918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 488702918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 488802918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 488902918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 489002918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4891e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4892e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4893e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 489402918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 489502918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4896e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4897e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 489802918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 489902918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 490002918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 490102918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 490202918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 490302918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 490402918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 490502918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 490602918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 4907700ca8c0SPhilipp Reisner [P_RS_THIN_REQ] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 490802918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 490973a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 49104a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4911036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 4912a0fb3c47SLars Ellenberg [P_TRIM] = { 0, sizeof(struct p_trim), receive_Data }, 4913700ca8c0SPhilipp Reisner [P_RS_DEALLOCATED] = { 0, sizeof(struct p_block_desc), receive_rs_deallocated }, 49149104d31aSLars Ellenberg [P_WSAME] = { 1, sizeof(struct p_wsame), receive_Data }, 491502918be2SPhilipp Reisner }; 491602918be2SPhilipp Reisner 4917bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4918b411b363SPhilipp Reisner { 491977351055SPhilipp Reisner struct packet_info pi; 492002918be2SPhilipp Reisner size_t shs; /* sub header size */ 492182bc0194SAndreas Gruenbacher int err; 4922b411b363SPhilipp Reisner 4923bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 49249104d31aSLars Ellenberg struct data_cmd const *cmd; 4925deebe195SAndreas Gruenbacher 4926bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4927c51a0ef3SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_header_maybe_unplug); 4928c51a0ef3SLars Ellenberg if (drbd_recv_header_maybe_unplug(connection, &pi)) 492902918be2SPhilipp Reisner goto err_out; 493002918be2SPhilipp Reisner 4931deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 49324a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 49331ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 49342fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 493502918be2SPhilipp Reisner goto err_out; 49360b33a916SLars Ellenberg } 4937b411b363SPhilipp Reisner 4938e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 49399104d31aSLars Ellenberg if (pi.cmd == P_SIZES && connection->agreed_features & DRBD_FF_WSAME) 49409104d31aSLars Ellenberg shs += sizeof(struct o_qlim); 4941e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 49421ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 49432fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4944c13f7e1aSLars Ellenberg goto err_out; 4945c13f7e1aSLars Ellenberg } 49469104d31aSLars Ellenberg if (pi.size < shs) { 49479104d31aSLars Ellenberg drbd_err(connection, "%s: unexpected packet size, expected:%d received:%d\n", 49489104d31aSLars Ellenberg cmdname(pi.cmd), (int)shs, pi.size); 49499104d31aSLars Ellenberg goto err_out; 49509104d31aSLars Ellenberg } 4951c13f7e1aSLars Ellenberg 4952c13f7e1aSLars Ellenberg if (shs) { 4953944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_all_warn); 4954bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 4955a5c31904SAndreas Gruenbacher if (err) 495602918be2SPhilipp Reisner goto err_out; 4957e2857216SAndreas Gruenbacher pi.size -= shs; 4958b411b363SPhilipp Reisner } 495902918be2SPhilipp Reisner 4960944410e9SLars Ellenberg update_receiver_timing_details(connection, cmd->fn); 4961bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 49624a76b161SAndreas Gruenbacher if (err) { 49631ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 49649f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 496502918be2SPhilipp Reisner goto err_out; 496602918be2SPhilipp Reisner } 496702918be2SPhilipp Reisner } 496882bc0194SAndreas Gruenbacher return; 496902918be2SPhilipp Reisner 497002918be2SPhilipp Reisner err_out: 4971bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4972b411b363SPhilipp Reisner } 4973b411b363SPhilipp Reisner 4974bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 4975f70b3511SPhilipp Reisner { 4976c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4977bbeb641cSPhilipp Reisner enum drbd_conns oc; 4978376694a0SPhilipp Reisner int vnr; 4979f70b3511SPhilipp Reisner 4980bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 4981b411b363SPhilipp Reisner return; 4982b411b363SPhilipp Reisner 4983545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4984545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4985545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4986545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4987545752d5SLars Ellenberg */ 4988bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4989545752d5SLars Ellenberg 4990668700b4SPhilipp Reisner /* ack_receiver does not clean up anything. it must not interfere, either */ 49911c03e520SPhilipp Reisner drbd_thread_stop(&connection->ack_receiver); 4992668700b4SPhilipp Reisner if (connection->ack_sender) { 4993668700b4SPhilipp Reisner destroy_workqueue(connection->ack_sender); 4994668700b4SPhilipp Reisner connection->ack_sender = NULL; 4995668700b4SPhilipp Reisner } 4996bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 4997360cc740SPhilipp Reisner 4998c141ebdaSPhilipp Reisner rcu_read_lock(); 4999c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5000c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5001b30ab791SAndreas Gruenbacher kref_get(&device->kref); 5002c141ebdaSPhilipp Reisner rcu_read_unlock(); 500369a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 5004c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5005c141ebdaSPhilipp Reisner rcu_read_lock(); 5006c141ebdaSPhilipp Reisner } 5007c141ebdaSPhilipp Reisner rcu_read_unlock(); 5008c141ebdaSPhilipp Reisner 5009bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 50101ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 501112038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 5012bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 5013bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 501412038a3aSPhilipp Reisner 50151ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 5016360cc740SPhilipp Reisner 5017bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 5018bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 5019cb703454SPhilipp Reisner 50200500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5021bde89a9eSAndreas Gruenbacher oc = connection->cstate; 5022bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 5023bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 5024bbeb641cSPhilipp Reisner 50250500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5026360cc740SPhilipp Reisner 5027f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 5028bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 5029360cc740SPhilipp Reisner } 5030360cc740SPhilipp Reisner 503169a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 5032360cc740SPhilipp Reisner { 503369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5034360cc740SPhilipp Reisner unsigned int i; 5035b411b363SPhilipp Reisner 503685719573SPhilipp Reisner /* wait for current activity to cease. */ 50370500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5038b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 5039b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 5040b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 50410500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5042b411b363SPhilipp Reisner 5043b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 5044b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 5045b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 5046b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 5047b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 5048b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 5049b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 5050b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 5051b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 5052b411b363SPhilipp Reisner * on the fly. */ 5053b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5054b30ab791SAndreas Gruenbacher device->rs_total = 0; 5055b30ab791SAndreas Gruenbacher device->rs_failed = 0; 5056b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 5057b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 5058b411b363SPhilipp Reisner 5059b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 50602bccef39SKees Cook resync_timer_fn(&device->resync_timer); 5061b411b363SPhilipp Reisner 5062b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 5063b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 5064b411b363SPhilipp Reisner * to be "canceled" */ 5065b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5066b411b363SPhilipp Reisner 5067b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 5068b411b363SPhilipp Reisner 5069d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 5070d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 5071d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 5072b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5073d10b4ea3SPhilipp Reisner 507408332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 507508332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 5076b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5077b411b363SPhilipp Reisner 5078b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 5079b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 5080b411b363SPhilipp Reisner 5081b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 508269a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 5083b411b363SPhilipp Reisner 5084b30ab791SAndreas Gruenbacher drbd_md_sync(device); 5085b411b363SPhilipp Reisner 5086be115b69SLars Ellenberg if (get_ldev(device)) { 5087be115b69SLars Ellenberg drbd_bitmap_io(device, &drbd_bm_write_copy_pages, 5088be115b69SLars Ellenberg "write from disconnected", BM_LOCKED_CHANGE_ALLOWED); 5089be115b69SLars Ellenberg put_ldev(device); 5090be115b69SLars Ellenberg } 509120ceb2b2SLars Ellenberg 5092b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 5093b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 5094b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 5095b411b363SPhilipp Reisner * 5096b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 5097b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 5098b411b363SPhilipp Reisner */ 5099b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 5100b411b363SPhilipp Reisner if (i) 5101d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 5102b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 5103435f0740SLars Ellenberg if (i) 5104d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 5105b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 5106b411b363SPhilipp Reisner if (i) 5107d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 5108b411b363SPhilipp Reisner 51090b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 51100b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 51110b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 51120b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 5113b411b363SPhilipp Reisner 5114360cc740SPhilipp Reisner return 0; 5115b411b363SPhilipp Reisner } 5116b411b363SPhilipp Reisner 5117b411b363SPhilipp Reisner /* 5118b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 5119b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 5120b411b363SPhilipp Reisner * 5121b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 5122b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 5123b411b363SPhilipp Reisner * 5124b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 5125b411b363SPhilipp Reisner */ 5126bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 5127b411b363SPhilipp Reisner { 51289f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 51299f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 5130b411b363SPhilipp Reisner 5131bde89a9eSAndreas Gruenbacher sock = &connection->data; 5132bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 51339f5bdc33SAndreas Gruenbacher if (!p) 5134e8d17b01SAndreas Gruenbacher return -EIO; 5135b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 5136b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 5137b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 513820c68fdeSLars Ellenberg p->feature_flags = cpu_to_be32(PRO_FEATURES); 5139bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 5140b411b363SPhilipp Reisner } 5141b411b363SPhilipp Reisner 5142b411b363SPhilipp Reisner /* 5143b411b363SPhilipp Reisner * return values: 5144b411b363SPhilipp Reisner * 1 yes, we have a valid connection 5145b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 5146b411b363SPhilipp Reisner * -1 peer talks different language, 5147b411b363SPhilipp Reisner * no point in trying again, please go standalone. 5148b411b363SPhilipp Reisner */ 5149bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 5150b411b363SPhilipp Reisner { 5151bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 5152e658983aSAndreas Gruenbacher struct p_connection_features *p; 5153e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 515477351055SPhilipp Reisner struct packet_info pi; 5155a5c31904SAndreas Gruenbacher int err; 5156b411b363SPhilipp Reisner 5157bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 5158e8d17b01SAndreas Gruenbacher if (err) 5159b411b363SPhilipp Reisner return 0; 5160b411b363SPhilipp Reisner 5161bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 516269bc7bc3SAndreas Gruenbacher if (err) 5163b411b363SPhilipp Reisner return 0; 5164b411b363SPhilipp Reisner 51656038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 51661ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 516777351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5168b411b363SPhilipp Reisner return -1; 5169b411b363SPhilipp Reisner } 5170b411b363SPhilipp Reisner 517177351055SPhilipp Reisner if (pi.size != expect) { 51721ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 517377351055SPhilipp Reisner expect, pi.size); 5174b411b363SPhilipp Reisner return -1; 5175b411b363SPhilipp Reisner } 5176b411b363SPhilipp Reisner 5177e658983aSAndreas Gruenbacher p = pi.data; 5178bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 5179a5c31904SAndreas Gruenbacher if (err) 5180b411b363SPhilipp Reisner return 0; 5181b411b363SPhilipp Reisner 5182b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 5183b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 5184b411b363SPhilipp Reisner if (p->protocol_max == 0) 5185b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 5186b411b363SPhilipp Reisner 5187b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 5188b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 5189b411b363SPhilipp Reisner goto incompat; 5190b411b363SPhilipp Reisner 5191bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 519220c68fdeSLars Ellenberg connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); 5193b411b363SPhilipp Reisner 51941ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 5195bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 5196b411b363SPhilipp Reisner 51979104d31aSLars Ellenberg drbd_info(connection, "Feature flags enabled on protocol level: 0x%x%s%s%s.\n", 51989104d31aSLars Ellenberg connection->agreed_features, 51999104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "", 52009104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "", 52019104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" : 52029104d31aSLars Ellenberg connection->agreed_features ? "" : " none"); 520392d94ae6SPhilipp Reisner 5204b411b363SPhilipp Reisner return 1; 5205b411b363SPhilipp Reisner 5206b411b363SPhilipp Reisner incompat: 52071ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 5208b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 5209b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 5210b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 5211b411b363SPhilipp Reisner return -1; 5212b411b363SPhilipp Reisner } 5213b411b363SPhilipp Reisner 5214b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 5215bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5216b411b363SPhilipp Reisner { 52171ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 52181ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 5219b10d96cbSJohannes Thoma return -1; 5220b411b363SPhilipp Reisner } 5221b411b363SPhilipp Reisner #else 5222b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 5223b10d96cbSJohannes Thoma 5224b10d96cbSJohannes Thoma /* Return value: 5225b10d96cbSJohannes Thoma 1 - auth succeeded, 5226b10d96cbSJohannes Thoma 0 - failed, try again (network error), 5227b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 5228b10d96cbSJohannes Thoma */ 5229b10d96cbSJohannes Thoma 5230bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5231b411b363SPhilipp Reisner { 52329f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 5233b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 5234b411b363SPhilipp Reisner char *response = NULL; 5235b411b363SPhilipp Reisner char *right_response = NULL; 5236b411b363SPhilipp Reisner char *peers_ch = NULL; 523744ed167dSPhilipp Reisner unsigned int key_len; 523844ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 5239b411b363SPhilipp Reisner unsigned int resp_size; 52409534d671SHerbert Xu SHASH_DESC_ON_STACK(desc, connection->cram_hmac_tfm); 524177351055SPhilipp Reisner struct packet_info pi; 524244ed167dSPhilipp Reisner struct net_conf *nc; 524369bc7bc3SAndreas Gruenbacher int err, rv; 5244b411b363SPhilipp Reisner 52459f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 52469f5bdc33SAndreas Gruenbacher 524744ed167dSPhilipp Reisner rcu_read_lock(); 5248bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 524944ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 525044ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 525144ed167dSPhilipp Reisner rcu_read_unlock(); 525244ed167dSPhilipp Reisner 52539534d671SHerbert Xu desc->tfm = connection->cram_hmac_tfm; 52549534d671SHerbert Xu desc->flags = 0; 5255b411b363SPhilipp Reisner 52569534d671SHerbert Xu rv = crypto_shash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 5257b411b363SPhilipp Reisner if (rv) { 52589534d671SHerbert Xu drbd_err(connection, "crypto_shash_setkey() failed with %d\n", rv); 5259b10d96cbSJohannes Thoma rv = -1; 5260b411b363SPhilipp Reisner goto fail; 5261b411b363SPhilipp Reisner } 5262b411b363SPhilipp Reisner 5263b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 5264b411b363SPhilipp Reisner 5265bde89a9eSAndreas Gruenbacher sock = &connection->data; 5266bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 52679f5bdc33SAndreas Gruenbacher rv = 0; 52689f5bdc33SAndreas Gruenbacher goto fail; 52699f5bdc33SAndreas Gruenbacher } 5270bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 52719f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 5272b411b363SPhilipp Reisner if (!rv) 5273b411b363SPhilipp Reisner goto fail; 5274b411b363SPhilipp Reisner 5275bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 527669bc7bc3SAndreas Gruenbacher if (err) { 5277b411b363SPhilipp Reisner rv = 0; 5278b411b363SPhilipp Reisner goto fail; 5279b411b363SPhilipp Reisner } 5280b411b363SPhilipp Reisner 528177351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 52821ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 528377351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5284b411b363SPhilipp Reisner rv = 0; 5285b411b363SPhilipp Reisner goto fail; 5286b411b363SPhilipp Reisner } 5287b411b363SPhilipp Reisner 528877351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 52891ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 5290b10d96cbSJohannes Thoma rv = -1; 5291b411b363SPhilipp Reisner goto fail; 5292b411b363SPhilipp Reisner } 5293b411b363SPhilipp Reisner 529467cca286SPhilipp Reisner if (pi.size < CHALLENGE_LEN) { 529567cca286SPhilipp Reisner drbd_err(connection, "AuthChallenge payload too small.\n"); 529667cca286SPhilipp Reisner rv = -1; 529767cca286SPhilipp Reisner goto fail; 529867cca286SPhilipp Reisner } 529967cca286SPhilipp Reisner 530077351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 5301b411b363SPhilipp Reisner if (peers_ch == NULL) { 53021ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 5303b10d96cbSJohannes Thoma rv = -1; 5304b411b363SPhilipp Reisner goto fail; 5305b411b363SPhilipp Reisner } 5306b411b363SPhilipp Reisner 5307bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 5308a5c31904SAndreas Gruenbacher if (err) { 5309b411b363SPhilipp Reisner rv = 0; 5310b411b363SPhilipp Reisner goto fail; 5311b411b363SPhilipp Reisner } 5312b411b363SPhilipp Reisner 531367cca286SPhilipp Reisner if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) { 531467cca286SPhilipp Reisner drbd_err(connection, "Peer presented the same challenge!\n"); 531567cca286SPhilipp Reisner rv = -1; 531667cca286SPhilipp Reisner goto fail; 531767cca286SPhilipp Reisner } 531867cca286SPhilipp Reisner 53199534d671SHerbert Xu resp_size = crypto_shash_digestsize(connection->cram_hmac_tfm); 5320b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 5321b411b363SPhilipp Reisner if (response == NULL) { 53221ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 5323b10d96cbSJohannes Thoma rv = -1; 5324b411b363SPhilipp Reisner goto fail; 5325b411b363SPhilipp Reisner } 5326b411b363SPhilipp Reisner 53279534d671SHerbert Xu rv = crypto_shash_digest(desc, peers_ch, pi.size, response); 5328b411b363SPhilipp Reisner if (rv) { 53291ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5330b10d96cbSJohannes Thoma rv = -1; 5331b411b363SPhilipp Reisner goto fail; 5332b411b363SPhilipp Reisner } 5333b411b363SPhilipp Reisner 5334bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 53359f5bdc33SAndreas Gruenbacher rv = 0; 53369f5bdc33SAndreas Gruenbacher goto fail; 53379f5bdc33SAndreas Gruenbacher } 5338bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 53399f5bdc33SAndreas Gruenbacher response, resp_size); 5340b411b363SPhilipp Reisner if (!rv) 5341b411b363SPhilipp Reisner goto fail; 5342b411b363SPhilipp Reisner 5343bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 534469bc7bc3SAndreas Gruenbacher if (err) { 5345b411b363SPhilipp Reisner rv = 0; 5346b411b363SPhilipp Reisner goto fail; 5347b411b363SPhilipp Reisner } 5348b411b363SPhilipp Reisner 534977351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 53501ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 535177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5352b411b363SPhilipp Reisner rv = 0; 5353b411b363SPhilipp Reisner goto fail; 5354b411b363SPhilipp Reisner } 5355b411b363SPhilipp Reisner 535677351055SPhilipp Reisner if (pi.size != resp_size) { 53571ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 5358b411b363SPhilipp Reisner rv = 0; 5359b411b363SPhilipp Reisner goto fail; 5360b411b363SPhilipp Reisner } 5361b411b363SPhilipp Reisner 5362bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 5363a5c31904SAndreas Gruenbacher if (err) { 5364b411b363SPhilipp Reisner rv = 0; 5365b411b363SPhilipp Reisner goto fail; 5366b411b363SPhilipp Reisner } 5367b411b363SPhilipp Reisner 5368b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 53692d1ee87dSJulia Lawall if (right_response == NULL) { 53701ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 5371b10d96cbSJohannes Thoma rv = -1; 5372b411b363SPhilipp Reisner goto fail; 5373b411b363SPhilipp Reisner } 5374b411b363SPhilipp Reisner 53759534d671SHerbert Xu rv = crypto_shash_digest(desc, my_challenge, CHALLENGE_LEN, 53769534d671SHerbert Xu right_response); 5377b411b363SPhilipp Reisner if (rv) { 53781ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5379b10d96cbSJohannes Thoma rv = -1; 5380b411b363SPhilipp Reisner goto fail; 5381b411b363SPhilipp Reisner } 5382b411b363SPhilipp Reisner 5383b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 5384b411b363SPhilipp Reisner 5385b411b363SPhilipp Reisner if (rv) 53861ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 538744ed167dSPhilipp Reisner resp_size); 5388b10d96cbSJohannes Thoma else 5389b10d96cbSJohannes Thoma rv = -1; 5390b411b363SPhilipp Reisner 5391b411b363SPhilipp Reisner fail: 5392b411b363SPhilipp Reisner kfree(peers_ch); 5393b411b363SPhilipp Reisner kfree(response); 5394b411b363SPhilipp Reisner kfree(right_response); 53959534d671SHerbert Xu shash_desc_zero(desc); 5396b411b363SPhilipp Reisner 5397b411b363SPhilipp Reisner return rv; 5398b411b363SPhilipp Reisner } 5399b411b363SPhilipp Reisner #endif 5400b411b363SPhilipp Reisner 54018fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 5402b411b363SPhilipp Reisner { 5403bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5404b411b363SPhilipp Reisner int h; 5405b411b363SPhilipp Reisner 54061ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 5407b411b363SPhilipp Reisner 5408b411b363SPhilipp Reisner do { 5409bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 5410b411b363SPhilipp Reisner if (h == 0) { 5411bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 541220ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 5413b411b363SPhilipp Reisner } 5414b411b363SPhilipp Reisner if (h == -1) { 54151ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 5416bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5417b411b363SPhilipp Reisner } 5418b411b363SPhilipp Reisner } while (h == 0); 5419b411b363SPhilipp Reisner 5420c51a0ef3SLars Ellenberg if (h > 0) { 5421c51a0ef3SLars Ellenberg blk_start_plug(&connection->receiver_plug); 5422bde89a9eSAndreas Gruenbacher drbdd(connection); 5423c51a0ef3SLars Ellenberg blk_finish_plug(&connection->receiver_plug); 5424c51a0ef3SLars Ellenberg } 5425b411b363SPhilipp Reisner 5426bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 5427b411b363SPhilipp Reisner 54281ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 5429b411b363SPhilipp Reisner return 0; 5430b411b363SPhilipp Reisner } 5431b411b363SPhilipp Reisner 5432b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 5433b411b363SPhilipp Reisner 5434bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5435b411b363SPhilipp Reisner { 5436e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5437b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5438b411b363SPhilipp Reisner 5439b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 5440bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 5441b411b363SPhilipp Reisner } else { 5442bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 54431ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 5444fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5445fc3b10a4SPhilipp Reisner } 5446bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5447e4f78edeSPhilipp Reisner 54482735a594SAndreas Gruenbacher return 0; 5449fc3b10a4SPhilipp Reisner } 5450e4f78edeSPhilipp Reisner 5451bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5452e4f78edeSPhilipp Reisner { 54539f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5454b30ab791SAndreas Gruenbacher struct drbd_device *device; 5455e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5456e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5457e4f78edeSPhilipp Reisner 54589f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 54599f4fe9adSAndreas Gruenbacher if (!peer_device) 54602735a594SAndreas Gruenbacher return -EIO; 54619f4fe9adSAndreas Gruenbacher device = peer_device->device; 54621952e916SAndreas Gruenbacher 5463bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 54640b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 5465bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 54664d0fc3fdSPhilipp Reisner } 54674d0fc3fdSPhilipp Reisner 5468e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 5469b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 5470e4f78edeSPhilipp Reisner } else { 5471b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 5472d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 5473b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5474b411b363SPhilipp Reisner } 5475b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 5476b411b363SPhilipp Reisner 54772735a594SAndreas Gruenbacher return 0; 5478b411b363SPhilipp Reisner } 5479b411b363SPhilipp Reisner 5480bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 5481b411b363SPhilipp Reisner { 5482bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 5483b411b363SPhilipp Reisner 5484b411b363SPhilipp Reisner } 5485b411b363SPhilipp Reisner 5486bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 5487b411b363SPhilipp Reisner { 5488b411b363SPhilipp Reisner /* restore idle timeout */ 5489bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 5490bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 5491bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5492b411b363SPhilipp Reisner 54932735a594SAndreas Gruenbacher return 0; 5494b411b363SPhilipp Reisner } 5495b411b363SPhilipp Reisner 5496bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 5497b411b363SPhilipp Reisner { 54989f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5499b30ab791SAndreas Gruenbacher struct drbd_device *device; 5500e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5501b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5502b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5503b411b363SPhilipp Reisner 55049f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55059f4fe9adSAndreas Gruenbacher if (!peer_device) 55062735a594SAndreas Gruenbacher return -EIO; 55079f4fe9adSAndreas Gruenbacher device = peer_device->device; 55081952e916SAndreas Gruenbacher 55099f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 5510b411b363SPhilipp Reisner 551169a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5512b411b363SPhilipp Reisner 5513b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 5514b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5515b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5516b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 5517b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 5518b30ab791SAndreas Gruenbacher put_ldev(device); 55191d53f09eSLars Ellenberg } 5520b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5521b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5522b411b363SPhilipp Reisner 55232735a594SAndreas Gruenbacher return 0; 5524b411b363SPhilipp Reisner } 5525b411b363SPhilipp Reisner 5526bc9c5c41SAndreas Gruenbacher static int 5527b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5528bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5529bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5530b411b363SPhilipp Reisner { 5531b411b363SPhilipp Reisner struct drbd_request *req; 5532b411b363SPhilipp Reisner struct bio_and_error m; 5533b411b363SPhilipp Reisner 55340500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5535b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5536b411b363SPhilipp Reisner if (unlikely(!req)) { 55370500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 553885997675SAndreas Gruenbacher return -EIO; 5539b411b363SPhilipp Reisner } 5540b411b363SPhilipp Reisner __req_mod(req, what, &m); 55410500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5542b411b363SPhilipp Reisner 5543b411b363SPhilipp Reisner if (m.bio) 5544b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 554585997675SAndreas Gruenbacher return 0; 5546b411b363SPhilipp Reisner } 5547b411b363SPhilipp Reisner 5548bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5549b411b363SPhilipp Reisner { 55509f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5551b30ab791SAndreas Gruenbacher struct drbd_device *device; 5552e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5553b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5554b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5555b411b363SPhilipp Reisner enum drbd_req_event what; 5556b411b363SPhilipp Reisner 55579f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55589f4fe9adSAndreas Gruenbacher if (!peer_device) 55592735a594SAndreas Gruenbacher return -EIO; 55609f4fe9adSAndreas Gruenbacher device = peer_device->device; 55611952e916SAndreas Gruenbacher 556269a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5563b411b363SPhilipp Reisner 5564579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5565b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5566b30ab791SAndreas Gruenbacher dec_rs_pending(device); 55672735a594SAndreas Gruenbacher return 0; 5568b411b363SPhilipp Reisner } 5569e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5570b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 55718554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5572b411b363SPhilipp Reisner break; 5573b411b363SPhilipp Reisner case P_WRITE_ACK: 55748554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5575b411b363SPhilipp Reisner break; 5576b411b363SPhilipp Reisner case P_RECV_ACK: 55778554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5578b411b363SPhilipp Reisner break; 5579d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5580d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 55817be8da07SAndreas Gruenbacher break; 55827be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 55837be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5584b411b363SPhilipp Reisner break; 5585b411b363SPhilipp Reisner default: 55862735a594SAndreas Gruenbacher BUG(); 5587b411b363SPhilipp Reisner } 5588b411b363SPhilipp Reisner 5589b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5590b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5591bc9c5c41SAndreas Gruenbacher what, false); 5592b411b363SPhilipp Reisner } 5593b411b363SPhilipp Reisner 5594bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5595b411b363SPhilipp Reisner { 55969f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5597b30ab791SAndreas Gruenbacher struct drbd_device *device; 5598e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5599b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 56002deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 560185997675SAndreas Gruenbacher int err; 5602b411b363SPhilipp Reisner 56039f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56049f4fe9adSAndreas Gruenbacher if (!peer_device) 56052735a594SAndreas Gruenbacher return -EIO; 56069f4fe9adSAndreas Gruenbacher device = peer_device->device; 5607b411b363SPhilipp Reisner 560869a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5609b411b363SPhilipp Reisner 5610579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5611b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5612b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 56132735a594SAndreas Gruenbacher return 0; 5614b411b363SPhilipp Reisner } 56152deb8336SPhilipp Reisner 5616b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5617b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5618303d1448SPhilipp Reisner NEG_ACKED, true); 561985997675SAndreas Gruenbacher if (err) { 56202deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 56212deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5622c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 56232deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 56242deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5625b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 56262deb8336SPhilipp Reisner } 56272735a594SAndreas Gruenbacher return 0; 5628b411b363SPhilipp Reisner } 5629b411b363SPhilipp Reisner 5630bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5631b411b363SPhilipp Reisner { 56329f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5633b30ab791SAndreas Gruenbacher struct drbd_device *device; 5634e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5635b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5636b411b363SPhilipp Reisner 56379f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56389f4fe9adSAndreas Gruenbacher if (!peer_device) 56392735a594SAndreas Gruenbacher return -EIO; 56409f4fe9adSAndreas Gruenbacher device = peer_device->device; 56411952e916SAndreas Gruenbacher 564269a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 56437be8da07SAndreas Gruenbacher 5644d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5645b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5646b411b363SPhilipp Reisner 5647b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5648b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 56498554df1cSAndreas Gruenbacher NEG_ACKED, false); 5650b411b363SPhilipp Reisner } 5651b411b363SPhilipp Reisner 5652bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5653b411b363SPhilipp Reisner { 56549f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5655b30ab791SAndreas Gruenbacher struct drbd_device *device; 5656b411b363SPhilipp Reisner sector_t sector; 5657b411b363SPhilipp Reisner int size; 5658e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 56591952e916SAndreas Gruenbacher 56609f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56619f4fe9adSAndreas Gruenbacher if (!peer_device) 56622735a594SAndreas Gruenbacher return -EIO; 56639f4fe9adSAndreas Gruenbacher device = peer_device->device; 5664b411b363SPhilipp Reisner 5665b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5666b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5667b411b363SPhilipp Reisner 566869a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5669b411b363SPhilipp Reisner 5670b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5671b411b363SPhilipp Reisner 5672b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5673b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5674e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5675d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5676b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5677d612d309SPhilipp Reisner case P_RS_CANCEL: 5678d612d309SPhilipp Reisner break; 5679d612d309SPhilipp Reisner default: 56802735a594SAndreas Gruenbacher BUG(); 5681d612d309SPhilipp Reisner } 5682b30ab791SAndreas Gruenbacher put_ldev(device); 5683b411b363SPhilipp Reisner } 5684b411b363SPhilipp Reisner 56852735a594SAndreas Gruenbacher return 0; 5686b411b363SPhilipp Reisner } 5687b411b363SPhilipp Reisner 5688bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5689b411b363SPhilipp Reisner { 5690e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5691c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 56929ed57dcbSLars Ellenberg int vnr; 5693b411b363SPhilipp Reisner 5694bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5695b411b363SPhilipp Reisner 56969ed57dcbSLars Ellenberg rcu_read_lock(); 5697c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5698c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5699c06ece6bSAndreas Gruenbacher 5700b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5701b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5702b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5703b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5704b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5705c4752ef1SPhilipp Reisner } 57069ed57dcbSLars Ellenberg } 57079ed57dcbSLars Ellenberg rcu_read_unlock(); 5708c4752ef1SPhilipp Reisner 57092735a594SAndreas Gruenbacher return 0; 5710b411b363SPhilipp Reisner } 5711b411b363SPhilipp Reisner 5712bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5713b411b363SPhilipp Reisner { 57149f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5715b30ab791SAndreas Gruenbacher struct drbd_device *device; 5716e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 571784b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5718b411b363SPhilipp Reisner sector_t sector; 5719b411b363SPhilipp Reisner int size; 5720b411b363SPhilipp Reisner 57219f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 57229f4fe9adSAndreas Gruenbacher if (!peer_device) 57232735a594SAndreas Gruenbacher return -EIO; 57249f4fe9adSAndreas Gruenbacher device = peer_device->device; 57251952e916SAndreas Gruenbacher 5726b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5727b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5728b411b363SPhilipp Reisner 572969a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5730b411b363SPhilipp Reisner 5731b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5732b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5733b411b363SPhilipp Reisner else 5734b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5735b411b363SPhilipp Reisner 5736b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 57372735a594SAndreas Gruenbacher return 0; 57381d53f09eSLars Ellenberg 5739b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5740b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5741b411b363SPhilipp Reisner 5742b30ab791SAndreas Gruenbacher --device->ov_left; 5743ea5442afSLars Ellenberg 5744ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5745b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5746b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5747ea5442afSLars Ellenberg 5748b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 574984b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 575084b8c06bSAndreas Gruenbacher if (dw) { 575184b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 575284b8c06bSAndreas Gruenbacher dw->device = device; 575384b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5754b411b363SPhilipp Reisner } else { 575584b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5756b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5757b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5758b411b363SPhilipp Reisner } 5759b411b363SPhilipp Reisner } 5760b30ab791SAndreas Gruenbacher put_ldev(device); 57612735a594SAndreas Gruenbacher return 0; 5762b411b363SPhilipp Reisner } 5763b411b363SPhilipp Reisner 5764bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 57650ced55a3SPhilipp Reisner { 57662735a594SAndreas Gruenbacher return 0; 57670ced55a3SPhilipp Reisner } 57680ced55a3SPhilipp Reisner 5769668700b4SPhilipp Reisner struct meta_sock_cmd { 5770b411b363SPhilipp Reisner size_t pkt_size; 5771bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5772b411b363SPhilipp Reisner }; 5773b411b363SPhilipp Reisner 5774668700b4SPhilipp Reisner static void set_rcvtimeo(struct drbd_connection *connection, bool ping_timeout) 5775668700b4SPhilipp Reisner { 5776668700b4SPhilipp Reisner long t; 5777668700b4SPhilipp Reisner struct net_conf *nc; 5778668700b4SPhilipp Reisner 5779668700b4SPhilipp Reisner rcu_read_lock(); 5780668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 5781668700b4SPhilipp Reisner t = ping_timeout ? nc->ping_timeo : nc->ping_int; 5782668700b4SPhilipp Reisner rcu_read_unlock(); 5783668700b4SPhilipp Reisner 5784668700b4SPhilipp Reisner t *= HZ; 5785668700b4SPhilipp Reisner if (ping_timeout) 5786668700b4SPhilipp Reisner t /= 10; 5787668700b4SPhilipp Reisner 5788668700b4SPhilipp Reisner connection->meta.socket->sk->sk_rcvtimeo = t; 5789668700b4SPhilipp Reisner } 5790668700b4SPhilipp Reisner 5791668700b4SPhilipp Reisner static void set_ping_timeout(struct drbd_connection *connection) 5792668700b4SPhilipp Reisner { 5793668700b4SPhilipp Reisner set_rcvtimeo(connection, 1); 5794668700b4SPhilipp Reisner } 5795668700b4SPhilipp Reisner 5796668700b4SPhilipp Reisner static void set_idle_timeout(struct drbd_connection *connection) 5797668700b4SPhilipp Reisner { 5798668700b4SPhilipp Reisner set_rcvtimeo(connection, 0); 5799668700b4SPhilipp Reisner } 5800668700b4SPhilipp Reisner 5801668700b4SPhilipp Reisner static struct meta_sock_cmd ack_receiver_tbl[] = { 5802e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5803e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5804b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5805b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5806b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5807d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5808b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5809b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5810b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5811b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5812b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5813b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5814b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 581502918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5816d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 58171952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 58181952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5819b411b363SPhilipp Reisner }; 5820b411b363SPhilipp Reisner 58211c03e520SPhilipp Reisner int drbd_ack_receiver(struct drbd_thread *thi) 5822b411b363SPhilipp Reisner { 5823bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5824668700b4SPhilipp Reisner struct meta_sock_cmd *cmd = NULL; 582577351055SPhilipp Reisner struct packet_info pi; 5826668700b4SPhilipp Reisner unsigned long pre_recv_jif; 5827257d0af6SPhilipp Reisner int rv; 5828bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5829b411b363SPhilipp Reisner int received = 0; 5830bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 583152b061a4SAndreas Gruenbacher int expect = header_size; 583244ed167dSPhilipp Reisner bool ping_timeout_active = false; 58333990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5834b411b363SPhilipp Reisner 58353990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 58363990e04dSPhilipp Reisner if (rv < 0) 5837668700b4SPhilipp Reisner drbd_err(connection, "drbd_ack_receiver: ERROR set priority, ret=%d\n", rv); 5838b411b363SPhilipp Reisner 5839e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 584080822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 584144ed167dSPhilipp Reisner 5842668700b4SPhilipp Reisner conn_reclaim_net_peer_reqs(connection); 584344ed167dSPhilipp Reisner 5844bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5845bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 58461ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5847841ce241SAndreas Gruenbacher goto reconnect; 5848841ce241SAndreas Gruenbacher } 5849668700b4SPhilipp Reisner set_ping_timeout(connection); 585044ed167dSPhilipp Reisner ping_timeout_active = true; 5851b411b363SPhilipp Reisner } 5852b411b363SPhilipp Reisner 5853668700b4SPhilipp Reisner pre_recv_jif = jiffies; 5854bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5855b411b363SPhilipp Reisner 5856b411b363SPhilipp Reisner /* Note: 5857b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5858b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5859b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5860b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5861b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5862b411b363SPhilipp Reisner * rv == expected: full header or command 5863b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5864b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5865b411b363SPhilipp Reisner */ 5866b411b363SPhilipp Reisner if (likely(rv > 0)) { 5867b411b363SPhilipp Reisner received += rv; 5868b411b363SPhilipp Reisner buf += rv; 5869b411b363SPhilipp Reisner } else if (rv == 0) { 5870bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5871b66623e3SPhilipp Reisner long t; 5872b66623e3SPhilipp Reisner rcu_read_lock(); 5873bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5874b66623e3SPhilipp Reisner rcu_read_unlock(); 5875b66623e3SPhilipp Reisner 5876bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5877bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5878b66623e3SPhilipp Reisner t); 5879599377acSPhilipp Reisner if (t) 5880599377acSPhilipp Reisner break; 5881599377acSPhilipp Reisner } 58821ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5883b411b363SPhilipp Reisner goto reconnect; 5884b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5885cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5886cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5887668700b4SPhilipp Reisner if (time_after(connection->last_received, pre_recv_jif)) 5888cb6518cbSLars Ellenberg continue; 5889f36af18cSLars Ellenberg if (ping_timeout_active) { 58901ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5891b411b363SPhilipp Reisner goto reconnect; 5892b411b363SPhilipp Reisner } 5893bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5894b411b363SPhilipp Reisner continue; 5895b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5896668700b4SPhilipp Reisner /* maybe drbd_thread_stop(): the while condition will notice. 5897668700b4SPhilipp Reisner * maybe woken for send_ping: we'll send a ping above, 5898668700b4SPhilipp Reisner * and change the rcvtimeo */ 5899668700b4SPhilipp Reisner flush_signals(current); 5900b411b363SPhilipp Reisner continue; 5901b411b363SPhilipp Reisner } else { 59021ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5903b411b363SPhilipp Reisner goto reconnect; 5904b411b363SPhilipp Reisner } 5905b411b363SPhilipp Reisner 5906b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5907bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5908b411b363SPhilipp Reisner goto reconnect; 5909668700b4SPhilipp Reisner cmd = &ack_receiver_tbl[pi.cmd]; 5910668700b4SPhilipp Reisner if (pi.cmd >= ARRAY_SIZE(ack_receiver_tbl) || !cmd->fn) { 59111ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 59122fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5913b411b363SPhilipp Reisner goto disconnect; 5914b411b363SPhilipp Reisner } 5915e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 591652b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 59171ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 591877351055SPhilipp Reisner pi.cmd, pi.size); 5919b411b363SPhilipp Reisner goto reconnect; 5920b411b363SPhilipp Reisner } 5921257d0af6SPhilipp Reisner } 5922b411b363SPhilipp Reisner if (received == expect) { 59232735a594SAndreas Gruenbacher bool err; 5924a4fbda8eSPhilipp Reisner 5925bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 59262735a594SAndreas Gruenbacher if (err) { 59271ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5928b411b363SPhilipp Reisner goto reconnect; 59291952e916SAndreas Gruenbacher } 5930b411b363SPhilipp Reisner 5931bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5932f36af18cSLars Ellenberg 5933668700b4SPhilipp Reisner if (cmd == &ack_receiver_tbl[P_PING_ACK]) { 5934668700b4SPhilipp Reisner set_idle_timeout(connection); 593544ed167dSPhilipp Reisner ping_timeout_active = false; 593644ed167dSPhilipp Reisner } 5937b411b363SPhilipp Reisner 5938bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5939b411b363SPhilipp Reisner received = 0; 594052b061a4SAndreas Gruenbacher expect = header_size; 5941b411b363SPhilipp Reisner cmd = NULL; 5942b411b363SPhilipp Reisner } 5943b411b363SPhilipp Reisner } 5944b411b363SPhilipp Reisner 5945b411b363SPhilipp Reisner if (0) { 5946b411b363SPhilipp Reisner reconnect: 5947bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5948bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5949b411b363SPhilipp Reisner } 5950b411b363SPhilipp Reisner if (0) { 5951b411b363SPhilipp Reisner disconnect: 5952bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5953b411b363SPhilipp Reisner } 5954b411b363SPhilipp Reisner 5955668700b4SPhilipp Reisner drbd_info(connection, "ack_receiver terminated\n"); 5956b411b363SPhilipp Reisner 5957b411b363SPhilipp Reisner return 0; 5958b411b363SPhilipp Reisner } 5959668700b4SPhilipp Reisner 5960668700b4SPhilipp Reisner void drbd_send_acks_wf(struct work_struct *ws) 5961668700b4SPhilipp Reisner { 5962668700b4SPhilipp Reisner struct drbd_peer_device *peer_device = 5963668700b4SPhilipp Reisner container_of(ws, struct drbd_peer_device, send_acks_work); 5964668700b4SPhilipp Reisner struct drbd_connection *connection = peer_device->connection; 5965668700b4SPhilipp Reisner struct drbd_device *device = peer_device->device; 5966668700b4SPhilipp Reisner struct net_conf *nc; 5967668700b4SPhilipp Reisner int tcp_cork, err; 5968668700b4SPhilipp Reisner 5969668700b4SPhilipp Reisner rcu_read_lock(); 5970668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 5971668700b4SPhilipp Reisner tcp_cork = nc->tcp_cork; 5972668700b4SPhilipp Reisner rcu_read_unlock(); 5973668700b4SPhilipp Reisner 5974668700b4SPhilipp Reisner if (tcp_cork) 5975668700b4SPhilipp Reisner drbd_tcp_cork(connection->meta.socket); 5976668700b4SPhilipp Reisner 5977668700b4SPhilipp Reisner err = drbd_finish_peer_reqs(device); 5978668700b4SPhilipp Reisner kref_put(&device->kref, drbd_destroy_device); 5979668700b4SPhilipp Reisner /* get is in drbd_endio_write_sec_final(). That is necessary to keep the 5980668700b4SPhilipp Reisner struct work_struct send_acks_work alive, which is in the peer_device object */ 5981668700b4SPhilipp Reisner 5982668700b4SPhilipp Reisner if (err) { 5983668700b4SPhilipp Reisner conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5984668700b4SPhilipp Reisner return; 5985668700b4SPhilipp Reisner } 5986668700b4SPhilipp Reisner 5987668700b4SPhilipp Reisner if (tcp_cork) 5988668700b4SPhilipp Reisner drbd_tcp_uncork(connection->meta.socket); 5989668700b4SPhilipp Reisner 5990668700b4SPhilipp Reisner return; 5991668700b4SPhilipp Reisner } 5992