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 3351816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * 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 381db830c46SAndreas Gruenbacher 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: 412db830c46SAndreas Gruenbacher 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 } 429db830c46SAndreas Gruenbacher 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 }; 519f730c848SAl Viro return kernel_recvmsg(sock, &msg, &iov, 1, size, msg.msg_flags); 520b411b363SPhilipp Reisner } 521b411b363SPhilipp Reisner 522bde89a9eSAndreas Gruenbacher static int drbd_recv(struct drbd_connection *connection, void *buf, size_t size) 523b411b363SPhilipp Reisner { 524b411b363SPhilipp Reisner int rv; 525b411b363SPhilipp Reisner 526bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->data.socket, buf, size, 0); 527b411b363SPhilipp Reisner 528b411b363SPhilipp Reisner if (rv < 0) { 529b411b363SPhilipp Reisner if (rv == -ECONNRESET) 5301ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was reset by peer\n"); 531b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 5321ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 533b411b363SPhilipp Reisner } else if (rv == 0) { 534bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 535b66623e3SPhilipp Reisner long t; 536b66623e3SPhilipp Reisner rcu_read_lock(); 537bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 538b66623e3SPhilipp Reisner rcu_read_unlock(); 539b66623e3SPhilipp Reisner 540bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, connection->cstate < C_WF_REPORT_PARAMS, t); 541b66623e3SPhilipp Reisner 542599377acSPhilipp Reisner if (t) 543599377acSPhilipp Reisner goto out; 544599377acSPhilipp Reisner } 5451ec861ebSAndreas Gruenbacher drbd_info(connection, "sock was shut down by peer\n"); 546599377acSPhilipp Reisner } 547599377acSPhilipp Reisner 548b411b363SPhilipp Reisner if (rv != size) 549bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_BROKEN_PIPE), CS_HARD); 550b411b363SPhilipp Reisner 551599377acSPhilipp Reisner out: 552b411b363SPhilipp Reisner return rv; 553b411b363SPhilipp Reisner } 554b411b363SPhilipp Reisner 555bde89a9eSAndreas Gruenbacher static int drbd_recv_all(struct drbd_connection *connection, void *buf, size_t size) 556c6967746SAndreas Gruenbacher { 557c6967746SAndreas Gruenbacher int err; 558c6967746SAndreas Gruenbacher 559bde89a9eSAndreas Gruenbacher err = drbd_recv(connection, buf, size); 560c6967746SAndreas Gruenbacher if (err != size) { 561c6967746SAndreas Gruenbacher if (err >= 0) 562c6967746SAndreas Gruenbacher err = -EIO; 563c6967746SAndreas Gruenbacher } else 564c6967746SAndreas Gruenbacher err = 0; 565c6967746SAndreas Gruenbacher return err; 566c6967746SAndreas Gruenbacher } 567c6967746SAndreas Gruenbacher 568bde89a9eSAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_connection *connection, void *buf, size_t size) 569a5c31904SAndreas Gruenbacher { 570a5c31904SAndreas Gruenbacher int err; 571a5c31904SAndreas Gruenbacher 572bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, buf, size); 573a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 5741ec861ebSAndreas Gruenbacher drbd_warn(connection, "short read (expected size %d)\n", (int)size); 575a5c31904SAndreas Gruenbacher return err; 576a5c31904SAndreas Gruenbacher } 577a5c31904SAndreas Gruenbacher 5785dbf1673SLars Ellenberg /* quoting tcp(7): 5795dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5805dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5815dbf1673SLars Ellenberg * This is our wrapper to do so. 5825dbf1673SLars Ellenberg */ 5835dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5845dbf1673SLars Ellenberg unsigned int rcv) 5855dbf1673SLars Ellenberg { 5865dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5875dbf1673SLars Ellenberg if (snd) { 5885dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5895dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5905dbf1673SLars Ellenberg } 5915dbf1673SLars Ellenberg if (rcv) { 5925dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5935dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5945dbf1673SLars Ellenberg } 5955dbf1673SLars Ellenberg } 5965dbf1673SLars Ellenberg 597bde89a9eSAndreas Gruenbacher static struct socket *drbd_try_connect(struct drbd_connection *connection) 598b411b363SPhilipp Reisner { 599b411b363SPhilipp Reisner const char *what; 600b411b363SPhilipp Reisner struct socket *sock; 601b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 60244ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 60344ed167dSPhilipp Reisner struct net_conf *nc; 60444ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 60569ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 606b411b363SPhilipp Reisner int disconnect_on_error = 1; 607b411b363SPhilipp Reisner 60844ed167dSPhilipp Reisner rcu_read_lock(); 609bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 61044ed167dSPhilipp Reisner if (!nc) { 61144ed167dSPhilipp Reisner rcu_read_unlock(); 612b411b363SPhilipp Reisner return NULL; 61344ed167dSPhilipp Reisner } 61444ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 61544ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 61669ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 617089c075dSAndreas Gruenbacher rcu_read_unlock(); 61844ed167dSPhilipp Reisner 619bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(src_in6)); 620bde89a9eSAndreas Gruenbacher memcpy(&src_in6, &connection->my_addr, my_addr_len); 62144ed167dSPhilipp Reisner 622bde89a9eSAndreas Gruenbacher if (((struct sockaddr *)&connection->my_addr)->sa_family == AF_INET6) 62344ed167dSPhilipp Reisner src_in6.sin6_port = 0; 62444ed167dSPhilipp Reisner else 62544ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 62644ed167dSPhilipp Reisner 627bde89a9eSAndreas Gruenbacher peer_addr_len = min_t(int, connection->peer_addr_len, sizeof(src_in6)); 628bde89a9eSAndreas Gruenbacher memcpy(&peer_in6, &connection->peer_addr, peer_addr_len); 629b411b363SPhilipp Reisner 630b411b363SPhilipp Reisner what = "sock_create_kern"; 631eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&src_in6)->sa_family, 632b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 633b411b363SPhilipp Reisner if (err < 0) { 634b411b363SPhilipp Reisner sock = NULL; 635b411b363SPhilipp Reisner goto out; 636b411b363SPhilipp Reisner } 637b411b363SPhilipp Reisner 638b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 63969ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 64044ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 641b411b363SPhilipp Reisner 642b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 643b411b363SPhilipp Reisner * for the outgoing connections. 644b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 645b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 646b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 647b411b363SPhilipp Reisner * a free one dynamically. 648b411b363SPhilipp Reisner */ 649b411b363SPhilipp Reisner what = "bind before connect"; 65044ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 651b411b363SPhilipp Reisner if (err < 0) 652b411b363SPhilipp Reisner goto out; 653b411b363SPhilipp Reisner 654b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 655b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 656b411b363SPhilipp Reisner disconnect_on_error = 0; 657b411b363SPhilipp Reisner what = "connect"; 65844ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 659b411b363SPhilipp Reisner 660b411b363SPhilipp Reisner out: 661b411b363SPhilipp Reisner if (err < 0) { 662b411b363SPhilipp Reisner if (sock) { 663b411b363SPhilipp Reisner sock_release(sock); 664b411b363SPhilipp Reisner sock = NULL; 665b411b363SPhilipp Reisner } 666b411b363SPhilipp Reisner switch (-err) { 667b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 668b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 669b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 670b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 671b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 672b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 673b411b363SPhilipp Reisner disconnect_on_error = 0; 674b411b363SPhilipp Reisner break; 675b411b363SPhilipp Reisner default: 6761ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 677b411b363SPhilipp Reisner } 678b411b363SPhilipp Reisner if (disconnect_on_error) 679bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 680b411b363SPhilipp Reisner } 68144ed167dSPhilipp Reisner 682b411b363SPhilipp Reisner return sock; 683b411b363SPhilipp Reisner } 684b411b363SPhilipp Reisner 6857a426fd8SPhilipp Reisner struct accept_wait_data { 686bde89a9eSAndreas Gruenbacher struct drbd_connection *connection; 6877a426fd8SPhilipp Reisner struct socket *s_listen; 6887a426fd8SPhilipp Reisner struct completion door_bell; 6897a426fd8SPhilipp Reisner void (*original_sk_state_change)(struct sock *sk); 6907a426fd8SPhilipp Reisner 6917a426fd8SPhilipp Reisner }; 6927a426fd8SPhilipp Reisner 693715306f6SAndreas Gruenbacher static void drbd_incoming_connection(struct sock *sk) 694b411b363SPhilipp Reisner { 6957a426fd8SPhilipp Reisner struct accept_wait_data *ad = sk->sk_user_data; 696715306f6SAndreas Gruenbacher void (*state_change)(struct sock *sk); 6977a426fd8SPhilipp Reisner 698715306f6SAndreas Gruenbacher state_change = ad->original_sk_state_change; 699715306f6SAndreas Gruenbacher if (sk->sk_state == TCP_ESTABLISHED) 7007a426fd8SPhilipp Reisner complete(&ad->door_bell); 701715306f6SAndreas Gruenbacher state_change(sk); 7027a426fd8SPhilipp Reisner } 7037a426fd8SPhilipp Reisner 704bde89a9eSAndreas Gruenbacher static int prepare_listen_socket(struct drbd_connection *connection, struct accept_wait_data *ad) 705b411b363SPhilipp Reisner { 7061f3e509bSPhilipp Reisner int err, sndbuf_size, rcvbuf_size, my_addr_len; 70744ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 7081f3e509bSPhilipp Reisner struct socket *s_listen; 70944ed167dSPhilipp Reisner struct net_conf *nc; 710b411b363SPhilipp Reisner const char *what; 711b411b363SPhilipp Reisner 71244ed167dSPhilipp Reisner rcu_read_lock(); 713bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 71444ed167dSPhilipp Reisner if (!nc) { 71544ed167dSPhilipp Reisner rcu_read_unlock(); 7167a426fd8SPhilipp Reisner return -EIO; 71744ed167dSPhilipp Reisner } 71844ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71944ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 72044ed167dSPhilipp Reisner rcu_read_unlock(); 721b411b363SPhilipp Reisner 722bde89a9eSAndreas Gruenbacher my_addr_len = min_t(int, connection->my_addr_len, sizeof(struct sockaddr_in6)); 723bde89a9eSAndreas Gruenbacher memcpy(&my_addr, &connection->my_addr, my_addr_len); 724b411b363SPhilipp Reisner 725b411b363SPhilipp Reisner what = "sock_create_kern"; 726eeb1bd5cSEric W. Biederman err = sock_create_kern(&init_net, ((struct sockaddr *)&my_addr)->sa_family, 727b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 728b411b363SPhilipp Reisner if (err) { 729b411b363SPhilipp Reisner s_listen = NULL; 730b411b363SPhilipp Reisner goto out; 731b411b363SPhilipp Reisner } 732b411b363SPhilipp Reisner 7334a17fd52SPavel Emelyanov s_listen->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 73444ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 735b411b363SPhilipp Reisner 736b411b363SPhilipp Reisner what = "bind before listen"; 73744ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 738b411b363SPhilipp Reisner if (err < 0) 739b411b363SPhilipp Reisner goto out; 740b411b363SPhilipp Reisner 7417a426fd8SPhilipp Reisner ad->s_listen = s_listen; 7427a426fd8SPhilipp Reisner write_lock_bh(&s_listen->sk->sk_callback_lock); 7437a426fd8SPhilipp Reisner ad->original_sk_state_change = s_listen->sk->sk_state_change; 744715306f6SAndreas Gruenbacher s_listen->sk->sk_state_change = drbd_incoming_connection; 7457a426fd8SPhilipp Reisner s_listen->sk->sk_user_data = ad; 7467a426fd8SPhilipp Reisner write_unlock_bh(&s_listen->sk->sk_callback_lock); 747b411b363SPhilipp Reisner 7482820fd39SPhilipp Reisner what = "listen"; 7492820fd39SPhilipp Reisner err = s_listen->ops->listen(s_listen, 5); 7502820fd39SPhilipp Reisner if (err < 0) 7512820fd39SPhilipp Reisner goto out; 7522820fd39SPhilipp Reisner 7537a426fd8SPhilipp Reisner return 0; 754b411b363SPhilipp Reisner out: 755b411b363SPhilipp Reisner if (s_listen) 756b411b363SPhilipp Reisner sock_release(s_listen); 757b411b363SPhilipp Reisner if (err < 0) { 758b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7591ec861ebSAndreas Gruenbacher drbd_err(connection, "%s failed, err = %d\n", what, err); 760bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 761b411b363SPhilipp Reisner } 762b411b363SPhilipp Reisner } 7631f3e509bSPhilipp Reisner 7647a426fd8SPhilipp Reisner return -EIO; 7651f3e509bSPhilipp Reisner } 7661f3e509bSPhilipp Reisner 767715306f6SAndreas Gruenbacher static void unregister_state_change(struct sock *sk, struct accept_wait_data *ad) 768715306f6SAndreas Gruenbacher { 769715306f6SAndreas Gruenbacher write_lock_bh(&sk->sk_callback_lock); 770715306f6SAndreas Gruenbacher sk->sk_state_change = ad->original_sk_state_change; 771715306f6SAndreas Gruenbacher sk->sk_user_data = NULL; 772715306f6SAndreas Gruenbacher write_unlock_bh(&sk->sk_callback_lock); 773715306f6SAndreas Gruenbacher } 774715306f6SAndreas Gruenbacher 775bde89a9eSAndreas Gruenbacher static struct socket *drbd_wait_for_connect(struct drbd_connection *connection, struct accept_wait_data *ad) 7761f3e509bSPhilipp Reisner { 7771f3e509bSPhilipp Reisner int timeo, connect_int, err = 0; 7781f3e509bSPhilipp Reisner struct socket *s_estab = NULL; 7791f3e509bSPhilipp Reisner struct net_conf *nc; 7801f3e509bSPhilipp Reisner 7811f3e509bSPhilipp Reisner rcu_read_lock(); 782bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 7831f3e509bSPhilipp Reisner if (!nc) { 7841f3e509bSPhilipp Reisner rcu_read_unlock(); 7851f3e509bSPhilipp Reisner return NULL; 7861f3e509bSPhilipp Reisner } 7871f3e509bSPhilipp Reisner connect_int = nc->connect_int; 7881f3e509bSPhilipp Reisner rcu_read_unlock(); 7891f3e509bSPhilipp Reisner 7901f3e509bSPhilipp Reisner timeo = connect_int * HZ; 79138b682b2SAkinobu Mita /* 28.5% random jitter */ 79238b682b2SAkinobu Mita timeo += (prandom_u32() & 1) ? timeo / 7 : -timeo / 7; 7931f3e509bSPhilipp Reisner 7947a426fd8SPhilipp Reisner err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo); 7957a426fd8SPhilipp Reisner if (err <= 0) 7967a426fd8SPhilipp Reisner return NULL; 7971f3e509bSPhilipp Reisner 7987a426fd8SPhilipp Reisner err = kernel_accept(ad->s_listen, &s_estab, 0); 799b411b363SPhilipp Reisner if (err < 0) { 800b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 8011ec861ebSAndreas Gruenbacher drbd_err(connection, "accept failed, err = %d\n", err); 802bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 803b411b363SPhilipp Reisner } 804b411b363SPhilipp Reisner } 805b411b363SPhilipp Reisner 806715306f6SAndreas Gruenbacher if (s_estab) 807715306f6SAndreas Gruenbacher unregister_state_change(s_estab->sk, ad); 808b411b363SPhilipp Reisner 809b411b363SPhilipp Reisner return s_estab; 810b411b363SPhilipp Reisner } 811b411b363SPhilipp Reisner 812bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *, void *, struct packet_info *); 813b411b363SPhilipp Reisner 814bde89a9eSAndreas Gruenbacher static int send_first_packet(struct drbd_connection *connection, struct drbd_socket *sock, 8159f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 8169f5bdc33SAndreas Gruenbacher { 817bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) 8189f5bdc33SAndreas Gruenbacher return -EIO; 819bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, cmd, 0, NULL, 0); 820b411b363SPhilipp Reisner } 821b411b363SPhilipp Reisner 822bde89a9eSAndreas Gruenbacher static int receive_first_packet(struct drbd_connection *connection, struct socket *sock) 823b411b363SPhilipp Reisner { 824bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 8259f5bdc33SAndreas Gruenbacher struct packet_info pi; 8264920e37aSPhilipp Reisner struct net_conf *nc; 8279f5bdc33SAndreas Gruenbacher int err; 828b411b363SPhilipp Reisner 8294920e37aSPhilipp Reisner rcu_read_lock(); 8304920e37aSPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8314920e37aSPhilipp Reisner if (!nc) { 8324920e37aSPhilipp Reisner rcu_read_unlock(); 8334920e37aSPhilipp Reisner return -EIO; 8344920e37aSPhilipp Reisner } 8354920e37aSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo * 4 * HZ / 10; 8364920e37aSPhilipp Reisner rcu_read_unlock(); 8374920e37aSPhilipp Reisner 838bde89a9eSAndreas Gruenbacher err = drbd_recv_short(sock, connection->data.rbuf, header_size, 0); 8399f5bdc33SAndreas Gruenbacher if (err != header_size) { 8409f5bdc33SAndreas Gruenbacher if (err >= 0) 8419f5bdc33SAndreas Gruenbacher err = -EIO; 8429f5bdc33SAndreas Gruenbacher return err; 8439f5bdc33SAndreas Gruenbacher } 844bde89a9eSAndreas Gruenbacher err = decode_header(connection, connection->data.rbuf, &pi); 8459f5bdc33SAndreas Gruenbacher if (err) 8469f5bdc33SAndreas Gruenbacher return err; 8479f5bdc33SAndreas Gruenbacher return pi.cmd; 848b411b363SPhilipp Reisner } 849b411b363SPhilipp Reisner 850b411b363SPhilipp Reisner /** 851b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 852b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 853b411b363SPhilipp Reisner */ 8545d0b17f1SPhilipp Reisner static bool drbd_socket_okay(struct socket **sock) 855b411b363SPhilipp Reisner { 856b411b363SPhilipp Reisner int rr; 857b411b363SPhilipp Reisner char tb[4]; 858b411b363SPhilipp Reisner 859b411b363SPhilipp Reisner if (!*sock) 86081e84650SAndreas Gruenbacher return false; 861b411b363SPhilipp Reisner 862dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 863b411b363SPhilipp Reisner 864b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 86581e84650SAndreas Gruenbacher return true; 866b411b363SPhilipp Reisner } else { 867b411b363SPhilipp Reisner sock_release(*sock); 868b411b363SPhilipp Reisner *sock = NULL; 86981e84650SAndreas Gruenbacher return false; 870b411b363SPhilipp Reisner } 871b411b363SPhilipp Reisner } 8725d0b17f1SPhilipp Reisner 8735d0b17f1SPhilipp Reisner static bool connection_established(struct drbd_connection *connection, 8745d0b17f1SPhilipp Reisner struct socket **sock1, 8755d0b17f1SPhilipp Reisner struct socket **sock2) 8765d0b17f1SPhilipp Reisner { 8775d0b17f1SPhilipp Reisner struct net_conf *nc; 8785d0b17f1SPhilipp Reisner int timeout; 8795d0b17f1SPhilipp Reisner bool ok; 8805d0b17f1SPhilipp Reisner 8815d0b17f1SPhilipp Reisner if (!*sock1 || !*sock2) 8825d0b17f1SPhilipp Reisner return false; 8835d0b17f1SPhilipp Reisner 8845d0b17f1SPhilipp Reisner rcu_read_lock(); 8855d0b17f1SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 8865d0b17f1SPhilipp Reisner timeout = (nc->sock_check_timeo ?: nc->ping_timeo) * HZ / 10; 8875d0b17f1SPhilipp Reisner rcu_read_unlock(); 8885d0b17f1SPhilipp Reisner schedule_timeout_interruptible(timeout); 8895d0b17f1SPhilipp Reisner 8905d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock1); 8915d0b17f1SPhilipp Reisner ok = drbd_socket_okay(sock2) && ok; 8925d0b17f1SPhilipp Reisner 8935d0b17f1SPhilipp Reisner return ok; 8945d0b17f1SPhilipp Reisner } 8955d0b17f1SPhilipp Reisner 8962325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8972325eb66SPhilipp Reisner in a connection */ 89869a22773SAndreas Gruenbacher int drbd_connected(struct drbd_peer_device *peer_device) 899907599e0SPhilipp Reisner { 90069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 9010829f5edSAndreas Gruenbacher int err; 902907599e0SPhilipp Reisner 903b30ab791SAndreas Gruenbacher atomic_set(&device->packet_seq, 0); 904b30ab791SAndreas Gruenbacher device->peer_seq = 0; 905907599e0SPhilipp Reisner 90669a22773SAndreas Gruenbacher device->state_mutex = peer_device->connection->agreed_pro_version < 100 ? 90769a22773SAndreas Gruenbacher &peer_device->connection->cstate_mutex : 908b30ab791SAndreas Gruenbacher &device->own_state_mutex; 9098410da8fSPhilipp Reisner 91069a22773SAndreas Gruenbacher err = drbd_send_sync_param(peer_device); 9110829f5edSAndreas Gruenbacher if (!err) 91269a22773SAndreas Gruenbacher err = drbd_send_sizes(peer_device, 0, 0); 9130829f5edSAndreas Gruenbacher if (!err) 91469a22773SAndreas Gruenbacher err = drbd_send_uuids(peer_device); 9150829f5edSAndreas Gruenbacher if (!err) 91669a22773SAndreas Gruenbacher err = drbd_send_current_state(peer_device); 917b30ab791SAndreas Gruenbacher clear_bit(USE_DEGR_WFC_T, &device->flags); 918b30ab791SAndreas Gruenbacher clear_bit(RESIZE_PENDING, &device->flags); 919b30ab791SAndreas Gruenbacher atomic_set(&device->ap_in_flight, 0); 920b30ab791SAndreas Gruenbacher mod_timer(&device->request_timer, jiffies + HZ); /* just start it here. */ 9210829f5edSAndreas Gruenbacher return err; 922907599e0SPhilipp Reisner } 923b411b363SPhilipp Reisner 924b411b363SPhilipp Reisner /* 925b411b363SPhilipp Reisner * return values: 926b411b363SPhilipp Reisner * 1 yes, we have a valid connection 927b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 928b411b363SPhilipp Reisner * -1 peer talks different language, 929b411b363SPhilipp Reisner * no point in trying again, please go standalone. 930b411b363SPhilipp Reisner * -2 We do not have a network config... 931b411b363SPhilipp Reisner */ 932bde89a9eSAndreas Gruenbacher static int conn_connect(struct drbd_connection *connection) 933b411b363SPhilipp Reisner { 9347da35862SPhilipp Reisner struct drbd_socket sock, msock; 935c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 93644ed167dSPhilipp Reisner struct net_conf *nc; 9375d0b17f1SPhilipp Reisner int vnr, timeout, h; 9385d0b17f1SPhilipp Reisner bool discard_my_data, ok; 939197296ffSPhilipp Reisner enum drbd_state_rv rv; 9407a426fd8SPhilipp Reisner struct accept_wait_data ad = { 941bde89a9eSAndreas Gruenbacher .connection = connection, 9427a426fd8SPhilipp Reisner .door_bell = COMPLETION_INITIALIZER_ONSTACK(ad.door_bell), 9437a426fd8SPhilipp Reisner }; 944b411b363SPhilipp Reisner 945bde89a9eSAndreas Gruenbacher clear_bit(DISCONNECT_SENT, &connection->flags); 946bde89a9eSAndreas Gruenbacher if (conn_request_state(connection, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 947b411b363SPhilipp Reisner return -2; 948b411b363SPhilipp Reisner 9497da35862SPhilipp Reisner mutex_init(&sock.mutex); 950bde89a9eSAndreas Gruenbacher sock.sbuf = connection->data.sbuf; 951bde89a9eSAndreas Gruenbacher sock.rbuf = connection->data.rbuf; 9527da35862SPhilipp Reisner sock.socket = NULL; 9537da35862SPhilipp Reisner mutex_init(&msock.mutex); 954bde89a9eSAndreas Gruenbacher msock.sbuf = connection->meta.sbuf; 955bde89a9eSAndreas Gruenbacher msock.rbuf = connection->meta.rbuf; 9567da35862SPhilipp Reisner msock.socket = NULL; 9577da35862SPhilipp Reisner 9580916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 959bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = 80; 960b411b363SPhilipp Reisner 961bde89a9eSAndreas Gruenbacher if (prepare_listen_socket(connection, &ad)) 9627a426fd8SPhilipp Reisner return 0; 963b411b363SPhilipp Reisner 964b411b363SPhilipp Reisner do { 9652bf89621SAndreas Gruenbacher struct socket *s; 966b411b363SPhilipp Reisner 967bde89a9eSAndreas Gruenbacher s = drbd_try_connect(connection); 968b411b363SPhilipp Reisner if (s) { 9697da35862SPhilipp Reisner if (!sock.socket) { 9707da35862SPhilipp Reisner sock.socket = s; 971bde89a9eSAndreas Gruenbacher send_first_packet(connection, &sock, P_INITIAL_DATA); 9727da35862SPhilipp Reisner } else if (!msock.socket) { 973bde89a9eSAndreas Gruenbacher clear_bit(RESOLVE_CONFLICTS, &connection->flags); 9747da35862SPhilipp Reisner msock.socket = s; 975bde89a9eSAndreas Gruenbacher send_first_packet(connection, &msock, P_INITIAL_META); 976b411b363SPhilipp Reisner } else { 9771ec861ebSAndreas Gruenbacher drbd_err(connection, "Logic error in conn_connect()\n"); 978b411b363SPhilipp Reisner goto out_release_sockets; 979b411b363SPhilipp Reisner } 980b411b363SPhilipp Reisner } 981b411b363SPhilipp Reisner 9825d0b17f1SPhilipp Reisner if (connection_established(connection, &sock.socket, &msock.socket)) 983b411b363SPhilipp Reisner break; 984b411b363SPhilipp Reisner 985b411b363SPhilipp Reisner retry: 986bde89a9eSAndreas Gruenbacher s = drbd_wait_for_connect(connection, &ad); 987b411b363SPhilipp Reisner if (s) { 988bde89a9eSAndreas Gruenbacher int fp = receive_first_packet(connection, s); 9897da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9907da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 99192f14951SPhilipp Reisner switch (fp) { 992e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9937da35862SPhilipp Reisner if (sock.socket) { 9941ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet S crossed\n"); 9957da35862SPhilipp Reisner sock_release(sock.socket); 99680c6eed4SPhilipp Reisner sock.socket = s; 99780c6eed4SPhilipp Reisner goto randomize; 998b411b363SPhilipp Reisner } 9997da35862SPhilipp Reisner sock.socket = s; 1000b411b363SPhilipp Reisner break; 1001e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 1002bde89a9eSAndreas Gruenbacher set_bit(RESOLVE_CONFLICTS, &connection->flags); 10037da35862SPhilipp Reisner if (msock.socket) { 10041ec861ebSAndreas Gruenbacher drbd_warn(connection, "initial packet M crossed\n"); 10057da35862SPhilipp Reisner sock_release(msock.socket); 100680c6eed4SPhilipp Reisner msock.socket = s; 100780c6eed4SPhilipp Reisner goto randomize; 1008b411b363SPhilipp Reisner } 10097da35862SPhilipp Reisner msock.socket = s; 1010b411b363SPhilipp Reisner break; 1011b411b363SPhilipp Reisner default: 10121ec861ebSAndreas Gruenbacher drbd_warn(connection, "Error receiving initial packet\n"); 1013b411b363SPhilipp Reisner sock_release(s); 101480c6eed4SPhilipp Reisner randomize: 101538b682b2SAkinobu Mita if (prandom_u32() & 1) 1016b411b363SPhilipp Reisner goto retry; 1017b411b363SPhilipp Reisner } 1018b411b363SPhilipp Reisner } 1019b411b363SPhilipp Reisner 1020bde89a9eSAndreas Gruenbacher if (connection->cstate <= C_DISCONNECTING) 1021b411b363SPhilipp Reisner goto out_release_sockets; 1022b411b363SPhilipp Reisner if (signal_pending(current)) { 1023b411b363SPhilipp Reisner flush_signals(current); 1024b411b363SPhilipp Reisner smp_rmb(); 1025bde89a9eSAndreas Gruenbacher if (get_t_state(&connection->receiver) == EXITING) 1026b411b363SPhilipp Reisner goto out_release_sockets; 1027b411b363SPhilipp Reisner } 1028b411b363SPhilipp Reisner 10295d0b17f1SPhilipp Reisner ok = connection_established(connection, &sock.socket, &msock.socket); 1030b666dbf8SPhilipp Reisner } while (!ok); 1031b411b363SPhilipp Reisner 10327a426fd8SPhilipp Reisner if (ad.s_listen) 10337a426fd8SPhilipp Reisner sock_release(ad.s_listen); 1034b411b363SPhilipp Reisner 103598683650SPhilipp Reisner sock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 103698683650SPhilipp Reisner msock.socket->sk->sk_reuse = SK_CAN_REUSE; /* SO_REUSEADDR */ 1037b411b363SPhilipp Reisner 10387da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 10397da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 1040b411b363SPhilipp Reisner 10417da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 10427da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 1043b411b363SPhilipp Reisner 1044b411b363SPhilipp Reisner /* NOT YET ... 1045bde89a9eSAndreas Gruenbacher * sock.socket->sk->sk_sndtimeo = connection->net_conf->timeout*HZ/10; 10467da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 10476038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 1048b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 104944ed167dSPhilipp Reisner rcu_read_lock(); 1050bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 1051b411b363SPhilipp Reisner 10527da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 10537da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 105444ed167dSPhilipp Reisner 10557da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 105644ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 105708b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 105844ed167dSPhilipp Reisner rcu_read_unlock(); 105944ed167dSPhilipp Reisner 10607da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 1061b411b363SPhilipp Reisner 1062b411b363SPhilipp Reisner /* we don't want delays. 106325985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 10647da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 10657da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 1066b411b363SPhilipp Reisner 1067bde89a9eSAndreas Gruenbacher connection->data.socket = sock.socket; 1068bde89a9eSAndreas Gruenbacher connection->meta.socket = msock.socket; 1069bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1070b411b363SPhilipp Reisner 1071bde89a9eSAndreas Gruenbacher h = drbd_do_features(connection); 1072b411b363SPhilipp Reisner if (h <= 0) 1073b411b363SPhilipp Reisner return h; 1074b411b363SPhilipp Reisner 1075bde89a9eSAndreas Gruenbacher if (connection->cram_hmac_tfm) { 1076b30ab791SAndreas Gruenbacher /* drbd_request_state(device, NS(conn, WFAuth)); */ 1077bde89a9eSAndreas Gruenbacher switch (drbd_do_auth(connection)) { 1078b10d96cbSJohannes Thoma case -1: 10791ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed\n"); 1080b411b363SPhilipp Reisner return -1; 1081b10d96cbSJohannes Thoma case 0: 10821ec861ebSAndreas Gruenbacher drbd_err(connection, "Authentication of peer failed, trying again.\n"); 1083b10d96cbSJohannes Thoma return 0; 1084b411b363SPhilipp Reisner } 1085b411b363SPhilipp Reisner } 1086b411b363SPhilipp Reisner 1087bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_sndtimeo = timeout; 1088bde89a9eSAndreas Gruenbacher connection->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1089b411b363SPhilipp Reisner 1090bde89a9eSAndreas Gruenbacher if (drbd_send_protocol(connection) == -EOPNOTSUPP) 10917e2455c1SPhilipp Reisner return -1; 10921e86ac48SPhilipp Reisner 109313c76abaSPhilipp Reisner /* Prevent a race between resync-handshake and 109413c76abaSPhilipp Reisner * being promoted to Primary. 109513c76abaSPhilipp Reisner * 109613c76abaSPhilipp Reisner * Grab and release the state mutex, so we know that any current 109713c76abaSPhilipp Reisner * drbd_set_role() is finished, and any incoming drbd_set_role 109813c76abaSPhilipp Reisner * will see the STATE_SENT flag, and wait for it to be cleared. 109913c76abaSPhilipp Reisner */ 110031007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 110131007745SPhilipp Reisner mutex_lock(peer_device->device->state_mutex); 110231007745SPhilipp Reisner 110331007745SPhilipp Reisner set_bit(STATE_SENT, &connection->flags); 110431007745SPhilipp Reisner 110531007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) 110631007745SPhilipp Reisner mutex_unlock(peer_device->device->state_mutex); 110731007745SPhilipp Reisner 110831007745SPhilipp Reisner rcu_read_lock(); 110931007745SPhilipp Reisner idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 111031007745SPhilipp Reisner struct drbd_device *device = peer_device->device; 111131007745SPhilipp Reisner kref_get(&device->kref); 111231007745SPhilipp Reisner rcu_read_unlock(); 111313c76abaSPhilipp Reisner 111408b165baSPhilipp Reisner if (discard_my_data) 1115b30ab791SAndreas Gruenbacher set_bit(DISCARD_MY_DATA, &device->flags); 111608b165baSPhilipp Reisner else 1117b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 111808b165baSPhilipp Reisner 111969a22773SAndreas Gruenbacher drbd_connected(peer_device); 112005a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 1121c141ebdaSPhilipp Reisner rcu_read_lock(); 1122c141ebdaSPhilipp Reisner } 1123c141ebdaSPhilipp Reisner rcu_read_unlock(); 1124c141ebdaSPhilipp Reisner 1125bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1126bde89a9eSAndreas Gruenbacher if (rv < SS_SUCCESS || connection->cstate != C_WF_REPORT_PARAMS) { 1127bde89a9eSAndreas Gruenbacher clear_bit(STATE_SENT, &connection->flags); 11281e86ac48SPhilipp Reisner return 0; 1129a1096a6eSPhilipp Reisner } 11301e86ac48SPhilipp Reisner 11311c03e520SPhilipp Reisner drbd_thread_start(&connection->ack_receiver); 113239e91a60SLars Ellenberg /* opencoded create_singlethread_workqueue(), 113339e91a60SLars Ellenberg * to be able to use format string arguments */ 113439e91a60SLars Ellenberg connection->ack_sender = 113539e91a60SLars Ellenberg alloc_ordered_workqueue("drbd_as_%s", WQ_MEM_RECLAIM, connection->resource->name); 1136668700b4SPhilipp Reisner if (!connection->ack_sender) { 1137668700b4SPhilipp Reisner drbd_err(connection, "Failed to create workqueue ack_sender\n"); 1138668700b4SPhilipp Reisner return 0; 1139668700b4SPhilipp Reisner } 1140b411b363SPhilipp Reisner 11410500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 114208b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 114308b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 114408b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 114508b165baSPhilipp Reisner * just to clear a single value. */ 1146bde89a9eSAndreas Gruenbacher connection->net_conf->discard_my_data = 0; 11470500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 114808b165baSPhilipp Reisner 1149d3fcb490SPhilipp Reisner return h; 1150b411b363SPhilipp Reisner 1151b411b363SPhilipp Reisner out_release_sockets: 11527a426fd8SPhilipp Reisner if (ad.s_listen) 11537a426fd8SPhilipp Reisner sock_release(ad.s_listen); 11547da35862SPhilipp Reisner if (sock.socket) 11557da35862SPhilipp Reisner sock_release(sock.socket); 11567da35862SPhilipp Reisner if (msock.socket) 11577da35862SPhilipp Reisner sock_release(msock.socket); 1158b411b363SPhilipp Reisner return -1; 1159b411b363SPhilipp Reisner } 1160b411b363SPhilipp Reisner 1161bde89a9eSAndreas Gruenbacher static int decode_header(struct drbd_connection *connection, void *header, struct packet_info *pi) 1162b411b363SPhilipp Reisner { 1163bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 1164b411b363SPhilipp Reisner 11650c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 11660c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 11670c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 11680c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 11691ec861ebSAndreas Gruenbacher drbd_err(connection, "Header padding is not zero\n"); 11700c8e36d9SAndreas Gruenbacher return -EINVAL; 117102918be2SPhilipp Reisner } 11720c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 11730c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 11740c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 11750c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1176e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1177e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1178e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1179b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1180eefc2f7dSPhilipp Reisner pi->vnr = 0; 1181e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1182e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1183e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1184e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1185e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 118677351055SPhilipp Reisner pi->vnr = 0; 118702918be2SPhilipp Reisner } else { 11881ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong magic value 0x%08x in protocol version %d\n", 1189e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1190bde89a9eSAndreas Gruenbacher connection->agreed_pro_version); 11918172f3e9SAndreas Gruenbacher return -EINVAL; 1192b411b363SPhilipp Reisner } 1193e658983aSAndreas Gruenbacher pi->data = header + header_size; 11948172f3e9SAndreas Gruenbacher return 0; 1195b411b363SPhilipp Reisner } 1196b411b363SPhilipp Reisner 1197c51a0ef3SLars Ellenberg static void drbd_unplug_all_devices(struct drbd_connection *connection) 1198c51a0ef3SLars Ellenberg { 1199c51a0ef3SLars Ellenberg if (current->plug == &connection->receiver_plug) { 1200c51a0ef3SLars Ellenberg blk_finish_plug(&connection->receiver_plug); 1201c51a0ef3SLars Ellenberg blk_start_plug(&connection->receiver_plug); 1202c51a0ef3SLars Ellenberg } /* else: maybe just schedule() ?? */ 1203c51a0ef3SLars Ellenberg } 1204c51a0ef3SLars Ellenberg 1205bde89a9eSAndreas Gruenbacher static int drbd_recv_header(struct drbd_connection *connection, struct packet_info *pi) 1206257d0af6SPhilipp Reisner { 1207bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 120869bc7bc3SAndreas Gruenbacher int err; 1209257d0af6SPhilipp Reisner 1210bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, buffer, drbd_header_size(connection)); 1211a5c31904SAndreas Gruenbacher if (err) 121269bc7bc3SAndreas Gruenbacher return err; 1213257d0af6SPhilipp Reisner 1214bde89a9eSAndreas Gruenbacher err = decode_header(connection, buffer, pi); 1215bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 1216b411b363SPhilipp Reisner 121769bc7bc3SAndreas Gruenbacher return err; 1218b411b363SPhilipp Reisner } 1219b411b363SPhilipp Reisner 1220c51a0ef3SLars Ellenberg static int drbd_recv_header_maybe_unplug(struct drbd_connection *connection, struct packet_info *pi) 1221c51a0ef3SLars Ellenberg { 1222c51a0ef3SLars Ellenberg void *buffer = connection->data.rbuf; 1223c51a0ef3SLars Ellenberg unsigned int size = drbd_header_size(connection); 1224c51a0ef3SLars Ellenberg int err; 1225c51a0ef3SLars Ellenberg 1226c51a0ef3SLars Ellenberg err = drbd_recv_short(connection->data.socket, buffer, size, MSG_NOSIGNAL|MSG_DONTWAIT); 1227c51a0ef3SLars Ellenberg if (err != size) { 1228c51a0ef3SLars Ellenberg /* If we have nothing in the receive buffer now, to reduce 1229c51a0ef3SLars Ellenberg * application latency, try to drain the backend queues as 1230c51a0ef3SLars Ellenberg * quickly as possible, and let remote TCP know what we have 1231c51a0ef3SLars Ellenberg * received so far. */ 1232c51a0ef3SLars Ellenberg if (err == -EAGAIN) { 1233c51a0ef3SLars Ellenberg drbd_tcp_quickack(connection->data.socket); 1234c51a0ef3SLars Ellenberg drbd_unplug_all_devices(connection); 1235c51a0ef3SLars Ellenberg } 1236c51a0ef3SLars Ellenberg if (err > 0) { 1237c51a0ef3SLars Ellenberg buffer += err; 1238c51a0ef3SLars Ellenberg size -= err; 1239c51a0ef3SLars Ellenberg } 1240c51a0ef3SLars Ellenberg err = drbd_recv_all_warn(connection, buffer, size); 1241c51a0ef3SLars Ellenberg if (err) 1242c51a0ef3SLars Ellenberg return err; 1243c51a0ef3SLars Ellenberg } 1244c51a0ef3SLars Ellenberg 1245c51a0ef3SLars Ellenberg err = decode_header(connection, connection->data.rbuf, pi); 1246c51a0ef3SLars Ellenberg connection->last_received = jiffies; 1247c51a0ef3SLars Ellenberg 1248c51a0ef3SLars Ellenberg return err; 1249c51a0ef3SLars Ellenberg } 1250f9ff0da5SLars Ellenberg /* This is blkdev_issue_flush, but asynchronous. 1251f9ff0da5SLars Ellenberg * We want to submit to all component volumes in parallel, 1252f9ff0da5SLars Ellenberg * then wait for all completions. 1253f9ff0da5SLars Ellenberg */ 1254f9ff0da5SLars Ellenberg struct issue_flush_context { 1255f9ff0da5SLars Ellenberg atomic_t pending; 1256f9ff0da5SLars Ellenberg int error; 1257f9ff0da5SLars Ellenberg struct completion done; 1258f9ff0da5SLars Ellenberg }; 1259f9ff0da5SLars Ellenberg struct one_flush_context { 1260f9ff0da5SLars Ellenberg struct drbd_device *device; 1261f9ff0da5SLars Ellenberg struct issue_flush_context *ctx; 1262f9ff0da5SLars Ellenberg }; 1263f9ff0da5SLars Ellenberg 1264f9ff0da5SLars Ellenberg void one_flush_endio(struct bio *bio) 1265f9ff0da5SLars Ellenberg { 1266f9ff0da5SLars Ellenberg struct one_flush_context *octx = bio->bi_private; 1267f9ff0da5SLars Ellenberg struct drbd_device *device = octx->device; 1268f9ff0da5SLars Ellenberg struct issue_flush_context *ctx = octx->ctx; 1269f9ff0da5SLars Ellenberg 12704e4cbee9SChristoph Hellwig if (bio->bi_status) { 12714e4cbee9SChristoph Hellwig ctx->error = blk_status_to_errno(bio->bi_status); 12724e4cbee9SChristoph Hellwig drbd_info(device, "local disk FLUSH FAILED with status %d\n", bio->bi_status); 1273f9ff0da5SLars Ellenberg } 1274f9ff0da5SLars Ellenberg kfree(octx); 1275f9ff0da5SLars Ellenberg bio_put(bio); 1276f9ff0da5SLars Ellenberg 1277f9ff0da5SLars Ellenberg clear_bit(FLUSH_PENDING, &device->flags); 1278f9ff0da5SLars Ellenberg put_ldev(device); 1279f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1280f9ff0da5SLars Ellenberg 1281f9ff0da5SLars Ellenberg if (atomic_dec_and_test(&ctx->pending)) 1282f9ff0da5SLars Ellenberg complete(&ctx->done); 1283f9ff0da5SLars Ellenberg } 1284f9ff0da5SLars Ellenberg 1285f9ff0da5SLars Ellenberg static void submit_one_flush(struct drbd_device *device, struct issue_flush_context *ctx) 1286f9ff0da5SLars Ellenberg { 1287f9ff0da5SLars Ellenberg struct bio *bio = bio_alloc(GFP_NOIO, 0); 1288f9ff0da5SLars Ellenberg struct one_flush_context *octx = kmalloc(sizeof(*octx), GFP_NOIO); 1289f9ff0da5SLars Ellenberg if (!bio || !octx) { 1290f9ff0da5SLars Ellenberg drbd_warn(device, "Could not allocate a bio, CANNOT ISSUE FLUSH\n"); 1291f9ff0da5SLars Ellenberg /* FIXME: what else can I do now? disconnecting or detaching 1292f9ff0da5SLars Ellenberg * really does not help to improve the state of the world, either. 1293f9ff0da5SLars Ellenberg */ 1294f9ff0da5SLars Ellenberg kfree(octx); 1295f9ff0da5SLars Ellenberg if (bio) 1296f9ff0da5SLars Ellenberg bio_put(bio); 1297f9ff0da5SLars Ellenberg 1298f9ff0da5SLars Ellenberg ctx->error = -ENOMEM; 1299f9ff0da5SLars Ellenberg put_ldev(device); 1300f9ff0da5SLars Ellenberg kref_put(&device->kref, drbd_destroy_device); 1301f9ff0da5SLars Ellenberg return; 1302f9ff0da5SLars Ellenberg } 1303f9ff0da5SLars Ellenberg 1304f9ff0da5SLars Ellenberg octx->device = device; 1305f9ff0da5SLars Ellenberg octx->ctx = ctx; 130674d46992SChristoph Hellwig bio_set_dev(bio, device->ldev->backing_bdev); 1307f9ff0da5SLars Ellenberg bio->bi_private = octx; 1308f9ff0da5SLars Ellenberg bio->bi_end_io = one_flush_endio; 130970fd7614SChristoph Hellwig bio->bi_opf = REQ_OP_FLUSH | REQ_PREFLUSH; 1310f9ff0da5SLars Ellenberg 1311f9ff0da5SLars Ellenberg device->flush_jif = jiffies; 1312f9ff0da5SLars Ellenberg set_bit(FLUSH_PENDING, &device->flags); 1313f9ff0da5SLars Ellenberg atomic_inc(&ctx->pending); 1314f9ff0da5SLars Ellenberg submit_bio(bio); 1315f9ff0da5SLars Ellenberg } 1316f9ff0da5SLars Ellenberg 1317bde89a9eSAndreas Gruenbacher static void drbd_flush(struct drbd_connection *connection) 1318b411b363SPhilipp Reisner { 1319f9ff0da5SLars Ellenberg if (connection->resource->write_ordering >= WO_BDEV_FLUSH) { 1320c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 1321f9ff0da5SLars Ellenberg struct issue_flush_context ctx; 13224b0007c0SPhilipp Reisner int vnr; 1323b411b363SPhilipp Reisner 1324f9ff0da5SLars Ellenberg atomic_set(&ctx.pending, 1); 1325f9ff0da5SLars Ellenberg ctx.error = 0; 1326f9ff0da5SLars Ellenberg init_completion(&ctx.done); 1327f9ff0da5SLars Ellenberg 1328615e087fSLars Ellenberg rcu_read_lock(); 1329c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1330c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1331c06ece6bSAndreas Gruenbacher 1332b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 1333615e087fSLars Ellenberg continue; 1334b30ab791SAndreas Gruenbacher kref_get(&device->kref); 1335615e087fSLars Ellenberg rcu_read_unlock(); 13364b0007c0SPhilipp Reisner 1337f9ff0da5SLars Ellenberg submit_one_flush(device, &ctx); 1338f9ff0da5SLars Ellenberg 1339f9ff0da5SLars Ellenberg rcu_read_lock(); 1340f9ff0da5SLars Ellenberg } 1341f9ff0da5SLars Ellenberg rcu_read_unlock(); 1342f9ff0da5SLars Ellenberg 1343f9ff0da5SLars Ellenberg /* Do we want to add a timeout, 1344f9ff0da5SLars Ellenberg * if disk-timeout is set? */ 1345f9ff0da5SLars Ellenberg if (!atomic_dec_and_test(&ctx.pending)) 1346f9ff0da5SLars Ellenberg wait_for_completion(&ctx.done); 1347f9ff0da5SLars Ellenberg 1348f9ff0da5SLars Ellenberg if (ctx.error) { 1349b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1350b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1351b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1352f9ff0da5SLars Ellenberg /* Any error is already reported by bio_endio callback. */ 1353f6ba8636SAndreas Gruenbacher drbd_bump_write_ordering(connection->resource, NULL, WO_DRAIN_IO); 1354b411b363SPhilipp Reisner } 1355b411b363SPhilipp Reisner } 1356b411b363SPhilipp Reisner } 1357b411b363SPhilipp Reisner 1358b411b363SPhilipp Reisner /** 1359b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1360b30ab791SAndreas Gruenbacher * @device: DRBD device. 1361b411b363SPhilipp Reisner * @epoch: Epoch object. 1362b411b363SPhilipp Reisner * @ev: Epoch event. 1363b411b363SPhilipp Reisner */ 1364bde89a9eSAndreas Gruenbacher static enum finish_epoch drbd_may_finish_epoch(struct drbd_connection *connection, 1365b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1366b411b363SPhilipp Reisner enum epoch_event ev) 1367b411b363SPhilipp Reisner { 13682451fc3bSPhilipp Reisner int epoch_size; 1369b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1370b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1371b411b363SPhilipp Reisner 1372bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1373b411b363SPhilipp Reisner do { 1374b411b363SPhilipp Reisner next_epoch = NULL; 1375b411b363SPhilipp Reisner 1376b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1377b411b363SPhilipp Reisner 1378b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1379b411b363SPhilipp Reisner case EV_PUT: 1380b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1381b411b363SPhilipp Reisner break; 1382b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1383b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1384b411b363SPhilipp Reisner break; 1385b411b363SPhilipp Reisner case EV_BECAME_LAST: 1386b411b363SPhilipp Reisner /* nothing to do*/ 1387b411b363SPhilipp Reisner break; 1388b411b363SPhilipp Reisner } 1389b411b363SPhilipp Reisner 1390b411b363SPhilipp Reisner if (epoch_size != 0 && 1391b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 139280f9fd55SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1393b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1394bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1395bde89a9eSAndreas Gruenbacher drbd_send_b_ack(epoch->connection, epoch->barrier_nr, epoch_size); 1396bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1397b411b363SPhilipp Reisner } 13989ed57dcbSLars Ellenberg #if 0 13999ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 14009ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 140180f9fd55SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 1402bde89a9eSAndreas Gruenbacher dec_unacked(epoch->connection); 14039ed57dcbSLars Ellenberg #endif 1404b411b363SPhilipp Reisner 1405bde89a9eSAndreas Gruenbacher if (connection->current_epoch != epoch) { 1406b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1407b411b363SPhilipp Reisner list_del(&epoch->list); 1408b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1409bde89a9eSAndreas Gruenbacher connection->epochs--; 1410b411b363SPhilipp Reisner kfree(epoch); 1411b411b363SPhilipp Reisner 1412b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1413b411b363SPhilipp Reisner rv = FE_DESTROYED; 1414b411b363SPhilipp Reisner } else { 1415b411b363SPhilipp Reisner epoch->flags = 0; 1416b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1417698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1418b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1419b411b363SPhilipp Reisner rv = FE_RECYCLED; 1420b411b363SPhilipp Reisner } 1421b411b363SPhilipp Reisner } 1422b411b363SPhilipp Reisner 1423b411b363SPhilipp Reisner if (!next_epoch) 1424b411b363SPhilipp Reisner break; 1425b411b363SPhilipp Reisner 1426b411b363SPhilipp Reisner epoch = next_epoch; 1427b411b363SPhilipp Reisner } while (1); 1428b411b363SPhilipp Reisner 1429bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1430b411b363SPhilipp Reisner 1431b411b363SPhilipp Reisner return rv; 1432b411b363SPhilipp Reisner } 1433b411b363SPhilipp Reisner 14348fe39aacSPhilipp Reisner static enum write_ordering_e 14358fe39aacSPhilipp Reisner max_allowed_wo(struct drbd_backing_dev *bdev, enum write_ordering_e wo) 14368fe39aacSPhilipp Reisner { 14378fe39aacSPhilipp Reisner struct disk_conf *dc; 14388fe39aacSPhilipp Reisner 14398fe39aacSPhilipp Reisner dc = rcu_dereference(bdev->disk_conf); 14408fe39aacSPhilipp Reisner 1441f6ba8636SAndreas Gruenbacher if (wo == WO_BDEV_FLUSH && !dc->disk_flushes) 1442f6ba8636SAndreas Gruenbacher wo = WO_DRAIN_IO; 1443f6ba8636SAndreas Gruenbacher if (wo == WO_DRAIN_IO && !dc->disk_drain) 1444f6ba8636SAndreas Gruenbacher wo = WO_NONE; 14458fe39aacSPhilipp Reisner 14468fe39aacSPhilipp Reisner return wo; 14478fe39aacSPhilipp Reisner } 14488fe39aacSPhilipp Reisner 1449b411b363SPhilipp Reisner /** 1450b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1451bde89a9eSAndreas Gruenbacher * @connection: DRBD connection. 1452b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1453b411b363SPhilipp Reisner */ 14548fe39aacSPhilipp Reisner void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, 14558fe39aacSPhilipp Reisner enum write_ordering_e wo) 1456b411b363SPhilipp Reisner { 1457e9526580SPhilipp Reisner struct drbd_device *device; 1458b411b363SPhilipp Reisner enum write_ordering_e pwo; 14594b0007c0SPhilipp Reisner int vnr; 1460b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1461f6ba8636SAndreas Gruenbacher [WO_NONE] = "none", 1462f6ba8636SAndreas Gruenbacher [WO_DRAIN_IO] = "drain", 1463f6ba8636SAndreas Gruenbacher [WO_BDEV_FLUSH] = "flush", 1464b411b363SPhilipp Reisner }; 1465b411b363SPhilipp Reisner 1466e9526580SPhilipp Reisner pwo = resource->write_ordering; 1467f6ba8636SAndreas Gruenbacher if (wo != WO_BDEV_FLUSH) 1468b411b363SPhilipp Reisner wo = min(pwo, wo); 1469daeda1ccSPhilipp Reisner rcu_read_lock(); 1470e9526580SPhilipp Reisner idr_for_each_entry(&resource->devices, device, vnr) { 14718fe39aacSPhilipp Reisner if (get_ldev(device)) { 14728fe39aacSPhilipp Reisner wo = max_allowed_wo(device->ldev, wo); 14738fe39aacSPhilipp Reisner if (device->ldev == bdev) 14748fe39aacSPhilipp Reisner bdev = NULL; 1475b30ab791SAndreas Gruenbacher put_ldev(device); 14764b0007c0SPhilipp Reisner } 14778fe39aacSPhilipp Reisner } 14788fe39aacSPhilipp Reisner 14798fe39aacSPhilipp Reisner if (bdev) 14808fe39aacSPhilipp Reisner wo = max_allowed_wo(bdev, wo); 14818fe39aacSPhilipp Reisner 148270df7092SLars Ellenberg rcu_read_unlock(); 148370df7092SLars Ellenberg 1484e9526580SPhilipp Reisner resource->write_ordering = wo; 1485f6ba8636SAndreas Gruenbacher if (pwo != resource->write_ordering || wo == WO_BDEV_FLUSH) 1486e9526580SPhilipp Reisner drbd_info(resource, "Method to ensure write ordering: %s\n", write_ordering_str[resource->write_ordering]); 1487b411b363SPhilipp Reisner } 1488b411b363SPhilipp Reisner 14899104d31aSLars Ellenberg static void drbd_issue_peer_discard(struct drbd_device *device, struct drbd_peer_request *peer_req) 1490dd4f699dSLars Ellenberg { 14910dbed96aSChristoph Hellwig struct block_device *bdev = device->ldev->backing_bdev; 1492dd4f699dSLars Ellenberg 14930dbed96aSChristoph Hellwig if (blkdev_issue_zeroout(bdev, peer_req->i.sector, peer_req->i.size >> 9, 14940dbed96aSChristoph Hellwig GFP_NOIO, 0)) 1495dd4f699dSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 14960dbed96aSChristoph Hellwig 1497dd4f699dSLars Ellenberg drbd_endio_write_sec_final(peer_req); 1498dd4f699dSLars Ellenberg } 1499dd4f699dSLars Ellenberg 15009104d31aSLars Ellenberg static void drbd_issue_peer_wsame(struct drbd_device *device, 15019104d31aSLars Ellenberg struct drbd_peer_request *peer_req) 15029104d31aSLars Ellenberg { 15039104d31aSLars Ellenberg struct block_device *bdev = device->ldev->backing_bdev; 15049104d31aSLars Ellenberg sector_t s = peer_req->i.sector; 15059104d31aSLars Ellenberg sector_t nr = peer_req->i.size >> 9; 15069104d31aSLars Ellenberg if (blkdev_issue_write_same(bdev, s, nr, GFP_NOIO, peer_req->pages)) 15079104d31aSLars Ellenberg peer_req->flags |= EE_WAS_ERROR; 15089104d31aSLars Ellenberg drbd_endio_write_sec_final(peer_req); 15099104d31aSLars Ellenberg } 15109104d31aSLars Ellenberg 15119104d31aSLars Ellenberg 1512b411b363SPhilipp Reisner /** 1513fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 1514b30ab791SAndreas Gruenbacher * @device: DRBD device. 1515db830c46SAndreas Gruenbacher * @peer_req: peer request 15161eff9d32SJens Axboe * @rw: flag field, see bio->bi_opf 151710f6d992SLars Ellenberg * 151810f6d992SLars Ellenberg * May spread the pages to multiple bios, 151910f6d992SLars Ellenberg * depending on bio_add_page restrictions. 152010f6d992SLars Ellenberg * 152110f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 152210f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 152310f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 152410f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 152510f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 152610f6d992SLars Ellenberg * on certain Xen deployments. 152745bb912bSLars Ellenberg */ 152845bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1529b30ab791SAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_device *device, 1530fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 1531bb3cc85eSMike Christie const unsigned op, const unsigned op_flags, 1532bb3cc85eSMike Christie const int fault_type) 153345bb912bSLars Ellenberg { 153445bb912bSLars Ellenberg struct bio *bios = NULL; 153545bb912bSLars Ellenberg struct bio *bio; 1536db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1537db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 153811f8b2b6SAndreas Gruenbacher unsigned data_size = peer_req->i.size; 153945bb912bSLars Ellenberg unsigned n_bios = 0; 154011f8b2b6SAndreas Gruenbacher unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 154110f6d992SLars Ellenberg int err = -ENOMEM; 154245bb912bSLars Ellenberg 1543dd4f699dSLars Ellenberg /* TRIM/DISCARD: for now, always use the helper function 1544dd4f699dSLars Ellenberg * blkdev_issue_zeroout(..., discard=true). 1545dd4f699dSLars Ellenberg * It's synchronous, but it does the right thing wrt. bio splitting. 1546dd4f699dSLars Ellenberg * Correctness first, performance later. Next step is to code an 1547dd4f699dSLars Ellenberg * asynchronous variant of the same. 1548dd4f699dSLars Ellenberg */ 15499104d31aSLars Ellenberg if (peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) { 1550a0fb3c47SLars Ellenberg /* wait for all pending IO completions, before we start 1551a0fb3c47SLars Ellenberg * zeroing things out. */ 15525dd2ca19SAndreas Gruenbacher conn_wait_active_ee_empty(peer_req->peer_device->connection); 155345d2933cSLars Ellenberg /* add it to the active list now, 155445d2933cSLars Ellenberg * so we can find it to present it in debugfs */ 155521ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 155621ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 1557700ca8c0SPhilipp Reisner 1558700ca8c0SPhilipp Reisner /* If this was a resync request from receive_rs_deallocated(), 1559700ca8c0SPhilipp Reisner * it is already on the sync_ee list */ 1560700ca8c0SPhilipp Reisner if (list_empty(&peer_req->w.list)) { 156145d2933cSLars Ellenberg spin_lock_irq(&device->resource->req_lock); 156245d2933cSLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 156345d2933cSLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 1564700ca8c0SPhilipp Reisner } 1565700ca8c0SPhilipp Reisner 15669104d31aSLars Ellenberg if (peer_req->flags & EE_IS_TRIM) 1567dd4f699dSLars Ellenberg drbd_issue_peer_discard(device, peer_req); 15689104d31aSLars Ellenberg else /* EE_WRITE_SAME */ 15699104d31aSLars Ellenberg drbd_issue_peer_wsame(device, peer_req); 1570a0fb3c47SLars Ellenberg return 0; 1571a0fb3c47SLars Ellenberg } 1572a0fb3c47SLars Ellenberg 157345bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 157445bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 157545bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 15769476f39dSLars Ellenberg * request in more than one bio. 15779476f39dSLars Ellenberg * 15789476f39dSLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 15799476f39dSLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 15809476f39dSLars Ellenberg */ 158145bb912bSLars Ellenberg next_bio: 158245bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 158345bb912bSLars Ellenberg if (!bio) { 1584a0fb3c47SLars Ellenberg drbd_err(device, "submit_ee: Allocation of a bio failed (nr_pages=%u)\n", nr_pages); 158545bb912bSLars Ellenberg goto fail; 158645bb912bSLars Ellenberg } 1587db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 15884f024f37SKent Overstreet bio->bi_iter.bi_sector = sector; 158974d46992SChristoph Hellwig bio_set_dev(bio, device->ldev->backing_bdev); 1590bb3cc85eSMike Christie bio_set_op_attrs(bio, op, op_flags); 1591db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1592fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 159345bb912bSLars Ellenberg 159445bb912bSLars Ellenberg bio->bi_next = bios; 159545bb912bSLars Ellenberg bios = bio; 159645bb912bSLars Ellenberg ++n_bios; 159745bb912bSLars Ellenberg 159845bb912bSLars Ellenberg page_chain_for_each(page) { 159911f8b2b6SAndreas Gruenbacher unsigned len = min_t(unsigned, data_size, PAGE_SIZE); 160006efffdaSMing Lei if (!bio_add_page(bio, page, len, 0)) 160145bb912bSLars Ellenberg goto next_bio; 160211f8b2b6SAndreas Gruenbacher data_size -= len; 160345bb912bSLars Ellenberg sector += len >> 9; 160445bb912bSLars Ellenberg --nr_pages; 160545bb912bSLars Ellenberg } 160611f8b2b6SAndreas Gruenbacher D_ASSERT(device, data_size == 0); 1607a0fb3c47SLars Ellenberg D_ASSERT(device, page == NULL); 160845bb912bSLars Ellenberg 1609db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 161021ae5d7fSLars Ellenberg /* for debugfs: update timestamp, mark as submitted */ 161121ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 161221ae5d7fSLars Ellenberg peer_req->flags |= EE_SUBMITTED; 161345bb912bSLars Ellenberg do { 161445bb912bSLars Ellenberg bio = bios; 161545bb912bSLars Ellenberg bios = bios->bi_next; 161645bb912bSLars Ellenberg bio->bi_next = NULL; 161745bb912bSLars Ellenberg 1618b30ab791SAndreas Gruenbacher drbd_generic_make_request(device, fault_type, bio); 161945bb912bSLars Ellenberg } while (bios); 162045bb912bSLars Ellenberg return 0; 162145bb912bSLars Ellenberg 162245bb912bSLars Ellenberg fail: 162345bb912bSLars Ellenberg while (bios) { 162445bb912bSLars Ellenberg bio = bios; 162545bb912bSLars Ellenberg bios = bios->bi_next; 162645bb912bSLars Ellenberg bio_put(bio); 162745bb912bSLars Ellenberg } 162810f6d992SLars Ellenberg return err; 162945bb912bSLars Ellenberg } 163045bb912bSLars Ellenberg 1631b30ab791SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_device *device, 1632db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 163353840641SAndreas Gruenbacher { 1634db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 163553840641SAndreas Gruenbacher 1636b30ab791SAndreas Gruenbacher drbd_remove_interval(&device->write_requests, i); 163753840641SAndreas Gruenbacher drbd_clear_interval(i); 163853840641SAndreas Gruenbacher 16396c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 164053840641SAndreas Gruenbacher if (i->waiting) 1641b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 164253840641SAndreas Gruenbacher } 164353840641SAndreas Gruenbacher 1644bde89a9eSAndreas Gruenbacher static void conn_wait_active_ee_empty(struct drbd_connection *connection) 164577fede51SPhilipp Reisner { 1646c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 164777fede51SPhilipp Reisner int vnr; 164877fede51SPhilipp Reisner 164977fede51SPhilipp Reisner rcu_read_lock(); 1650c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 1651c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1652c06ece6bSAndreas Gruenbacher 1653b30ab791SAndreas Gruenbacher kref_get(&device->kref); 165477fede51SPhilipp Reisner rcu_read_unlock(); 1655b30ab791SAndreas Gruenbacher drbd_wait_ee_list_empty(device, &device->active_ee); 165605a10ec7SAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 165777fede51SPhilipp Reisner rcu_read_lock(); 165877fede51SPhilipp Reisner } 165977fede51SPhilipp Reisner rcu_read_unlock(); 166077fede51SPhilipp Reisner } 166177fede51SPhilipp Reisner 1662bde89a9eSAndreas Gruenbacher static int receive_Barrier(struct drbd_connection *connection, struct packet_info *pi) 1663b411b363SPhilipp Reisner { 16642451fc3bSPhilipp Reisner int rv; 1665e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1666b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1667b411b363SPhilipp Reisner 16689ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 16699ed57dcbSLars Ellenberg * not a specific (peer)device. 16709ed57dcbSLars Ellenberg */ 1671bde89a9eSAndreas Gruenbacher connection->current_epoch->barrier_nr = p->barrier; 1672bde89a9eSAndreas Gruenbacher connection->current_epoch->connection = connection; 1673bde89a9eSAndreas Gruenbacher rv = drbd_may_finish_epoch(connection, connection->current_epoch, EV_GOT_BARRIER_NR); 1674b411b363SPhilipp Reisner 1675b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1676b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1677b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1678b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1679b411b363SPhilipp Reisner * completed. */ 1680e9526580SPhilipp Reisner switch (connection->resource->write_ordering) { 1681f6ba8636SAndreas Gruenbacher case WO_NONE: 1682b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 168382bc0194SAndreas Gruenbacher return 0; 1684b411b363SPhilipp Reisner 1685b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1686b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1687b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 16882451fc3bSPhilipp Reisner if (epoch) 16892451fc3bSPhilipp Reisner break; 16902451fc3bSPhilipp Reisner else 16911ec861ebSAndreas Gruenbacher drbd_warn(connection, "Allocation of an epoch failed, slowing down\n"); 16922451fc3bSPhilipp Reisner /* Fall through */ 16932451fc3bSPhilipp Reisner 1694f6ba8636SAndreas Gruenbacher case WO_BDEV_FLUSH: 1695f6ba8636SAndreas Gruenbacher case WO_DRAIN_IO: 1696bde89a9eSAndreas Gruenbacher conn_wait_active_ee_empty(connection); 1697bde89a9eSAndreas Gruenbacher drbd_flush(connection); 16982451fc3bSPhilipp Reisner 1699bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 17002451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 17012451fc3bSPhilipp Reisner if (epoch) 17022451fc3bSPhilipp Reisner break; 1703b411b363SPhilipp Reisner } 1704b411b363SPhilipp Reisner 170582bc0194SAndreas Gruenbacher return 0; 17062451fc3bSPhilipp Reisner default: 1707e9526580SPhilipp Reisner drbd_err(connection, "Strangeness in connection->write_ordering %d\n", 1708e9526580SPhilipp Reisner connection->resource->write_ordering); 170982bc0194SAndreas Gruenbacher return -EIO; 1710b411b363SPhilipp Reisner } 1711b411b363SPhilipp Reisner 1712b411b363SPhilipp Reisner epoch->flags = 0; 1713b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1714b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1715b411b363SPhilipp Reisner 1716bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 1717bde89a9eSAndreas Gruenbacher if (atomic_read(&connection->current_epoch->epoch_size)) { 1718bde89a9eSAndreas Gruenbacher list_add(&epoch->list, &connection->current_epoch->list); 1719bde89a9eSAndreas Gruenbacher connection->current_epoch = epoch; 1720bde89a9eSAndreas Gruenbacher connection->epochs++; 1721b411b363SPhilipp Reisner } else { 1722b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1723b411b363SPhilipp Reisner kfree(epoch); 1724b411b363SPhilipp Reisner } 1725bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 1726b411b363SPhilipp Reisner 172782bc0194SAndreas Gruenbacher return 0; 1728b411b363SPhilipp Reisner } 1729b411b363SPhilipp Reisner 17309104d31aSLars Ellenberg /* quick wrapper in case payload size != request_size (write same) */ 17319104d31aSLars Ellenberg static void drbd_csum_ee_size(struct crypto_ahash *h, 17329104d31aSLars Ellenberg struct drbd_peer_request *r, void *d, 17339104d31aSLars Ellenberg unsigned int payload_size) 17349104d31aSLars Ellenberg { 17359104d31aSLars Ellenberg unsigned int tmp = r->i.size; 17369104d31aSLars Ellenberg r->i.size = payload_size; 17379104d31aSLars Ellenberg drbd_csum_ee(h, r, d); 17389104d31aSLars Ellenberg r->i.size = tmp; 17399104d31aSLars Ellenberg } 17409104d31aSLars Ellenberg 1741b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 17429104d31aSLars Ellenberg * and from receive_Data. 17439104d31aSLars Ellenberg * data_size: actual payload ("data in") 17449104d31aSLars Ellenberg * for normal writes that is bi_size. 17459104d31aSLars Ellenberg * for discards, that is zero. 17469104d31aSLars Ellenberg * for write same, it is logical_block_size. 17479104d31aSLars Ellenberg * both trim and write same have the bi_size ("data len to be affected") 17489104d31aSLars Ellenberg * as extra argument in the packet header. 17499104d31aSLars Ellenberg */ 1750f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 175169a22773SAndreas Gruenbacher read_in_block(struct drbd_peer_device *peer_device, u64 id, sector_t sector, 1752a0fb3c47SLars Ellenberg struct packet_info *pi) __must_hold(local) 1753b411b363SPhilipp Reisner { 175469a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1755b30ab791SAndreas Gruenbacher const sector_t capacity = drbd_get_capacity(device->this_bdev); 1756db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1757b411b363SPhilipp Reisner struct page *page; 175811f8b2b6SAndreas Gruenbacher int digest_size, err; 175911f8b2b6SAndreas Gruenbacher unsigned int data_size = pi->size, ds; 176069a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 176169a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 17626b4388acSPhilipp Reisner unsigned long *data; 1763a0fb3c47SLars Ellenberg struct p_trim *trim = (pi->cmd == P_TRIM) ? pi->data : NULL; 17649104d31aSLars Ellenberg struct p_trim *wsame = (pi->cmd == P_WSAME) ? pi->data : NULL; 1765b411b363SPhilipp Reisner 176611f8b2b6SAndreas Gruenbacher digest_size = 0; 1767a0fb3c47SLars Ellenberg if (!trim && peer_device->connection->peer_integrity_tfm) { 17689534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 17699f5bdc33SAndreas Gruenbacher /* 17709f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 17719f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 17729f5bdc33SAndreas Gruenbacher */ 177311f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1774a5c31904SAndreas Gruenbacher if (err) 1775b411b363SPhilipp Reisner return NULL; 177611f8b2b6SAndreas Gruenbacher data_size -= digest_size; 177788104ca4SAndreas Gruenbacher } 1778b411b363SPhilipp Reisner 17799104d31aSLars Ellenberg /* assume request_size == data_size, but special case trim and wsame. */ 17809104d31aSLars Ellenberg ds = data_size; 1781a0fb3c47SLars Ellenberg if (trim) { 17829104d31aSLars Ellenberg if (!expect(data_size == 0)) 17839104d31aSLars Ellenberg return NULL; 17849104d31aSLars Ellenberg ds = be32_to_cpu(trim->size); 17859104d31aSLars Ellenberg } else if (wsame) { 17869104d31aSLars Ellenberg if (data_size != queue_logical_block_size(device->rq_queue)) { 17879104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != drbd logical block size (%u)\n", 17889104d31aSLars Ellenberg data_size, queue_logical_block_size(device->rq_queue)); 17899104d31aSLars Ellenberg return NULL; 17909104d31aSLars Ellenberg } 17919104d31aSLars Ellenberg if (data_size != bdev_logical_block_size(device->ldev->backing_bdev)) { 17929104d31aSLars Ellenberg drbd_err(peer_device, "data size (%u) != backend logical block size (%u)\n", 17939104d31aSLars Ellenberg data_size, bdev_logical_block_size(device->ldev->backing_bdev)); 17949104d31aSLars Ellenberg return NULL; 17959104d31aSLars Ellenberg } 17969104d31aSLars Ellenberg ds = be32_to_cpu(wsame->size); 1797a0fb3c47SLars Ellenberg } 1798a0fb3c47SLars Ellenberg 17999104d31aSLars Ellenberg if (!expect(IS_ALIGNED(ds, 512))) 1800841ce241SAndreas Gruenbacher return NULL; 18019104d31aSLars Ellenberg if (trim || wsame) { 18029104d31aSLars Ellenberg if (!expect(ds <= (DRBD_MAX_BBIO_SECTORS << 9))) 18039104d31aSLars Ellenberg return NULL; 18049104d31aSLars Ellenberg } else if (!expect(ds <= DRBD_MAX_BIO_SIZE)) 1805841ce241SAndreas Gruenbacher return NULL; 1806b411b363SPhilipp Reisner 18076666032aSLars Ellenberg /* even though we trust out peer, 18086666032aSLars Ellenberg * we sometimes have to double check. */ 18099104d31aSLars Ellenberg if (sector + (ds>>9) > capacity) { 1810d0180171SAndreas Gruenbacher drbd_err(device, "request from peer beyond end of local disk: " 1811fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 18126666032aSLars Ellenberg (unsigned long long)capacity, 18139104d31aSLars Ellenberg (unsigned long long)sector, ds); 18146666032aSLars Ellenberg return NULL; 18156666032aSLars Ellenberg } 18166666032aSLars Ellenberg 1817b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1818b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1819b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 18209104d31aSLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, id, sector, ds, data_size, GFP_NOIO); 1821db830c46SAndreas Gruenbacher if (!peer_req) 1822b411b363SPhilipp Reisner return NULL; 182345bb912bSLars Ellenberg 182421ae5d7fSLars Ellenberg peer_req->flags |= EE_WRITE; 18259104d31aSLars Ellenberg if (trim) { 18269104d31aSLars Ellenberg peer_req->flags |= EE_IS_TRIM; 182781a3537aSLars Ellenberg return peer_req; 18289104d31aSLars Ellenberg } 18299104d31aSLars Ellenberg if (wsame) 18309104d31aSLars Ellenberg peer_req->flags |= EE_WRITE_SAME; 1831a73ff323SLars Ellenberg 18329104d31aSLars Ellenberg /* receive payload size bytes into page chain */ 1833b411b363SPhilipp Reisner ds = data_size; 1834db830c46SAndreas Gruenbacher page = peer_req->pages; 183545bb912bSLars Ellenberg page_chain_for_each(page) { 183645bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 18376b4388acSPhilipp Reisner data = kmap(page); 183869a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1839b30ab791SAndreas Gruenbacher if (drbd_insert_fault(device, DRBD_FAULT_RECEIVE)) { 1840d0180171SAndreas Gruenbacher drbd_err(device, "Fault injection: Corrupting data on receive\n"); 18416b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 18426b4388acSPhilipp Reisner } 1843b411b363SPhilipp Reisner kunmap(page); 1844a5c31904SAndreas Gruenbacher if (err) { 1845b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1846b411b363SPhilipp Reisner return NULL; 1847b411b363SPhilipp Reisner } 1848a5c31904SAndreas Gruenbacher ds -= len; 1849b411b363SPhilipp Reisner } 1850b411b363SPhilipp Reisner 185111f8b2b6SAndreas Gruenbacher if (digest_size) { 18529104d31aSLars Ellenberg drbd_csum_ee_size(peer_device->connection->peer_integrity_tfm, peer_req, dig_vv, data_size); 185311f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 1854d0180171SAndreas Gruenbacher drbd_err(device, "Digest integrity check FAILED: %llus +%u\n", 1855470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1856b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 1857b411b363SPhilipp Reisner return NULL; 1858b411b363SPhilipp Reisner } 1859b411b363SPhilipp Reisner } 1860b30ab791SAndreas Gruenbacher device->recv_cnt += data_size >> 9; 1861db830c46SAndreas Gruenbacher return peer_req; 1862b411b363SPhilipp Reisner } 1863b411b363SPhilipp Reisner 1864b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1865b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1866b411b363SPhilipp Reisner */ 186769a22773SAndreas Gruenbacher static int drbd_drain_block(struct drbd_peer_device *peer_device, int data_size) 1868b411b363SPhilipp Reisner { 1869b411b363SPhilipp Reisner struct page *page; 1870a5c31904SAndreas Gruenbacher int err = 0; 1871b411b363SPhilipp Reisner void *data; 1872b411b363SPhilipp Reisner 1873c3470cdeSLars Ellenberg if (!data_size) 1874fc5be839SAndreas Gruenbacher return 0; 1875c3470cdeSLars Ellenberg 187669a22773SAndreas Gruenbacher page = drbd_alloc_pages(peer_device, 1, 1); 1877b411b363SPhilipp Reisner 1878b411b363SPhilipp Reisner data = kmap(page); 1879b411b363SPhilipp Reisner while (data_size) { 1880fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1881fc5be839SAndreas Gruenbacher 188269a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, data, len); 1883a5c31904SAndreas Gruenbacher if (err) 1884b411b363SPhilipp Reisner break; 1885a5c31904SAndreas Gruenbacher data_size -= len; 1886b411b363SPhilipp Reisner } 1887b411b363SPhilipp Reisner kunmap(page); 188869a22773SAndreas Gruenbacher drbd_free_pages(peer_device->device, page, 0); 1889fc5be839SAndreas Gruenbacher return err; 1890b411b363SPhilipp Reisner } 1891b411b363SPhilipp Reisner 189269a22773SAndreas Gruenbacher static int recv_dless_read(struct drbd_peer_device *peer_device, struct drbd_request *req, 1893b411b363SPhilipp Reisner sector_t sector, int data_size) 1894b411b363SPhilipp Reisner { 18957988613bSKent Overstreet struct bio_vec bvec; 18967988613bSKent Overstreet struct bvec_iter iter; 1897b411b363SPhilipp Reisner struct bio *bio; 189811f8b2b6SAndreas Gruenbacher int digest_size, err, expect; 189969a22773SAndreas Gruenbacher void *dig_in = peer_device->connection->int_dig_in; 190069a22773SAndreas Gruenbacher void *dig_vv = peer_device->connection->int_dig_vv; 1901b411b363SPhilipp Reisner 190211f8b2b6SAndreas Gruenbacher digest_size = 0; 190369a22773SAndreas Gruenbacher if (peer_device->connection->peer_integrity_tfm) { 19049534d671SHerbert Xu digest_size = crypto_ahash_digestsize(peer_device->connection->peer_integrity_tfm); 190511f8b2b6SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, dig_in, digest_size); 1906a5c31904SAndreas Gruenbacher if (err) 1907a5c31904SAndreas Gruenbacher return err; 190811f8b2b6SAndreas Gruenbacher data_size -= digest_size; 190988104ca4SAndreas Gruenbacher } 1910b411b363SPhilipp Reisner 1911b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1912b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 191369a22773SAndreas Gruenbacher peer_device->device->recv_cnt += data_size>>9; 1914b411b363SPhilipp Reisner 1915b411b363SPhilipp Reisner bio = req->master_bio; 191669a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, sector == bio->bi_iter.bi_sector); 1917b411b363SPhilipp Reisner 19187988613bSKent Overstreet bio_for_each_segment(bvec, bio, iter) { 19197988613bSKent Overstreet void *mapped = kmap(bvec.bv_page) + bvec.bv_offset; 19207988613bSKent Overstreet expect = min_t(int, data_size, bvec.bv_len); 192169a22773SAndreas Gruenbacher err = drbd_recv_all_warn(peer_device->connection, mapped, expect); 19227988613bSKent Overstreet kunmap(bvec.bv_page); 1923a5c31904SAndreas Gruenbacher if (err) 1924a5c31904SAndreas Gruenbacher return err; 1925a5c31904SAndreas Gruenbacher data_size -= expect; 1926b411b363SPhilipp Reisner } 1927b411b363SPhilipp Reisner 192811f8b2b6SAndreas Gruenbacher if (digest_size) { 192969a22773SAndreas Gruenbacher drbd_csum_bio(peer_device->connection->peer_integrity_tfm, bio, dig_vv); 193011f8b2b6SAndreas Gruenbacher if (memcmp(dig_in, dig_vv, digest_size)) { 193169a22773SAndreas Gruenbacher drbd_err(peer_device, "Digest integrity check FAILED. Broken NICs?\n"); 193228284cefSAndreas Gruenbacher return -EINVAL; 1933b411b363SPhilipp Reisner } 1934b411b363SPhilipp Reisner } 1935b411b363SPhilipp Reisner 193669a22773SAndreas Gruenbacher D_ASSERT(peer_device->device, data_size == 0); 193728284cefSAndreas Gruenbacher return 0; 1938b411b363SPhilipp Reisner } 1939b411b363SPhilipp Reisner 1940a990be46SAndreas Gruenbacher /* 1941668700b4SPhilipp Reisner * e_end_resync_block() is called in ack_sender context via 1942a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1943a990be46SAndreas Gruenbacher */ 194499920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1945b411b363SPhilipp Reisner { 19468050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 1947a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1948a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 1949a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1950db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 195199920dc5SAndreas Gruenbacher int err; 1952b411b363SPhilipp Reisner 19530b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 1954b411b363SPhilipp Reisner 1955db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1956b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 1957a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_RS_WRITE_ACK, peer_req); 1958b411b363SPhilipp Reisner } else { 1959b411b363SPhilipp Reisner /* Record failure to sync */ 1960b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, peer_req->i.size); 1961b411b363SPhilipp Reisner 1962a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 1963b411b363SPhilipp Reisner } 1964b30ab791SAndreas Gruenbacher dec_unacked(device); 1965b411b363SPhilipp Reisner 196699920dc5SAndreas Gruenbacher return err; 1967b411b363SPhilipp Reisner } 1968b411b363SPhilipp Reisner 196969a22773SAndreas Gruenbacher static int recv_resync_read(struct drbd_peer_device *peer_device, sector_t sector, 1970a0fb3c47SLars Ellenberg struct packet_info *pi) __releases(local) 1971b411b363SPhilipp Reisner { 197269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 1973db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1974b411b363SPhilipp Reisner 1975a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, ID_SYNCER, sector, pi); 1976db830c46SAndreas Gruenbacher if (!peer_req) 197745bb912bSLars Ellenberg goto fail; 1978b411b363SPhilipp Reisner 1979b30ab791SAndreas Gruenbacher dec_rs_pending(device); 1980b411b363SPhilipp Reisner 1981b30ab791SAndreas Gruenbacher inc_unacked(device); 1982b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1983b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1984b411b363SPhilipp Reisner 1985a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 198621ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 198745bb912bSLars Ellenberg 19880500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 1989b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->sync_ee); 19900500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 1991b411b363SPhilipp Reisner 1992a0fb3c47SLars Ellenberg atomic_add(pi->size >> 9, &device->rs_sect_ev); 1993bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_WRITE, 0, 1994bb3cc85eSMike Christie DRBD_FAULT_RS_WR) == 0) 1995e1c1b0fcSAndreas Gruenbacher return 0; 199645bb912bSLars Ellenberg 199710f6d992SLars Ellenberg /* don't care for the reason here */ 1998d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 19990500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2000a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 20010500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 200222cc37a9SLars Ellenberg 2003b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 200445bb912bSLars Ellenberg fail: 2005b30ab791SAndreas Gruenbacher put_ldev(device); 2006e1c1b0fcSAndreas Gruenbacher return -EIO; 2007b411b363SPhilipp Reisner } 2008b411b363SPhilipp Reisner 2009668eebc6SAndreas Gruenbacher static struct drbd_request * 2010b30ab791SAndreas Gruenbacher find_request(struct drbd_device *device, struct rb_root *root, u64 id, 2011bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 2012b411b363SPhilipp Reisner { 2013b411b363SPhilipp Reisner struct drbd_request *req; 2014668eebc6SAndreas Gruenbacher 2015bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 2016bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 20175e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 2018668eebc6SAndreas Gruenbacher return req; 2019c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 2020d0180171SAndreas Gruenbacher drbd_err(device, "%s: failed to find request 0x%lx, sector %llus\n", func, 2021c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 2022c3afd8f5SAndreas Gruenbacher } 2023668eebc6SAndreas Gruenbacher return NULL; 2024668eebc6SAndreas Gruenbacher } 2025668eebc6SAndreas Gruenbacher 2026bde89a9eSAndreas Gruenbacher static int receive_DataReply(struct drbd_connection *connection, struct packet_info *pi) 2027b411b363SPhilipp Reisner { 20289f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2029b30ab791SAndreas Gruenbacher struct drbd_device *device; 2030b411b363SPhilipp Reisner struct drbd_request *req; 2031b411b363SPhilipp Reisner sector_t sector; 203282bc0194SAndreas Gruenbacher int err; 2033e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20344a76b161SAndreas Gruenbacher 20359f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 20369f4fe9adSAndreas Gruenbacher if (!peer_device) 20374a76b161SAndreas Gruenbacher return -EIO; 20389f4fe9adSAndreas Gruenbacher device = peer_device->device; 2039b411b363SPhilipp Reisner 2040b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2041b411b363SPhilipp Reisner 20420500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2043b30ab791SAndreas Gruenbacher req = find_request(device, &device->read_requests, p->block_id, sector, false, __func__); 20440500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2045c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 204682bc0194SAndreas Gruenbacher return -EIO; 2047b411b363SPhilipp Reisner 204824c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 2049b411b363SPhilipp Reisner * special casing it there for the various failure cases. 2050b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 205169a22773SAndreas Gruenbacher err = recv_dless_read(peer_device, req, sector, pi->size); 205282bc0194SAndreas Gruenbacher if (!err) 20538554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 2054b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 2055b411b363SPhilipp Reisner * I don't think we may complete this just yet 2056b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 2057b411b363SPhilipp Reisner 205882bc0194SAndreas Gruenbacher return err; 2059b411b363SPhilipp Reisner } 2060b411b363SPhilipp Reisner 2061bde89a9eSAndreas Gruenbacher static int receive_RSDataReply(struct drbd_connection *connection, struct packet_info *pi) 2062b411b363SPhilipp Reisner { 20639f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2064b30ab791SAndreas Gruenbacher struct drbd_device *device; 2065b411b363SPhilipp Reisner sector_t sector; 206682bc0194SAndreas Gruenbacher int err; 2067e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20684a76b161SAndreas Gruenbacher 20699f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 20709f4fe9adSAndreas Gruenbacher if (!peer_device) 20714a76b161SAndreas Gruenbacher return -EIO; 20729f4fe9adSAndreas Gruenbacher device = peer_device->device; 2073b411b363SPhilipp Reisner 2074b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 20750b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->block_id == ID_SYNCER); 2076b411b363SPhilipp Reisner 2077b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 2078b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 2079b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 2080fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 2081a0fb3c47SLars Ellenberg err = recv_resync_read(peer_device, sector, pi); 2082b411b363SPhilipp Reisner } else { 2083b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 2084d0180171SAndreas Gruenbacher drbd_err(device, "Can not write resync data to local disk.\n"); 2085b411b363SPhilipp Reisner 208669a22773SAndreas Gruenbacher err = drbd_drain_block(peer_device, pi->size); 2087b411b363SPhilipp Reisner 208869a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2089b411b363SPhilipp Reisner } 2090b411b363SPhilipp Reisner 2091b30ab791SAndreas Gruenbacher atomic_add(pi->size >> 9, &device->rs_sect_in); 2092778f271dSPhilipp Reisner 209382bc0194SAndreas Gruenbacher return err; 2094b411b363SPhilipp Reisner } 2095b411b363SPhilipp Reisner 2096b30ab791SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_device *device, 20977be8da07SAndreas Gruenbacher sector_t sector, int size) 2098b411b363SPhilipp Reisner { 20997be8da07SAndreas Gruenbacher struct drbd_interval *i; 21007be8da07SAndreas Gruenbacher struct drbd_request *req; 2101b411b363SPhilipp Reisner 2102b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 21037be8da07SAndreas Gruenbacher if (!i->local) 21047be8da07SAndreas Gruenbacher continue; 21057be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 21067be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 21077be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 21087be8da07SAndreas Gruenbacher continue; 21092312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 21102312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 2111d4dabbe2SLars Ellenberg __req_mod(req, CONFLICT_RESOLVED, NULL); 21127be8da07SAndreas Gruenbacher } 21137be8da07SAndreas Gruenbacher } 21147be8da07SAndreas Gruenbacher 2115a990be46SAndreas Gruenbacher /* 2116668700b4SPhilipp Reisner * e_end_block() is called in ack_sender context via drbd_finish_peer_reqs(). 2117b411b363SPhilipp Reisner */ 211899920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 2119b411b363SPhilipp Reisner { 21208050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2121a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2122a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 2123a8cd15baSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2124db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 212599920dc5SAndreas Gruenbacher int err = 0, pcmd; 2126b411b363SPhilipp Reisner 2127303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 2128db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 2129b30ab791SAndreas Gruenbacher pcmd = (device->state.conn >= C_SYNC_SOURCE && 2130b30ab791SAndreas Gruenbacher device->state.conn <= C_PAUSED_SYNC_T && 2131db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 2132b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 2133a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, pcmd, peer_req); 2134b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 2135b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, peer_req->i.size); 2136b411b363SPhilipp Reisner } else { 2137a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, P_NEG_ACK, peer_req); 2138b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 2139b411b363SPhilipp Reisner * maybe assert this? */ 2140b411b363SPhilipp Reisner } 2141b30ab791SAndreas Gruenbacher dec_unacked(device); 2142b411b363SPhilipp Reisner } 214308d0dabfSLars Ellenberg 2144b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 2145b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 2146302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 21470500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 21480b0ba1efSAndreas Gruenbacher D_ASSERT(device, !drbd_interval_empty(&peer_req->i)); 2149b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 21507be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 2151b30ab791SAndreas Gruenbacher restart_conflicting_writes(device, sector, peer_req->i.size); 21520500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2153bb3bfe96SAndreas Gruenbacher } else 21540b0ba1efSAndreas Gruenbacher D_ASSERT(device, drbd_interval_empty(&peer_req->i)); 2155b411b363SPhilipp Reisner 21565dd2ca19SAndreas Gruenbacher drbd_may_finish_epoch(peer_device->connection, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 2157b411b363SPhilipp Reisner 215899920dc5SAndreas Gruenbacher return err; 2159b411b363SPhilipp Reisner } 2160b411b363SPhilipp Reisner 2161a8cd15baSAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 2162b411b363SPhilipp Reisner { 21638050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 2164a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2165a8cd15baSAndreas Gruenbacher struct drbd_peer_device *peer_device = peer_req->peer_device; 216699920dc5SAndreas Gruenbacher int err; 2167b411b363SPhilipp Reisner 2168a8cd15baSAndreas Gruenbacher err = drbd_send_ack(peer_device, ack, peer_req); 2169a8cd15baSAndreas Gruenbacher dec_unacked(peer_device->device); 2170b411b363SPhilipp Reisner 217199920dc5SAndreas Gruenbacher return err; 2172b411b363SPhilipp Reisner } 2173b411b363SPhilipp Reisner 2174d4dabbe2SLars Ellenberg static int e_send_superseded(struct drbd_work *w, int unused) 2175b6a370baSPhilipp Reisner { 2176a8cd15baSAndreas Gruenbacher return e_send_ack(w, P_SUPERSEDED); 21777be8da07SAndreas Gruenbacher } 2178b6a370baSPhilipp Reisner 217999920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 21807be8da07SAndreas Gruenbacher { 2181a8cd15baSAndreas Gruenbacher struct drbd_peer_request *peer_req = 2182a8cd15baSAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 2183a8cd15baSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 21847be8da07SAndreas Gruenbacher 2185a8cd15baSAndreas Gruenbacher return e_send_ack(w, connection->agreed_pro_version >= 100 ? 2186d4dabbe2SLars Ellenberg P_RETRY_WRITE : P_SUPERSEDED); 21877be8da07SAndreas Gruenbacher } 21887be8da07SAndreas Gruenbacher 21893e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 21903e394da1SAndreas Gruenbacher { 21913e394da1SAndreas Gruenbacher /* 21923e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 21933e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 21943e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 21953e394da1SAndreas Gruenbacher */ 21963e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 21973e394da1SAndreas Gruenbacher } 21983e394da1SAndreas Gruenbacher 21993e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 22003e394da1SAndreas Gruenbacher { 22013e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 22023e394da1SAndreas Gruenbacher } 22033e394da1SAndreas Gruenbacher 220469a22773SAndreas Gruenbacher static void update_peer_seq(struct drbd_peer_device *peer_device, unsigned int peer_seq) 22053e394da1SAndreas Gruenbacher { 220669a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 22073c13b680SLars Ellenberg unsigned int newest_peer_seq; 22083e394da1SAndreas Gruenbacher 220969a22773SAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) { 2210b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2211b30ab791SAndreas Gruenbacher newest_peer_seq = seq_max(device->peer_seq, peer_seq); 2212b30ab791SAndreas Gruenbacher device->peer_seq = newest_peer_seq; 2213b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2214b30ab791SAndreas Gruenbacher /* wake up only if we actually changed device->peer_seq */ 22153c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 2216b30ab791SAndreas Gruenbacher wake_up(&device->seq_wait); 22173e394da1SAndreas Gruenbacher } 22187be8da07SAndreas Gruenbacher } 22193e394da1SAndreas Gruenbacher 2220d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 2221d93f6302SLars Ellenberg { 2222d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 2223d93f6302SLars Ellenberg } 2224d93f6302SLars Ellenberg 2225d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 2226b30ab791SAndreas Gruenbacher static bool overlapping_resync_write(struct drbd_device *device, struct drbd_peer_request *peer_req) 2227d93f6302SLars Ellenberg { 2228d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 22297e5fec31SFabian Frederick bool rv = false; 2230b6a370baSPhilipp Reisner 22310500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2232a8cd15baSAndreas Gruenbacher list_for_each_entry(rs_req, &device->sync_ee, w.list) { 2233d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 2234d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 22357e5fec31SFabian Frederick rv = true; 2236b6a370baSPhilipp Reisner break; 2237b6a370baSPhilipp Reisner } 2238b6a370baSPhilipp Reisner } 22390500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2240b6a370baSPhilipp Reisner 2241b6a370baSPhilipp Reisner return rv; 2242b6a370baSPhilipp Reisner } 2243b6a370baSPhilipp Reisner 2244b411b363SPhilipp Reisner /* Called from receive_Data. 2245b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 2246b411b363SPhilipp Reisner * 2247b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 2248b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 2249b411b363SPhilipp Reisner * been sent. 2250b411b363SPhilipp Reisner * 2251b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 2252b411b363SPhilipp Reisner * 2253b30ab791SAndreas Gruenbacher * In case packet_seq is larger than device->peer_seq number, there are 2254b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 2255b30ab791SAndreas Gruenbacher * In case we are the logically next packet, we update device->peer_seq 2256b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 2257b411b363SPhilipp Reisner * 2258b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 2259b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 2260b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 2261b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 2262b411b363SPhilipp Reisner * 2263b411b363SPhilipp Reisner * returns 0 if we may process the packet, 2264b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 226569a22773SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_peer_device *peer_device, const u32 peer_seq) 2266b411b363SPhilipp Reisner { 226769a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2268b411b363SPhilipp Reisner DEFINE_WAIT(wait); 2269b411b363SPhilipp Reisner long timeout; 2270b874d231SPhilipp Reisner int ret = 0, tp; 22717be8da07SAndreas Gruenbacher 227269a22773SAndreas Gruenbacher if (!test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags)) 22737be8da07SAndreas Gruenbacher return 0; 22747be8da07SAndreas Gruenbacher 2275b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 2276b411b363SPhilipp Reisner for (;;) { 2277b30ab791SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, device->peer_seq)) { 2278b30ab791SAndreas Gruenbacher device->peer_seq = seq_max(device->peer_seq, peer_seq); 2279b411b363SPhilipp Reisner break; 22807be8da07SAndreas Gruenbacher } 2281b874d231SPhilipp Reisner 2282b411b363SPhilipp Reisner if (signal_pending(current)) { 2283b411b363SPhilipp Reisner ret = -ERESTARTSYS; 2284b411b363SPhilipp Reisner break; 2285b411b363SPhilipp Reisner } 2286b874d231SPhilipp Reisner 2287b874d231SPhilipp Reisner rcu_read_lock(); 22885dd2ca19SAndreas Gruenbacher tp = rcu_dereference(peer_device->connection->net_conf)->two_primaries; 2289b874d231SPhilipp Reisner rcu_read_unlock(); 2290b874d231SPhilipp Reisner 2291b874d231SPhilipp Reisner if (!tp) 2292b874d231SPhilipp Reisner break; 2293b874d231SPhilipp Reisner 2294b874d231SPhilipp Reisner /* Only need to wait if two_primaries is enabled */ 2295b30ab791SAndreas Gruenbacher prepare_to_wait(&device->seq_wait, &wait, TASK_INTERRUPTIBLE); 2296b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 229744ed167dSPhilipp Reisner rcu_read_lock(); 229869a22773SAndreas Gruenbacher timeout = rcu_dereference(peer_device->connection->net_conf)->ping_timeo*HZ/10; 229944ed167dSPhilipp Reisner rcu_read_unlock(); 230071b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 2301b30ab791SAndreas Gruenbacher spin_lock(&device->peer_seq_lock); 23027be8da07SAndreas Gruenbacher if (!timeout) { 2303b411b363SPhilipp Reisner ret = -ETIMEDOUT; 2304d0180171SAndreas Gruenbacher drbd_err(device, "Timed out waiting for missing ack packets; disconnecting\n"); 2305b411b363SPhilipp Reisner break; 2306b411b363SPhilipp Reisner } 2307b411b363SPhilipp Reisner } 2308b30ab791SAndreas Gruenbacher spin_unlock(&device->peer_seq_lock); 2309b30ab791SAndreas Gruenbacher finish_wait(&device->seq_wait, &wait); 2310b411b363SPhilipp Reisner return ret; 2311b411b363SPhilipp Reisner } 2312b411b363SPhilipp Reisner 2313688593c5SLars Ellenberg /* see also bio_flags_to_wire() 2314688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 2315688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 2316bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_flags(u32 dpf) 231776d2e7ecSPhilipp Reisner { 231876d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 231976d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 232028a8f0d3SMike Christie (dpf & DP_FLUSH ? REQ_PREFLUSH : 0); 2321bb3cc85eSMike Christie } 2322bb3cc85eSMike Christie 2323bb3cc85eSMike Christie static unsigned long wire_flags_to_bio_op(u32 dpf) 2324bb3cc85eSMike Christie { 2325bb3cc85eSMike Christie if (dpf & DP_DISCARD) 232645c21793SChristoph Hellwig return REQ_OP_WRITE_ZEROES; 2327bb3cc85eSMike Christie else 2328bb3cc85eSMike Christie return REQ_OP_WRITE; 232976d2e7ecSPhilipp Reisner } 233076d2e7ecSPhilipp Reisner 2331b30ab791SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_device *device, sector_t sector, 23327be8da07SAndreas Gruenbacher unsigned int size) 2333b411b363SPhilipp Reisner { 23347be8da07SAndreas Gruenbacher struct drbd_interval *i; 23357be8da07SAndreas Gruenbacher 23367be8da07SAndreas Gruenbacher repeat: 2337b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 23387be8da07SAndreas Gruenbacher struct drbd_request *req; 23397be8da07SAndreas Gruenbacher struct bio_and_error m; 23407be8da07SAndreas Gruenbacher 23417be8da07SAndreas Gruenbacher if (!i->local) 23427be8da07SAndreas Gruenbacher continue; 23437be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 23447be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 23457be8da07SAndreas Gruenbacher continue; 23467be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 23477be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 23480500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 23497be8da07SAndreas Gruenbacher if (m.bio) 2350b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 23510500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 23527be8da07SAndreas Gruenbacher goto repeat; 23537be8da07SAndreas Gruenbacher } 23547be8da07SAndreas Gruenbacher } 23557be8da07SAndreas Gruenbacher 2356b30ab791SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_device *device, 23577be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 23587be8da07SAndreas Gruenbacher { 2359e33b32deSAndreas Gruenbacher struct drbd_connection *connection = peer_req->peer_device->connection; 2360bde89a9eSAndreas Gruenbacher bool resolve_conflicts = test_bit(RESOLVE_CONFLICTS, &connection->flags); 23617be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 23627be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 23637be8da07SAndreas Gruenbacher struct drbd_interval *i; 23647be8da07SAndreas Gruenbacher bool equal; 23657be8da07SAndreas Gruenbacher int err; 23667be8da07SAndreas Gruenbacher 23677be8da07SAndreas Gruenbacher /* 23687be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 23697be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 23707be8da07SAndreas Gruenbacher */ 2371b30ab791SAndreas Gruenbacher drbd_insert_interval(&device->write_requests, &peer_req->i); 23727be8da07SAndreas Gruenbacher 23737be8da07SAndreas Gruenbacher repeat: 2374b30ab791SAndreas Gruenbacher drbd_for_each_overlap(i, &device->write_requests, sector, size) { 23757be8da07SAndreas Gruenbacher if (i == &peer_req->i) 23767be8da07SAndreas Gruenbacher continue; 237708d0dabfSLars Ellenberg if (i->completed) 237808d0dabfSLars Ellenberg continue; 23797be8da07SAndreas Gruenbacher 23807be8da07SAndreas Gruenbacher if (!i->local) { 23817be8da07SAndreas Gruenbacher /* 23827be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 23837be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 23847be8da07SAndreas Gruenbacher * earlier peer request to complete. 23857be8da07SAndreas Gruenbacher */ 2386b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, i); 23877be8da07SAndreas Gruenbacher if (err) 23887be8da07SAndreas Gruenbacher goto out; 23897be8da07SAndreas Gruenbacher goto repeat; 23907be8da07SAndreas Gruenbacher } 23917be8da07SAndreas Gruenbacher 23927be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 23937be8da07SAndreas Gruenbacher if (resolve_conflicts) { 23947be8da07SAndreas Gruenbacher /* 23957be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 2396d4dabbe2SLars Ellenberg * overlapping request, it can be considered overwritten 2397d4dabbe2SLars Ellenberg * and thus superseded; otherwise, it will be retried 2398d4dabbe2SLars Ellenberg * once all overlapping requests have completed. 23997be8da07SAndreas Gruenbacher */ 2400d4dabbe2SLars Ellenberg bool superseded = i->sector <= sector && i->sector + 24017be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 24027be8da07SAndreas Gruenbacher 24037be8da07SAndreas Gruenbacher if (!equal) 2404d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24057be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 24067be8da07SAndreas Gruenbacher "assuming %s came first\n", 24077be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24087be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 2409d4dabbe2SLars Ellenberg superseded ? "local" : "remote"); 24107be8da07SAndreas Gruenbacher 2411a8cd15baSAndreas Gruenbacher peer_req->w.cb = superseded ? e_send_superseded : 24127be8da07SAndreas Gruenbacher e_send_retry_write; 2413a8cd15baSAndreas Gruenbacher list_add_tail(&peer_req->w.list, &device->done_ee); 2414668700b4SPhilipp Reisner queue_work(connection->ack_sender, &peer_req->peer_device->send_acks_work); 24157be8da07SAndreas Gruenbacher 24167be8da07SAndreas Gruenbacher err = -ENOENT; 24177be8da07SAndreas Gruenbacher goto out; 24187be8da07SAndreas Gruenbacher } else { 24197be8da07SAndreas Gruenbacher struct drbd_request *req = 24207be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 24217be8da07SAndreas Gruenbacher 24227be8da07SAndreas Gruenbacher if (!equal) 2423d0180171SAndreas Gruenbacher drbd_alert(device, "Concurrent writes detected: " 24247be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 24257be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 24267be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 24277be8da07SAndreas Gruenbacher 24287be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 24297be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 24307be8da07SAndreas Gruenbacher /* 24317be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 2432d4dabbe2SLars Ellenberg * decide if this request has been superseded 2433d4dabbe2SLars Ellenberg * or needs to be retried. 2434d4dabbe2SLars Ellenberg * Requests that have been superseded will 24357be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 24367be8da07SAndreas Gruenbacher * 24377be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 24387be8da07SAndreas Gruenbacher * request to finish locally before submitting 24397be8da07SAndreas Gruenbacher * the conflicting peer request. 24407be8da07SAndreas Gruenbacher */ 2441b30ab791SAndreas Gruenbacher err = drbd_wait_misc(device, &req->i); 24427be8da07SAndreas Gruenbacher if (err) { 2443e33b32deSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_TIMEOUT), CS_HARD); 2444b30ab791SAndreas Gruenbacher fail_postponed_requests(device, sector, size); 24457be8da07SAndreas Gruenbacher goto out; 24467be8da07SAndreas Gruenbacher } 24477be8da07SAndreas Gruenbacher goto repeat; 24487be8da07SAndreas Gruenbacher } 24497be8da07SAndreas Gruenbacher /* 24507be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 24517be8da07SAndreas Gruenbacher * the new peer request has completed. 24527be8da07SAndreas Gruenbacher */ 24537be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 24547be8da07SAndreas Gruenbacher } 24557be8da07SAndreas Gruenbacher } 24567be8da07SAndreas Gruenbacher err = 0; 24577be8da07SAndreas Gruenbacher 24587be8da07SAndreas Gruenbacher out: 24597be8da07SAndreas Gruenbacher if (err) 2460b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 24617be8da07SAndreas Gruenbacher return err; 24627be8da07SAndreas Gruenbacher } 24637be8da07SAndreas Gruenbacher 2464b411b363SPhilipp Reisner /* mirrored write */ 2465bde89a9eSAndreas Gruenbacher static int receive_Data(struct drbd_connection *connection, struct packet_info *pi) 2466b411b363SPhilipp Reisner { 24679f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2468b30ab791SAndreas Gruenbacher struct drbd_device *device; 246921ae5d7fSLars Ellenberg struct net_conf *nc; 2470b411b363SPhilipp Reisner sector_t sector; 2471db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2472e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 24737be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2474bb3cc85eSMike Christie int op, op_flags; 2475b411b363SPhilipp Reisner u32 dp_flags; 2476302bdeaeSPhilipp Reisner int err, tp; 24777be8da07SAndreas Gruenbacher 24789f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 24799f4fe9adSAndreas Gruenbacher if (!peer_device) 24804a76b161SAndreas Gruenbacher return -EIO; 24819f4fe9adSAndreas Gruenbacher device = peer_device->device; 2482b411b363SPhilipp Reisner 2483b30ab791SAndreas Gruenbacher if (!get_ldev(device)) { 248482bc0194SAndreas Gruenbacher int err2; 2485b411b363SPhilipp Reisner 248669a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 248769a22773SAndreas Gruenbacher drbd_send_ack_dp(peer_device, P_NEG_ACK, p, pi->size); 2488bde89a9eSAndreas Gruenbacher atomic_inc(&connection->current_epoch->epoch_size); 248969a22773SAndreas Gruenbacher err2 = drbd_drain_block(peer_device, pi->size); 249082bc0194SAndreas Gruenbacher if (!err) 249182bc0194SAndreas Gruenbacher err = err2; 249282bc0194SAndreas Gruenbacher return err; 2493b411b363SPhilipp Reisner } 2494b411b363SPhilipp Reisner 2495fcefa62eSAndreas Gruenbacher /* 2496fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2497fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2498fcefa62eSAndreas Gruenbacher * end of this function. 2499fcefa62eSAndreas Gruenbacher */ 2500b411b363SPhilipp Reisner 2501b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2502a0fb3c47SLars Ellenberg peer_req = read_in_block(peer_device, p->block_id, sector, pi); 2503db830c46SAndreas Gruenbacher if (!peer_req) { 2504b30ab791SAndreas Gruenbacher put_ldev(device); 250582bc0194SAndreas Gruenbacher return -EIO; 2506b411b363SPhilipp Reisner } 2507b411b363SPhilipp Reisner 2508a8cd15baSAndreas Gruenbacher peer_req->w.cb = e_end_block; 250921ae5d7fSLars Ellenberg peer_req->submit_jif = jiffies; 251021ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 2511b411b363SPhilipp Reisner 2512688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2513bb3cc85eSMike Christie op = wire_flags_to_bio_op(dp_flags); 2514bb3cc85eSMike Christie op_flags = wire_flags_to_bio_flags(dp_flags); 2515a0fb3c47SLars Ellenberg if (pi->cmd == P_TRIM) { 2516a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->i.size > 0); 251745c21793SChristoph Hellwig D_ASSERT(peer_device, op == REQ_OP_WRITE_ZEROES); 2518a0fb3c47SLars Ellenberg D_ASSERT(peer_device, peer_req->pages == NULL); 2519a0fb3c47SLars Ellenberg } else if (peer_req->pages == NULL) { 25200b0ba1efSAndreas Gruenbacher D_ASSERT(device, peer_req->i.size == 0); 25210b0ba1efSAndreas Gruenbacher D_ASSERT(device, dp_flags & DP_FLUSH); 2522a73ff323SLars Ellenberg } 2523688593c5SLars Ellenberg 2524688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2525db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2526688593c5SLars Ellenberg 2527bde89a9eSAndreas Gruenbacher spin_lock(&connection->epoch_lock); 2528bde89a9eSAndreas Gruenbacher peer_req->epoch = connection->current_epoch; 2529db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2530db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2531bde89a9eSAndreas Gruenbacher spin_unlock(&connection->epoch_lock); 2532b411b363SPhilipp Reisner 2533302bdeaeSPhilipp Reisner rcu_read_lock(); 253421ae5d7fSLars Ellenberg nc = rcu_dereference(peer_device->connection->net_conf); 253521ae5d7fSLars Ellenberg tp = nc->two_primaries; 253621ae5d7fSLars Ellenberg if (peer_device->connection->agreed_pro_version < 100) { 253721ae5d7fSLars Ellenberg switch (nc->wire_protocol) { 253821ae5d7fSLars Ellenberg case DRBD_PROT_C: 253921ae5d7fSLars Ellenberg dp_flags |= DP_SEND_WRITE_ACK; 254021ae5d7fSLars Ellenberg break; 254121ae5d7fSLars Ellenberg case DRBD_PROT_B: 254221ae5d7fSLars Ellenberg dp_flags |= DP_SEND_RECEIVE_ACK; 254321ae5d7fSLars Ellenberg break; 254421ae5d7fSLars Ellenberg } 254521ae5d7fSLars Ellenberg } 2546302bdeaeSPhilipp Reisner rcu_read_unlock(); 254721ae5d7fSLars Ellenberg 254821ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_WRITE_ACK) { 254921ae5d7fSLars Ellenberg peer_req->flags |= EE_SEND_WRITE_ACK; 255021ae5d7fSLars Ellenberg inc_unacked(device); 255121ae5d7fSLars Ellenberg /* corresponding dec_unacked() in e_end_block() 255221ae5d7fSLars Ellenberg * respective _drbd_clear_done_ee */ 255321ae5d7fSLars Ellenberg } 255421ae5d7fSLars Ellenberg 255521ae5d7fSLars Ellenberg if (dp_flags & DP_SEND_RECEIVE_ACK) { 255621ae5d7fSLars Ellenberg /* I really don't like it that the receiver thread 255721ae5d7fSLars Ellenberg * sends on the msock, but anyways */ 25585dd2ca19SAndreas Gruenbacher drbd_send_ack(peer_device, P_RECV_ACK, peer_req); 255921ae5d7fSLars Ellenberg } 256021ae5d7fSLars Ellenberg 2561302bdeaeSPhilipp Reisner if (tp) { 256221ae5d7fSLars Ellenberg /* two primaries implies protocol C */ 256321ae5d7fSLars Ellenberg D_ASSERT(device, dp_flags & DP_SEND_WRITE_ACK); 2564302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 256569a22773SAndreas Gruenbacher err = wait_for_and_update_peer_seq(peer_device, peer_seq); 25667be8da07SAndreas Gruenbacher if (err) 2567b411b363SPhilipp Reisner goto out_interrupted; 25680500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2569b30ab791SAndreas Gruenbacher err = handle_write_conflicts(device, peer_req); 25707be8da07SAndreas Gruenbacher if (err) { 25710500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 25727be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2573b30ab791SAndreas Gruenbacher put_ldev(device); 257482bc0194SAndreas Gruenbacher return 0; 2575b411b363SPhilipp Reisner } 2576b411b363SPhilipp Reisner goto out_interrupted; 2577b411b363SPhilipp Reisner } 2578b874d231SPhilipp Reisner } else { 257969a22773SAndreas Gruenbacher update_peer_seq(peer_device, peer_seq); 25800500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2581b874d231SPhilipp Reisner } 25829104d31aSLars Ellenberg /* TRIM and WRITE_SAME are processed synchronously, 25839104d31aSLars Ellenberg * we wait for all pending requests, respectively wait for 2584a0fb3c47SLars Ellenberg * active_ee to become empty in drbd_submit_peer_request(); 2585a0fb3c47SLars Ellenberg * better not add ourselves here. */ 25869104d31aSLars Ellenberg if ((peer_req->flags & (EE_IS_TRIM|EE_WRITE_SAME)) == 0) 2587b9ed7080SLars Ellenberg list_add_tail(&peer_req->w.list, &device->active_ee); 25880500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 2589b411b363SPhilipp Reisner 2590b30ab791SAndreas Gruenbacher if (device->state.conn == C_SYNC_TARGET) 2591b30ab791SAndreas Gruenbacher wait_event(device->ee_wait, !overlapping_resync_write(device, peer_req)); 2592b6a370baSPhilipp Reisner 2593b30ab791SAndreas Gruenbacher if (device->state.pdsk < D_INCONSISTENT) { 2594b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2595b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, peer_req->i.sector, peer_req->i.size); 2596db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 25974dd726f0SLars Ellenberg drbd_al_begin_io(device, &peer_req->i); 259821ae5d7fSLars Ellenberg peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2599b411b363SPhilipp Reisner } 2600b411b363SPhilipp Reisner 2601bb3cc85eSMike Christie err = drbd_submit_peer_request(device, peer_req, op, op_flags, 2602bb3cc85eSMike Christie DRBD_FAULT_DT_WR); 260382bc0194SAndreas Gruenbacher if (!err) 260482bc0194SAndreas Gruenbacher return 0; 2605b411b363SPhilipp Reisner 260610f6d992SLars Ellenberg /* don't care for the reason here */ 2607d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 26080500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2609a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 2610b30ab791SAndreas Gruenbacher drbd_remove_epoch_entry_interval(device, peer_req); 26110500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 261221ae5d7fSLars Ellenberg if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) { 261321ae5d7fSLars Ellenberg peer_req->flags &= ~EE_CALL_AL_COMPLETE_IO; 2614b30ab791SAndreas Gruenbacher drbd_al_complete_io(device, &peer_req->i); 261521ae5d7fSLars Ellenberg } 261622cc37a9SLars Ellenberg 2617b411b363SPhilipp Reisner out_interrupted: 26187e5fec31SFabian Frederick drbd_may_finish_epoch(connection, peer_req->epoch, EV_PUT | EV_CLEANUP); 2619b30ab791SAndreas Gruenbacher put_ldev(device); 2620b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 262182bc0194SAndreas Gruenbacher return err; 2622b411b363SPhilipp Reisner } 2623b411b363SPhilipp Reisner 26240f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 26250f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 26260f0601f4SLars Ellenberg * 26270f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 26280f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 26290f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 26300f0601f4SLars Ellenberg * activity, it obviously is "busy". 26310f0601f4SLars Ellenberg * 26320f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 26330f0601f4SLars Ellenberg * to have a short time average so we can react faster. 26340f0601f4SLars Ellenberg */ 2635ad3fee79SLars Ellenberg bool drbd_rs_should_slow_down(struct drbd_device *device, sector_t sector, 2636ad3fee79SLars Ellenberg bool throttle_if_app_is_waiting) 2637e8299874SLars Ellenberg { 2638e8299874SLars Ellenberg struct lc_element *tmp; 2639ad3fee79SLars Ellenberg bool throttle = drbd_rs_c_min_rate_throttle(device); 2640e8299874SLars Ellenberg 2641ad3fee79SLars Ellenberg if (!throttle || throttle_if_app_is_waiting) 2642ad3fee79SLars Ellenberg return throttle; 2643e8299874SLars Ellenberg 2644e8299874SLars Ellenberg spin_lock_irq(&device->al_lock); 2645e8299874SLars Ellenberg tmp = lc_find(device->resync, BM_SECT_TO_EXT(sector)); 2646e8299874SLars Ellenberg if (tmp) { 2647e8299874SLars Ellenberg struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2648e8299874SLars Ellenberg if (test_bit(BME_PRIORITY, &bm_ext->flags)) 2649e8299874SLars Ellenberg throttle = false; 2650ad3fee79SLars Ellenberg /* Do not slow down if app IO is already waiting for this extent, 2651ad3fee79SLars Ellenberg * and our progress is necessary for application IO to complete. */ 2652e8299874SLars Ellenberg } 2653e8299874SLars Ellenberg spin_unlock_irq(&device->al_lock); 2654e8299874SLars Ellenberg 2655e8299874SLars Ellenberg return throttle; 2656e8299874SLars Ellenberg } 2657e8299874SLars Ellenberg 2658e8299874SLars Ellenberg bool drbd_rs_c_min_rate_throttle(struct drbd_device *device) 26590f0601f4SLars Ellenberg { 2660b30ab791SAndreas Gruenbacher struct gendisk *disk = device->ldev->backing_bdev->bd_contains->bd_disk; 26610f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2662daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2663e8299874SLars Ellenberg int curr_events; 2664daeda1ccSPhilipp Reisner 2665daeda1ccSPhilipp Reisner rcu_read_lock(); 2666b30ab791SAndreas Gruenbacher c_min_rate = rcu_dereference(device->ldev->disk_conf)->c_min_rate; 2667daeda1ccSPhilipp Reisner rcu_read_unlock(); 26680f0601f4SLars Ellenberg 26690f0601f4SLars Ellenberg /* feature disabled? */ 2670daeda1ccSPhilipp Reisner if (c_min_rate == 0) 2671e8299874SLars Ellenberg return false; 2672e3555d85SPhilipp Reisner 26730f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 26740f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 2675b30ab791SAndreas Gruenbacher atomic_read(&device->rs_sect_ev); 2676ad3fee79SLars Ellenberg 2677ad3fee79SLars Ellenberg if (atomic_read(&device->ap_actlog_cnt) 2678ff8bd88bSLars Ellenberg || curr_events - device->rs_last_events > 64) { 26790f0601f4SLars Ellenberg unsigned long rs_left; 26800f0601f4SLars Ellenberg int i; 26810f0601f4SLars Ellenberg 2682b30ab791SAndreas Gruenbacher device->rs_last_events = curr_events; 26830f0601f4SLars Ellenberg 26840f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 26850f0601f4SLars Ellenberg * approx. */ 2686b30ab791SAndreas Gruenbacher i = (device->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 26872649f080SLars Ellenberg 2688b30ab791SAndreas Gruenbacher if (device->state.conn == C_VERIFY_S || device->state.conn == C_VERIFY_T) 2689b30ab791SAndreas Gruenbacher rs_left = device->ov_left; 26902649f080SLars Ellenberg else 2691b30ab791SAndreas Gruenbacher rs_left = drbd_bm_total_weight(device) - device->rs_failed; 26920f0601f4SLars Ellenberg 2693b30ab791SAndreas Gruenbacher dt = ((long)jiffies - (long)device->rs_mark_time[i]) / HZ; 26940f0601f4SLars Ellenberg if (!dt) 26950f0601f4SLars Ellenberg dt++; 2696b30ab791SAndreas Gruenbacher db = device->rs_mark_left[i] - rs_left; 26970f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 26980f0601f4SLars Ellenberg 2699daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 2700e8299874SLars Ellenberg return true; 27010f0601f4SLars Ellenberg } 2702e8299874SLars Ellenberg return false; 27030f0601f4SLars Ellenberg } 27040f0601f4SLars Ellenberg 2705bde89a9eSAndreas Gruenbacher static int receive_DataRequest(struct drbd_connection *connection, struct packet_info *pi) 2706b411b363SPhilipp Reisner { 27079f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 2708b30ab791SAndreas Gruenbacher struct drbd_device *device; 2709b411b363SPhilipp Reisner sector_t sector; 27104a76b161SAndreas Gruenbacher sector_t capacity; 2711db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2712b411b363SPhilipp Reisner struct digest_info *di = NULL; 2713b18b37beSPhilipp Reisner int size, verb; 2714b411b363SPhilipp Reisner unsigned int fault_type; 2715e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 27164a76b161SAndreas Gruenbacher 27179f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 27189f4fe9adSAndreas Gruenbacher if (!peer_device) 27194a76b161SAndreas Gruenbacher return -EIO; 27209f4fe9adSAndreas Gruenbacher device = peer_device->device; 2721b30ab791SAndreas Gruenbacher capacity = drbd_get_capacity(device->this_bdev); 2722b411b363SPhilipp Reisner 2723b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2724b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2725b411b363SPhilipp Reisner 2726c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2727d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2728b411b363SPhilipp Reisner (unsigned long long)sector, size); 272982bc0194SAndreas Gruenbacher return -EINVAL; 2730b411b363SPhilipp Reisner } 2731b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2732d0180171SAndreas Gruenbacher drbd_err(device, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2733b411b363SPhilipp Reisner (unsigned long long)sector, size); 273482bc0194SAndreas Gruenbacher return -EINVAL; 2735b411b363SPhilipp Reisner } 2736b411b363SPhilipp Reisner 2737b30ab791SAndreas Gruenbacher if (!get_ldev_if_state(device, D_UP_TO_DATE)) { 2738b18b37beSPhilipp Reisner verb = 1; 2739e2857216SAndreas Gruenbacher switch (pi->cmd) { 2740b18b37beSPhilipp Reisner case P_DATA_REQUEST: 274169a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_DREPLY, p); 2742b18b37beSPhilipp Reisner break; 2743700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2744b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2745b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2746b18b37beSPhilipp Reisner case P_OV_REQUEST: 274769a22773SAndreas Gruenbacher drbd_send_ack_rp(peer_device, P_NEG_RS_DREPLY , p); 2748b18b37beSPhilipp Reisner break; 2749b18b37beSPhilipp Reisner case P_OV_REPLY: 2750b18b37beSPhilipp Reisner verb = 0; 2751b30ab791SAndreas Gruenbacher dec_rs_pending(device); 275269a22773SAndreas Gruenbacher drbd_send_ack_ex(peer_device, P_OV_RESULT, sector, size, ID_IN_SYNC); 2753b18b37beSPhilipp Reisner break; 2754b18b37beSPhilipp Reisner default: 275549ba9b1bSAndreas Gruenbacher BUG(); 2756b18b37beSPhilipp Reisner } 2757b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2758d0180171SAndreas Gruenbacher drbd_err(device, "Can not satisfy peer's read request, " 2759b411b363SPhilipp Reisner "no local data.\n"); 2760b18b37beSPhilipp Reisner 2761a821cc4aSLars Ellenberg /* drain possibly payload */ 276269a22773SAndreas Gruenbacher return drbd_drain_block(peer_device, pi->size); 2763b411b363SPhilipp Reisner } 2764b411b363SPhilipp Reisner 2765b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2766b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2767b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2768a0fb3c47SLars Ellenberg peer_req = drbd_alloc_peer_req(peer_device, p->block_id, sector, size, 27699104d31aSLars Ellenberg size, GFP_NOIO); 2770db830c46SAndreas Gruenbacher if (!peer_req) { 2771b30ab791SAndreas Gruenbacher put_ldev(device); 277282bc0194SAndreas Gruenbacher return -ENOMEM; 2773b411b363SPhilipp Reisner } 2774b411b363SPhilipp Reisner 2775e2857216SAndreas Gruenbacher switch (pi->cmd) { 2776b411b363SPhilipp Reisner case P_DATA_REQUEST: 2777a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2778b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 277980a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 278021ae5d7fSLars Ellenberg peer_req->flags |= EE_APPLICATION; 278180a40e43SLars Ellenberg goto submit; 278280a40e43SLars Ellenberg 2783700ca8c0SPhilipp Reisner case P_RS_THIN_REQ: 2784700ca8c0SPhilipp Reisner /* If at some point in the future we have a smart way to 2785700ca8c0SPhilipp Reisner find out if this data block is completely deallocated, 2786700ca8c0SPhilipp Reisner then we would do something smarter here than reading 2787700ca8c0SPhilipp Reisner the block... */ 2788700ca8c0SPhilipp Reisner peer_req->flags |= EE_RS_THIN_REQ; 2789b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2790a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2791b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 27925f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2793b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2794b411b363SPhilipp Reisner break; 2795b411b363SPhilipp Reisner 2796b411b363SPhilipp Reisner case P_OV_REPLY: 2797b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2798b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2799e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2800b411b363SPhilipp Reisner if (!di) 2801b411b363SPhilipp Reisner goto out_free_e; 2802b411b363SPhilipp Reisner 2803e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2804b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2805b411b363SPhilipp Reisner 2806db830c46SAndreas Gruenbacher peer_req->digest = di; 2807db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2808c36c3cedSLars Ellenberg 28099f4fe9adSAndreas Gruenbacher if (drbd_recv_all(peer_device->connection, di->digest, pi->size)) 2810b411b363SPhilipp Reisner goto out_free_e; 2811b411b363SPhilipp Reisner 2812e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 28139f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 2814a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 28155f9915bbSLars Ellenberg /* used in the sector offset progress display */ 2816b30ab791SAndreas Gruenbacher device->bm_resync_fo = BM_SECT_TO_BIT(sector); 2817aaaba345SLars Ellenberg /* remember to report stats in drbd_resync_finished */ 2818aaaba345SLars Ellenberg device->use_csums = true; 2819e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 28202649f080SLars Ellenberg /* track progress, we may need to throttle */ 2821b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_in); 2822a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2823b30ab791SAndreas Gruenbacher dec_rs_pending(device); 28240f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 28250f0601f4SLars Ellenberg * but accounting still needs to be done. */ 28260f0601f4SLars Ellenberg goto submit_for_resync; 2827b411b363SPhilipp Reisner } 2828b411b363SPhilipp Reisner break; 2829b411b363SPhilipp Reisner 2830b411b363SPhilipp Reisner case P_OV_REQUEST: 2831b30ab791SAndreas Gruenbacher if (device->ov_start_sector == ~(sector_t)0 && 28329f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90) { 2833de228bbaSLars Ellenberg unsigned long now = jiffies; 2834de228bbaSLars Ellenberg int i; 2835b30ab791SAndreas Gruenbacher device->ov_start_sector = sector; 2836b30ab791SAndreas Gruenbacher device->ov_position = sector; 2837b30ab791SAndreas Gruenbacher device->ov_left = drbd_bm_bits(device) - BM_SECT_TO_BIT(sector); 2838b30ab791SAndreas Gruenbacher device->rs_total = device->ov_left; 2839de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2840b30ab791SAndreas Gruenbacher device->rs_mark_left[i] = device->ov_left; 2841b30ab791SAndreas Gruenbacher device->rs_mark_time[i] = now; 2842de228bbaSLars Ellenberg } 2843d0180171SAndreas Gruenbacher drbd_info(device, "Online Verify start sector: %llu\n", 2844b411b363SPhilipp Reisner (unsigned long long)sector); 2845b411b363SPhilipp Reisner } 2846a8cd15baSAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2847b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2848b411b363SPhilipp Reisner break; 2849b411b363SPhilipp Reisner 2850b411b363SPhilipp Reisner default: 285149ba9b1bSAndreas Gruenbacher BUG(); 2852b411b363SPhilipp Reisner } 2853b411b363SPhilipp Reisner 28540f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 28550f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 28560f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 28570f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 28580f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 28590f0601f4SLars Ellenberg * 28600f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 28610f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 28620f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 28630f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 28640f0601f4SLars Ellenberg * a while, anyways. 28650f0601f4SLars Ellenberg */ 2866b411b363SPhilipp Reisner 28670f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 28680f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 28690f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 28700f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 28710f0601f4SLars Ellenberg * 28720f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 28730f0601f4SLars Ellenberg * we would also throttle its application reads. 28740f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 28750f0601f4SLars Ellenberg */ 2876c5a2c150SLars Ellenberg 2877c5a2c150SLars Ellenberg /* Even though this may be a resync request, we do add to "read_ee"; 2878c5a2c150SLars Ellenberg * "sync_ee" is only used for resync WRITEs. 2879c5a2c150SLars Ellenberg * Add to list early, so debugfs can find this request 2880c5a2c150SLars Ellenberg * even if we have to sleep below. */ 2881c5a2c150SLars Ellenberg spin_lock_irq(&device->resource->req_lock); 2882c5a2c150SLars Ellenberg list_add_tail(&peer_req->w.list, &device->read_ee); 2883c5a2c150SLars Ellenberg spin_unlock_irq(&device->resource->req_lock); 2884c5a2c150SLars Ellenberg 2885944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_should_slow_down); 2886ad3fee79SLars Ellenberg if (device->state.peer != R_PRIMARY 2887ad3fee79SLars Ellenberg && drbd_rs_should_slow_down(device, sector, false)) 2888e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2889944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_rs_begin_io); 2890b30ab791SAndreas Gruenbacher if (drbd_rs_begin_io(device, sector)) 289180a40e43SLars Ellenberg goto out_free_e; 2892b411b363SPhilipp Reisner 28930f0601f4SLars Ellenberg submit_for_resync: 2894b30ab791SAndreas Gruenbacher atomic_add(size >> 9, &device->rs_sect_ev); 28950f0601f4SLars Ellenberg 289680a40e43SLars Ellenberg submit: 2897944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_submit_peer_request); 2898b30ab791SAndreas Gruenbacher inc_unacked(device); 2899bb3cc85eSMike Christie if (drbd_submit_peer_request(device, peer_req, REQ_OP_READ, 0, 2900bb3cc85eSMike Christie fault_type) == 0) 290182bc0194SAndreas Gruenbacher return 0; 2902b411b363SPhilipp Reisner 290310f6d992SLars Ellenberg /* don't care for the reason here */ 2904d0180171SAndreas Gruenbacher drbd_err(device, "submit failed, triggering re-connect\n"); 2905c5a2c150SLars Ellenberg 2906c5a2c150SLars Ellenberg out_free_e: 29070500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 2908a8cd15baSAndreas Gruenbacher list_del(&peer_req->w.list); 29090500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 291022cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 291122cc37a9SLars Ellenberg 2912b30ab791SAndreas Gruenbacher put_ldev(device); 2913b30ab791SAndreas Gruenbacher drbd_free_peer_req(device, peer_req); 291482bc0194SAndreas Gruenbacher return -EIO; 2915b411b363SPhilipp Reisner } 2916b411b363SPhilipp Reisner 291769a22773SAndreas Gruenbacher /** 291869a22773SAndreas Gruenbacher * drbd_asb_recover_0p - Recover after split-brain with no remaining primaries 291969a22773SAndreas Gruenbacher */ 292069a22773SAndreas Gruenbacher static int drbd_asb_recover_0p(struct drbd_peer_device *peer_device) __must_hold(local) 2921b411b363SPhilipp Reisner { 292269a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 2923b411b363SPhilipp Reisner int self, peer, rv = -100; 2924b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 292544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2926b411b363SPhilipp Reisner 2927b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & 1; 2928b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & 1; 2929b411b363SPhilipp Reisner 2930b30ab791SAndreas Gruenbacher ch_peer = device->p_uuid[UI_SIZE]; 2931b30ab791SAndreas Gruenbacher ch_self = device->comm_bm_set; 2932b411b363SPhilipp Reisner 293344ed167dSPhilipp Reisner rcu_read_lock(); 293469a22773SAndreas Gruenbacher after_sb_0p = rcu_dereference(peer_device->connection->net_conf)->after_sb_0p; 293544ed167dSPhilipp Reisner rcu_read_unlock(); 293644ed167dSPhilipp Reisner switch (after_sb_0p) { 2937b411b363SPhilipp Reisner case ASB_CONSENSUS: 2938b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2939b411b363SPhilipp Reisner case ASB_CALL_HELPER: 294044ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2941d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 2942b411b363SPhilipp Reisner break; 2943b411b363SPhilipp Reisner case ASB_DISCONNECT: 2944b411b363SPhilipp Reisner break; 2945b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2946b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2947b411b363SPhilipp Reisner rv = -1; 2948b411b363SPhilipp Reisner break; 2949b411b363SPhilipp Reisner } 2950b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2951b411b363SPhilipp Reisner rv = 1; 2952b411b363SPhilipp Reisner break; 2953b411b363SPhilipp Reisner } 2954b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2955b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2956b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2957b411b363SPhilipp Reisner rv = 1; 2958b411b363SPhilipp Reisner break; 2959b411b363SPhilipp Reisner } 2960b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2961b411b363SPhilipp Reisner rv = -1; 2962b411b363SPhilipp Reisner break; 2963b411b363SPhilipp Reisner } 2964b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2965d0180171SAndreas Gruenbacher drbd_warn(device, "Discard younger/older primary did not find a decision\n" 2966b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2967b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2968b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 296969a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2970b411b363SPhilipp Reisner ? -1 : 1; 2971b411b363SPhilipp Reisner break; 2972b411b363SPhilipp Reisner } else { 2973b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2974b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2975b411b363SPhilipp Reisner } 297644ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2977b411b363SPhilipp Reisner break; 2978b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2979b411b363SPhilipp Reisner if (ch_self < ch_peer) 2980b411b363SPhilipp Reisner rv = -1; 2981b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2982b411b363SPhilipp Reisner rv = 1; 2983b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2984b411b363SPhilipp Reisner /* Well, then use something else. */ 298569a22773SAndreas Gruenbacher rv = test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) 2986b411b363SPhilipp Reisner ? -1 : 1; 2987b411b363SPhilipp Reisner break; 2988b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2989b411b363SPhilipp Reisner rv = -1; 2990b411b363SPhilipp Reisner break; 2991b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2992b411b363SPhilipp Reisner rv = 1; 2993b411b363SPhilipp Reisner } 2994b411b363SPhilipp Reisner 2995b411b363SPhilipp Reisner return rv; 2996b411b363SPhilipp Reisner } 2997b411b363SPhilipp Reisner 299869a22773SAndreas Gruenbacher /** 299969a22773SAndreas Gruenbacher * drbd_asb_recover_1p - Recover after split-brain with one remaining primary 300069a22773SAndreas Gruenbacher */ 300169a22773SAndreas Gruenbacher static int drbd_asb_recover_1p(struct drbd_peer_device *peer_device) __must_hold(local) 3002b411b363SPhilipp Reisner { 300369a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 30046184ea21SAndreas Gruenbacher int hg, rv = -100; 300544ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 3006b411b363SPhilipp Reisner 300744ed167dSPhilipp Reisner rcu_read_lock(); 300869a22773SAndreas Gruenbacher after_sb_1p = rcu_dereference(peer_device->connection->net_conf)->after_sb_1p; 300944ed167dSPhilipp Reisner rcu_read_unlock(); 301044ed167dSPhilipp Reisner switch (after_sb_1p) { 3011b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3012b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3013b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3014b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3015b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 301644ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3017d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3018b411b363SPhilipp Reisner break; 3019b411b363SPhilipp Reisner case ASB_DISCONNECT: 3020b411b363SPhilipp Reisner break; 3021b411b363SPhilipp Reisner case ASB_CONSENSUS: 302269a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3023b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_SECONDARY) 3024b411b363SPhilipp Reisner rv = hg; 3025b30ab791SAndreas Gruenbacher if (hg == 1 && device->state.role == R_PRIMARY) 3026b411b363SPhilipp Reisner rv = hg; 3027b411b363SPhilipp Reisner break; 3028b411b363SPhilipp Reisner case ASB_VIOLENTLY: 302969a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3030b411b363SPhilipp Reisner break; 3031b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 3032b30ab791SAndreas Gruenbacher return device->state.role == R_PRIMARY ? 1 : -1; 3033b411b363SPhilipp Reisner case ASB_CALL_HELPER: 303469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3035b30ab791SAndreas Gruenbacher if (hg == -1 && device->state.role == R_PRIMARY) { 3036bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3037bb437946SAndreas Gruenbacher 3038b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3039b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3040b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3041b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3042bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3043b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3044b411b363SPhilipp Reisner } else { 3045d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3046b411b363SPhilipp Reisner rv = hg; 3047b411b363SPhilipp Reisner } 3048b411b363SPhilipp Reisner } else 3049b411b363SPhilipp Reisner rv = hg; 3050b411b363SPhilipp Reisner } 3051b411b363SPhilipp Reisner 3052b411b363SPhilipp Reisner return rv; 3053b411b363SPhilipp Reisner } 3054b411b363SPhilipp Reisner 305569a22773SAndreas Gruenbacher /** 305669a22773SAndreas Gruenbacher * drbd_asb_recover_2p - Recover after split-brain with two remaining primaries 305769a22773SAndreas Gruenbacher */ 305869a22773SAndreas Gruenbacher static int drbd_asb_recover_2p(struct drbd_peer_device *peer_device) __must_hold(local) 3059b411b363SPhilipp Reisner { 306069a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 30616184ea21SAndreas Gruenbacher int hg, rv = -100; 306244ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 3063b411b363SPhilipp Reisner 306444ed167dSPhilipp Reisner rcu_read_lock(); 306569a22773SAndreas Gruenbacher after_sb_2p = rcu_dereference(peer_device->connection->net_conf)->after_sb_2p; 306644ed167dSPhilipp Reisner rcu_read_unlock(); 306744ed167dSPhilipp Reisner switch (after_sb_2p) { 3068b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 3069b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 3070b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 3071b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 3072b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 3073b411b363SPhilipp Reisner case ASB_CONSENSUS: 3074b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 307544ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 3076d0180171SAndreas Gruenbacher drbd_err(device, "Configuration error.\n"); 3077b411b363SPhilipp Reisner break; 3078b411b363SPhilipp Reisner case ASB_VIOLENTLY: 307969a22773SAndreas Gruenbacher rv = drbd_asb_recover_0p(peer_device); 3080b411b363SPhilipp Reisner break; 3081b411b363SPhilipp Reisner case ASB_DISCONNECT: 3082b411b363SPhilipp Reisner break; 3083b411b363SPhilipp Reisner case ASB_CALL_HELPER: 308469a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3085b411b363SPhilipp Reisner if (hg == -1) { 3086bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 3087bb437946SAndreas Gruenbacher 3088b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 3089b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 3090b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 3091b30ab791SAndreas Gruenbacher rv2 = drbd_change_state(device, CS_VERBOSE, NS(role, R_SECONDARY)); 3092bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 3093b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost-after-sb"); 3094b411b363SPhilipp Reisner } else { 3095d0180171SAndreas Gruenbacher drbd_warn(device, "Successfully gave up primary role.\n"); 3096b411b363SPhilipp Reisner rv = hg; 3097b411b363SPhilipp Reisner } 3098b411b363SPhilipp Reisner } else 3099b411b363SPhilipp Reisner rv = hg; 3100b411b363SPhilipp Reisner } 3101b411b363SPhilipp Reisner 3102b411b363SPhilipp Reisner return rv; 3103b411b363SPhilipp Reisner } 3104b411b363SPhilipp Reisner 3105b30ab791SAndreas Gruenbacher static void drbd_uuid_dump(struct drbd_device *device, char *text, u64 *uuid, 3106b411b363SPhilipp Reisner u64 bits, u64 flags) 3107b411b363SPhilipp Reisner { 3108b411b363SPhilipp Reisner if (!uuid) { 3109d0180171SAndreas Gruenbacher drbd_info(device, "%s uuid info vanished while I was looking!\n", text); 3110b411b363SPhilipp Reisner return; 3111b411b363SPhilipp Reisner } 3112d0180171SAndreas Gruenbacher drbd_info(device, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 3113b411b363SPhilipp Reisner text, 3114b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 3115b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 3116b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 3117b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 3118b411b363SPhilipp Reisner (unsigned long long)bits, 3119b411b363SPhilipp Reisner (unsigned long long)flags); 3120b411b363SPhilipp Reisner } 3121b411b363SPhilipp Reisner 3122b411b363SPhilipp Reisner /* 3123b411b363SPhilipp Reisner 100 after split brain try auto recover 3124b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 3125b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 3126b411b363SPhilipp Reisner 0 no Sync 3127b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 3128b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 3129b411b363SPhilipp Reisner -100 after split brain, disconnect 3130b411b363SPhilipp Reisner -1000 unrelated data 31314a23f264SPhilipp Reisner -1091 requires proto 91 31324a23f264SPhilipp Reisner -1096 requires proto 96 3133b411b363SPhilipp Reisner */ 3134f2d3d75bSLars Ellenberg 3135f2d3d75bSLars Ellenberg static int drbd_uuid_compare(struct drbd_device *const device, enum drbd_role const peer_role, int *rule_nr) __must_hold(local) 3136b411b363SPhilipp Reisner { 313744a4d551SLars Ellenberg struct drbd_peer_device *const peer_device = first_peer_device(device); 313844a4d551SLars Ellenberg struct drbd_connection *const connection = peer_device ? peer_device->connection : NULL; 3139b411b363SPhilipp Reisner u64 self, peer; 3140b411b363SPhilipp Reisner int i, j; 3141b411b363SPhilipp Reisner 3142b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3143b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3144b411b363SPhilipp Reisner 3145b411b363SPhilipp Reisner *rule_nr = 10; 3146b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 3147b411b363SPhilipp Reisner return 0; 3148b411b363SPhilipp Reisner 3149b411b363SPhilipp Reisner *rule_nr = 20; 3150b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 3151b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 3152b411b363SPhilipp Reisner return -2; 3153b411b363SPhilipp Reisner 3154b411b363SPhilipp Reisner *rule_nr = 30; 3155b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 3156b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 3157b411b363SPhilipp Reisner return 2; 3158b411b363SPhilipp Reisner 3159b411b363SPhilipp Reisner if (self == peer) { 3160b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 3161b411b363SPhilipp Reisner 3162b30ab791SAndreas Gruenbacher if (device->p_uuid[UI_BITMAP] == (u64)0 && device->ldev->md.uuid[UI_BITMAP] != (u64)0) { 3163b411b363SPhilipp Reisner 316444a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 31654a23f264SPhilipp Reisner return -1091; 3166b411b363SPhilipp Reisner 3167b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 3168b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 3169d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource, missed the resync finished event, corrected myself:\n"); 3170b30ab791SAndreas Gruenbacher drbd_uuid_move_history(device); 3171b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_HISTORY_START] = device->ldev->md.uuid[UI_BITMAP]; 3172b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_BITMAP] = 0; 3173b411b363SPhilipp Reisner 3174b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3175b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3176b411b363SPhilipp Reisner *rule_nr = 34; 3177b411b363SPhilipp Reisner } else { 3178d0180171SAndreas Gruenbacher drbd_info(device, "was SyncSource (peer failed to write sync_uuid)\n"); 3179b411b363SPhilipp Reisner *rule_nr = 36; 3180b411b363SPhilipp Reisner } 3181b411b363SPhilipp Reisner 3182b411b363SPhilipp Reisner return 1; 3183b411b363SPhilipp Reisner } 3184b411b363SPhilipp Reisner 3185b30ab791SAndreas Gruenbacher if (device->ldev->md.uuid[UI_BITMAP] == (u64)0 && device->p_uuid[UI_BITMAP] != (u64)0) { 3186b411b363SPhilipp Reisner 318744a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 31884a23f264SPhilipp Reisner return -1091; 3189b411b363SPhilipp Reisner 3190b30ab791SAndreas Gruenbacher if ((device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (device->p_uuid[UI_BITMAP] & ~((u64)1)) && 3191b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (device->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 3192d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 3193b411b363SPhilipp Reisner 3194b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START + 1] = device->p_uuid[UI_HISTORY_START]; 3195b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_BITMAP]; 3196b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = 0UL; 3197b411b363SPhilipp Reisner 3198b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3199b411b363SPhilipp Reisner *rule_nr = 35; 3200b411b363SPhilipp Reisner } else { 3201d0180171SAndreas Gruenbacher drbd_info(device, "was SyncTarget (failed to write sync_uuid)\n"); 3202b411b363SPhilipp Reisner *rule_nr = 37; 3203b411b363SPhilipp Reisner } 3204b411b363SPhilipp Reisner 3205b411b363SPhilipp Reisner return -1; 3206b411b363SPhilipp Reisner } 3207b411b363SPhilipp Reisner 3208b411b363SPhilipp Reisner /* Common power [off|failure] */ 3209b30ab791SAndreas Gruenbacher rct = (test_bit(CRASHED_PRIMARY, &device->flags) ? 1 : 0) + 3210b30ab791SAndreas Gruenbacher (device->p_uuid[UI_FLAGS] & 2); 3211b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 3212b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 3213b411b363SPhilipp Reisner *rule_nr = 40; 3214b411b363SPhilipp Reisner 3215f2d3d75bSLars Ellenberg /* Neither has the "crashed primary" flag set, 3216f2d3d75bSLars Ellenberg * only a replication link hickup. */ 3217f2d3d75bSLars Ellenberg if (rct == 0) 3218f2d3d75bSLars Ellenberg return 0; 3219f2d3d75bSLars Ellenberg 3220f2d3d75bSLars Ellenberg /* Current UUID equal and no bitmap uuid; does not necessarily 3221f2d3d75bSLars Ellenberg * mean this was a "simultaneous hard crash", maybe IO was 3222f2d3d75bSLars Ellenberg * frozen, so no UUID-bump happened. 3223f2d3d75bSLars Ellenberg * This is a protocol change, overload DRBD_FF_WSAME as flag 3224f2d3d75bSLars Ellenberg * for "new-enough" peer DRBD version. */ 3225f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY || peer_role == R_PRIMARY) { 3226f2d3d75bSLars Ellenberg *rule_nr = 41; 3227f2d3d75bSLars Ellenberg if (!(connection->agreed_features & DRBD_FF_WSAME)) { 3228f2d3d75bSLars Ellenberg drbd_warn(peer_device, "Equivalent unrotated UUIDs, but current primary present.\n"); 3229f2d3d75bSLars Ellenberg return -(0x10000 | PRO_VERSION_MAX | (DRBD_FF_WSAME << 8)); 3230f2d3d75bSLars Ellenberg } 3231f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY && peer_role == R_PRIMARY) { 3232f2d3d75bSLars Ellenberg /* At least one has the "crashed primary" bit set, 3233f2d3d75bSLars Ellenberg * both are primary now, but neither has rotated its UUIDs? 3234f2d3d75bSLars Ellenberg * "Can not happen." */ 3235f2d3d75bSLars Ellenberg drbd_err(peer_device, "Equivalent unrotated UUIDs, but both are primary. Can not resolve this.\n"); 3236f2d3d75bSLars Ellenberg return -100; 3237f2d3d75bSLars Ellenberg } 3238f2d3d75bSLars Ellenberg if (device->state.role == R_PRIMARY) 3239f2d3d75bSLars Ellenberg return 1; 3240f2d3d75bSLars Ellenberg return -1; 3241f2d3d75bSLars Ellenberg } 3242f2d3d75bSLars Ellenberg 3243f2d3d75bSLars Ellenberg /* Both are secondary. 3244f2d3d75bSLars Ellenberg * Really looks like recovery from simultaneous hard crash. 3245f2d3d75bSLars Ellenberg * Check which had been primary before, and arbitrate. */ 3246b411b363SPhilipp Reisner switch (rct) { 3247f2d3d75bSLars Ellenberg case 0: /* !self_pri && !peer_pri */ return 0; /* already handled */ 3248b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 3249b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 3250b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 325144a4d551SLars Ellenberg dc = test_bit(RESOLVE_CONFLICTS, &connection->flags); 3252b411b363SPhilipp Reisner return dc ? -1 : 1; 3253b411b363SPhilipp Reisner } 3254b411b363SPhilipp Reisner } 3255b411b363SPhilipp Reisner 3256b411b363SPhilipp Reisner *rule_nr = 50; 3257b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3258b411b363SPhilipp Reisner if (self == peer) 3259b411b363SPhilipp Reisner return -1; 3260b411b363SPhilipp Reisner 3261b411b363SPhilipp Reisner *rule_nr = 51; 3262b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_HISTORY_START] & ~((u64)1); 3263b411b363SPhilipp Reisner if (self == peer) { 326444a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3265b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 3266b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 3267b30ab791SAndreas Gruenbacher peer + UUID_NEW_BM_OFFSET == (device->p_uuid[UI_BITMAP] & ~((u64)1))) { 3268b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3269b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 3270b411b363SPhilipp Reisner 327144a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 32724a23f264SPhilipp Reisner return -1091; 3273b411b363SPhilipp Reisner 3274b30ab791SAndreas Gruenbacher device->p_uuid[UI_BITMAP] = device->p_uuid[UI_HISTORY_START]; 3275b30ab791SAndreas Gruenbacher device->p_uuid[UI_HISTORY_START] = device->p_uuid[UI_HISTORY_START + 1]; 32764a23f264SPhilipp Reisner 3277d0180171SAndreas Gruenbacher drbd_info(device, "Lost last syncUUID packet, corrected:\n"); 3278b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 32794a23f264SPhilipp Reisner 3280b411b363SPhilipp Reisner return -1; 3281b411b363SPhilipp Reisner } 3282b411b363SPhilipp Reisner } 3283b411b363SPhilipp Reisner 3284b411b363SPhilipp Reisner *rule_nr = 60; 3285b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 3286b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3287b30ab791SAndreas Gruenbacher peer = device->p_uuid[i] & ~((u64)1); 3288b411b363SPhilipp Reisner if (self == peer) 3289b411b363SPhilipp Reisner return -2; 3290b411b363SPhilipp Reisner } 3291b411b363SPhilipp Reisner 3292b411b363SPhilipp Reisner *rule_nr = 70; 3293b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3294b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3295b411b363SPhilipp Reisner if (self == peer) 3296b411b363SPhilipp Reisner return 1; 3297b411b363SPhilipp Reisner 3298b411b363SPhilipp Reisner *rule_nr = 71; 3299b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 3300b411b363SPhilipp Reisner if (self == peer) { 330144a4d551SLars Ellenberg if (connection->agreed_pro_version < 96 ? 3302b30ab791SAndreas Gruenbacher (device->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 3303b30ab791SAndreas Gruenbacher (device->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 3304b30ab791SAndreas Gruenbacher self + UUID_NEW_BM_OFFSET == (device->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 3305b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 3306b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 3307b411b363SPhilipp Reisner 330844a4d551SLars Ellenberg if (connection->agreed_pro_version < 91) 33094a23f264SPhilipp Reisner return -1091; 3310b411b363SPhilipp Reisner 3311b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_BITMAP, device->ldev->md.uuid[UI_HISTORY_START]); 3312b30ab791SAndreas Gruenbacher __drbd_uuid_set(device, UI_HISTORY_START, device->ldev->md.uuid[UI_HISTORY_START + 1]); 3313b411b363SPhilipp Reisner 3314d0180171SAndreas Gruenbacher drbd_info(device, "Last syncUUID did not get through, corrected:\n"); 3315b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, 3316b30ab791SAndreas Gruenbacher device->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(device) : 0, 0); 3317b411b363SPhilipp Reisner 3318b411b363SPhilipp Reisner return 1; 3319b411b363SPhilipp Reisner } 3320b411b363SPhilipp Reisner } 3321b411b363SPhilipp Reisner 3322b411b363SPhilipp Reisner 3323b411b363SPhilipp Reisner *rule_nr = 80; 3324b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_CURRENT] & ~((u64)1); 3325b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3326b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3327b411b363SPhilipp Reisner if (self == peer) 3328b411b363SPhilipp Reisner return 2; 3329b411b363SPhilipp Reisner } 3330b411b363SPhilipp Reisner 3331b411b363SPhilipp Reisner *rule_nr = 90; 3332b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 3333b30ab791SAndreas Gruenbacher peer = device->p_uuid[UI_BITMAP] & ~((u64)1); 3334b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 3335b411b363SPhilipp Reisner return 100; 3336b411b363SPhilipp Reisner 3337b411b363SPhilipp Reisner *rule_nr = 100; 3338b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 3339b30ab791SAndreas Gruenbacher self = device->ldev->md.uuid[i] & ~((u64)1); 3340b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 3341b30ab791SAndreas Gruenbacher peer = device->p_uuid[j] & ~((u64)1); 3342b411b363SPhilipp Reisner if (self == peer) 3343b411b363SPhilipp Reisner return -100; 3344b411b363SPhilipp Reisner } 3345b411b363SPhilipp Reisner } 3346b411b363SPhilipp Reisner 3347b411b363SPhilipp Reisner return -1000; 3348b411b363SPhilipp Reisner } 3349b411b363SPhilipp Reisner 3350b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 3351b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 3352b411b363SPhilipp Reisner */ 335369a22773SAndreas Gruenbacher static enum drbd_conns drbd_sync_handshake(struct drbd_peer_device *peer_device, 335469a22773SAndreas Gruenbacher enum drbd_role peer_role, 3355b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 3356b411b363SPhilipp Reisner { 335769a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 3358b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 3359b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 336044ed167dSPhilipp Reisner struct net_conf *nc; 33616dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 3362b411b363SPhilipp Reisner 3363b30ab791SAndreas Gruenbacher mydisk = device->state.disk; 3364b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 3365b30ab791SAndreas Gruenbacher mydisk = device->new_state_tmp.disk; 3366b411b363SPhilipp Reisner 3367d0180171SAndreas Gruenbacher drbd_info(device, "drbd_sync_handshake:\n"); 33689f2247bbSPhilipp Reisner 3369b30ab791SAndreas Gruenbacher spin_lock_irq(&device->ldev->md.uuid_lock); 3370b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "self", device->ldev->md.uuid, device->comm_bm_set, 0); 3371b30ab791SAndreas Gruenbacher drbd_uuid_dump(device, "peer", device->p_uuid, 3372b30ab791SAndreas Gruenbacher device->p_uuid[UI_SIZE], device->p_uuid[UI_FLAGS]); 3373b411b363SPhilipp Reisner 3374f2d3d75bSLars Ellenberg hg = drbd_uuid_compare(device, peer_role, &rule_nr); 3375b30ab791SAndreas Gruenbacher spin_unlock_irq(&device->ldev->md.uuid_lock); 3376b411b363SPhilipp Reisner 3377d0180171SAndreas Gruenbacher drbd_info(device, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 3378b411b363SPhilipp Reisner 3379b411b363SPhilipp Reisner if (hg == -1000) { 3380d0180171SAndreas Gruenbacher drbd_alert(device, "Unrelated data, aborting!\n"); 3381b411b363SPhilipp Reisner return C_MASK; 3382b411b363SPhilipp Reisner } 3383f2d3d75bSLars Ellenberg if (hg < -0x10000) { 3384f2d3d75bSLars Ellenberg int proto, fflags; 3385f2d3d75bSLars Ellenberg hg = -hg; 3386f2d3d75bSLars Ellenberg proto = hg & 0xff; 3387f2d3d75bSLars Ellenberg fflags = (hg >> 8) & 0xff; 3388f2d3d75bSLars Ellenberg drbd_alert(device, "To resolve this both sides have to support at least protocol %d and feature flags 0x%x\n", 3389f2d3d75bSLars Ellenberg proto, fflags); 3390f2d3d75bSLars Ellenberg return C_MASK; 3391f2d3d75bSLars Ellenberg } 33924a23f264SPhilipp Reisner if (hg < -1000) { 3393d0180171SAndreas Gruenbacher drbd_alert(device, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 3394b411b363SPhilipp Reisner return C_MASK; 3395b411b363SPhilipp Reisner } 3396b411b363SPhilipp Reisner 3397b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 3398b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 3399b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 3400b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 3401b411b363SPhilipp Reisner if (f) 3402b411b363SPhilipp Reisner hg = hg*2; 3403d0180171SAndreas Gruenbacher drbd_info(device, "Becoming sync %s due to disk states.\n", 3404b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 3405b411b363SPhilipp Reisner } 3406b411b363SPhilipp Reisner 34073a11a487SAdam Gandelman if (abs(hg) == 100) 3408b30ab791SAndreas Gruenbacher drbd_khelper(device, "initial-split-brain"); 34093a11a487SAdam Gandelman 341044ed167dSPhilipp Reisner rcu_read_lock(); 341169a22773SAndreas Gruenbacher nc = rcu_dereference(peer_device->connection->net_conf); 341244ed167dSPhilipp Reisner 341344ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 3414b30ab791SAndreas Gruenbacher int pcount = (device->state.role == R_PRIMARY) 3415b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 3416b411b363SPhilipp Reisner int forced = (hg == -100); 3417b411b363SPhilipp Reisner 3418b411b363SPhilipp Reisner switch (pcount) { 3419b411b363SPhilipp Reisner case 0: 342069a22773SAndreas Gruenbacher hg = drbd_asb_recover_0p(peer_device); 3421b411b363SPhilipp Reisner break; 3422b411b363SPhilipp Reisner case 1: 342369a22773SAndreas Gruenbacher hg = drbd_asb_recover_1p(peer_device); 3424b411b363SPhilipp Reisner break; 3425b411b363SPhilipp Reisner case 2: 342669a22773SAndreas Gruenbacher hg = drbd_asb_recover_2p(peer_device); 3427b411b363SPhilipp Reisner break; 3428b411b363SPhilipp Reisner } 3429b411b363SPhilipp Reisner if (abs(hg) < 100) { 3430d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, %d primaries, " 3431b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 3432b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 3433b411b363SPhilipp Reisner if (forced) { 3434d0180171SAndreas Gruenbacher drbd_warn(device, "Doing a full sync, since" 3435b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 3436b411b363SPhilipp Reisner hg = hg*2; 3437b411b363SPhilipp Reisner } 3438b411b363SPhilipp Reisner } 3439b411b363SPhilipp Reisner } 3440b411b363SPhilipp Reisner 3441b411b363SPhilipp Reisner if (hg == -100) { 3442b30ab791SAndreas Gruenbacher if (test_bit(DISCARD_MY_DATA, &device->flags) && !(device->p_uuid[UI_FLAGS]&1)) 3443b411b363SPhilipp Reisner hg = -1; 3444b30ab791SAndreas Gruenbacher if (!test_bit(DISCARD_MY_DATA, &device->flags) && (device->p_uuid[UI_FLAGS]&1)) 3445b411b363SPhilipp Reisner hg = 1; 3446b411b363SPhilipp Reisner 3447b411b363SPhilipp Reisner if (abs(hg) < 100) 3448d0180171SAndreas Gruenbacher drbd_warn(device, "Split-Brain detected, manually solved. " 3449b411b363SPhilipp Reisner "Sync from %s node\n", 3450b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 3451b411b363SPhilipp Reisner } 345244ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 34536dff2902SAndreas Gruenbacher tentative = nc->tentative; 345444ed167dSPhilipp Reisner rcu_read_unlock(); 3455b411b363SPhilipp Reisner 3456b411b363SPhilipp Reisner if (hg == -100) { 3457580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 3458580b9767SLars Ellenberg * after an attempted attach on a diskless node. 3459580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 3460580b9767SLars Ellenberg * to that disk, in a way... */ 3461d0180171SAndreas Gruenbacher drbd_alert(device, "Split-Brain detected but unresolved, dropping connection!\n"); 3462b30ab791SAndreas Gruenbacher drbd_khelper(device, "split-brain"); 3463b411b363SPhilipp Reisner return C_MASK; 3464b411b363SPhilipp Reisner } 3465b411b363SPhilipp Reisner 3466b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 3467d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncSource, but I am inconsistent!\n"); 3468b411b363SPhilipp Reisner return C_MASK; 3469b411b363SPhilipp Reisner } 3470b411b363SPhilipp Reisner 3471b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3472b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && device->state.disk >= D_CONSISTENT) { 347344ed167dSPhilipp Reisner switch (rr_conflict) { 3474b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3475b30ab791SAndreas Gruenbacher drbd_khelper(device, "pri-lost"); 3476b411b363SPhilipp Reisner /* fall through */ 3477b411b363SPhilipp Reisner case ASB_DISCONNECT: 3478d0180171SAndreas Gruenbacher drbd_err(device, "I shall become SyncTarget, but I am primary!\n"); 3479b411b363SPhilipp Reisner return C_MASK; 3480b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3481d0180171SAndreas Gruenbacher drbd_warn(device, "Becoming SyncTarget, violating the stable-data" 3482b411b363SPhilipp Reisner "assumption\n"); 3483b411b363SPhilipp Reisner } 3484b411b363SPhilipp Reisner } 3485b411b363SPhilipp Reisner 348669a22773SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &peer_device->connection->flags)) { 3487cf14c2e9SPhilipp Reisner if (hg == 0) 3488d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: No resync, would become Connected immediately.\n"); 3489cf14c2e9SPhilipp Reisner else 3490d0180171SAndreas Gruenbacher drbd_info(device, "dry-run connect: Would become %s, doing a %s resync.", 3491cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3492cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3493cf14c2e9SPhilipp Reisner return C_MASK; 3494cf14c2e9SPhilipp Reisner } 3495cf14c2e9SPhilipp Reisner 3496b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3497d0180171SAndreas Gruenbacher drbd_info(device, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 3498b30ab791SAndreas Gruenbacher if (drbd_bitmap_io(device, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 349920ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3500b411b363SPhilipp Reisner return C_MASK; 3501b411b363SPhilipp Reisner } 3502b411b363SPhilipp Reisner 3503b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3504b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3505b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3506b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3507b411b363SPhilipp Reisner } else { 3508b411b363SPhilipp Reisner rv = C_CONNECTED; 3509b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device)) { 3510d0180171SAndreas Gruenbacher drbd_info(device, "No resync, but %lu bits in bitmap!\n", 3511b30ab791SAndreas Gruenbacher drbd_bm_total_weight(device)); 3512b411b363SPhilipp Reisner } 3513b411b363SPhilipp Reisner } 3514b411b363SPhilipp Reisner 3515b411b363SPhilipp Reisner return rv; 3516b411b363SPhilipp Reisner } 3517b411b363SPhilipp Reisner 3518f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3519b411b363SPhilipp Reisner { 3520b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3521f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3522f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3523b411b363SPhilipp Reisner 3524b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3525f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3526f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3527b411b363SPhilipp Reisner 3528b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3529f179d76dSPhilipp Reisner return peer; 3530b411b363SPhilipp Reisner } 3531b411b363SPhilipp Reisner 3532bde89a9eSAndreas Gruenbacher static int receive_protocol(struct drbd_connection *connection, struct packet_info *pi) 3533b411b363SPhilipp Reisner { 3534e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3535036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3536036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3537036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3538036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 35399534d671SHerbert Xu struct crypto_ahash *peer_integrity_tfm = NULL; 35407aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3541b411b363SPhilipp Reisner 3542b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3543b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3544b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3545b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3546b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3547cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 35486139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3549cf14c2e9SPhilipp Reisner 3550bde89a9eSAndreas Gruenbacher if (connection->agreed_pro_version >= 87) { 355186db0618SAndreas Gruenbacher int err; 355286db0618SAndreas Gruenbacher 355388104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 355486db0618SAndreas Gruenbacher return -EIO; 3555bde89a9eSAndreas Gruenbacher err = drbd_recv_all(connection, integrity_alg, pi->size); 355686db0618SAndreas Gruenbacher if (err) 355786db0618SAndreas Gruenbacher return err; 355888104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3559036b17eaSPhilipp Reisner } 356086db0618SAndreas Gruenbacher 35617d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 3562bde89a9eSAndreas Gruenbacher clear_bit(CONN_DRY_RUN, &connection->flags); 3563cf14c2e9SPhilipp Reisner 3564cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 3565bde89a9eSAndreas Gruenbacher set_bit(CONN_DRY_RUN, &connection->flags); 3566b411b363SPhilipp Reisner 356744ed167dSPhilipp Reisner rcu_read_lock(); 3568bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 356944ed167dSPhilipp Reisner 3570036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 35711ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "protocol"); 357244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3573b411b363SPhilipp Reisner } 3574b411b363SPhilipp Reisner 3575f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 35761ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-0pri"); 357744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3578b411b363SPhilipp Reisner } 3579b411b363SPhilipp Reisner 3580f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 35811ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-1pri"); 358244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3583b411b363SPhilipp Reisner } 3584b411b363SPhilipp Reisner 3585f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 35861ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "after-sb-2pri"); 358744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3588b411b363SPhilipp Reisner } 3589b411b363SPhilipp Reisner 35906139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 35911ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "discard-my-data"); 359244ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3593b411b363SPhilipp Reisner } 3594b411b363SPhilipp Reisner 359544ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 35961ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "allow-two-primaries"); 359744ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3598b411b363SPhilipp Reisner } 3599b411b363SPhilipp Reisner 3600036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 36011ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible %s settings\n", "data-integrity-alg"); 3602036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3603036b17eaSPhilipp Reisner } 3604036b17eaSPhilipp Reisner 360586db0618SAndreas Gruenbacher rcu_read_unlock(); 3606fbc12f45SAndreas Gruenbacher } 36077d4c782cSAndreas Gruenbacher 36087d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 36097d4c782cSAndreas Gruenbacher int hash_size; 36107d4c782cSAndreas Gruenbacher 36117d4c782cSAndreas Gruenbacher /* 36127d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 36137d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 36147d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 36157d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 36167d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 36177d4c782cSAndreas Gruenbacher * change. 36187d4c782cSAndreas Gruenbacher */ 36197d4c782cSAndreas Gruenbacher 36209534d671SHerbert Xu peer_integrity_tfm = crypto_alloc_ahash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 36211b57e663SLars Ellenberg if (IS_ERR(peer_integrity_tfm)) { 36221b57e663SLars Ellenberg peer_integrity_tfm = NULL; 36231ec861ebSAndreas Gruenbacher drbd_err(connection, "peer data-integrity-alg %s not supported\n", 36247d4c782cSAndreas Gruenbacher integrity_alg); 3625b411b363SPhilipp Reisner goto disconnect; 3626b411b363SPhilipp Reisner } 3627b411b363SPhilipp Reisner 36289534d671SHerbert Xu hash_size = crypto_ahash_digestsize(peer_integrity_tfm); 36297d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 36307d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 36317d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 36321ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of buffers for data integrity checking failed\n"); 36337d4c782cSAndreas Gruenbacher goto disconnect; 36347d4c782cSAndreas Gruenbacher } 36357d4c782cSAndreas Gruenbacher } 36367d4c782cSAndreas Gruenbacher 36377d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 36387d4c782cSAndreas Gruenbacher if (!new_net_conf) { 36391ec861ebSAndreas Gruenbacher drbd_err(connection, "Allocation of new net_conf failed\n"); 3640b411b363SPhilipp Reisner goto disconnect; 3641b411b363SPhilipp Reisner } 3642b411b363SPhilipp Reisner 3643bde89a9eSAndreas Gruenbacher mutex_lock(&connection->data.mutex); 36440500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 3645bde89a9eSAndreas Gruenbacher old_net_conf = connection->net_conf; 36467d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 3647b411b363SPhilipp Reisner 36487d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 36497d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 36507d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 36517d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 36527d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 3653b411b363SPhilipp Reisner 3654bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 36550500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3656bde89a9eSAndreas Gruenbacher mutex_unlock(&connection->data.mutex); 3657b411b363SPhilipp Reisner 36589534d671SHerbert Xu crypto_free_ahash(connection->peer_integrity_tfm); 3659bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_in); 3660bde89a9eSAndreas Gruenbacher kfree(connection->int_dig_vv); 3661bde89a9eSAndreas Gruenbacher connection->peer_integrity_tfm = peer_integrity_tfm; 3662bde89a9eSAndreas Gruenbacher connection->int_dig_in = int_dig_in; 3663bde89a9eSAndreas Gruenbacher connection->int_dig_vv = int_dig_vv; 3664b411b363SPhilipp Reisner 36657d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 36661ec861ebSAndreas Gruenbacher drbd_info(connection, "peer data-integrity-alg: %s\n", 36677d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 3668b411b363SPhilipp Reisner 36697d4c782cSAndreas Gruenbacher synchronize_rcu(); 36707d4c782cSAndreas Gruenbacher kfree(old_net_conf); 367182bc0194SAndreas Gruenbacher return 0; 3672b411b363SPhilipp Reisner 367344ed167dSPhilipp Reisner disconnect_rcu_unlock: 367444ed167dSPhilipp Reisner rcu_read_unlock(); 3675b411b363SPhilipp Reisner disconnect: 36769534d671SHerbert Xu crypto_free_ahash(peer_integrity_tfm); 3677036b17eaSPhilipp Reisner kfree(int_dig_in); 3678036b17eaSPhilipp Reisner kfree(int_dig_vv); 3679bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 368082bc0194SAndreas Gruenbacher return -EIO; 3681b411b363SPhilipp Reisner } 3682b411b363SPhilipp Reisner 3683b411b363SPhilipp Reisner /* helper function 3684b411b363SPhilipp Reisner * input: alg name, feature name 3685b411b363SPhilipp Reisner * return: NULL (alg name was "") 3686b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3687b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 36889534d671SHerbert Xu static struct crypto_ahash *drbd_crypto_alloc_digest_safe(const struct drbd_device *device, 3689b411b363SPhilipp Reisner const char *alg, const char *name) 3690b411b363SPhilipp Reisner { 36919534d671SHerbert Xu struct crypto_ahash *tfm; 3692b411b363SPhilipp Reisner 3693b411b363SPhilipp Reisner if (!alg[0]) 3694b411b363SPhilipp Reisner return NULL; 3695b411b363SPhilipp Reisner 36969534d671SHerbert Xu tfm = crypto_alloc_ahash(alg, 0, CRYPTO_ALG_ASYNC); 3697b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3698d0180171SAndreas Gruenbacher drbd_err(device, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3699b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3700b411b363SPhilipp Reisner return tfm; 3701b411b363SPhilipp Reisner } 3702b411b363SPhilipp Reisner return tfm; 3703b411b363SPhilipp Reisner } 3704b411b363SPhilipp Reisner 3705bde89a9eSAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_connection *connection, struct packet_info *pi) 3706b411b363SPhilipp Reisner { 3707bde89a9eSAndreas Gruenbacher void *buffer = connection->data.rbuf; 37084a76b161SAndreas Gruenbacher int size = pi->size; 37094a76b161SAndreas Gruenbacher 37104a76b161SAndreas Gruenbacher while (size) { 37114a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 3712bde89a9eSAndreas Gruenbacher s = drbd_recv(connection, buffer, s); 37134a76b161SAndreas Gruenbacher if (s <= 0) { 37144a76b161SAndreas Gruenbacher if (s < 0) 37154a76b161SAndreas Gruenbacher return s; 37164a76b161SAndreas Gruenbacher break; 37174a76b161SAndreas Gruenbacher } 37184a76b161SAndreas Gruenbacher size -= s; 37194a76b161SAndreas Gruenbacher } 37204a76b161SAndreas Gruenbacher if (size) 37214a76b161SAndreas Gruenbacher return -EIO; 37224a76b161SAndreas Gruenbacher return 0; 37234a76b161SAndreas Gruenbacher } 37244a76b161SAndreas Gruenbacher 37254a76b161SAndreas Gruenbacher /* 37264a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 37274a76b161SAndreas Gruenbacher * 37284a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 37294a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 37304a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 37314a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 37324a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 37334a76b161SAndreas Gruenbacher * 37344a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 37354a76b161SAndreas Gruenbacher */ 3736bde89a9eSAndreas Gruenbacher static int config_unknown_volume(struct drbd_connection *connection, struct packet_info *pi) 37374a76b161SAndreas Gruenbacher { 37381ec861ebSAndreas Gruenbacher drbd_warn(connection, "%s packet received for volume %u, which is not configured locally\n", 37392fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 3740bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 37414a76b161SAndreas Gruenbacher } 37424a76b161SAndreas Gruenbacher 3743bde89a9eSAndreas Gruenbacher static int receive_SyncParam(struct drbd_connection *connection, struct packet_info *pi) 37444a76b161SAndreas Gruenbacher { 37459f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3746b30ab791SAndreas Gruenbacher struct drbd_device *device; 3747e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3748b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 37499534d671SHerbert Xu struct crypto_ahash *verify_tfm = NULL; 37509534d671SHerbert Xu struct crypto_ahash *csums_tfm = NULL; 37512ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3752813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 3753bde89a9eSAndreas Gruenbacher const int apv = connection->agreed_pro_version; 3754813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3755778f271dSPhilipp Reisner int fifo_size = 0; 375682bc0194SAndreas Gruenbacher int err; 3757b411b363SPhilipp Reisner 37589f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 37599f4fe9adSAndreas Gruenbacher if (!peer_device) 3760bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 37619f4fe9adSAndreas Gruenbacher device = peer_device->device; 3762b411b363SPhilipp Reisner 3763b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3764b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3765b411b363SPhilipp Reisner + SHARED_SECRET_MAX 37668e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 37678e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3768b411b363SPhilipp Reisner 3769e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3770d0180171SAndreas Gruenbacher drbd_err(device, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3771e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 377282bc0194SAndreas Gruenbacher return -EIO; 3773b411b363SPhilipp Reisner } 3774b411b363SPhilipp Reisner 3775b411b363SPhilipp Reisner if (apv <= 88) { 3776e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3777e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 37788e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3779e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3780e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 37810b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 37828e26f9ccSPhilipp Reisner } else { 3783e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3784e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 37850b0ba1efSAndreas Gruenbacher D_ASSERT(device, data_size == 0); 3786b411b363SPhilipp Reisner } 3787b411b363SPhilipp Reisner 3788b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3789e658983aSAndreas Gruenbacher p = pi->data; 3790b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3791b411b363SPhilipp Reisner 37929f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, header_size); 379382bc0194SAndreas Gruenbacher if (err) 379482bc0194SAndreas Gruenbacher return err; 3795b411b363SPhilipp Reisner 37960500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 37979f4fe9adSAndreas Gruenbacher old_net_conf = peer_device->connection->net_conf; 3798b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 3799daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3800daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3801b30ab791SAndreas Gruenbacher put_ldev(device); 38020500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3803d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 3804daeda1ccSPhilipp Reisner return -ENOMEM; 3805f399002eSLars Ellenberg } 3806b411b363SPhilipp Reisner 3807b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 3808daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3809daeda1ccSPhilipp Reisner 38106394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3811813472ceSPhilipp Reisner } 3812b411b363SPhilipp Reisner 3813b411b363SPhilipp Reisner if (apv >= 88) { 3814b411b363SPhilipp Reisner if (apv == 88) { 38155de73827SPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3816d0180171SAndreas Gruenbacher drbd_err(device, "verify-alg of wrong size, " 38175de73827SPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3818b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3819813472ceSPhilipp Reisner err = -EIO; 3820813472ceSPhilipp Reisner goto reconnect; 3821b411b363SPhilipp Reisner } 3822b411b363SPhilipp Reisner 38239f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p->verify_alg, data_size); 3824813472ceSPhilipp Reisner if (err) 3825813472ceSPhilipp Reisner goto reconnect; 3826b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3827b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38280b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[data_size-1] == 0); 3829b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3830b411b363SPhilipp Reisner 3831b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3832b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3833b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 38340b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->verify_alg[SHARED_SECRET_MAX-1] == 0); 38350b0ba1efSAndreas Gruenbacher D_ASSERT(device, p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3836b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3837b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3838b411b363SPhilipp Reisner } 3839b411b363SPhilipp Reisner 38402ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3841b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3842d0180171SAndreas Gruenbacher drbd_err(device, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 38432ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3844b411b363SPhilipp Reisner goto disconnect; 3845b411b363SPhilipp Reisner } 3846b30ab791SAndreas Gruenbacher verify_tfm = drbd_crypto_alloc_digest_safe(device, 3847b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3848b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3849b411b363SPhilipp Reisner verify_tfm = NULL; 3850b411b363SPhilipp Reisner goto disconnect; 3851b411b363SPhilipp Reisner } 3852b411b363SPhilipp Reisner } 3853b411b363SPhilipp Reisner 38542ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3855b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) { 3856d0180171SAndreas Gruenbacher drbd_err(device, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 38572ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3858b411b363SPhilipp Reisner goto disconnect; 3859b411b363SPhilipp Reisner } 3860b30ab791SAndreas Gruenbacher csums_tfm = drbd_crypto_alloc_digest_safe(device, 3861b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3862b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3863b411b363SPhilipp Reisner csums_tfm = NULL; 3864b411b363SPhilipp Reisner goto disconnect; 3865b411b363SPhilipp Reisner } 3866b411b363SPhilipp Reisner } 3867b411b363SPhilipp Reisner 3868813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3869daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3870daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3871daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3872daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3873778f271dSPhilipp Reisner 3874daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3875b30ab791SAndreas Gruenbacher if (fifo_size != device->rs_plan_s->size) { 3876813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3877813472ceSPhilipp Reisner if (!new_plan) { 3878d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of fifo_buffer failed"); 3879b30ab791SAndreas Gruenbacher put_ldev(device); 3880778f271dSPhilipp Reisner goto disconnect; 3881778f271dSPhilipp Reisner } 3882778f271dSPhilipp Reisner } 38838e26f9ccSPhilipp Reisner } 3884b411b363SPhilipp Reisner 388591fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 38862ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 38872ec91e0eSPhilipp Reisner if (!new_net_conf) { 3888d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new net_conf failed\n"); 388991fd4dadSPhilipp Reisner goto disconnect; 389091fd4dadSPhilipp Reisner } 389191fd4dadSPhilipp Reisner 38922ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 389391fd4dadSPhilipp Reisner 3894b411b363SPhilipp Reisner if (verify_tfm) { 38952ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 38962ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 38979534d671SHerbert Xu crypto_free_ahash(peer_device->connection->verify_tfm); 38989f4fe9adSAndreas Gruenbacher peer_device->connection->verify_tfm = verify_tfm; 3899d0180171SAndreas Gruenbacher drbd_info(device, "using verify-alg: \"%s\"\n", p->verify_alg); 3900b411b363SPhilipp Reisner } 3901b411b363SPhilipp Reisner if (csums_tfm) { 39022ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 39032ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 39049534d671SHerbert Xu crypto_free_ahash(peer_device->connection->csums_tfm); 39059f4fe9adSAndreas Gruenbacher peer_device->connection->csums_tfm = csums_tfm; 3906d0180171SAndreas Gruenbacher drbd_info(device, "using csums-alg: \"%s\"\n", p->csums_alg); 3907b411b363SPhilipp Reisner } 3908bde89a9eSAndreas Gruenbacher rcu_assign_pointer(connection->net_conf, new_net_conf); 3909778f271dSPhilipp Reisner } 3910b411b363SPhilipp Reisner } 3911b411b363SPhilipp Reisner 3912813472ceSPhilipp Reisner if (new_disk_conf) { 3913b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 3914b30ab791SAndreas Gruenbacher put_ldev(device); 3915b411b363SPhilipp Reisner } 3916813472ceSPhilipp Reisner 3917813472ceSPhilipp Reisner if (new_plan) { 3918b30ab791SAndreas Gruenbacher old_plan = device->rs_plan_s; 3919b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->rs_plan_s, new_plan); 3920813472ceSPhilipp Reisner } 3921daeda1ccSPhilipp Reisner 39220500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3923daeda1ccSPhilipp Reisner synchronize_rcu(); 3924daeda1ccSPhilipp Reisner if (new_net_conf) 3925daeda1ccSPhilipp Reisner kfree(old_net_conf); 3926daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3927813472ceSPhilipp Reisner kfree(old_plan); 3928daeda1ccSPhilipp Reisner 392982bc0194SAndreas Gruenbacher return 0; 3930b411b363SPhilipp Reisner 3931813472ceSPhilipp Reisner reconnect: 3932813472ceSPhilipp Reisner if (new_disk_conf) { 3933b30ab791SAndreas Gruenbacher put_ldev(device); 3934813472ceSPhilipp Reisner kfree(new_disk_conf); 3935813472ceSPhilipp Reisner } 39360500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3937813472ceSPhilipp Reisner return -EIO; 3938813472ceSPhilipp Reisner 3939b411b363SPhilipp Reisner disconnect: 3940813472ceSPhilipp Reisner kfree(new_plan); 3941813472ceSPhilipp Reisner if (new_disk_conf) { 3942b30ab791SAndreas Gruenbacher put_ldev(device); 3943813472ceSPhilipp Reisner kfree(new_disk_conf); 3944813472ceSPhilipp Reisner } 39450500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 3946b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3947b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 39489534d671SHerbert Xu crypto_free_ahash(csums_tfm); 3949b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 39509534d671SHerbert Xu crypto_free_ahash(verify_tfm); 39519f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 395282bc0194SAndreas Gruenbacher return -EIO; 3953b411b363SPhilipp Reisner } 3954b411b363SPhilipp Reisner 3955b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3956b30ab791SAndreas Gruenbacher static void warn_if_differ_considerably(struct drbd_device *device, 3957b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3958b411b363SPhilipp Reisner { 3959b411b363SPhilipp Reisner sector_t d; 3960b411b363SPhilipp Reisner if (a == 0 || b == 0) 3961b411b363SPhilipp Reisner return; 3962b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3963b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3964d0180171SAndreas Gruenbacher drbd_warn(device, "Considerable difference in %s: %llus vs. %llus\n", s, 3965b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3966b411b363SPhilipp Reisner } 3967b411b363SPhilipp Reisner 3968bde89a9eSAndreas Gruenbacher static int receive_sizes(struct drbd_connection *connection, struct packet_info *pi) 3969b411b363SPhilipp Reisner { 39709f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 3971b30ab791SAndreas Gruenbacher struct drbd_device *device; 3972e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 39739104d31aSLars Ellenberg struct o_qlim *o = (connection->agreed_features & DRBD_FF_WSAME) ? p->qlim : NULL; 3974e96c9633SPhilipp Reisner enum determine_dev_size dd = DS_UNCHANGED; 39756a8d68b1SLars Ellenberg sector_t p_size, p_usize, p_csize, my_usize; 3976b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3977e89b591cSPhilipp Reisner enum dds_flags ddsf; 3978b411b363SPhilipp Reisner 39799f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 39809f4fe9adSAndreas Gruenbacher if (!peer_device) 3981bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 39829f4fe9adSAndreas Gruenbacher device = peer_device->device; 39834a76b161SAndreas Gruenbacher 3984b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3985b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 39866a8d68b1SLars Ellenberg p_csize = be64_to_cpu(p->c_size); 3987b411b363SPhilipp Reisner 3988b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3989b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3990b30ab791SAndreas Gruenbacher device->p_size = p_size; 3991b411b363SPhilipp Reisner 3992b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 399360bac040SLars Ellenberg sector_t new_size, cur_size; 3994daeda1ccSPhilipp Reisner rcu_read_lock(); 3995b30ab791SAndreas Gruenbacher my_usize = rcu_dereference(device->ldev->disk_conf)->disk_size; 3996daeda1ccSPhilipp Reisner rcu_read_unlock(); 3997daeda1ccSPhilipp Reisner 3998b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "lower level device sizes", 3999b30ab791SAndreas Gruenbacher p_size, drbd_get_max_capacity(device->ldev)); 4000b30ab791SAndreas Gruenbacher warn_if_differ_considerably(device, "user requested size", 4001daeda1ccSPhilipp Reisner p_usize, my_usize); 4002b411b363SPhilipp Reisner 4003b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 4004b411b363SPhilipp Reisner * param exchange, choose the minimum */ 4005b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_REPORT_PARAMS) 4006daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 4007b411b363SPhilipp Reisner 4008b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 4009b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 401060bac040SLars Ellenberg new_size = drbd_new_dev_size(device, device->ldev, p_usize, 0); 401160bac040SLars Ellenberg cur_size = drbd_get_capacity(device->this_bdev); 401260bac040SLars Ellenberg if (new_size < cur_size && 4013b30ab791SAndreas Gruenbacher device->state.disk >= D_OUTDATED && 4014b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED) { 401560bac040SLars Ellenberg drbd_err(device, "The peer's disk size is too small! (%llu < %llu sectors)\n", 401660bac040SLars Ellenberg (unsigned long long)new_size, (unsigned long long)cur_size); 40179f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 4018b30ab791SAndreas Gruenbacher put_ldev(device); 401982bc0194SAndreas Gruenbacher return -EIO; 4020b411b363SPhilipp Reisner } 4021daeda1ccSPhilipp Reisner 4022daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 4023daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 4024daeda1ccSPhilipp Reisner 4025daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 4026daeda1ccSPhilipp Reisner if (!new_disk_conf) { 4027d0180171SAndreas Gruenbacher drbd_err(device, "Allocation of new disk_conf failed\n"); 4028b30ab791SAndreas Gruenbacher put_ldev(device); 4029daeda1ccSPhilipp Reisner return -ENOMEM; 4030daeda1ccSPhilipp Reisner } 4031daeda1ccSPhilipp Reisner 40320500813fSAndreas Gruenbacher mutex_lock(&connection->resource->conf_update); 4033b30ab791SAndreas Gruenbacher old_disk_conf = device->ldev->disk_conf; 4034daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 4035daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 4036daeda1ccSPhilipp Reisner 4037b30ab791SAndreas Gruenbacher rcu_assign_pointer(device->ldev->disk_conf, new_disk_conf); 40380500813fSAndreas Gruenbacher mutex_unlock(&connection->resource->conf_update); 4039daeda1ccSPhilipp Reisner synchronize_rcu(); 4040daeda1ccSPhilipp Reisner kfree(old_disk_conf); 4041daeda1ccSPhilipp Reisner 4042d0180171SAndreas Gruenbacher drbd_info(device, "Peer sets u_size to %lu sectors\n", 4043daeda1ccSPhilipp Reisner (unsigned long)my_usize); 4044daeda1ccSPhilipp Reisner } 4045daeda1ccSPhilipp Reisner 4046b30ab791SAndreas Gruenbacher put_ldev(device); 4047b411b363SPhilipp Reisner } 4048b411b363SPhilipp Reisner 404920c68fdeSLars Ellenberg device->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 4050dd4f699dSLars Ellenberg /* Leave drbd_reconsider_queue_parameters() before drbd_determine_dev_size(). 405120c68fdeSLars Ellenberg In case we cleared the QUEUE_FLAG_DISCARD from our queue in 4052dd4f699dSLars Ellenberg drbd_reconsider_queue_parameters(), we can be sure that after 405320c68fdeSLars Ellenberg drbd_determine_dev_size() no REQ_DISCARDs are in the queue. */ 405420c68fdeSLars Ellenberg 4055e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 4056b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 40579104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, device->ldev, o); 4058b30ab791SAndreas Gruenbacher dd = drbd_determine_dev_size(device, ddsf, NULL); 4059b30ab791SAndreas Gruenbacher put_ldev(device); 4060e96c9633SPhilipp Reisner if (dd == DS_ERROR) 406182bc0194SAndreas Gruenbacher return -EIO; 4062b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4063b411b363SPhilipp Reisner } else { 40646a8d68b1SLars Ellenberg /* 40656a8d68b1SLars Ellenberg * I am diskless, need to accept the peer's *current* size. 40666a8d68b1SLars Ellenberg * I must NOT accept the peers backing disk size, 40676a8d68b1SLars Ellenberg * it may have been larger than mine all along... 40686a8d68b1SLars Ellenberg * 40696a8d68b1SLars Ellenberg * At this point, the peer knows more about my disk, or at 40706a8d68b1SLars Ellenberg * least about what we last agreed upon, than myself. 40716a8d68b1SLars Ellenberg * So if his c_size is less than his d_size, the most likely 40726a8d68b1SLars Ellenberg * reason is that *my* d_size was smaller last time we checked. 40736a8d68b1SLars Ellenberg * 40746a8d68b1SLars Ellenberg * However, if he sends a zero current size, 40756a8d68b1SLars Ellenberg * take his (user-capped or) backing disk size anyways. 40766a8d68b1SLars Ellenberg */ 40779104d31aSLars Ellenberg drbd_reconsider_queue_parameters(device, NULL, o); 40786a8d68b1SLars Ellenberg drbd_set_my_capacity(device, p_csize ?: p_usize ?: p_size); 4079b411b363SPhilipp Reisner } 4080b411b363SPhilipp Reisner 4081b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4082b30ab791SAndreas Gruenbacher if (device->ldev->known_size != drbd_get_capacity(device->ldev->backing_bdev)) { 4083b30ab791SAndreas Gruenbacher device->ldev->known_size = drbd_get_capacity(device->ldev->backing_bdev); 4084b411b363SPhilipp Reisner ldsc = 1; 4085b411b363SPhilipp Reisner } 4086b411b363SPhilipp Reisner 4087b30ab791SAndreas Gruenbacher put_ldev(device); 4088b411b363SPhilipp Reisner } 4089b411b363SPhilipp Reisner 4090b30ab791SAndreas Gruenbacher if (device->state.conn > C_WF_REPORT_PARAMS) { 4091b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 4092b30ab791SAndreas Gruenbacher drbd_get_capacity(device->this_bdev) || ldsc) { 4093b411b363SPhilipp Reisner /* we have different sizes, probably peer 4094b411b363SPhilipp Reisner * needs to know my new size... */ 409569a22773SAndreas Gruenbacher drbd_send_sizes(peer_device, 0, ddsf); 4096b411b363SPhilipp Reisner } 4097b30ab791SAndreas Gruenbacher if (test_and_clear_bit(RESIZE_PENDING, &device->flags) || 4098b30ab791SAndreas Gruenbacher (dd == DS_GREW && device->state.conn == C_CONNECTED)) { 4099b30ab791SAndreas Gruenbacher if (device->state.pdsk >= D_INCONSISTENT && 4100b30ab791SAndreas Gruenbacher device->state.disk >= D_INCONSISTENT) { 4101e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 4102d0180171SAndreas Gruenbacher drbd_info(device, "Resync of new storage suppressed with --assume-clean\n"); 4103b411b363SPhilipp Reisner else 4104b30ab791SAndreas Gruenbacher resync_after_online_grow(device); 4105e89b591cSPhilipp Reisner } else 4106b30ab791SAndreas Gruenbacher set_bit(RESYNC_AFTER_NEG, &device->flags); 4107b411b363SPhilipp Reisner } 4108b411b363SPhilipp Reisner } 4109b411b363SPhilipp Reisner 411082bc0194SAndreas Gruenbacher return 0; 4111b411b363SPhilipp Reisner } 4112b411b363SPhilipp Reisner 4113bde89a9eSAndreas Gruenbacher static int receive_uuids(struct drbd_connection *connection, struct packet_info *pi) 4114b411b363SPhilipp Reisner { 41159f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4116b30ab791SAndreas Gruenbacher struct drbd_device *device; 4117e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 4118b411b363SPhilipp Reisner u64 *p_uuid; 411962b0da3aSLars Ellenberg int i, updated_uuids = 0; 4120b411b363SPhilipp Reisner 41219f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 41229f4fe9adSAndreas Gruenbacher if (!peer_device) 4123bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 41249f4fe9adSAndreas Gruenbacher device = peer_device->device; 41254a76b161SAndreas Gruenbacher 4126b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 4127063eacf8SJing Wang if (!p_uuid) { 4128d0180171SAndreas Gruenbacher drbd_err(device, "kmalloc of p_uuid failed\n"); 4129063eacf8SJing Wang return false; 4130063eacf8SJing Wang } 4131b411b363SPhilipp Reisner 4132b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 4133b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 4134b411b363SPhilipp Reisner 4135b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 4136b30ab791SAndreas Gruenbacher device->p_uuid = p_uuid; 4137b411b363SPhilipp Reisner 4138b30ab791SAndreas Gruenbacher if (device->state.conn < C_CONNECTED && 4139b30ab791SAndreas Gruenbacher device->state.disk < D_INCONSISTENT && 4140b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY && 4141b30ab791SAndreas Gruenbacher (device->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 4142d0180171SAndreas Gruenbacher drbd_err(device, "Can only connect to data with current UUID=%016llX\n", 4143b30ab791SAndreas Gruenbacher (unsigned long long)device->ed_uuid); 41449f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 414582bc0194SAndreas Gruenbacher return -EIO; 4146b411b363SPhilipp Reisner } 4147b411b363SPhilipp Reisner 4148b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 4149b411b363SPhilipp Reisner int skip_initial_sync = 4150b30ab791SAndreas Gruenbacher device->state.conn == C_CONNECTED && 41519f4fe9adSAndreas Gruenbacher peer_device->connection->agreed_pro_version >= 90 && 4152b30ab791SAndreas Gruenbacher device->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 4153b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 4154b411b363SPhilipp Reisner if (skip_initial_sync) { 4155d0180171SAndreas Gruenbacher drbd_info(device, "Accepted new current UUID, preparing to skip initial sync\n"); 4156b30ab791SAndreas Gruenbacher drbd_bitmap_io(device, &drbd_bmio_clear_n_write, 415720ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 415820ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 4159b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, p_uuid[UI_CURRENT]); 4160b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0); 4161b30ab791SAndreas Gruenbacher _drbd_set_state(_NS2(device, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 4162b411b363SPhilipp Reisner CS_VERBOSE, NULL); 4163b30ab791SAndreas Gruenbacher drbd_md_sync(device); 416462b0da3aSLars Ellenberg updated_uuids = 1; 4165b411b363SPhilipp Reisner } 4166b30ab791SAndreas Gruenbacher put_ldev(device); 4167b30ab791SAndreas Gruenbacher } else if (device->state.disk < D_INCONSISTENT && 4168b30ab791SAndreas Gruenbacher device->state.role == R_PRIMARY) { 416918a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 417018a50fa2SPhilipp Reisner for me. */ 4171b30ab791SAndreas Gruenbacher updated_uuids = drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 4172b411b363SPhilipp Reisner } 4173b411b363SPhilipp Reisner 4174b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 4175b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 4176b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 4177b411b363SPhilipp Reisner new disk state... */ 4178b30ab791SAndreas Gruenbacher mutex_lock(device->state_mutex); 4179b30ab791SAndreas Gruenbacher mutex_unlock(device->state_mutex); 4180b30ab791SAndreas Gruenbacher if (device->state.conn >= C_CONNECTED && device->state.disk < D_INCONSISTENT) 4181b30ab791SAndreas Gruenbacher updated_uuids |= drbd_set_ed_uuid(device, p_uuid[UI_CURRENT]); 418262b0da3aSLars Ellenberg 418362b0da3aSLars Ellenberg if (updated_uuids) 4184b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "receiver updated UUIDs to"); 4185b411b363SPhilipp Reisner 418682bc0194SAndreas Gruenbacher return 0; 4187b411b363SPhilipp Reisner } 4188b411b363SPhilipp Reisner 4189b411b363SPhilipp Reisner /** 4190b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 4191b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 4192b411b363SPhilipp Reisner */ 4193b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 4194b411b363SPhilipp Reisner { 4195b411b363SPhilipp Reisner union drbd_state ms; 4196b411b363SPhilipp Reisner 4197b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 4198369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 4199b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 4200b411b363SPhilipp Reisner 4201b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 4202b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 4203b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 4204b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 4205b411b363SPhilipp Reisner [C_MASK] = C_MASK, 4206b411b363SPhilipp Reisner }; 4207b411b363SPhilipp Reisner 4208b411b363SPhilipp Reisner ms.i = ps.i; 4209b411b363SPhilipp Reisner 4210b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 4211b411b363SPhilipp Reisner ms.peer = ps.role; 4212b411b363SPhilipp Reisner ms.role = ps.peer; 4213b411b363SPhilipp Reisner ms.pdsk = ps.disk; 4214b411b363SPhilipp Reisner ms.disk = ps.pdsk; 4215b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 4216b411b363SPhilipp Reisner 4217b411b363SPhilipp Reisner return ms; 4218b411b363SPhilipp Reisner } 4219b411b363SPhilipp Reisner 4220bde89a9eSAndreas Gruenbacher static int receive_req_state(struct drbd_connection *connection, struct packet_info *pi) 4221b411b363SPhilipp Reisner { 42229f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4223b30ab791SAndreas Gruenbacher struct drbd_device *device; 4224e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4225b411b363SPhilipp Reisner union drbd_state mask, val; 4226bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 4227b411b363SPhilipp Reisner 42289f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42299f4fe9adSAndreas Gruenbacher if (!peer_device) 42304a76b161SAndreas Gruenbacher return -EIO; 42319f4fe9adSAndreas Gruenbacher device = peer_device->device; 42324a76b161SAndreas Gruenbacher 4233b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4234b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 4235b411b363SPhilipp Reisner 42369f4fe9adSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &peer_device->connection->flags) && 4237b30ab791SAndreas Gruenbacher mutex_is_locked(device->state_mutex)) { 423869a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, SS_CONCURRENT_ST_CHG); 423982bc0194SAndreas Gruenbacher return 0; 4240b411b363SPhilipp Reisner } 4241b411b363SPhilipp Reisner 4242b411b363SPhilipp Reisner mask = convert_state(mask); 4243b411b363SPhilipp Reisner val = convert_state(val); 4244b411b363SPhilipp Reisner 4245b30ab791SAndreas Gruenbacher rv = drbd_change_state(device, CS_VERBOSE, mask, val); 424669a22773SAndreas Gruenbacher drbd_send_sr_reply(peer_device, rv); 4247047cd4a6SPhilipp Reisner 4248b30ab791SAndreas Gruenbacher drbd_md_sync(device); 4249b411b363SPhilipp Reisner 425082bc0194SAndreas Gruenbacher return 0; 4251b411b363SPhilipp Reisner } 4252b411b363SPhilipp Reisner 4253bde89a9eSAndreas Gruenbacher static int receive_req_conn_state(struct drbd_connection *connection, struct packet_info *pi) 4254b411b363SPhilipp Reisner { 4255e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 4256dfafcc8aSPhilipp Reisner union drbd_state mask, val; 4257dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 4258dfafcc8aSPhilipp Reisner 4259dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 4260dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 4261dfafcc8aSPhilipp Reisner 4262bde89a9eSAndreas Gruenbacher if (test_bit(RESOLVE_CONFLICTS, &connection->flags) && 4263bde89a9eSAndreas Gruenbacher mutex_is_locked(&connection->cstate_mutex)) { 4264bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, SS_CONCURRENT_ST_CHG); 426582bc0194SAndreas Gruenbacher return 0; 4266dfafcc8aSPhilipp Reisner } 4267dfafcc8aSPhilipp Reisner 4268dfafcc8aSPhilipp Reisner mask = convert_state(mask); 4269dfafcc8aSPhilipp Reisner val = convert_state(val); 4270dfafcc8aSPhilipp Reisner 4271bde89a9eSAndreas Gruenbacher rv = conn_request_state(connection, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 4272bde89a9eSAndreas Gruenbacher conn_send_sr_reply(connection, rv); 4273dfafcc8aSPhilipp Reisner 427482bc0194SAndreas Gruenbacher return 0; 4275dfafcc8aSPhilipp Reisner } 4276dfafcc8aSPhilipp Reisner 4277bde89a9eSAndreas Gruenbacher static int receive_state(struct drbd_connection *connection, struct packet_info *pi) 4278b411b363SPhilipp Reisner { 42799f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4280b30ab791SAndreas Gruenbacher struct drbd_device *device; 4281e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 42824ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 4283b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 428465d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 4285b411b363SPhilipp Reisner int rv; 4286b411b363SPhilipp Reisner 42879f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 42889f4fe9adSAndreas Gruenbacher if (!peer_device) 4289bde89a9eSAndreas Gruenbacher return config_unknown_volume(connection, pi); 42909f4fe9adSAndreas Gruenbacher device = peer_device->device; 42914a76b161SAndreas Gruenbacher 4292b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 4293b411b363SPhilipp Reisner 4294b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 4295b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 4296b30ab791SAndreas Gruenbacher real_peer_disk = device->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 4297d0180171SAndreas Gruenbacher drbd_info(device, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 4298b411b363SPhilipp Reisner } 4299b411b363SPhilipp Reisner 43000500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4301b411b363SPhilipp Reisner retry: 4302b30ab791SAndreas Gruenbacher os = ns = drbd_read_state(device); 43030500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4304b411b363SPhilipp Reisner 4305668700b4SPhilipp Reisner /* If some other part of the code (ack_receiver thread, timeout) 4306545752d5SLars Ellenberg * already decided to close the connection again, 4307545752d5SLars Ellenberg * we must not "re-establish" it here. */ 4308545752d5SLars Ellenberg if (os.conn <= C_TEAR_DOWN) 430958ffa580SLars Ellenberg return -ECONNRESET; 4310545752d5SLars Ellenberg 431140424e4aSLars Ellenberg /* If this is the "end of sync" confirmation, usually the peer disk 431240424e4aSLars Ellenberg * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 431340424e4aSLars Ellenberg * set) resync started in PausedSyncT, or if the timing of pause-/ 431440424e4aSLars Ellenberg * unpause-sync events has been "just right", the peer disk may 431540424e4aSLars Ellenberg * transition from D_CONSISTENT to D_UP_TO_DATE as well. 431640424e4aSLars Ellenberg */ 431740424e4aSLars Ellenberg if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 431840424e4aSLars Ellenberg real_peer_disk == D_UP_TO_DATE && 4319e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 4320e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 4321e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 4322e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 4323e9ef7bb6SLars Ellenberg * syncing states. 4324e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 4325e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 4326e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 4327e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 4328e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 4329e9ef7bb6SLars Ellenberg 4330e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 4331e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 4332e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 4333e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 4334e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 4335b30ab791SAndreas Gruenbacher if (drbd_bm_total_weight(device) <= device->rs_failed) 4336b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 433782bc0194SAndreas Gruenbacher return 0; 4338e9ef7bb6SLars Ellenberg } 4339e9ef7bb6SLars Ellenberg } 4340e9ef7bb6SLars Ellenberg 434102b91b55SLars Ellenberg /* explicit verify finished notification, stop sector reached. */ 434202b91b55SLars Ellenberg if (os.conn == C_VERIFY_T && os.disk == D_UP_TO_DATE && 434302b91b55SLars Ellenberg peer_state.conn == C_CONNECTED && real_peer_disk == D_UP_TO_DATE) { 4344b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 4345b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 434658ffa580SLars Ellenberg return 0; 434702b91b55SLars Ellenberg } 434802b91b55SLars Ellenberg 4349e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 4350e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 4351e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 4352e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 4353e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 4354e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 4355e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 4356e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 4357e9ef7bb6SLars Ellenberg 43584ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 43594ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4360b411b363SPhilipp Reisner 436167531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 436267531718SPhilipp Reisner ns.conn = C_BEHIND; 436367531718SPhilipp Reisner 4364b30ab791SAndreas Gruenbacher if (device->p_uuid && peer_state.disk >= D_NEGOTIATING && 4365b30ab791SAndreas Gruenbacher get_ldev_if_state(device, D_NEGOTIATING)) { 4366b411b363SPhilipp Reisner int cr; /* consider resync */ 4367b411b363SPhilipp Reisner 4368b411b363SPhilipp Reisner /* if we established a new connection */ 43694ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 4370b411b363SPhilipp Reisner /* if we had an established connection 4371b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 43724ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4373b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 43744ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 4375b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 4376b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 4377b30ab791SAndreas Gruenbacher cr |= test_bit(CONSIDER_RESYNC, &device->flags); 4378b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 4379b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 43804ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 4381b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 4382b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 4383b411b363SPhilipp Reisner 4384b411b363SPhilipp Reisner if (cr) 438569a22773SAndreas Gruenbacher ns.conn = drbd_sync_handshake(peer_device, peer_state.role, real_peer_disk); 4386b411b363SPhilipp Reisner 4387b30ab791SAndreas Gruenbacher put_ldev(device); 43884ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 43894ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 4390b30ab791SAndreas Gruenbacher if (device->state.disk == D_NEGOTIATING) { 4391b30ab791SAndreas Gruenbacher drbd_force_state(device, NS(disk, D_FAILED)); 4392b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 4393d0180171SAndreas Gruenbacher drbd_err(device, "Disk attach process on the peer node was aborted.\n"); 4394b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 4395580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 4396b411b363SPhilipp Reisner } else { 43979f4fe9adSAndreas Gruenbacher if (test_and_clear_bit(CONN_DRY_RUN, &peer_device->connection->flags)) 439882bc0194SAndreas Gruenbacher return -EIO; 43990b0ba1efSAndreas Gruenbacher D_ASSERT(device, os.conn == C_WF_REPORT_PARAMS); 44009f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 440182bc0194SAndreas Gruenbacher return -EIO; 4402b411b363SPhilipp Reisner } 4403b411b363SPhilipp Reisner } 4404b411b363SPhilipp Reisner } 4405b411b363SPhilipp Reisner 44060500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 4407b30ab791SAndreas Gruenbacher if (os.i != drbd_read_state(device).i) 4408b411b363SPhilipp Reisner goto retry; 4409b30ab791SAndreas Gruenbacher clear_bit(CONSIDER_RESYNC, &device->flags); 4410b411b363SPhilipp Reisner ns.peer = peer_state.role; 4411b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 4412b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 44134ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 4414b30ab791SAndreas Gruenbacher ns.disk = device->new_state_tmp.disk; 44154ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 4416b30ab791SAndreas Gruenbacher if (ns.pdsk == D_CONSISTENT && drbd_suspended(device) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 4417b30ab791SAndreas Gruenbacher test_bit(NEW_CUR_UUID, &device->flags)) { 44188554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 4419481c6f50SPhilipp Reisner for temporal network outages! */ 44200500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4421d0180171SAndreas Gruenbacher drbd_err(device, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 44229f4fe9adSAndreas Gruenbacher tl_clear(peer_device->connection); 4423b30ab791SAndreas Gruenbacher drbd_uuid_new_current(device); 4424b30ab791SAndreas Gruenbacher clear_bit(NEW_CUR_UUID, &device->flags); 44259f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 442682bc0194SAndreas Gruenbacher return -EIO; 4427481c6f50SPhilipp Reisner } 4428b30ab791SAndreas Gruenbacher rv = _drbd_set_state(device, ns, cs_flags, NULL); 4429b30ab791SAndreas Gruenbacher ns = drbd_read_state(device); 44300500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 4431b411b363SPhilipp Reisner 4432b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 44339f4fe9adSAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_DISCONNECTING), CS_HARD); 443482bc0194SAndreas Gruenbacher return -EIO; 4435b411b363SPhilipp Reisner } 4436b411b363SPhilipp Reisner 44374ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 44384ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 4439b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 4440b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 4441b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 4442b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 444369a22773SAndreas Gruenbacher drbd_send_uuids(peer_device); 444469a22773SAndreas Gruenbacher drbd_send_current_state(peer_device); 4445b411b363SPhilipp Reisner } 4446b411b363SPhilipp Reisner } 4447b411b363SPhilipp Reisner 4448b30ab791SAndreas Gruenbacher clear_bit(DISCARD_MY_DATA, &device->flags); 4449b411b363SPhilipp Reisner 4450b30ab791SAndreas Gruenbacher drbd_md_sync(device); /* update connected indicator, la_size_sect, ... */ 4451b411b363SPhilipp Reisner 445282bc0194SAndreas Gruenbacher return 0; 4453b411b363SPhilipp Reisner } 4454b411b363SPhilipp Reisner 4455bde89a9eSAndreas Gruenbacher static int receive_sync_uuid(struct drbd_connection *connection, struct packet_info *pi) 4456b411b363SPhilipp Reisner { 44579f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4458b30ab791SAndreas Gruenbacher struct drbd_device *device; 4459e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 44604a76b161SAndreas Gruenbacher 44619f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 44629f4fe9adSAndreas Gruenbacher if (!peer_device) 44634a76b161SAndreas Gruenbacher return -EIO; 44649f4fe9adSAndreas Gruenbacher device = peer_device->device; 4465b411b363SPhilipp Reisner 4466b30ab791SAndreas Gruenbacher wait_event(device->misc_wait, 4467b30ab791SAndreas Gruenbacher device->state.conn == C_WF_SYNC_UUID || 4468b30ab791SAndreas Gruenbacher device->state.conn == C_BEHIND || 4469b30ab791SAndreas Gruenbacher device->state.conn < C_CONNECTED || 4470b30ab791SAndreas Gruenbacher device->state.disk < D_NEGOTIATING); 4471b411b363SPhilipp Reisner 44720b0ba1efSAndreas Gruenbacher /* D_ASSERT(device, device->state.conn == C_WF_SYNC_UUID ); */ 4473b411b363SPhilipp Reisner 4474b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 4475b411b363SPhilipp Reisner _not_ be rotated into the history */ 4476b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_NEGOTIATING)) { 4477b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_CURRENT, be64_to_cpu(p->uuid)); 4478b30ab791SAndreas Gruenbacher _drbd_uuid_set(device, UI_BITMAP, 0UL); 4479b411b363SPhilipp Reisner 4480b30ab791SAndreas Gruenbacher drbd_print_uuids(device, "updated sync uuid"); 4481b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_TARGET); 4482b411b363SPhilipp Reisner 4483b30ab791SAndreas Gruenbacher put_ldev(device); 4484b411b363SPhilipp Reisner } else 4485d0180171SAndreas Gruenbacher drbd_err(device, "Ignoring SyncUUID packet!\n"); 4486b411b363SPhilipp Reisner 448782bc0194SAndreas Gruenbacher return 0; 4488b411b363SPhilipp Reisner } 4489b411b363SPhilipp Reisner 44902c46407dSAndreas Gruenbacher /** 44912c46407dSAndreas Gruenbacher * receive_bitmap_plain 44922c46407dSAndreas Gruenbacher * 44932c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 44942c46407dSAndreas Gruenbacher * code upon failure. 44952c46407dSAndreas Gruenbacher */ 44962c46407dSAndreas Gruenbacher static int 449769a22773SAndreas Gruenbacher receive_bitmap_plain(struct drbd_peer_device *peer_device, unsigned int size, 4498e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 4499b411b363SPhilipp Reisner { 450050d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 450169a22773SAndreas Gruenbacher drbd_header_size(peer_device->connection); 4502e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 450350d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 4504e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 45052c46407dSAndreas Gruenbacher int err; 4506b411b363SPhilipp Reisner 450750d0b1adSAndreas Gruenbacher if (want != size) { 450869a22773SAndreas Gruenbacher drbd_err(peer_device, "%s:want (%u) != size (%u)\n", __func__, want, size); 45092c46407dSAndreas Gruenbacher return -EIO; 4510b411b363SPhilipp Reisner } 4511b411b363SPhilipp Reisner if (want == 0) 45122c46407dSAndreas Gruenbacher return 0; 451369a22773SAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, want); 451482bc0194SAndreas Gruenbacher if (err) 45152c46407dSAndreas Gruenbacher return err; 4516b411b363SPhilipp Reisner 451769a22773SAndreas Gruenbacher drbd_bm_merge_lel(peer_device->device, c->word_offset, num_words, p); 4518b411b363SPhilipp Reisner 4519b411b363SPhilipp Reisner c->word_offset += num_words; 4520b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4521b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4522b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4523b411b363SPhilipp Reisner 45242c46407dSAndreas Gruenbacher return 1; 4525b411b363SPhilipp Reisner } 4526b411b363SPhilipp Reisner 4527a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4528a02d1240SAndreas Gruenbacher { 4529a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4530a02d1240SAndreas Gruenbacher } 4531a02d1240SAndreas Gruenbacher 4532a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4533a02d1240SAndreas Gruenbacher { 4534a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4535a02d1240SAndreas Gruenbacher } 4536a02d1240SAndreas Gruenbacher 4537a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4538a02d1240SAndreas Gruenbacher { 4539a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4540a02d1240SAndreas Gruenbacher } 4541a02d1240SAndreas Gruenbacher 45422c46407dSAndreas Gruenbacher /** 45432c46407dSAndreas Gruenbacher * recv_bm_rle_bits 45442c46407dSAndreas Gruenbacher * 45452c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 45462c46407dSAndreas Gruenbacher * code upon failure. 45472c46407dSAndreas Gruenbacher */ 45482c46407dSAndreas Gruenbacher static int 454969a22773SAndreas Gruenbacher recv_bm_rle_bits(struct drbd_peer_device *peer_device, 4550b411b363SPhilipp Reisner struct p_compressed_bm *p, 4551c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4552c6d25cfeSPhilipp Reisner unsigned int len) 4553b411b363SPhilipp Reisner { 4554b411b363SPhilipp Reisner struct bitstream bs; 4555b411b363SPhilipp Reisner u64 look_ahead; 4556b411b363SPhilipp Reisner u64 rl; 4557b411b363SPhilipp Reisner u64 tmp; 4558b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4559b411b363SPhilipp Reisner unsigned long e; 4560a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4561b411b363SPhilipp Reisner int have; 4562b411b363SPhilipp Reisner int bits; 4563b411b363SPhilipp Reisner 4564a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4565b411b363SPhilipp Reisner 4566b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4567b411b363SPhilipp Reisner if (bits < 0) 45682c46407dSAndreas Gruenbacher return -EIO; 4569b411b363SPhilipp Reisner 4570b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4571b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4572b411b363SPhilipp Reisner if (bits <= 0) 45732c46407dSAndreas Gruenbacher return -EIO; 4574b411b363SPhilipp Reisner 4575b411b363SPhilipp Reisner if (toggle) { 4576b411b363SPhilipp Reisner e = s + rl -1; 4577b411b363SPhilipp Reisner if (e >= c->bm_bits) { 457869a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 45792c46407dSAndreas Gruenbacher return -EIO; 4580b411b363SPhilipp Reisner } 458169a22773SAndreas Gruenbacher _drbd_bm_set_bits(peer_device->device, s, e); 4582b411b363SPhilipp Reisner } 4583b411b363SPhilipp Reisner 4584b411b363SPhilipp Reisner if (have < bits) { 458569a22773SAndreas Gruenbacher drbd_err(peer_device, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4586b411b363SPhilipp Reisner have, bits, look_ahead, 4587b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4588b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 45892c46407dSAndreas Gruenbacher return -EIO; 4590b411b363SPhilipp Reisner } 4591d2da5b0cSLars Ellenberg /* if we consumed all 64 bits, assign 0; >> 64 is "undefined"; */ 4592d2da5b0cSLars Ellenberg if (likely(bits < 64)) 4593b411b363SPhilipp Reisner look_ahead >>= bits; 4594d2da5b0cSLars Ellenberg else 4595d2da5b0cSLars Ellenberg look_ahead = 0; 4596b411b363SPhilipp Reisner have -= bits; 4597b411b363SPhilipp Reisner 4598b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4599b411b363SPhilipp Reisner if (bits < 0) 46002c46407dSAndreas Gruenbacher return -EIO; 4601b411b363SPhilipp Reisner look_ahead |= tmp << have; 4602b411b363SPhilipp Reisner have += bits; 4603b411b363SPhilipp Reisner } 4604b411b363SPhilipp Reisner 4605b411b363SPhilipp Reisner c->bit_offset = s; 4606b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4607b411b363SPhilipp Reisner 46082c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4609b411b363SPhilipp Reisner } 4610b411b363SPhilipp Reisner 46112c46407dSAndreas Gruenbacher /** 46122c46407dSAndreas Gruenbacher * decode_bitmap_c 46132c46407dSAndreas Gruenbacher * 46142c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 46152c46407dSAndreas Gruenbacher * code upon failure. 46162c46407dSAndreas Gruenbacher */ 46172c46407dSAndreas Gruenbacher static int 461869a22773SAndreas Gruenbacher decode_bitmap_c(struct drbd_peer_device *peer_device, 4619b411b363SPhilipp Reisner struct p_compressed_bm *p, 4620c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4621c6d25cfeSPhilipp Reisner unsigned int len) 4622b411b363SPhilipp Reisner { 4623a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 462469a22773SAndreas Gruenbacher return recv_bm_rle_bits(peer_device, p, c, len - sizeof(*p)); 4625b411b363SPhilipp Reisner 4626b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4627b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4628b411b363SPhilipp Reisner * during all our tests. */ 4629b411b363SPhilipp Reisner 463069a22773SAndreas Gruenbacher drbd_err(peer_device, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 463169a22773SAndreas Gruenbacher conn_request_state(peer_device->connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 46322c46407dSAndreas Gruenbacher return -EIO; 4633b411b363SPhilipp Reisner } 4634b411b363SPhilipp Reisner 4635b30ab791SAndreas Gruenbacher void INFO_bm_xfer_stats(struct drbd_device *device, 4636b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4637b411b363SPhilipp Reisner { 4638b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 4639a6b32bc3SAndreas Gruenbacher unsigned int header_size = drbd_header_size(first_peer_device(device)->connection); 464050d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 464150d0b1adSAndreas Gruenbacher unsigned int plain = 464250d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 464350d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 464450d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 464550d0b1adSAndreas Gruenbacher unsigned int r; 4646b411b363SPhilipp Reisner 4647b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4648b411b363SPhilipp Reisner if (total == 0) 4649b411b363SPhilipp Reisner return; 4650b411b363SPhilipp Reisner 4651b411b363SPhilipp Reisner /* don't report if not compressed */ 4652b411b363SPhilipp Reisner if (total >= plain) 4653b411b363SPhilipp Reisner return; 4654b411b363SPhilipp Reisner 4655b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4656b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4657b411b363SPhilipp Reisner : (1000 * total / plain); 4658b411b363SPhilipp Reisner 4659b411b363SPhilipp Reisner if (r > 1000) 4660b411b363SPhilipp Reisner r = 1000; 4661b411b363SPhilipp Reisner 4662b411b363SPhilipp Reisner r = 1000 - r; 4663d0180171SAndreas Gruenbacher drbd_info(device, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4664b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4665b411b363SPhilipp Reisner direction, 4666b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4667b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4668b411b363SPhilipp Reisner total, r/10, r % 10); 4669b411b363SPhilipp Reisner } 4670b411b363SPhilipp Reisner 4671b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4672b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4673b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4674b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4675b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4676b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4677b411b363SPhilipp Reisner 4678b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 4679bde89a9eSAndreas Gruenbacher static int receive_bitmap(struct drbd_connection *connection, struct packet_info *pi) 4680b411b363SPhilipp Reisner { 46819f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4682b30ab791SAndreas Gruenbacher struct drbd_device *device; 4683b411b363SPhilipp Reisner struct bm_xfer_ctx c; 46842c46407dSAndreas Gruenbacher int err; 46854a76b161SAndreas Gruenbacher 46869f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 46879f4fe9adSAndreas Gruenbacher if (!peer_device) 46884a76b161SAndreas Gruenbacher return -EIO; 46899f4fe9adSAndreas Gruenbacher device = peer_device->device; 4690b411b363SPhilipp Reisner 4691b30ab791SAndreas Gruenbacher drbd_bm_lock(device, "receive bitmap", BM_LOCKED_SET_ALLOWED); 469220ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 469320ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4694b411b363SPhilipp Reisner 4695b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4696b30ab791SAndreas Gruenbacher .bm_bits = drbd_bm_bits(device), 4697b30ab791SAndreas Gruenbacher .bm_words = drbd_bm_words(device), 4698b411b363SPhilipp Reisner }; 4699b411b363SPhilipp Reisner 47002c46407dSAndreas Gruenbacher for(;;) { 4701e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 470269a22773SAndreas Gruenbacher err = receive_bitmap_plain(peer_device, pi->size, pi->data, &c); 4703e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4704b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4705b411b363SPhilipp Reisner * and the feature is enabled! */ 4706e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4707b411b363SPhilipp Reisner 4708bde89a9eSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(connection)) { 4709d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too large\n"); 471082bc0194SAndreas Gruenbacher err = -EIO; 4711b411b363SPhilipp Reisner goto out; 4712b411b363SPhilipp Reisner } 4713e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4714d0180171SAndreas Gruenbacher drbd_err(device, "ReportCBitmap packet too small (l:%u)\n", pi->size); 471582bc0194SAndreas Gruenbacher err = -EIO; 471678fcbdaeSAndreas Gruenbacher goto out; 4717b411b363SPhilipp Reisner } 47189f4fe9adSAndreas Gruenbacher err = drbd_recv_all(peer_device->connection, p, pi->size); 4719e658983aSAndreas Gruenbacher if (err) 4720e658983aSAndreas Gruenbacher goto out; 472169a22773SAndreas Gruenbacher err = decode_bitmap_c(peer_device, p, &c, pi->size); 4722b411b363SPhilipp Reisner } else { 4723d0180171SAndreas Gruenbacher drbd_warn(device, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 472482bc0194SAndreas Gruenbacher err = -EIO; 4725b411b363SPhilipp Reisner goto out; 4726b411b363SPhilipp Reisner } 4727b411b363SPhilipp Reisner 4728e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 4729bde89a9eSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(connection) + pi->size; 4730b411b363SPhilipp Reisner 47312c46407dSAndreas Gruenbacher if (err <= 0) { 47322c46407dSAndreas Gruenbacher if (err < 0) 47332c46407dSAndreas Gruenbacher goto out; 4734b411b363SPhilipp Reisner break; 47352c46407dSAndreas Gruenbacher } 47369f4fe9adSAndreas Gruenbacher err = drbd_recv_header(peer_device->connection, pi); 473782bc0194SAndreas Gruenbacher if (err) 4738b411b363SPhilipp Reisner goto out; 47392c46407dSAndreas Gruenbacher } 4740b411b363SPhilipp Reisner 4741b30ab791SAndreas Gruenbacher INFO_bm_xfer_stats(device, "receive", &c); 4742b411b363SPhilipp Reisner 4743b30ab791SAndreas Gruenbacher if (device->state.conn == C_WF_BITMAP_T) { 4744de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4745de1f8e4aSAndreas Gruenbacher 4746b30ab791SAndreas Gruenbacher err = drbd_send_bitmap(device); 474782bc0194SAndreas Gruenbacher if (err) 4748b411b363SPhilipp Reisner goto out; 4749b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4750b30ab791SAndreas Gruenbacher rv = _drbd_request_state(device, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 47510b0ba1efSAndreas Gruenbacher D_ASSERT(device, rv == SS_SUCCESS); 4752b30ab791SAndreas Gruenbacher } else if (device->state.conn != C_WF_BITMAP_S) { 4753b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4754b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4755d0180171SAndreas Gruenbacher drbd_info(device, "unexpected cstate (%s) in receive_bitmap\n", 4756b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4757b411b363SPhilipp Reisner } 475882bc0194SAndreas Gruenbacher err = 0; 4759b411b363SPhilipp Reisner 4760b411b363SPhilipp Reisner out: 4761b30ab791SAndreas Gruenbacher drbd_bm_unlock(device); 4762b30ab791SAndreas Gruenbacher if (!err && device->state.conn == C_WF_BITMAP_S) 4763b30ab791SAndreas Gruenbacher drbd_start_resync(device, C_SYNC_SOURCE); 476482bc0194SAndreas Gruenbacher return err; 4765b411b363SPhilipp Reisner } 4766b411b363SPhilipp Reisner 4767bde89a9eSAndreas Gruenbacher static int receive_skip(struct drbd_connection *connection, struct packet_info *pi) 4768b411b363SPhilipp Reisner { 47691ec861ebSAndreas Gruenbacher drbd_warn(connection, "skipping unknown optional packet type %d, l: %d!\n", 4770e2857216SAndreas Gruenbacher pi->cmd, pi->size); 4771b411b363SPhilipp Reisner 4772bde89a9eSAndreas Gruenbacher return ignore_remaining_packet(connection, pi); 4773b411b363SPhilipp Reisner } 4774b411b363SPhilipp Reisner 4775bde89a9eSAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_connection *connection, struct packet_info *pi) 4776b411b363SPhilipp Reisner { 4777b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4778b411b363SPhilipp Reisner * with the data requests being unplugged */ 4779bde89a9eSAndreas Gruenbacher drbd_tcp_quickack(connection->data.socket); 4780b411b363SPhilipp Reisner 478182bc0194SAndreas Gruenbacher return 0; 4782b411b363SPhilipp Reisner } 4783b411b363SPhilipp Reisner 4784bde89a9eSAndreas Gruenbacher static int receive_out_of_sync(struct drbd_connection *connection, struct packet_info *pi) 478573a01a18SPhilipp Reisner { 47869f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4787b30ab791SAndreas Gruenbacher struct drbd_device *device; 4788e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 47894a76b161SAndreas Gruenbacher 47909f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 47919f4fe9adSAndreas Gruenbacher if (!peer_device) 47924a76b161SAndreas Gruenbacher return -EIO; 47939f4fe9adSAndreas Gruenbacher device = peer_device->device; 479473a01a18SPhilipp Reisner 4795b30ab791SAndreas Gruenbacher switch (device->state.conn) { 4796f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4797f735e363SLars Ellenberg case C_WF_BITMAP_T: 4798f735e363SLars Ellenberg case C_BEHIND: 4799f735e363SLars Ellenberg break; 4800f735e363SLars Ellenberg default: 4801d0180171SAndreas Gruenbacher drbd_err(device, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4802b30ab791SAndreas Gruenbacher drbd_conn_str(device->state.conn)); 4803f735e363SLars Ellenberg } 4804f735e363SLars Ellenberg 4805b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 480673a01a18SPhilipp Reisner 480782bc0194SAndreas Gruenbacher return 0; 480873a01a18SPhilipp Reisner } 480973a01a18SPhilipp Reisner 4810700ca8c0SPhilipp Reisner static int receive_rs_deallocated(struct drbd_connection *connection, struct packet_info *pi) 4811700ca8c0SPhilipp Reisner { 4812700ca8c0SPhilipp Reisner struct drbd_peer_device *peer_device; 4813700ca8c0SPhilipp Reisner struct p_block_desc *p = pi->data; 4814700ca8c0SPhilipp Reisner struct drbd_device *device; 4815700ca8c0SPhilipp Reisner sector_t sector; 4816700ca8c0SPhilipp Reisner int size, err = 0; 4817700ca8c0SPhilipp Reisner 4818700ca8c0SPhilipp Reisner peer_device = conn_peer_device(connection, pi->vnr); 4819700ca8c0SPhilipp Reisner if (!peer_device) 4820700ca8c0SPhilipp Reisner return -EIO; 4821700ca8c0SPhilipp Reisner device = peer_device->device; 4822700ca8c0SPhilipp Reisner 4823700ca8c0SPhilipp Reisner sector = be64_to_cpu(p->sector); 4824700ca8c0SPhilipp Reisner size = be32_to_cpu(p->blksize); 4825700ca8c0SPhilipp Reisner 4826700ca8c0SPhilipp Reisner dec_rs_pending(device); 4827700ca8c0SPhilipp Reisner 4828700ca8c0SPhilipp Reisner if (get_ldev(device)) { 4829700ca8c0SPhilipp Reisner struct drbd_peer_request *peer_req; 483045c21793SChristoph Hellwig const int op = REQ_OP_WRITE_ZEROES; 4831700ca8c0SPhilipp Reisner 4832700ca8c0SPhilipp Reisner peer_req = drbd_alloc_peer_req(peer_device, ID_SYNCER, sector, 48339104d31aSLars Ellenberg size, 0, GFP_NOIO); 4834700ca8c0SPhilipp Reisner if (!peer_req) { 4835700ca8c0SPhilipp Reisner put_ldev(device); 4836700ca8c0SPhilipp Reisner return -ENOMEM; 4837700ca8c0SPhilipp Reisner } 4838700ca8c0SPhilipp Reisner 4839700ca8c0SPhilipp Reisner peer_req->w.cb = e_end_resync_block; 4840700ca8c0SPhilipp Reisner peer_req->submit_jif = jiffies; 4841700ca8c0SPhilipp Reisner peer_req->flags |= EE_IS_TRIM; 4842700ca8c0SPhilipp Reisner 4843700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4844700ca8c0SPhilipp Reisner list_add_tail(&peer_req->w.list, &device->sync_ee); 4845700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4846700ca8c0SPhilipp Reisner 4847700ca8c0SPhilipp Reisner atomic_add(pi->size >> 9, &device->rs_sect_ev); 4848700ca8c0SPhilipp Reisner err = drbd_submit_peer_request(device, peer_req, op, 0, DRBD_FAULT_RS_WR); 4849700ca8c0SPhilipp Reisner 4850700ca8c0SPhilipp Reisner if (err) { 4851700ca8c0SPhilipp Reisner spin_lock_irq(&device->resource->req_lock); 4852700ca8c0SPhilipp Reisner list_del(&peer_req->w.list); 4853700ca8c0SPhilipp Reisner spin_unlock_irq(&device->resource->req_lock); 4854700ca8c0SPhilipp Reisner 4855700ca8c0SPhilipp Reisner drbd_free_peer_req(device, peer_req); 4856700ca8c0SPhilipp Reisner put_ldev(device); 4857700ca8c0SPhilipp Reisner err = 0; 4858700ca8c0SPhilipp Reisner goto fail; 4859700ca8c0SPhilipp Reisner } 4860700ca8c0SPhilipp Reisner 4861700ca8c0SPhilipp Reisner inc_unacked(device); 4862700ca8c0SPhilipp Reisner 4863700ca8c0SPhilipp Reisner /* No put_ldev() here. Gets called in drbd_endio_write_sec_final(), 4864700ca8c0SPhilipp Reisner as well as drbd_rs_complete_io() */ 4865700ca8c0SPhilipp Reisner } else { 4866700ca8c0SPhilipp Reisner fail: 4867700ca8c0SPhilipp Reisner drbd_rs_complete_io(device, sector); 4868700ca8c0SPhilipp Reisner drbd_send_ack_ex(peer_device, P_NEG_ACK, sector, size, ID_SYNCER); 4869700ca8c0SPhilipp Reisner } 4870700ca8c0SPhilipp Reisner 4871700ca8c0SPhilipp Reisner atomic_add(size >> 9, &device->rs_sect_in); 4872700ca8c0SPhilipp Reisner 4873700ca8c0SPhilipp Reisner return err; 4874700ca8c0SPhilipp Reisner } 4875700ca8c0SPhilipp Reisner 487602918be2SPhilipp Reisner struct data_cmd { 487702918be2SPhilipp Reisner int expect_payload; 48789104d31aSLars Ellenberg unsigned int pkt_size; 4879bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *, struct packet_info *); 4880b411b363SPhilipp Reisner }; 4881b411b363SPhilipp Reisner 488202918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 488302918be2SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 488402918be2SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 488502918be2SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 488602918be2SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4887e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4888e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4889e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 489002918be2SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 489102918be2SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4892e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4893e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 489402918be2SPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 489502918be2SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 489602918be2SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 489702918be2SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 489802918be2SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 489902918be2SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 490002918be2SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 490102918be2SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 490202918be2SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 4903700ca8c0SPhilipp Reisner [P_RS_THIN_REQ] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 490402918be2SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 490573a01a18SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 49064a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4907036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 4908a0fb3c47SLars Ellenberg [P_TRIM] = { 0, sizeof(struct p_trim), receive_Data }, 4909700ca8c0SPhilipp Reisner [P_RS_DEALLOCATED] = { 0, sizeof(struct p_block_desc), receive_rs_deallocated }, 49109104d31aSLars Ellenberg [P_WSAME] = { 1, sizeof(struct p_wsame), receive_Data }, 491102918be2SPhilipp Reisner }; 491202918be2SPhilipp Reisner 4913bde89a9eSAndreas Gruenbacher static void drbdd(struct drbd_connection *connection) 4914b411b363SPhilipp Reisner { 491577351055SPhilipp Reisner struct packet_info pi; 491602918be2SPhilipp Reisner size_t shs; /* sub header size */ 491782bc0194SAndreas Gruenbacher int err; 4918b411b363SPhilipp Reisner 4919bde89a9eSAndreas Gruenbacher while (get_t_state(&connection->receiver) == RUNNING) { 49209104d31aSLars Ellenberg struct data_cmd const *cmd; 4921deebe195SAndreas Gruenbacher 4922bde89a9eSAndreas Gruenbacher drbd_thread_current_set_cpu(&connection->receiver); 4923c51a0ef3SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_header_maybe_unplug); 4924c51a0ef3SLars Ellenberg if (drbd_recv_header_maybe_unplug(connection, &pi)) 492502918be2SPhilipp Reisner goto err_out; 492602918be2SPhilipp Reisner 4927deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 49284a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 49291ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected data packet %s (0x%04x)", 49302fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 493102918be2SPhilipp Reisner goto err_out; 49320b33a916SLars Ellenberg } 4933b411b363SPhilipp Reisner 4934e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 49359104d31aSLars Ellenberg if (pi.cmd == P_SIZES && connection->agreed_features & DRBD_FF_WSAME) 49369104d31aSLars Ellenberg shs += sizeof(struct o_qlim); 4937e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 49381ec861ebSAndreas Gruenbacher drbd_err(connection, "No payload expected %s l:%d\n", 49392fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4940c13f7e1aSLars Ellenberg goto err_out; 4941c13f7e1aSLars Ellenberg } 49429104d31aSLars Ellenberg if (pi.size < shs) { 49439104d31aSLars Ellenberg drbd_err(connection, "%s: unexpected packet size, expected:%d received:%d\n", 49449104d31aSLars Ellenberg cmdname(pi.cmd), (int)shs, pi.size); 49459104d31aSLars Ellenberg goto err_out; 49469104d31aSLars Ellenberg } 4947c13f7e1aSLars Ellenberg 4948c13f7e1aSLars Ellenberg if (shs) { 4949944410e9SLars Ellenberg update_receiver_timing_details(connection, drbd_recv_all_warn); 4950bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, pi.data, shs); 4951a5c31904SAndreas Gruenbacher if (err) 495202918be2SPhilipp Reisner goto err_out; 4953e2857216SAndreas Gruenbacher pi.size -= shs; 4954b411b363SPhilipp Reisner } 495502918be2SPhilipp Reisner 4956944410e9SLars Ellenberg update_receiver_timing_details(connection, cmd->fn); 4957bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 49584a76b161SAndreas Gruenbacher if (err) { 49591ec861ebSAndreas Gruenbacher drbd_err(connection, "error receiving %s, e: %d l: %d!\n", 49609f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 496102918be2SPhilipp Reisner goto err_out; 496202918be2SPhilipp Reisner } 496302918be2SPhilipp Reisner } 496482bc0194SAndreas Gruenbacher return; 496502918be2SPhilipp Reisner 496602918be2SPhilipp Reisner err_out: 4967bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4968b411b363SPhilipp Reisner } 4969b411b363SPhilipp Reisner 4970bde89a9eSAndreas Gruenbacher static void conn_disconnect(struct drbd_connection *connection) 4971f70b3511SPhilipp Reisner { 4972c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 4973bbeb641cSPhilipp Reisner enum drbd_conns oc; 4974376694a0SPhilipp Reisner int vnr; 4975f70b3511SPhilipp Reisner 4976bde89a9eSAndreas Gruenbacher if (connection->cstate == C_STANDALONE) 4977b411b363SPhilipp Reisner return; 4978b411b363SPhilipp Reisner 4979545752d5SLars Ellenberg /* We are about to start the cleanup after connection loss. 4980545752d5SLars Ellenberg * Make sure drbd_make_request knows about that. 4981545752d5SLars Ellenberg * Usually we should be in some network failure state already, 4982545752d5SLars Ellenberg * but just in case we are not, we fix it up here. 4983545752d5SLars Ellenberg */ 4984bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4985545752d5SLars Ellenberg 4986668700b4SPhilipp Reisner /* ack_receiver does not clean up anything. it must not interfere, either */ 49871c03e520SPhilipp Reisner drbd_thread_stop(&connection->ack_receiver); 4988668700b4SPhilipp Reisner if (connection->ack_sender) { 4989668700b4SPhilipp Reisner destroy_workqueue(connection->ack_sender); 4990668700b4SPhilipp Reisner connection->ack_sender = NULL; 4991668700b4SPhilipp Reisner } 4992bde89a9eSAndreas Gruenbacher drbd_free_sock(connection); 4993360cc740SPhilipp Reisner 4994c141ebdaSPhilipp Reisner rcu_read_lock(); 4995c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 4996c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 4997b30ab791SAndreas Gruenbacher kref_get(&device->kref); 4998c141ebdaSPhilipp Reisner rcu_read_unlock(); 499969a22773SAndreas Gruenbacher drbd_disconnected(peer_device); 5000c06ece6bSAndreas Gruenbacher kref_put(&device->kref, drbd_destroy_device); 5001c141ebdaSPhilipp Reisner rcu_read_lock(); 5002c141ebdaSPhilipp Reisner } 5003c141ebdaSPhilipp Reisner rcu_read_unlock(); 5004c141ebdaSPhilipp Reisner 5005bde89a9eSAndreas Gruenbacher if (!list_empty(&connection->current_epoch->list)) 50061ec861ebSAndreas Gruenbacher drbd_err(connection, "ASSERTION FAILED: connection->current_epoch->list not empty\n"); 500712038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 5008bde89a9eSAndreas Gruenbacher atomic_set(&connection->current_epoch->epoch_size, 0); 5009bde89a9eSAndreas Gruenbacher connection->send.seen_any_write_yet = false; 501012038a3aSPhilipp Reisner 50111ec861ebSAndreas Gruenbacher drbd_info(connection, "Connection closed\n"); 5012360cc740SPhilipp Reisner 5013bde89a9eSAndreas Gruenbacher if (conn_highest_role(connection) == R_PRIMARY && conn_highest_pdsk(connection) >= D_UNKNOWN) 5014bde89a9eSAndreas Gruenbacher conn_try_outdate_peer_async(connection); 5015cb703454SPhilipp Reisner 50160500813fSAndreas Gruenbacher spin_lock_irq(&connection->resource->req_lock); 5017bde89a9eSAndreas Gruenbacher oc = connection->cstate; 5018bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 5019bde89a9eSAndreas Gruenbacher _conn_request_state(connection, NS(conn, C_UNCONNECTED), CS_VERBOSE); 5020bbeb641cSPhilipp Reisner 50210500813fSAndreas Gruenbacher spin_unlock_irq(&connection->resource->req_lock); 5022360cc740SPhilipp Reisner 5023f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 5024bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 5025360cc740SPhilipp Reisner } 5026360cc740SPhilipp Reisner 502769a22773SAndreas Gruenbacher static int drbd_disconnected(struct drbd_peer_device *peer_device) 5028360cc740SPhilipp Reisner { 502969a22773SAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5030360cc740SPhilipp Reisner unsigned int i; 5031b411b363SPhilipp Reisner 503285719573SPhilipp Reisner /* wait for current activity to cease. */ 50330500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5034b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->active_ee); 5035b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->sync_ee); 5036b30ab791SAndreas Gruenbacher _drbd_wait_ee_list_empty(device, &device->read_ee); 50370500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5038b411b363SPhilipp Reisner 5039b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 5040b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 5041b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 5042b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 5043b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 5044b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 5045b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 5046b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 5047b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 5048b411b363SPhilipp Reisner * on the fly. */ 5049b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5050b30ab791SAndreas Gruenbacher device->rs_total = 0; 5051b30ab791SAndreas Gruenbacher device->rs_failed = 0; 5052b30ab791SAndreas Gruenbacher atomic_set(&device->rs_pending_cnt, 0); 5053b30ab791SAndreas Gruenbacher wake_up(&device->misc_wait); 5054b411b363SPhilipp Reisner 5055b30ab791SAndreas Gruenbacher del_timer_sync(&device->resync_timer); 5056b30ab791SAndreas Gruenbacher resync_timer_fn((unsigned long)device); 5057b411b363SPhilipp Reisner 5058b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 5059b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 5060b411b363SPhilipp Reisner * to be "canceled" */ 5061b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5062b411b363SPhilipp Reisner 5063b30ab791SAndreas Gruenbacher drbd_finish_peer_reqs(device); 5064b411b363SPhilipp Reisner 5065d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 5066d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 5067d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 5068b5043c5eSAndreas Gruenbacher drbd_flush_workqueue(&peer_device->connection->sender_work); 5069d10b4ea3SPhilipp Reisner 507008332d73SLars Ellenberg /* need to do it again, drbd_finish_peer_reqs() may have populated it 507108332d73SLars Ellenberg * again via drbd_try_clear_on_disk_bm(). */ 5072b30ab791SAndreas Gruenbacher drbd_rs_cancel_all(device); 5073b411b363SPhilipp Reisner 5074b30ab791SAndreas Gruenbacher kfree(device->p_uuid); 5075b30ab791SAndreas Gruenbacher device->p_uuid = NULL; 5076b411b363SPhilipp Reisner 5077b30ab791SAndreas Gruenbacher if (!drbd_suspended(device)) 507869a22773SAndreas Gruenbacher tl_clear(peer_device->connection); 5079b411b363SPhilipp Reisner 5080b30ab791SAndreas Gruenbacher drbd_md_sync(device); 5081b411b363SPhilipp Reisner 5082be115b69SLars Ellenberg if (get_ldev(device)) { 5083be115b69SLars Ellenberg drbd_bitmap_io(device, &drbd_bm_write_copy_pages, 5084be115b69SLars Ellenberg "write from disconnected", BM_LOCKED_CHANGE_ALLOWED); 5085be115b69SLars Ellenberg put_ldev(device); 5086be115b69SLars Ellenberg } 508720ceb2b2SLars Ellenberg 5088b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 5089b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 5090b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 5091b411b363SPhilipp Reisner * 5092b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 5093b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 5094b411b363SPhilipp Reisner */ 5095b30ab791SAndreas Gruenbacher i = drbd_free_peer_reqs(device, &device->net_ee); 5096b411b363SPhilipp Reisner if (i) 5097d0180171SAndreas Gruenbacher drbd_info(device, "net_ee not empty, killed %u entries\n", i); 5098b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use_by_net); 5099435f0740SLars Ellenberg if (i) 5100d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use_by_net = %d, expected 0\n", i); 5101b30ab791SAndreas Gruenbacher i = atomic_read(&device->pp_in_use); 5102b411b363SPhilipp Reisner if (i) 5103d0180171SAndreas Gruenbacher drbd_info(device, "pp_in_use = %d, expected 0\n", i); 5104b411b363SPhilipp Reisner 51050b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->read_ee)); 51060b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->active_ee)); 51070b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->sync_ee)); 51080b0ba1efSAndreas Gruenbacher D_ASSERT(device, list_empty(&device->done_ee)); 5109b411b363SPhilipp Reisner 5110360cc740SPhilipp Reisner return 0; 5111b411b363SPhilipp Reisner } 5112b411b363SPhilipp Reisner 5113b411b363SPhilipp Reisner /* 5114b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 5115b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 5116b411b363SPhilipp Reisner * 5117b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 5118b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 5119b411b363SPhilipp Reisner * 5120b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 5121b411b363SPhilipp Reisner */ 5122bde89a9eSAndreas Gruenbacher static int drbd_send_features(struct drbd_connection *connection) 5123b411b363SPhilipp Reisner { 51249f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 51259f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 5126b411b363SPhilipp Reisner 5127bde89a9eSAndreas Gruenbacher sock = &connection->data; 5128bde89a9eSAndreas Gruenbacher p = conn_prepare_command(connection, sock); 51299f5bdc33SAndreas Gruenbacher if (!p) 5130e8d17b01SAndreas Gruenbacher return -EIO; 5131b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 5132b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 5133b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 513420c68fdeSLars Ellenberg p->feature_flags = cpu_to_be32(PRO_FEATURES); 5135bde89a9eSAndreas Gruenbacher return conn_send_command(connection, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 5136b411b363SPhilipp Reisner } 5137b411b363SPhilipp Reisner 5138b411b363SPhilipp Reisner /* 5139b411b363SPhilipp Reisner * return values: 5140b411b363SPhilipp Reisner * 1 yes, we have a valid connection 5141b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 5142b411b363SPhilipp Reisner * -1 peer talks different language, 5143b411b363SPhilipp Reisner * no point in trying again, please go standalone. 5144b411b363SPhilipp Reisner */ 5145bde89a9eSAndreas Gruenbacher static int drbd_do_features(struct drbd_connection *connection) 5146b411b363SPhilipp Reisner { 5147bde89a9eSAndreas Gruenbacher /* ASSERT current == connection->receiver ... */ 5148e658983aSAndreas Gruenbacher struct p_connection_features *p; 5149e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 515077351055SPhilipp Reisner struct packet_info pi; 5151a5c31904SAndreas Gruenbacher int err; 5152b411b363SPhilipp Reisner 5153bde89a9eSAndreas Gruenbacher err = drbd_send_features(connection); 5154e8d17b01SAndreas Gruenbacher if (err) 5155b411b363SPhilipp Reisner return 0; 5156b411b363SPhilipp Reisner 5157bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 515869bc7bc3SAndreas Gruenbacher if (err) 5159b411b363SPhilipp Reisner return 0; 5160b411b363SPhilipp Reisner 51616038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 51621ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 516377351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5164b411b363SPhilipp Reisner return -1; 5165b411b363SPhilipp Reisner } 5166b411b363SPhilipp Reisner 516777351055SPhilipp Reisner if (pi.size != expect) { 51681ec861ebSAndreas Gruenbacher drbd_err(connection, "expected ConnectionFeatures length: %u, received: %u\n", 516977351055SPhilipp Reisner expect, pi.size); 5170b411b363SPhilipp Reisner return -1; 5171b411b363SPhilipp Reisner } 5172b411b363SPhilipp Reisner 5173e658983aSAndreas Gruenbacher p = pi.data; 5174bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, p, expect); 5175a5c31904SAndreas Gruenbacher if (err) 5176b411b363SPhilipp Reisner return 0; 5177b411b363SPhilipp Reisner 5178b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 5179b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 5180b411b363SPhilipp Reisner if (p->protocol_max == 0) 5181b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 5182b411b363SPhilipp Reisner 5183b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 5184b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 5185b411b363SPhilipp Reisner goto incompat; 5186b411b363SPhilipp Reisner 5187bde89a9eSAndreas Gruenbacher connection->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 518820c68fdeSLars Ellenberg connection->agreed_features = PRO_FEATURES & be32_to_cpu(p->feature_flags); 5189b411b363SPhilipp Reisner 51901ec861ebSAndreas Gruenbacher drbd_info(connection, "Handshake successful: " 5191bde89a9eSAndreas Gruenbacher "Agreed network protocol version %d\n", connection->agreed_pro_version); 5192b411b363SPhilipp Reisner 51939104d31aSLars Ellenberg drbd_info(connection, "Feature flags enabled on protocol level: 0x%x%s%s%s.\n", 51949104d31aSLars Ellenberg connection->agreed_features, 51959104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_TRIM ? " TRIM" : "", 51969104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_THIN_RESYNC ? " THIN_RESYNC" : "", 51979104d31aSLars Ellenberg connection->agreed_features & DRBD_FF_WSAME ? " WRITE_SAME" : 51989104d31aSLars Ellenberg connection->agreed_features ? "" : " none"); 519992d94ae6SPhilipp Reisner 5200b411b363SPhilipp Reisner return 1; 5201b411b363SPhilipp Reisner 5202b411b363SPhilipp Reisner incompat: 52031ec861ebSAndreas Gruenbacher drbd_err(connection, "incompatible DRBD dialects: " 5204b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 5205b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 5206b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 5207b411b363SPhilipp Reisner return -1; 5208b411b363SPhilipp Reisner } 5209b411b363SPhilipp Reisner 5210b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 5211bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5212b411b363SPhilipp Reisner { 52131ec861ebSAndreas Gruenbacher drbd_err(connection, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 52141ec861ebSAndreas Gruenbacher drbd_err(connection, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 5215b10d96cbSJohannes Thoma return -1; 5216b411b363SPhilipp Reisner } 5217b411b363SPhilipp Reisner #else 5218b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 5219b10d96cbSJohannes Thoma 5220b10d96cbSJohannes Thoma /* Return value: 5221b10d96cbSJohannes Thoma 1 - auth succeeded, 5222b10d96cbSJohannes Thoma 0 - failed, try again (network error), 5223b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 5224b10d96cbSJohannes Thoma */ 5225b10d96cbSJohannes Thoma 5226bde89a9eSAndreas Gruenbacher static int drbd_do_auth(struct drbd_connection *connection) 5227b411b363SPhilipp Reisner { 52289f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 5229b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 5230b411b363SPhilipp Reisner char *response = NULL; 5231b411b363SPhilipp Reisner char *right_response = NULL; 5232b411b363SPhilipp Reisner char *peers_ch = NULL; 523344ed167dSPhilipp Reisner unsigned int key_len; 523444ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 5235b411b363SPhilipp Reisner unsigned int resp_size; 52369534d671SHerbert Xu SHASH_DESC_ON_STACK(desc, connection->cram_hmac_tfm); 523777351055SPhilipp Reisner struct packet_info pi; 523844ed167dSPhilipp Reisner struct net_conf *nc; 523969bc7bc3SAndreas Gruenbacher int err, rv; 5240b411b363SPhilipp Reisner 52419f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 52429f5bdc33SAndreas Gruenbacher 524344ed167dSPhilipp Reisner rcu_read_lock(); 5244bde89a9eSAndreas Gruenbacher nc = rcu_dereference(connection->net_conf); 524544ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 524644ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 524744ed167dSPhilipp Reisner rcu_read_unlock(); 524844ed167dSPhilipp Reisner 52499534d671SHerbert Xu desc->tfm = connection->cram_hmac_tfm; 52509534d671SHerbert Xu desc->flags = 0; 5251b411b363SPhilipp Reisner 52529534d671SHerbert Xu rv = crypto_shash_setkey(connection->cram_hmac_tfm, (u8 *)secret, key_len); 5253b411b363SPhilipp Reisner if (rv) { 52549534d671SHerbert Xu drbd_err(connection, "crypto_shash_setkey() failed with %d\n", rv); 5255b10d96cbSJohannes Thoma rv = -1; 5256b411b363SPhilipp Reisner goto fail; 5257b411b363SPhilipp Reisner } 5258b411b363SPhilipp Reisner 5259b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 5260b411b363SPhilipp Reisner 5261bde89a9eSAndreas Gruenbacher sock = &connection->data; 5262bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 52639f5bdc33SAndreas Gruenbacher rv = 0; 52649f5bdc33SAndreas Gruenbacher goto fail; 52659f5bdc33SAndreas Gruenbacher } 5266bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_CHALLENGE, 0, 52679f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 5268b411b363SPhilipp Reisner if (!rv) 5269b411b363SPhilipp Reisner goto fail; 5270b411b363SPhilipp Reisner 5271bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 527269bc7bc3SAndreas Gruenbacher if (err) { 5273b411b363SPhilipp Reisner rv = 0; 5274b411b363SPhilipp Reisner goto fail; 5275b411b363SPhilipp Reisner } 5276b411b363SPhilipp Reisner 527777351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 52781ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge packet, received: %s (0x%04x)\n", 527977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5280b411b363SPhilipp Reisner rv = 0; 5281b411b363SPhilipp Reisner goto fail; 5282b411b363SPhilipp Reisner } 5283b411b363SPhilipp Reisner 528477351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 52851ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthChallenge payload too big.\n"); 5286b10d96cbSJohannes Thoma rv = -1; 5287b411b363SPhilipp Reisner goto fail; 5288b411b363SPhilipp Reisner } 5289b411b363SPhilipp Reisner 529067cca286SPhilipp Reisner if (pi.size < CHALLENGE_LEN) { 529167cca286SPhilipp Reisner drbd_err(connection, "AuthChallenge payload too small.\n"); 529267cca286SPhilipp Reisner rv = -1; 529367cca286SPhilipp Reisner goto fail; 529467cca286SPhilipp Reisner } 529567cca286SPhilipp Reisner 529677351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 5297b411b363SPhilipp Reisner if (peers_ch == NULL) { 52981ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of peers_ch failed\n"); 5299b10d96cbSJohannes Thoma rv = -1; 5300b411b363SPhilipp Reisner goto fail; 5301b411b363SPhilipp Reisner } 5302b411b363SPhilipp Reisner 5303bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, peers_ch, pi.size); 5304a5c31904SAndreas Gruenbacher if (err) { 5305b411b363SPhilipp Reisner rv = 0; 5306b411b363SPhilipp Reisner goto fail; 5307b411b363SPhilipp Reisner } 5308b411b363SPhilipp Reisner 530967cca286SPhilipp Reisner if (!memcmp(my_challenge, peers_ch, CHALLENGE_LEN)) { 531067cca286SPhilipp Reisner drbd_err(connection, "Peer presented the same challenge!\n"); 531167cca286SPhilipp Reisner rv = -1; 531267cca286SPhilipp Reisner goto fail; 531367cca286SPhilipp Reisner } 531467cca286SPhilipp Reisner 53159534d671SHerbert Xu resp_size = crypto_shash_digestsize(connection->cram_hmac_tfm); 5316b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 5317b411b363SPhilipp Reisner if (response == NULL) { 53181ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of response failed\n"); 5319b10d96cbSJohannes Thoma rv = -1; 5320b411b363SPhilipp Reisner goto fail; 5321b411b363SPhilipp Reisner } 5322b411b363SPhilipp Reisner 53239534d671SHerbert Xu rv = crypto_shash_digest(desc, peers_ch, pi.size, response); 5324b411b363SPhilipp Reisner if (rv) { 53251ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5326b10d96cbSJohannes Thoma rv = -1; 5327b411b363SPhilipp Reisner goto fail; 5328b411b363SPhilipp Reisner } 5329b411b363SPhilipp Reisner 5330bde89a9eSAndreas Gruenbacher if (!conn_prepare_command(connection, sock)) { 53319f5bdc33SAndreas Gruenbacher rv = 0; 53329f5bdc33SAndreas Gruenbacher goto fail; 53339f5bdc33SAndreas Gruenbacher } 5334bde89a9eSAndreas Gruenbacher rv = !conn_send_command(connection, sock, P_AUTH_RESPONSE, 0, 53359f5bdc33SAndreas Gruenbacher response, resp_size); 5336b411b363SPhilipp Reisner if (!rv) 5337b411b363SPhilipp Reisner goto fail; 5338b411b363SPhilipp Reisner 5339bde89a9eSAndreas Gruenbacher err = drbd_recv_header(connection, &pi); 534069bc7bc3SAndreas Gruenbacher if (err) { 5341b411b363SPhilipp Reisner rv = 0; 5342b411b363SPhilipp Reisner goto fail; 5343b411b363SPhilipp Reisner } 5344b411b363SPhilipp Reisner 534577351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 53461ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse packet, received: %s (0x%04x)\n", 534777351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 5348b411b363SPhilipp Reisner rv = 0; 5349b411b363SPhilipp Reisner goto fail; 5350b411b363SPhilipp Reisner } 5351b411b363SPhilipp Reisner 535277351055SPhilipp Reisner if (pi.size != resp_size) { 53531ec861ebSAndreas Gruenbacher drbd_err(connection, "expected AuthResponse payload of wrong size\n"); 5354b411b363SPhilipp Reisner rv = 0; 5355b411b363SPhilipp Reisner goto fail; 5356b411b363SPhilipp Reisner } 5357b411b363SPhilipp Reisner 5358bde89a9eSAndreas Gruenbacher err = drbd_recv_all_warn(connection, response , resp_size); 5359a5c31904SAndreas Gruenbacher if (err) { 5360b411b363SPhilipp Reisner rv = 0; 5361b411b363SPhilipp Reisner goto fail; 5362b411b363SPhilipp Reisner } 5363b411b363SPhilipp Reisner 5364b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 53652d1ee87dSJulia Lawall if (right_response == NULL) { 53661ec861ebSAndreas Gruenbacher drbd_err(connection, "kmalloc of right_response failed\n"); 5367b10d96cbSJohannes Thoma rv = -1; 5368b411b363SPhilipp Reisner goto fail; 5369b411b363SPhilipp Reisner } 5370b411b363SPhilipp Reisner 53719534d671SHerbert Xu rv = crypto_shash_digest(desc, my_challenge, CHALLENGE_LEN, 53729534d671SHerbert Xu right_response); 5373b411b363SPhilipp Reisner if (rv) { 53741ec861ebSAndreas Gruenbacher drbd_err(connection, "crypto_hash_digest() failed with %d\n", rv); 5375b10d96cbSJohannes Thoma rv = -1; 5376b411b363SPhilipp Reisner goto fail; 5377b411b363SPhilipp Reisner } 5378b411b363SPhilipp Reisner 5379b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 5380b411b363SPhilipp Reisner 5381b411b363SPhilipp Reisner if (rv) 53821ec861ebSAndreas Gruenbacher drbd_info(connection, "Peer authenticated using %d bytes HMAC\n", 538344ed167dSPhilipp Reisner resp_size); 5384b10d96cbSJohannes Thoma else 5385b10d96cbSJohannes Thoma rv = -1; 5386b411b363SPhilipp Reisner 5387b411b363SPhilipp Reisner fail: 5388b411b363SPhilipp Reisner kfree(peers_ch); 5389b411b363SPhilipp Reisner kfree(response); 5390b411b363SPhilipp Reisner kfree(right_response); 53919534d671SHerbert Xu shash_desc_zero(desc); 5392b411b363SPhilipp Reisner 5393b411b363SPhilipp Reisner return rv; 5394b411b363SPhilipp Reisner } 5395b411b363SPhilipp Reisner #endif 5396b411b363SPhilipp Reisner 53978fe60551SAndreas Gruenbacher int drbd_receiver(struct drbd_thread *thi) 5398b411b363SPhilipp Reisner { 5399bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5400b411b363SPhilipp Reisner int h; 5401b411b363SPhilipp Reisner 54021ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver (re)started\n"); 5403b411b363SPhilipp Reisner 5404b411b363SPhilipp Reisner do { 5405bde89a9eSAndreas Gruenbacher h = conn_connect(connection); 5406b411b363SPhilipp Reisner if (h == 0) { 5407bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 540820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 5409b411b363SPhilipp Reisner } 5410b411b363SPhilipp Reisner if (h == -1) { 54111ec861ebSAndreas Gruenbacher drbd_warn(connection, "Discarding network configuration.\n"); 5412bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5413b411b363SPhilipp Reisner } 5414b411b363SPhilipp Reisner } while (h == 0); 5415b411b363SPhilipp Reisner 5416c51a0ef3SLars Ellenberg if (h > 0) { 5417c51a0ef3SLars Ellenberg blk_start_plug(&connection->receiver_plug); 5418bde89a9eSAndreas Gruenbacher drbdd(connection); 5419c51a0ef3SLars Ellenberg blk_finish_plug(&connection->receiver_plug); 5420c51a0ef3SLars Ellenberg } 5421b411b363SPhilipp Reisner 5422bde89a9eSAndreas Gruenbacher conn_disconnect(connection); 5423b411b363SPhilipp Reisner 54241ec861ebSAndreas Gruenbacher drbd_info(connection, "receiver terminated\n"); 5425b411b363SPhilipp Reisner return 0; 5426b411b363SPhilipp Reisner } 5427b411b363SPhilipp Reisner 5428b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 5429b411b363SPhilipp Reisner 5430bde89a9eSAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5431b411b363SPhilipp Reisner { 5432e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5433b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5434b411b363SPhilipp Reisner 5435b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 5436bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_OKAY, &connection->flags); 5437b411b363SPhilipp Reisner } else { 5438bde89a9eSAndreas Gruenbacher set_bit(CONN_WD_ST_CHG_FAIL, &connection->flags); 54391ec861ebSAndreas Gruenbacher drbd_err(connection, "Requested state change failed by peer: %s (%d)\n", 5440fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5441fc3b10a4SPhilipp Reisner } 5442bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5443e4f78edeSPhilipp Reisner 54442735a594SAndreas Gruenbacher return 0; 5445fc3b10a4SPhilipp Reisner } 5446e4f78edeSPhilipp Reisner 5447bde89a9eSAndreas Gruenbacher static int got_RqSReply(struct drbd_connection *connection, struct packet_info *pi) 5448e4f78edeSPhilipp Reisner { 54499f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5450b30ab791SAndreas Gruenbacher struct drbd_device *device; 5451e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 5452e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 5453e4f78edeSPhilipp Reisner 54549f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 54559f4fe9adSAndreas Gruenbacher if (!peer_device) 54562735a594SAndreas Gruenbacher return -EIO; 54579f4fe9adSAndreas Gruenbacher device = peer_device->device; 54581952e916SAndreas Gruenbacher 5459bde89a9eSAndreas Gruenbacher if (test_bit(CONN_WD_ST_CHG_REQ, &connection->flags)) { 54600b0ba1efSAndreas Gruenbacher D_ASSERT(device, connection->agreed_pro_version < 100); 5461bde89a9eSAndreas Gruenbacher return got_conn_RqSReply(connection, pi); 54624d0fc3fdSPhilipp Reisner } 54634d0fc3fdSPhilipp Reisner 5464e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 5465b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_SUCCESS, &device->flags); 5466e4f78edeSPhilipp Reisner } else { 5467b30ab791SAndreas Gruenbacher set_bit(CL_ST_CHG_FAIL, &device->flags); 5468d0180171SAndreas Gruenbacher drbd_err(device, "Requested state change failed by peer: %s (%d)\n", 5469b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 5470b411b363SPhilipp Reisner } 5471b30ab791SAndreas Gruenbacher wake_up(&device->state_wait); 5472b411b363SPhilipp Reisner 54732735a594SAndreas Gruenbacher return 0; 5474b411b363SPhilipp Reisner } 5475b411b363SPhilipp Reisner 5476bde89a9eSAndreas Gruenbacher static int got_Ping(struct drbd_connection *connection, struct packet_info *pi) 5477b411b363SPhilipp Reisner { 5478bde89a9eSAndreas Gruenbacher return drbd_send_ping_ack(connection); 5479b411b363SPhilipp Reisner 5480b411b363SPhilipp Reisner } 5481b411b363SPhilipp Reisner 5482bde89a9eSAndreas Gruenbacher static int got_PingAck(struct drbd_connection *connection, struct packet_info *pi) 5483b411b363SPhilipp Reisner { 5484b411b363SPhilipp Reisner /* restore idle timeout */ 5485bde89a9eSAndreas Gruenbacher connection->meta.socket->sk->sk_rcvtimeo = connection->net_conf->ping_int*HZ; 5486bde89a9eSAndreas Gruenbacher if (!test_and_set_bit(GOT_PING_ACK, &connection->flags)) 5487bde89a9eSAndreas Gruenbacher wake_up(&connection->ping_wait); 5488b411b363SPhilipp Reisner 54892735a594SAndreas Gruenbacher return 0; 5490b411b363SPhilipp Reisner } 5491b411b363SPhilipp Reisner 5492bde89a9eSAndreas Gruenbacher static int got_IsInSync(struct drbd_connection *connection, struct packet_info *pi) 5493b411b363SPhilipp Reisner { 54949f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5495b30ab791SAndreas Gruenbacher struct drbd_device *device; 5496e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5497b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5498b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5499b411b363SPhilipp Reisner 55009f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55019f4fe9adSAndreas Gruenbacher if (!peer_device) 55022735a594SAndreas Gruenbacher return -EIO; 55039f4fe9adSAndreas Gruenbacher device = peer_device->device; 55041952e916SAndreas Gruenbacher 55059f4fe9adSAndreas Gruenbacher D_ASSERT(device, peer_device->connection->agreed_pro_version >= 89); 5506b411b363SPhilipp Reisner 550769a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5508b411b363SPhilipp Reisner 5509b30ab791SAndreas Gruenbacher if (get_ldev(device)) { 5510b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5511b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5512b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 5513b30ab791SAndreas Gruenbacher device->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 5514b30ab791SAndreas Gruenbacher put_ldev(device); 55151d53f09eSLars Ellenberg } 5516b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5517b30ab791SAndreas Gruenbacher atomic_add(blksize >> 9, &device->rs_sect_in); 5518b411b363SPhilipp Reisner 55192735a594SAndreas Gruenbacher return 0; 5520b411b363SPhilipp Reisner } 5521b411b363SPhilipp Reisner 5522bc9c5c41SAndreas Gruenbacher static int 5523b30ab791SAndreas Gruenbacher validate_req_change_req_state(struct drbd_device *device, u64 id, sector_t sector, 5524bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 5525bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 5526b411b363SPhilipp Reisner { 5527b411b363SPhilipp Reisner struct drbd_request *req; 5528b411b363SPhilipp Reisner struct bio_and_error m; 5529b411b363SPhilipp Reisner 55300500813fSAndreas Gruenbacher spin_lock_irq(&device->resource->req_lock); 5531b30ab791SAndreas Gruenbacher req = find_request(device, root, id, sector, missing_ok, func); 5532b411b363SPhilipp Reisner if (unlikely(!req)) { 55330500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 553485997675SAndreas Gruenbacher return -EIO; 5535b411b363SPhilipp Reisner } 5536b411b363SPhilipp Reisner __req_mod(req, what, &m); 55370500813fSAndreas Gruenbacher spin_unlock_irq(&device->resource->req_lock); 5538b411b363SPhilipp Reisner 5539b411b363SPhilipp Reisner if (m.bio) 5540b30ab791SAndreas Gruenbacher complete_master_bio(device, &m); 554185997675SAndreas Gruenbacher return 0; 5542b411b363SPhilipp Reisner } 5543b411b363SPhilipp Reisner 5544bde89a9eSAndreas Gruenbacher static int got_BlockAck(struct drbd_connection *connection, struct packet_info *pi) 5545b411b363SPhilipp Reisner { 55469f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5547b30ab791SAndreas Gruenbacher struct drbd_device *device; 5548e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5549b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5550b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 5551b411b363SPhilipp Reisner enum drbd_req_event what; 5552b411b363SPhilipp Reisner 55539f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 55549f4fe9adSAndreas Gruenbacher if (!peer_device) 55552735a594SAndreas Gruenbacher return -EIO; 55569f4fe9adSAndreas Gruenbacher device = peer_device->device; 55571952e916SAndreas Gruenbacher 555869a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5559b411b363SPhilipp Reisner 5560579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5561b30ab791SAndreas Gruenbacher drbd_set_in_sync(device, sector, blksize); 5562b30ab791SAndreas Gruenbacher dec_rs_pending(device); 55632735a594SAndreas Gruenbacher return 0; 5564b411b363SPhilipp Reisner } 5565e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5566b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 55678554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 5568b411b363SPhilipp Reisner break; 5569b411b363SPhilipp Reisner case P_WRITE_ACK: 55708554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 5571b411b363SPhilipp Reisner break; 5572b411b363SPhilipp Reisner case P_RECV_ACK: 55738554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 5574b411b363SPhilipp Reisner break; 5575d4dabbe2SLars Ellenberg case P_SUPERSEDED: 5576d4dabbe2SLars Ellenberg what = CONFLICT_RESOLVED; 55777be8da07SAndreas Gruenbacher break; 55787be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 55797be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 5580b411b363SPhilipp Reisner break; 5581b411b363SPhilipp Reisner default: 55822735a594SAndreas Gruenbacher BUG(); 5583b411b363SPhilipp Reisner } 5584b411b363SPhilipp Reisner 5585b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5586b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5587bc9c5c41SAndreas Gruenbacher what, false); 5588b411b363SPhilipp Reisner } 5589b411b363SPhilipp Reisner 5590bde89a9eSAndreas Gruenbacher static int got_NegAck(struct drbd_connection *connection, struct packet_info *pi) 5591b411b363SPhilipp Reisner { 55929f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5593b30ab791SAndreas Gruenbacher struct drbd_device *device; 5594e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5595b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 55962deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 559785997675SAndreas Gruenbacher int err; 5598b411b363SPhilipp Reisner 55999f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56009f4fe9adSAndreas Gruenbacher if (!peer_device) 56012735a594SAndreas Gruenbacher return -EIO; 56029f4fe9adSAndreas Gruenbacher device = peer_device->device; 5603b411b363SPhilipp Reisner 560469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5605b411b363SPhilipp Reisner 5606579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 5607b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5608b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 56092735a594SAndreas Gruenbacher return 0; 5610b411b363SPhilipp Reisner } 56112deb8336SPhilipp Reisner 5612b30ab791SAndreas Gruenbacher err = validate_req_change_req_state(device, p->block_id, sector, 5613b30ab791SAndreas Gruenbacher &device->write_requests, __func__, 5614303d1448SPhilipp Reisner NEG_ACKED, true); 561585997675SAndreas Gruenbacher if (err) { 56162deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 56172deb8336SPhilipp Reisner The master bio might already be completed, therefore the 5618c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 56192deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 56202deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 5621b30ab791SAndreas Gruenbacher drbd_set_out_of_sync(device, sector, size); 56222deb8336SPhilipp Reisner } 56232735a594SAndreas Gruenbacher return 0; 5624b411b363SPhilipp Reisner } 5625b411b363SPhilipp Reisner 5626bde89a9eSAndreas Gruenbacher static int got_NegDReply(struct drbd_connection *connection, struct packet_info *pi) 5627b411b363SPhilipp Reisner { 56289f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5629b30ab791SAndreas Gruenbacher struct drbd_device *device; 5630e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5631b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 5632b411b363SPhilipp Reisner 56339f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56349f4fe9adSAndreas Gruenbacher if (!peer_device) 56352735a594SAndreas Gruenbacher return -EIO; 56369f4fe9adSAndreas Gruenbacher device = peer_device->device; 56371952e916SAndreas Gruenbacher 563869a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 56397be8da07SAndreas Gruenbacher 5640d0180171SAndreas Gruenbacher drbd_err(device, "Got NegDReply; Sector %llus, len %u.\n", 5641b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5642b411b363SPhilipp Reisner 5643b30ab791SAndreas Gruenbacher return validate_req_change_req_state(device, p->block_id, sector, 5644b30ab791SAndreas Gruenbacher &device->read_requests, __func__, 56458554df1cSAndreas Gruenbacher NEG_ACKED, false); 5646b411b363SPhilipp Reisner } 5647b411b363SPhilipp Reisner 5648bde89a9eSAndreas Gruenbacher static int got_NegRSDReply(struct drbd_connection *connection, struct packet_info *pi) 5649b411b363SPhilipp Reisner { 56509f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5651b30ab791SAndreas Gruenbacher struct drbd_device *device; 5652b411b363SPhilipp Reisner sector_t sector; 5653b411b363SPhilipp Reisner int size; 5654e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 56551952e916SAndreas Gruenbacher 56569f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 56579f4fe9adSAndreas Gruenbacher if (!peer_device) 56582735a594SAndreas Gruenbacher return -EIO; 56599f4fe9adSAndreas Gruenbacher device = peer_device->device; 5660b411b363SPhilipp Reisner 5661b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5662b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5663b411b363SPhilipp Reisner 566469a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5665b411b363SPhilipp Reisner 5666b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5667b411b363SPhilipp Reisner 5668b30ab791SAndreas Gruenbacher if (get_ldev_if_state(device, D_FAILED)) { 5669b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5670e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5671d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5672b30ab791SAndreas Gruenbacher drbd_rs_failed_io(device, sector, size); 5673d612d309SPhilipp Reisner case P_RS_CANCEL: 5674d612d309SPhilipp Reisner break; 5675d612d309SPhilipp Reisner default: 56762735a594SAndreas Gruenbacher BUG(); 5677d612d309SPhilipp Reisner } 5678b30ab791SAndreas Gruenbacher put_ldev(device); 5679b411b363SPhilipp Reisner } 5680b411b363SPhilipp Reisner 56812735a594SAndreas Gruenbacher return 0; 5682b411b363SPhilipp Reisner } 5683b411b363SPhilipp Reisner 5684bde89a9eSAndreas Gruenbacher static int got_BarrierAck(struct drbd_connection *connection, struct packet_info *pi) 5685b411b363SPhilipp Reisner { 5686e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 5687c06ece6bSAndreas Gruenbacher struct drbd_peer_device *peer_device; 56889ed57dcbSLars Ellenberg int vnr; 5689b411b363SPhilipp Reisner 5690bde89a9eSAndreas Gruenbacher tl_release(connection, p->barrier, be32_to_cpu(p->set_size)); 5691b411b363SPhilipp Reisner 56929ed57dcbSLars Ellenberg rcu_read_lock(); 5693c06ece6bSAndreas Gruenbacher idr_for_each_entry(&connection->peer_devices, peer_device, vnr) { 5694c06ece6bSAndreas Gruenbacher struct drbd_device *device = peer_device->device; 5695c06ece6bSAndreas Gruenbacher 5696b30ab791SAndreas Gruenbacher if (device->state.conn == C_AHEAD && 5697b30ab791SAndreas Gruenbacher atomic_read(&device->ap_in_flight) == 0 && 5698b30ab791SAndreas Gruenbacher !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &device->flags)) { 5699b30ab791SAndreas Gruenbacher device->start_resync_timer.expires = jiffies + HZ; 5700b30ab791SAndreas Gruenbacher add_timer(&device->start_resync_timer); 5701c4752ef1SPhilipp Reisner } 57029ed57dcbSLars Ellenberg } 57039ed57dcbSLars Ellenberg rcu_read_unlock(); 5704c4752ef1SPhilipp Reisner 57052735a594SAndreas Gruenbacher return 0; 5706b411b363SPhilipp Reisner } 5707b411b363SPhilipp Reisner 5708bde89a9eSAndreas Gruenbacher static int got_OVResult(struct drbd_connection *connection, struct packet_info *pi) 5709b411b363SPhilipp Reisner { 57109f4fe9adSAndreas Gruenbacher struct drbd_peer_device *peer_device; 5711b30ab791SAndreas Gruenbacher struct drbd_device *device; 5712e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 571384b8c06bSAndreas Gruenbacher struct drbd_device_work *dw; 5714b411b363SPhilipp Reisner sector_t sector; 5715b411b363SPhilipp Reisner int size; 5716b411b363SPhilipp Reisner 57179f4fe9adSAndreas Gruenbacher peer_device = conn_peer_device(connection, pi->vnr); 57189f4fe9adSAndreas Gruenbacher if (!peer_device) 57192735a594SAndreas Gruenbacher return -EIO; 57209f4fe9adSAndreas Gruenbacher device = peer_device->device; 57211952e916SAndreas Gruenbacher 5722b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5723b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5724b411b363SPhilipp Reisner 572569a22773SAndreas Gruenbacher update_peer_seq(peer_device, be32_to_cpu(p->seq_num)); 5726b411b363SPhilipp Reisner 5727b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 5728b30ab791SAndreas Gruenbacher drbd_ov_out_of_sync_found(device, sector, size); 5729b411b363SPhilipp Reisner else 5730b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5731b411b363SPhilipp Reisner 5732b30ab791SAndreas Gruenbacher if (!get_ldev(device)) 57332735a594SAndreas Gruenbacher return 0; 57341d53f09eSLars Ellenberg 5735b30ab791SAndreas Gruenbacher drbd_rs_complete_io(device, sector); 5736b30ab791SAndreas Gruenbacher dec_rs_pending(device); 5737b411b363SPhilipp Reisner 5738b30ab791SAndreas Gruenbacher --device->ov_left; 5739ea5442afSLars Ellenberg 5740ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5741b30ab791SAndreas Gruenbacher if ((device->ov_left & 0x200) == 0x200) 5742b30ab791SAndreas Gruenbacher drbd_advance_rs_marks(device, device->ov_left); 5743ea5442afSLars Ellenberg 5744b30ab791SAndreas Gruenbacher if (device->ov_left == 0) { 574584b8c06bSAndreas Gruenbacher dw = kmalloc(sizeof(*dw), GFP_NOIO); 574684b8c06bSAndreas Gruenbacher if (dw) { 574784b8c06bSAndreas Gruenbacher dw->w.cb = w_ov_finished; 574884b8c06bSAndreas Gruenbacher dw->device = device; 574984b8c06bSAndreas Gruenbacher drbd_queue_work(&peer_device->connection->sender_work, &dw->w); 5750b411b363SPhilipp Reisner } else { 575184b8c06bSAndreas Gruenbacher drbd_err(device, "kmalloc(dw) failed."); 5752b30ab791SAndreas Gruenbacher ov_out_of_sync_print(device); 5753b30ab791SAndreas Gruenbacher drbd_resync_finished(device); 5754b411b363SPhilipp Reisner } 5755b411b363SPhilipp Reisner } 5756b30ab791SAndreas Gruenbacher put_ldev(device); 57572735a594SAndreas Gruenbacher return 0; 5758b411b363SPhilipp Reisner } 5759b411b363SPhilipp Reisner 5760bde89a9eSAndreas Gruenbacher static int got_skip(struct drbd_connection *connection, struct packet_info *pi) 57610ced55a3SPhilipp Reisner { 57622735a594SAndreas Gruenbacher return 0; 57630ced55a3SPhilipp Reisner } 57640ced55a3SPhilipp Reisner 5765668700b4SPhilipp Reisner struct meta_sock_cmd { 5766b411b363SPhilipp Reisner size_t pkt_size; 5767bde89a9eSAndreas Gruenbacher int (*fn)(struct drbd_connection *connection, struct packet_info *); 5768b411b363SPhilipp Reisner }; 5769b411b363SPhilipp Reisner 5770668700b4SPhilipp Reisner static void set_rcvtimeo(struct drbd_connection *connection, bool ping_timeout) 5771668700b4SPhilipp Reisner { 5772668700b4SPhilipp Reisner long t; 5773668700b4SPhilipp Reisner struct net_conf *nc; 5774668700b4SPhilipp Reisner 5775668700b4SPhilipp Reisner rcu_read_lock(); 5776668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 5777668700b4SPhilipp Reisner t = ping_timeout ? nc->ping_timeo : nc->ping_int; 5778668700b4SPhilipp Reisner rcu_read_unlock(); 5779668700b4SPhilipp Reisner 5780668700b4SPhilipp Reisner t *= HZ; 5781668700b4SPhilipp Reisner if (ping_timeout) 5782668700b4SPhilipp Reisner t /= 10; 5783668700b4SPhilipp Reisner 5784668700b4SPhilipp Reisner connection->meta.socket->sk->sk_rcvtimeo = t; 5785668700b4SPhilipp Reisner } 5786668700b4SPhilipp Reisner 5787668700b4SPhilipp Reisner static void set_ping_timeout(struct drbd_connection *connection) 5788668700b4SPhilipp Reisner { 5789668700b4SPhilipp Reisner set_rcvtimeo(connection, 1); 5790668700b4SPhilipp Reisner } 5791668700b4SPhilipp Reisner 5792668700b4SPhilipp Reisner static void set_idle_timeout(struct drbd_connection *connection) 5793668700b4SPhilipp Reisner { 5794668700b4SPhilipp Reisner set_rcvtimeo(connection, 0); 5795668700b4SPhilipp Reisner } 5796668700b4SPhilipp Reisner 5797668700b4SPhilipp Reisner static struct meta_sock_cmd ack_receiver_tbl[] = { 5798e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5799e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 5800b411b363SPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5801b411b363SPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5802b411b363SPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 5803d4dabbe2SLars Ellenberg [P_SUPERSEDED] = { sizeof(struct p_block_ack), got_BlockAck }, 5804b411b363SPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 5805b411b363SPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 5806b411b363SPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 5807b411b363SPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 5808b411b363SPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 5809b411b363SPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 5810b411b363SPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 581102918be2SPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 5812d612d309SPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 58131952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 58141952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 5815b411b363SPhilipp Reisner }; 5816b411b363SPhilipp Reisner 58171c03e520SPhilipp Reisner int drbd_ack_receiver(struct drbd_thread *thi) 5818b411b363SPhilipp Reisner { 5819bde89a9eSAndreas Gruenbacher struct drbd_connection *connection = thi->connection; 5820668700b4SPhilipp Reisner struct meta_sock_cmd *cmd = NULL; 582177351055SPhilipp Reisner struct packet_info pi; 5822668700b4SPhilipp Reisner unsigned long pre_recv_jif; 5823257d0af6SPhilipp Reisner int rv; 5824bde89a9eSAndreas Gruenbacher void *buf = connection->meta.rbuf; 5825b411b363SPhilipp Reisner int received = 0; 5826bde89a9eSAndreas Gruenbacher unsigned int header_size = drbd_header_size(connection); 582752b061a4SAndreas Gruenbacher int expect = header_size; 582844ed167dSPhilipp Reisner bool ping_timeout_active = false; 58293990e04dSPhilipp Reisner struct sched_param param = { .sched_priority = 2 }; 5830b411b363SPhilipp Reisner 58313990e04dSPhilipp Reisner rv = sched_setscheduler(current, SCHED_RR, ¶m); 58323990e04dSPhilipp Reisner if (rv < 0) 5833668700b4SPhilipp Reisner drbd_err(connection, "drbd_ack_receiver: ERROR set priority, ret=%d\n", rv); 5834b411b363SPhilipp Reisner 5835e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 583680822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 583744ed167dSPhilipp Reisner 5838668700b4SPhilipp Reisner conn_reclaim_net_peer_reqs(connection); 583944ed167dSPhilipp Reisner 5840bde89a9eSAndreas Gruenbacher if (test_and_clear_bit(SEND_PING, &connection->flags)) { 5841bde89a9eSAndreas Gruenbacher if (drbd_send_ping(connection)) { 58421ec861ebSAndreas Gruenbacher drbd_err(connection, "drbd_send_ping has failed\n"); 5843841ce241SAndreas Gruenbacher goto reconnect; 5844841ce241SAndreas Gruenbacher } 5845668700b4SPhilipp Reisner set_ping_timeout(connection); 584644ed167dSPhilipp Reisner ping_timeout_active = true; 5847b411b363SPhilipp Reisner } 5848b411b363SPhilipp Reisner 5849668700b4SPhilipp Reisner pre_recv_jif = jiffies; 5850bde89a9eSAndreas Gruenbacher rv = drbd_recv_short(connection->meta.socket, buf, expect-received, 0); 5851b411b363SPhilipp Reisner 5852b411b363SPhilipp Reisner /* Note: 5853b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5854b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5855b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5856b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5857b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5858b411b363SPhilipp Reisner * rv == expected: full header or command 5859b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5860b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5861b411b363SPhilipp Reisner */ 5862b411b363SPhilipp Reisner if (likely(rv > 0)) { 5863b411b363SPhilipp Reisner received += rv; 5864b411b363SPhilipp Reisner buf += rv; 5865b411b363SPhilipp Reisner } else if (rv == 0) { 5866bde89a9eSAndreas Gruenbacher if (test_bit(DISCONNECT_SENT, &connection->flags)) { 5867b66623e3SPhilipp Reisner long t; 5868b66623e3SPhilipp Reisner rcu_read_lock(); 5869bde89a9eSAndreas Gruenbacher t = rcu_dereference(connection->net_conf)->ping_timeo * HZ/10; 5870b66623e3SPhilipp Reisner rcu_read_unlock(); 5871b66623e3SPhilipp Reisner 5872bde89a9eSAndreas Gruenbacher t = wait_event_timeout(connection->ping_wait, 5873bde89a9eSAndreas Gruenbacher connection->cstate < C_WF_REPORT_PARAMS, 5874b66623e3SPhilipp Reisner t); 5875599377acSPhilipp Reisner if (t) 5876599377acSPhilipp Reisner break; 5877599377acSPhilipp Reisner } 58781ec861ebSAndreas Gruenbacher drbd_err(connection, "meta connection shut down by peer.\n"); 5879b411b363SPhilipp Reisner goto reconnect; 5880b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5881cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5882cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 5883668700b4SPhilipp Reisner if (time_after(connection->last_received, pre_recv_jif)) 5884cb6518cbSLars Ellenberg continue; 5885f36af18cSLars Ellenberg if (ping_timeout_active) { 58861ec861ebSAndreas Gruenbacher drbd_err(connection, "PingAck did not arrive in time.\n"); 5887b411b363SPhilipp Reisner goto reconnect; 5888b411b363SPhilipp Reisner } 5889bde89a9eSAndreas Gruenbacher set_bit(SEND_PING, &connection->flags); 5890b411b363SPhilipp Reisner continue; 5891b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5892668700b4SPhilipp Reisner /* maybe drbd_thread_stop(): the while condition will notice. 5893668700b4SPhilipp Reisner * maybe woken for send_ping: we'll send a ping above, 5894668700b4SPhilipp Reisner * and change the rcvtimeo */ 5895668700b4SPhilipp Reisner flush_signals(current); 5896b411b363SPhilipp Reisner continue; 5897b411b363SPhilipp Reisner } else { 58981ec861ebSAndreas Gruenbacher drbd_err(connection, "sock_recvmsg returned %d\n", rv); 5899b411b363SPhilipp Reisner goto reconnect; 5900b411b363SPhilipp Reisner } 5901b411b363SPhilipp Reisner 5902b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5903bde89a9eSAndreas Gruenbacher if (decode_header(connection, connection->meta.rbuf, &pi)) 5904b411b363SPhilipp Reisner goto reconnect; 5905668700b4SPhilipp Reisner cmd = &ack_receiver_tbl[pi.cmd]; 5906668700b4SPhilipp Reisner if (pi.cmd >= ARRAY_SIZE(ack_receiver_tbl) || !cmd->fn) { 59071ec861ebSAndreas Gruenbacher drbd_err(connection, "Unexpected meta packet %s (0x%04x)\n", 59082fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5909b411b363SPhilipp Reisner goto disconnect; 5910b411b363SPhilipp Reisner } 5911e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 591252b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 59131ec861ebSAndreas Gruenbacher drbd_err(connection, "Wrong packet size on meta (c: %d, l: %d)\n", 591477351055SPhilipp Reisner pi.cmd, pi.size); 5915b411b363SPhilipp Reisner goto reconnect; 5916b411b363SPhilipp Reisner } 5917257d0af6SPhilipp Reisner } 5918b411b363SPhilipp Reisner if (received == expect) { 59192735a594SAndreas Gruenbacher bool err; 5920a4fbda8eSPhilipp Reisner 5921bde89a9eSAndreas Gruenbacher err = cmd->fn(connection, &pi); 59222735a594SAndreas Gruenbacher if (err) { 59231ec861ebSAndreas Gruenbacher drbd_err(connection, "%pf failed\n", cmd->fn); 5924b411b363SPhilipp Reisner goto reconnect; 59251952e916SAndreas Gruenbacher } 5926b411b363SPhilipp Reisner 5927bde89a9eSAndreas Gruenbacher connection->last_received = jiffies; 5928f36af18cSLars Ellenberg 5929668700b4SPhilipp Reisner if (cmd == &ack_receiver_tbl[P_PING_ACK]) { 5930668700b4SPhilipp Reisner set_idle_timeout(connection); 593144ed167dSPhilipp Reisner ping_timeout_active = false; 593244ed167dSPhilipp Reisner } 5933b411b363SPhilipp Reisner 5934bde89a9eSAndreas Gruenbacher buf = connection->meta.rbuf; 5935b411b363SPhilipp Reisner received = 0; 593652b061a4SAndreas Gruenbacher expect = header_size; 5937b411b363SPhilipp Reisner cmd = NULL; 5938b411b363SPhilipp Reisner } 5939b411b363SPhilipp Reisner } 5940b411b363SPhilipp Reisner 5941b411b363SPhilipp Reisner if (0) { 5942b411b363SPhilipp Reisner reconnect: 5943bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5944bde89a9eSAndreas Gruenbacher conn_md_sync(connection); 5945b411b363SPhilipp Reisner } 5946b411b363SPhilipp Reisner if (0) { 5947b411b363SPhilipp Reisner disconnect: 5948bde89a9eSAndreas Gruenbacher conn_request_state(connection, NS(conn, C_DISCONNECTING), CS_HARD); 5949b411b363SPhilipp Reisner } 5950b411b363SPhilipp Reisner 5951668700b4SPhilipp Reisner drbd_info(connection, "ack_receiver terminated\n"); 5952b411b363SPhilipp Reisner 5953b411b363SPhilipp Reisner return 0; 5954b411b363SPhilipp Reisner } 5955668700b4SPhilipp Reisner 5956668700b4SPhilipp Reisner void drbd_send_acks_wf(struct work_struct *ws) 5957668700b4SPhilipp Reisner { 5958668700b4SPhilipp Reisner struct drbd_peer_device *peer_device = 5959668700b4SPhilipp Reisner container_of(ws, struct drbd_peer_device, send_acks_work); 5960668700b4SPhilipp Reisner struct drbd_connection *connection = peer_device->connection; 5961668700b4SPhilipp Reisner struct drbd_device *device = peer_device->device; 5962668700b4SPhilipp Reisner struct net_conf *nc; 5963668700b4SPhilipp Reisner int tcp_cork, err; 5964668700b4SPhilipp Reisner 5965668700b4SPhilipp Reisner rcu_read_lock(); 5966668700b4SPhilipp Reisner nc = rcu_dereference(connection->net_conf); 5967668700b4SPhilipp Reisner tcp_cork = nc->tcp_cork; 5968668700b4SPhilipp Reisner rcu_read_unlock(); 5969668700b4SPhilipp Reisner 5970668700b4SPhilipp Reisner if (tcp_cork) 5971668700b4SPhilipp Reisner drbd_tcp_cork(connection->meta.socket); 5972668700b4SPhilipp Reisner 5973668700b4SPhilipp Reisner err = drbd_finish_peer_reqs(device); 5974668700b4SPhilipp Reisner kref_put(&device->kref, drbd_destroy_device); 5975668700b4SPhilipp Reisner /* get is in drbd_endio_write_sec_final(). That is necessary to keep the 5976668700b4SPhilipp Reisner struct work_struct send_acks_work alive, which is in the peer_device object */ 5977668700b4SPhilipp Reisner 5978668700b4SPhilipp Reisner if (err) { 5979668700b4SPhilipp Reisner conn_request_state(connection, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5980668700b4SPhilipp Reisner return; 5981668700b4SPhilipp Reisner } 5982668700b4SPhilipp Reisner 5983668700b4SPhilipp Reisner if (tcp_cork) 5984668700b4SPhilipp Reisner drbd_tcp_uncork(connection->meta.socket); 5985668700b4SPhilipp Reisner 5986668700b4SPhilipp Reisner return; 5987668700b4SPhilipp Reisner } 5988