1b411b363SPhilipp Reisner /* 2b411b363SPhilipp Reisner drbd_receiver.c 3b411b363SPhilipp Reisner 4b411b363SPhilipp Reisner This file is part of DRBD by Philipp Reisner and Lars Ellenberg. 5b411b363SPhilipp Reisner 6b411b363SPhilipp Reisner Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. 7b411b363SPhilipp Reisner Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>. 8b411b363SPhilipp Reisner Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>. 9b411b363SPhilipp Reisner 10b411b363SPhilipp Reisner drbd is free software; you can redistribute it and/or modify 11b411b363SPhilipp Reisner it under the terms of the GNU General Public License as published by 12b411b363SPhilipp Reisner the Free Software Foundation; either version 2, or (at your option) 13b411b363SPhilipp Reisner any later version. 14b411b363SPhilipp Reisner 15b411b363SPhilipp Reisner drbd is distributed in the hope that it will be useful, 16b411b363SPhilipp Reisner but WITHOUT ANY WARRANTY; without even the implied warranty of 17b411b363SPhilipp Reisner MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18b411b363SPhilipp Reisner GNU General Public License for more details. 19b411b363SPhilipp Reisner 20b411b363SPhilipp Reisner You should have received a copy of the GNU General Public License 21b411b363SPhilipp Reisner along with drbd; see the file COPYING. If not, write to 22b411b363SPhilipp Reisner the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 23b411b363SPhilipp Reisner */ 24b411b363SPhilipp Reisner 25b411b363SPhilipp Reisner 26b411b363SPhilipp Reisner #include <linux/module.h> 27b411b363SPhilipp Reisner 28b411b363SPhilipp Reisner #include <asm/uaccess.h> 29b411b363SPhilipp Reisner #include <net/sock.h> 30b411b363SPhilipp Reisner 31b411b363SPhilipp Reisner #include <linux/drbd.h> 32b411b363SPhilipp Reisner #include <linux/fs.h> 33b411b363SPhilipp Reisner #include <linux/file.h> 34b411b363SPhilipp Reisner #include <linux/in.h> 35b411b363SPhilipp Reisner #include <linux/mm.h> 36b411b363SPhilipp Reisner #include <linux/memcontrol.h> 37b411b363SPhilipp Reisner #include <linux/mm_inline.h> 38b411b363SPhilipp Reisner #include <linux/slab.h> 39b411b363SPhilipp Reisner #include <linux/pkt_sched.h> 40b411b363SPhilipp Reisner #define __KERNEL_SYSCALLS__ 41b411b363SPhilipp Reisner #include <linux/unistd.h> 42b411b363SPhilipp Reisner #include <linux/vmalloc.h> 43b411b363SPhilipp Reisner #include <linux/random.h> 44b411b363SPhilipp Reisner #include <linux/string.h> 45b411b363SPhilipp Reisner #include <linux/scatterlist.h> 46b411b363SPhilipp Reisner #include "drbd_int.h" 47b411b363SPhilipp Reisner #include "drbd_req.h" 48b411b363SPhilipp Reisner 49b411b363SPhilipp Reisner #include "drbd_vli.h" 50b411b363SPhilipp Reisner 5177351055SPhilipp Reisner struct packet_info { 5277351055SPhilipp Reisner enum drbd_packet cmd; 53e2857216SAndreas Gruenbacher unsigned int size; 54e2857216SAndreas Gruenbacher unsigned int vnr; 55e658983aSAndreas Gruenbacher void *data; 5677351055SPhilipp Reisner }; 5777351055SPhilipp Reisner 58b411b363SPhilipp Reisner enum finish_epoch { 59b411b363SPhilipp Reisner FE_STILL_LIVE, 60b411b363SPhilipp Reisner FE_DESTROYED, 61b411b363SPhilipp Reisner FE_RECYCLED, 62b411b363SPhilipp Reisner }; 63b411b363SPhilipp Reisner 646038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn); 6513e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 66c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev); 67b411b363SPhilipp Reisner 68b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 6999920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 73b411b363SPhilipp Reisner 7445bb912bSLars Ellenberg /* 7545bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7645bb912bSLars Ellenberg * page->private being our "next" pointer. 7745bb912bSLars Ellenberg */ 7845bb912bSLars Ellenberg 7945bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8045bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8145bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8245bb912bSLars Ellenberg */ 8345bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8445bb912bSLars Ellenberg { 8545bb912bSLars Ellenberg struct page *page; 8645bb912bSLars Ellenberg struct page *tmp; 8745bb912bSLars Ellenberg 8845bb912bSLars Ellenberg BUG_ON(!n); 8945bb912bSLars Ellenberg BUG_ON(!head); 9045bb912bSLars Ellenberg 9145bb912bSLars Ellenberg page = *head; 9223ce4227SPhilipp Reisner 9323ce4227SPhilipp Reisner if (!page) 9423ce4227SPhilipp Reisner return NULL; 9523ce4227SPhilipp Reisner 9645bb912bSLars Ellenberg while (page) { 9745bb912bSLars Ellenberg tmp = page_chain_next(page); 9845bb912bSLars Ellenberg if (--n == 0) 9945bb912bSLars Ellenberg break; /* found sufficient pages */ 10045bb912bSLars Ellenberg if (tmp == NULL) 10145bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10245bb912bSLars Ellenberg return NULL; 10345bb912bSLars Ellenberg page = tmp; 10445bb912bSLars Ellenberg } 10545bb912bSLars Ellenberg 10645bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10745bb912bSLars Ellenberg set_page_private(page, 0); 10845bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10945bb912bSLars Ellenberg page = *head; 11045bb912bSLars Ellenberg *head = tmp; 11145bb912bSLars Ellenberg return page; 11245bb912bSLars Ellenberg } 11345bb912bSLars Ellenberg 11445bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11545bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11645bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11745bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11845bb912bSLars Ellenberg { 11945bb912bSLars Ellenberg struct page *tmp; 12045bb912bSLars Ellenberg int i = 1; 12145bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12245bb912bSLars Ellenberg ++i, page = tmp; 12345bb912bSLars Ellenberg if (len) 12445bb912bSLars Ellenberg *len = i; 12545bb912bSLars Ellenberg return page; 12645bb912bSLars Ellenberg } 12745bb912bSLars Ellenberg 12845bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12945bb912bSLars Ellenberg { 13045bb912bSLars Ellenberg struct page *tmp; 13145bb912bSLars Ellenberg int i = 0; 13245bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13345bb912bSLars Ellenberg put_page(page); 13445bb912bSLars Ellenberg ++i; 13545bb912bSLars Ellenberg } 13645bb912bSLars Ellenberg return i; 13745bb912bSLars Ellenberg } 13845bb912bSLars Ellenberg 13945bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14045bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14145bb912bSLars Ellenberg { 14245bb912bSLars Ellenberg #if 1 14345bb912bSLars Ellenberg struct page *tmp; 14445bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14545bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14645bb912bSLars Ellenberg #endif 14745bb912bSLars Ellenberg 14845bb912bSLars Ellenberg /* add chain to head */ 14945bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15045bb912bSLars Ellenberg *head = chain_first; 15145bb912bSLars Ellenberg } 15245bb912bSLars Ellenberg 15318c2d522SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_conf *mdev, 15418c2d522SAndreas Gruenbacher unsigned int number) 155b411b363SPhilipp Reisner { 156b411b363SPhilipp Reisner struct page *page = NULL; 15745bb912bSLars Ellenberg struct page *tmp = NULL; 15818c2d522SAndreas Gruenbacher unsigned int i = 0; 159b411b363SPhilipp Reisner 160b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 161b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16245bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 163b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16445bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16545bb912bSLars Ellenberg if (page) 16645bb912bSLars Ellenberg drbd_pp_vacant -= number; 167b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16845bb912bSLars Ellenberg if (page) 16945bb912bSLars Ellenberg return page; 170b411b363SPhilipp Reisner } 17145bb912bSLars Ellenberg 172b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 173b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 174b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17545bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17645bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17745bb912bSLars Ellenberg if (!tmp) 17845bb912bSLars Ellenberg break; 17945bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18045bb912bSLars Ellenberg page = tmp; 18145bb912bSLars Ellenberg } 18245bb912bSLars Ellenberg 18345bb912bSLars Ellenberg if (i == number) 184b411b363SPhilipp Reisner return page; 18545bb912bSLars Ellenberg 18645bb912bSLars Ellenberg /* Not enough pages immediately available this time. 187c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 18845bb912bSLars Ellenberg * function "soon". */ 18945bb912bSLars Ellenberg if (page) { 19045bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19145bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19245bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19345bb912bSLars Ellenberg drbd_pp_vacant += i; 19445bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19545bb912bSLars Ellenberg } 19645bb912bSLars Ellenberg return NULL; 197b411b363SPhilipp Reisner } 198b411b363SPhilipp Reisner 199a990be46SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_conf *mdev, 200a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 201b411b363SPhilipp Reisner { 202db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 203b411b363SPhilipp Reisner struct list_head *le, *tle; 204b411b363SPhilipp Reisner 205b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 206b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 207b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 208b411b363SPhilipp Reisner stop to examine the list... */ 209b411b363SPhilipp Reisner 210b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 211db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 212045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 213b411b363SPhilipp Reisner break; 214b411b363SPhilipp Reisner list_move(le, to_be_freed); 215b411b363SPhilipp Reisner } 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner 218b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 219b411b363SPhilipp Reisner { 220b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 221db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 222b411b363SPhilipp Reisner 22387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 224a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 22587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 226b411b363SPhilipp Reisner 227db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 2283967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 229b411b363SPhilipp Reisner } 230b411b363SPhilipp Reisner 231b411b363SPhilipp Reisner /** 232c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 233b411b363SPhilipp Reisner * @mdev: DRBD device. 23445bb912bSLars Ellenberg * @number: number of pages requested 23545bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 236b411b363SPhilipp Reisner * 23745bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23845bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23945bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 24045bb912bSLars Ellenberg * 24145bb912bSLars Ellenberg * Returns a page chain linked via page->private. 242b411b363SPhilipp Reisner */ 243c37c8ecfSAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_conf *mdev, unsigned int number, 244c37c8ecfSAndreas Gruenbacher bool retry) 245b411b363SPhilipp Reisner { 246b411b363SPhilipp Reisner struct page *page = NULL; 24744ed167dSPhilipp Reisner struct net_conf *nc; 248b411b363SPhilipp Reisner DEFINE_WAIT(wait); 24944ed167dSPhilipp Reisner int mxb; 250b411b363SPhilipp Reisner 25145bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 25245bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25344ed167dSPhilipp Reisner rcu_read_lock(); 25444ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 25544ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 25644ed167dSPhilipp Reisner rcu_read_unlock(); 25744ed167dSPhilipp Reisner 25844ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) 25918c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 260b411b363SPhilipp Reisner 26145bb912bSLars Ellenberg while (page == NULL) { 262b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 263b411b363SPhilipp Reisner 264b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 265b411b363SPhilipp Reisner 26644ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) { 26718c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 268b411b363SPhilipp Reisner if (page) 269b411b363SPhilipp Reisner break; 270b411b363SPhilipp Reisner } 271b411b363SPhilipp Reisner 272b411b363SPhilipp Reisner if (!retry) 273b411b363SPhilipp Reisner break; 274b411b363SPhilipp Reisner 275b411b363SPhilipp Reisner if (signal_pending(current)) { 276c37c8ecfSAndreas Gruenbacher dev_warn(DEV, "drbd_alloc_pages interrupted!\n"); 277b411b363SPhilipp Reisner break; 278b411b363SPhilipp Reisner } 279b411b363SPhilipp Reisner 280b411b363SPhilipp Reisner schedule(); 281b411b363SPhilipp Reisner } 282b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 283b411b363SPhilipp Reisner 28445bb912bSLars Ellenberg if (page) 28545bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 286b411b363SPhilipp Reisner return page; 287b411b363SPhilipp Reisner } 288b411b363SPhilipp Reisner 289c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 29087eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 29145bb912bSLars Ellenberg * Either links the page chain back to the global pool, 29245bb912bSLars Ellenberg * or returns all pages to the system. */ 2935cc287e0SAndreas Gruenbacher static void drbd_free_pages(struct drbd_conf *mdev, struct page *page, int is_net) 294b411b363SPhilipp Reisner { 295435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 296b411b363SPhilipp Reisner int i; 297435f0740SLars Ellenberg 2981816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 29945bb912bSLars Ellenberg i = page_chain_free(page); 30045bb912bSLars Ellenberg else { 30145bb912bSLars Ellenberg struct page *tmp; 30245bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 303b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 30445bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 30545bb912bSLars Ellenberg drbd_pp_vacant += i; 306b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 307b411b363SPhilipp Reisner } 308435f0740SLars Ellenberg i = atomic_sub_return(i, a); 30945bb912bSLars Ellenberg if (i < 0) 310435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 311435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 312b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 313b411b363SPhilipp Reisner } 314b411b363SPhilipp Reisner 315b411b363SPhilipp Reisner /* 316b411b363SPhilipp Reisner You need to hold the req_lock: 317b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 318b411b363SPhilipp Reisner 319b411b363SPhilipp Reisner You must not have the req_lock: 3203967deb1SAndreas Gruenbacher drbd_free_peer_req() 3210db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3227721f567SAndreas Gruenbacher drbd_free_peer_reqs() 323b411b363SPhilipp Reisner drbd_ee_fix_bhs() 324a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 325b411b363SPhilipp Reisner drbd_clear_done_ee() 326b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 327b411b363SPhilipp Reisner */ 328b411b363SPhilipp Reisner 329f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 3300db55363SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector, 331f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 332b411b363SPhilipp Reisner { 333db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 334b411b363SPhilipp Reisner struct page *page; 33545bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 336b411b363SPhilipp Reisner 3370cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 338b411b363SPhilipp Reisner return NULL; 339b411b363SPhilipp Reisner 340db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 341db830c46SAndreas Gruenbacher if (!peer_req) { 342b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 3430db55363SAndreas Gruenbacher dev_err(DEV, "%s: allocation failed\n", __func__); 344b411b363SPhilipp Reisner return NULL; 345b411b363SPhilipp Reisner } 346b411b363SPhilipp Reisner 347c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 34845bb912bSLars Ellenberg if (!page) 34945bb912bSLars Ellenberg goto fail; 350b411b363SPhilipp Reisner 351db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 352db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 353db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 354db830c46SAndreas Gruenbacher peer_req->i.local = false; 355db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 35653840641SAndreas Gruenbacher 357db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 358a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 359db830c46SAndreas Gruenbacher peer_req->pages = page; 360db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 361db830c46SAndreas Gruenbacher peer_req->flags = 0; 3629a8e7753SAndreas Gruenbacher /* 3639a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3649a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3659a8e7753SAndreas Gruenbacher */ 366db830c46SAndreas Gruenbacher peer_req->block_id = id; 367b411b363SPhilipp Reisner 368db830c46SAndreas Gruenbacher return peer_req; 369b411b363SPhilipp Reisner 37045bb912bSLars Ellenberg fail: 371db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 372b411b363SPhilipp Reisner return NULL; 373b411b363SPhilipp Reisner } 374b411b363SPhilipp Reisner 3753967deb1SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 376f6ffca9fSAndreas Gruenbacher int is_net) 377b411b363SPhilipp Reisner { 378db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 379db830c46SAndreas Gruenbacher kfree(peer_req->digest); 3805cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, peer_req->pages, is_net); 381db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 382db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 383db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 384b411b363SPhilipp Reisner } 385b411b363SPhilipp Reisner 3867721f567SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_conf *mdev, struct list_head *list) 387b411b363SPhilipp Reisner { 388b411b363SPhilipp Reisner LIST_HEAD(work_list); 389db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 390b411b363SPhilipp Reisner int count = 0; 391435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 392b411b363SPhilipp Reisner 39387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 394b411b363SPhilipp Reisner list_splice_init(list, &work_list); 39587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 396b411b363SPhilipp Reisner 397db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 3983967deb1SAndreas Gruenbacher __drbd_free_peer_req(mdev, peer_req, is_net); 399b411b363SPhilipp Reisner count++; 400b411b363SPhilipp Reisner } 401b411b363SPhilipp Reisner return count; 402b411b363SPhilipp Reisner } 403b411b363SPhilipp Reisner 404a990be46SAndreas Gruenbacher /* 405a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 406b411b363SPhilipp Reisner */ 407a990be46SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_conf *mdev) 408b411b363SPhilipp Reisner { 409b411b363SPhilipp Reisner LIST_HEAD(work_list); 410b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 411db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 412e2b3032bSAndreas Gruenbacher int err = 0; 413b411b363SPhilipp Reisner 41487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 415a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 416b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 41787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 418b411b363SPhilipp Reisner 419db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 4203967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 421b411b363SPhilipp Reisner 422b411b363SPhilipp Reisner /* possible callbacks here: 4237be8da07SAndreas Gruenbacher * e_end_block, and e_end_resync_block, e_send_discard_write. 424b411b363SPhilipp Reisner * all ignore the last argument. 425b411b363SPhilipp Reisner */ 426db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 427e2b3032bSAndreas Gruenbacher int err2; 428e2b3032bSAndreas Gruenbacher 429b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 430e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 431e2b3032bSAndreas Gruenbacher if (!err) 432e2b3032bSAndreas Gruenbacher err = err2; 4333967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 434b411b363SPhilipp Reisner } 435b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 436b411b363SPhilipp Reisner 437e2b3032bSAndreas Gruenbacher return err; 438b411b363SPhilipp Reisner } 439b411b363SPhilipp Reisner 440d4da1537SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, 441d4da1537SAndreas Gruenbacher struct list_head *head) 442b411b363SPhilipp Reisner { 443b411b363SPhilipp Reisner DEFINE_WAIT(wait); 444b411b363SPhilipp Reisner 445b411b363SPhilipp Reisner /* avoids spin_lock/unlock 446b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 447b411b363SPhilipp Reisner while (!list_empty(head)) { 448b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 44987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4507eaceaccSJens Axboe io_schedule(); 451b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 45287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 453b411b363SPhilipp Reisner } 454b411b363SPhilipp Reisner } 455b411b363SPhilipp Reisner 456d4da1537SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_conf *mdev, 457d4da1537SAndreas Gruenbacher struct list_head *head) 458b411b363SPhilipp Reisner { 45987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 460b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 46187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 462b411b363SPhilipp Reisner } 463b411b363SPhilipp Reisner 464b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 465b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4667653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 467b411b363SPhilipp Reisner { 468b411b363SPhilipp Reisner struct sock *sk = sock->sk; 469b411b363SPhilipp Reisner int err = 0; 470b411b363SPhilipp Reisner 471b411b363SPhilipp Reisner *what = "listen"; 472b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 473b411b363SPhilipp Reisner if (err < 0) 474b411b363SPhilipp Reisner goto out; 475b411b363SPhilipp Reisner 476b411b363SPhilipp Reisner *what = "sock_create_lite"; 477b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 478b411b363SPhilipp Reisner newsock); 479b411b363SPhilipp Reisner if (err < 0) 480b411b363SPhilipp Reisner goto out; 481b411b363SPhilipp Reisner 482b411b363SPhilipp Reisner *what = "accept"; 483b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 484b411b363SPhilipp Reisner if (err < 0) { 485b411b363SPhilipp Reisner sock_release(*newsock); 486b411b363SPhilipp Reisner *newsock = NULL; 487b411b363SPhilipp Reisner goto out; 488b411b363SPhilipp Reisner } 489b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 490b411b363SPhilipp Reisner 491b411b363SPhilipp Reisner out: 492b411b363SPhilipp Reisner return err; 493b411b363SPhilipp Reisner } 494b411b363SPhilipp Reisner 495dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 496b411b363SPhilipp Reisner { 497b411b363SPhilipp Reisner mm_segment_t oldfs; 498b411b363SPhilipp Reisner struct kvec iov = { 499b411b363SPhilipp Reisner .iov_base = buf, 500b411b363SPhilipp Reisner .iov_len = size, 501b411b363SPhilipp Reisner }; 502b411b363SPhilipp Reisner struct msghdr msg = { 503b411b363SPhilipp Reisner .msg_iovlen = 1, 504b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 505b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 506b411b363SPhilipp Reisner }; 507b411b363SPhilipp Reisner int rv; 508b411b363SPhilipp Reisner 509b411b363SPhilipp Reisner oldfs = get_fs(); 510b411b363SPhilipp Reisner set_fs(KERNEL_DS); 511b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 512b411b363SPhilipp Reisner set_fs(oldfs); 513b411b363SPhilipp Reisner 514b411b363SPhilipp Reisner return rv; 515b411b363SPhilipp Reisner } 516b411b363SPhilipp Reisner 517de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 518b411b363SPhilipp Reisner { 519b411b363SPhilipp Reisner mm_segment_t oldfs; 520b411b363SPhilipp Reisner struct kvec iov = { 521b411b363SPhilipp Reisner .iov_base = buf, 522b411b363SPhilipp Reisner .iov_len = size, 523b411b363SPhilipp Reisner }; 524b411b363SPhilipp Reisner struct msghdr msg = { 525b411b363SPhilipp Reisner .msg_iovlen = 1, 526b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 527b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 528b411b363SPhilipp Reisner }; 529b411b363SPhilipp Reisner int rv; 530b411b363SPhilipp Reisner 531b411b363SPhilipp Reisner oldfs = get_fs(); 532b411b363SPhilipp Reisner set_fs(KERNEL_DS); 533b411b363SPhilipp Reisner 534b411b363SPhilipp Reisner for (;;) { 535de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 536b411b363SPhilipp Reisner if (rv == size) 537b411b363SPhilipp Reisner break; 538b411b363SPhilipp Reisner 539b411b363SPhilipp Reisner /* Note: 540b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 541b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 542b411b363SPhilipp Reisner */ 543b411b363SPhilipp Reisner 544b411b363SPhilipp Reisner if (rv < 0) { 545b411b363SPhilipp Reisner if (rv == -ECONNRESET) 546de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 547b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 548de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 549b411b363SPhilipp Reisner break; 550b411b363SPhilipp Reisner } else if (rv == 0) { 551de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 552b411b363SPhilipp Reisner break; 553b411b363SPhilipp Reisner } else { 554b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 555b411b363SPhilipp Reisner * after we read a partial message 556b411b363SPhilipp Reisner */ 557b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 558b411b363SPhilipp Reisner break; 559b411b363SPhilipp Reisner } 560b411b363SPhilipp Reisner }; 561b411b363SPhilipp Reisner 562b411b363SPhilipp Reisner set_fs(oldfs); 563b411b363SPhilipp Reisner 564b411b363SPhilipp Reisner if (rv != size) 565bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 566b411b363SPhilipp Reisner 567b411b363SPhilipp Reisner return rv; 568b411b363SPhilipp Reisner } 569b411b363SPhilipp Reisner 570c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 571c6967746SAndreas Gruenbacher { 572c6967746SAndreas Gruenbacher int err; 573c6967746SAndreas Gruenbacher 574c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 575c6967746SAndreas Gruenbacher if (err != size) { 576c6967746SAndreas Gruenbacher if (err >= 0) 577c6967746SAndreas Gruenbacher err = -EIO; 578c6967746SAndreas Gruenbacher } else 579c6967746SAndreas Gruenbacher err = 0; 580c6967746SAndreas Gruenbacher return err; 581c6967746SAndreas Gruenbacher } 582c6967746SAndreas Gruenbacher 583a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 584a5c31904SAndreas Gruenbacher { 585a5c31904SAndreas Gruenbacher int err; 586a5c31904SAndreas Gruenbacher 587a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 588a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 589a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 590a5c31904SAndreas Gruenbacher return err; 591a5c31904SAndreas Gruenbacher } 592a5c31904SAndreas Gruenbacher 5935dbf1673SLars Ellenberg /* quoting tcp(7): 5945dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5955dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5965dbf1673SLars Ellenberg * This is our wrapper to do so. 5975dbf1673SLars Ellenberg */ 5985dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5995dbf1673SLars Ellenberg unsigned int rcv) 6005dbf1673SLars Ellenberg { 6015dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 6025dbf1673SLars Ellenberg if (snd) { 6035dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 6045dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 6055dbf1673SLars Ellenberg } 6065dbf1673SLars Ellenberg if (rcv) { 6075dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 6085dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 6095dbf1673SLars Ellenberg } 6105dbf1673SLars Ellenberg } 6115dbf1673SLars Ellenberg 612eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 613b411b363SPhilipp Reisner { 614b411b363SPhilipp Reisner const char *what; 615b411b363SPhilipp Reisner struct socket *sock; 616b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 61744ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 61844ed167dSPhilipp Reisner struct net_conf *nc; 61944ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 62069ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 621b411b363SPhilipp Reisner int disconnect_on_error = 1; 622b411b363SPhilipp Reisner 62344ed167dSPhilipp Reisner rcu_read_lock(); 62444ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 62544ed167dSPhilipp Reisner if (!nc) { 62644ed167dSPhilipp Reisner rcu_read_unlock(); 627b411b363SPhilipp Reisner return NULL; 62844ed167dSPhilipp Reisner } 62944ed167dSPhilipp Reisner 63044ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 63144ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 63269ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 63344ed167dSPhilipp Reisner 63444ed167dSPhilipp Reisner my_addr_len = min_t(int, nc->my_addr_len, sizeof(src_in6)); 63544ed167dSPhilipp Reisner memcpy(&src_in6, nc->my_addr, my_addr_len); 63644ed167dSPhilipp Reisner 63744ed167dSPhilipp Reisner if (((struct sockaddr *)nc->my_addr)->sa_family == AF_INET6) 63844ed167dSPhilipp Reisner src_in6.sin6_port = 0; 63944ed167dSPhilipp Reisner else 64044ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 64144ed167dSPhilipp Reisner 64244ed167dSPhilipp Reisner peer_addr_len = min_t(int, nc->peer_addr_len, sizeof(src_in6)); 64344ed167dSPhilipp Reisner memcpy(&peer_in6, nc->peer_addr, peer_addr_len); 64444ed167dSPhilipp Reisner 64544ed167dSPhilipp Reisner rcu_read_unlock(); 646b411b363SPhilipp Reisner 647b411b363SPhilipp Reisner what = "sock_create_kern"; 64844ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 649b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 650b411b363SPhilipp Reisner if (err < 0) { 651b411b363SPhilipp Reisner sock = NULL; 652b411b363SPhilipp Reisner goto out; 653b411b363SPhilipp Reisner } 654b411b363SPhilipp Reisner 655b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 65669ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 65744ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 658b411b363SPhilipp Reisner 659b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 660b411b363SPhilipp Reisner * for the outgoing connections. 661b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 662b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 663b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 664b411b363SPhilipp Reisner * a free one dynamically. 665b411b363SPhilipp Reisner */ 666b411b363SPhilipp Reisner what = "bind before connect"; 66744ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 668b411b363SPhilipp Reisner if (err < 0) 669b411b363SPhilipp Reisner goto out; 670b411b363SPhilipp Reisner 671b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 672b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 673b411b363SPhilipp Reisner disconnect_on_error = 0; 674b411b363SPhilipp Reisner what = "connect"; 67544ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 676b411b363SPhilipp Reisner 677b411b363SPhilipp Reisner out: 678b411b363SPhilipp Reisner if (err < 0) { 679b411b363SPhilipp Reisner if (sock) { 680b411b363SPhilipp Reisner sock_release(sock); 681b411b363SPhilipp Reisner sock = NULL; 682b411b363SPhilipp Reisner } 683b411b363SPhilipp Reisner switch (-err) { 684b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 685b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 686b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 687b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 688b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 689b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 690b411b363SPhilipp Reisner disconnect_on_error = 0; 691b411b363SPhilipp Reisner break; 692b411b363SPhilipp Reisner default: 693eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 694b411b363SPhilipp Reisner } 695b411b363SPhilipp Reisner if (disconnect_on_error) 696bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 697b411b363SPhilipp Reisner } 69844ed167dSPhilipp Reisner 699b411b363SPhilipp Reisner return sock; 700b411b363SPhilipp Reisner } 701b411b363SPhilipp Reisner 7027653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 703b411b363SPhilipp Reisner { 70444ed167dSPhilipp Reisner int timeo, err, my_addr_len; 70569ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 706b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 70744ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 70844ed167dSPhilipp Reisner struct net_conf *nc; 709b411b363SPhilipp Reisner const char *what; 710b411b363SPhilipp Reisner 71144ed167dSPhilipp Reisner rcu_read_lock(); 71244ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 71344ed167dSPhilipp Reisner if (!nc) { 71444ed167dSPhilipp Reisner rcu_read_unlock(); 715b411b363SPhilipp Reisner return NULL; 71644ed167dSPhilipp Reisner } 71744ed167dSPhilipp Reisner 71844ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71944ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 72069ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 72144ed167dSPhilipp Reisner 72244ed167dSPhilipp Reisner my_addr_len = min_t(int, nc->my_addr_len, sizeof(struct sockaddr_in6)); 72344ed167dSPhilipp Reisner memcpy(&my_addr, nc->my_addr, my_addr_len); 72444ed167dSPhilipp Reisner rcu_read_unlock(); 725b411b363SPhilipp Reisner 726b411b363SPhilipp Reisner what = "sock_create_kern"; 72744ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 728b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 729b411b363SPhilipp Reisner if (err) { 730b411b363SPhilipp Reisner s_listen = NULL; 731b411b363SPhilipp Reisner goto out; 732b411b363SPhilipp Reisner } 733b411b363SPhilipp Reisner 73469ef82deSAndreas Gruenbacher timeo = connect_int * HZ; 735b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 736b411b363SPhilipp Reisner 737b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 738b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 739b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 74044ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 741b411b363SPhilipp Reisner 742b411b363SPhilipp Reisner what = "bind before listen"; 74344ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 744b411b363SPhilipp Reisner if (err < 0) 745b411b363SPhilipp Reisner goto out; 746b411b363SPhilipp Reisner 7477653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 748b411b363SPhilipp Reisner 749b411b363SPhilipp Reisner out: 750b411b363SPhilipp Reisner if (s_listen) 751b411b363SPhilipp Reisner sock_release(s_listen); 752b411b363SPhilipp Reisner if (err < 0) { 753b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7547653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 755bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 756b411b363SPhilipp Reisner } 757b411b363SPhilipp Reisner } 758b411b363SPhilipp Reisner 759b411b363SPhilipp Reisner return s_estab; 760b411b363SPhilipp Reisner } 761b411b363SPhilipp Reisner 762e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 763b411b363SPhilipp Reisner 7649f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7659f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7669f5bdc33SAndreas Gruenbacher { 7679f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7689f5bdc33SAndreas Gruenbacher return -EIO; 769e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 770b411b363SPhilipp Reisner } 771b411b363SPhilipp Reisner 7729f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 773b411b363SPhilipp Reisner { 7749f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7759f5bdc33SAndreas Gruenbacher struct packet_info pi; 7769f5bdc33SAndreas Gruenbacher int err; 777b411b363SPhilipp Reisner 7789f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7799f5bdc33SAndreas Gruenbacher if (err != header_size) { 7809f5bdc33SAndreas Gruenbacher if (err >= 0) 7819f5bdc33SAndreas Gruenbacher err = -EIO; 7829f5bdc33SAndreas Gruenbacher return err; 7839f5bdc33SAndreas Gruenbacher } 7849f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 7859f5bdc33SAndreas Gruenbacher if (err) 7869f5bdc33SAndreas Gruenbacher return err; 7879f5bdc33SAndreas Gruenbacher return pi.cmd; 788b411b363SPhilipp Reisner } 789b411b363SPhilipp Reisner 790b411b363SPhilipp Reisner /** 791b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 792b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 793b411b363SPhilipp Reisner */ 794dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 795b411b363SPhilipp Reisner { 796b411b363SPhilipp Reisner int rr; 797b411b363SPhilipp Reisner char tb[4]; 798b411b363SPhilipp Reisner 799b411b363SPhilipp Reisner if (!*sock) 80081e84650SAndreas Gruenbacher return false; 801b411b363SPhilipp Reisner 802dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 803b411b363SPhilipp Reisner 804b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 80581e84650SAndreas Gruenbacher return true; 806b411b363SPhilipp Reisner } else { 807b411b363SPhilipp Reisner sock_release(*sock); 808b411b363SPhilipp Reisner *sock = NULL; 80981e84650SAndreas Gruenbacher return false; 810b411b363SPhilipp Reisner } 811b411b363SPhilipp Reisner } 8122325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8132325eb66SPhilipp Reisner in a connection */ 814c141ebdaSPhilipp Reisner int drbd_connected(struct drbd_conf *mdev) 815907599e0SPhilipp Reisner { 8160829f5edSAndreas Gruenbacher int err; 817907599e0SPhilipp Reisner 818907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 819907599e0SPhilipp Reisner mdev->peer_seq = 0; 820907599e0SPhilipp Reisner 8218410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8228410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8238410da8fSPhilipp Reisner &mdev->own_state_mutex; 8248410da8fSPhilipp Reisner 8250829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8260829f5edSAndreas Gruenbacher if (!err) 8270829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8280829f5edSAndreas Gruenbacher if (!err) 8290829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8300829f5edSAndreas Gruenbacher if (!err) 8310829f5edSAndreas Gruenbacher err = drbd_send_state(mdev); 832907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 833907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8348b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8350829f5edSAndreas Gruenbacher return err; 836907599e0SPhilipp Reisner } 837907599e0SPhilipp Reisner 838b411b363SPhilipp Reisner /* 839b411b363SPhilipp Reisner * return values: 840b411b363SPhilipp Reisner * 1 yes, we have a valid connection 841b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 842b411b363SPhilipp Reisner * -1 peer talks different language, 843b411b363SPhilipp Reisner * no point in trying again, please go standalone. 844b411b363SPhilipp Reisner * -2 We do not have a network config... 845b411b363SPhilipp Reisner */ 84681fa2e67SPhilipp Reisner static int conn_connect(struct drbd_tconn *tconn) 847b411b363SPhilipp Reisner { 8482bf89621SAndreas Gruenbacher struct socket *sock, *msock; 849c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 85044ed167dSPhilipp Reisner struct net_conf *nc; 851c141ebdaSPhilipp Reisner int vnr, timeout, try, h, ok; 852b411b363SPhilipp Reisner 853bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 854b411b363SPhilipp Reisner return -2; 855b411b363SPhilipp Reisner 856907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 8570916e0e3SAndreas Gruenbacher 8580916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8590916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 860b411b363SPhilipp Reisner 861b411b363SPhilipp Reisner do { 8622bf89621SAndreas Gruenbacher struct socket *s; 8632bf89621SAndreas Gruenbacher 864b411b363SPhilipp Reisner for (try = 0;;) { 865b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 866907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 867b411b363SPhilipp Reisner if (s || ++try >= 3) 868b411b363SPhilipp Reisner break; 869b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 87020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 871b411b363SPhilipp Reisner } 872b411b363SPhilipp Reisner 873b411b363SPhilipp Reisner if (s) { 8742bf89621SAndreas Gruenbacher if (!tconn->data.socket) { 8752bf89621SAndreas Gruenbacher tconn->data.socket = s; 8769f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->data, P_INITIAL_DATA); 8772bf89621SAndreas Gruenbacher } else if (!tconn->meta.socket) { 8782bf89621SAndreas Gruenbacher tconn->meta.socket = s; 8799f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->meta, P_INITIAL_META); 880b411b363SPhilipp Reisner } else { 88181fa2e67SPhilipp Reisner conn_err(tconn, "Logic error in conn_connect()\n"); 882b411b363SPhilipp Reisner goto out_release_sockets; 883b411b363SPhilipp Reisner } 884b411b363SPhilipp Reisner } 885b411b363SPhilipp Reisner 8862bf89621SAndreas Gruenbacher if (tconn->data.socket && tconn->meta.socket) { 887907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 8882bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 8892bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 890b411b363SPhilipp Reisner if (ok) 891b411b363SPhilipp Reisner break; 892b411b363SPhilipp Reisner } 893b411b363SPhilipp Reisner 894b411b363SPhilipp Reisner retry: 895907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 896b411b363SPhilipp Reisner if (s) { 8979f5bdc33SAndreas Gruenbacher try = receive_first_packet(tconn, s); 8982bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->data.socket); 8992bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->meta.socket); 900b411b363SPhilipp Reisner switch (try) { 901e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9022bf89621SAndreas Gruenbacher if (tconn->data.socket) { 903907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9042bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 905b411b363SPhilipp Reisner } 9062bf89621SAndreas Gruenbacher tconn->data.socket = s; 907b411b363SPhilipp Reisner break; 908e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 9092bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 910907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9112bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 912b411b363SPhilipp Reisner } 9132bf89621SAndreas Gruenbacher tconn->meta.socket = s; 914907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 915b411b363SPhilipp Reisner break; 916b411b363SPhilipp Reisner default: 917907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 918b411b363SPhilipp Reisner sock_release(s); 919b411b363SPhilipp Reisner if (random32() & 1) 920b411b363SPhilipp Reisner goto retry; 921b411b363SPhilipp Reisner } 922b411b363SPhilipp Reisner } 923b411b363SPhilipp Reisner 924bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 925b411b363SPhilipp Reisner goto out_release_sockets; 926b411b363SPhilipp Reisner if (signal_pending(current)) { 927b411b363SPhilipp Reisner flush_signals(current); 928b411b363SPhilipp Reisner smp_rmb(); 929907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 930b411b363SPhilipp Reisner goto out_release_sockets; 931b411b363SPhilipp Reisner } 932b411b363SPhilipp Reisner 9332bf89621SAndreas Gruenbacher if (tconn->data.socket && &tconn->meta.socket) { 9342bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 9352bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 936b411b363SPhilipp Reisner if (ok) 937b411b363SPhilipp Reisner break; 938b411b363SPhilipp Reisner } 939b411b363SPhilipp Reisner } while (1); 940b411b363SPhilipp Reisner 9412bf89621SAndreas Gruenbacher sock = tconn->data.socket; 9422bf89621SAndreas Gruenbacher msock = tconn->meta.socket; 9432bf89621SAndreas Gruenbacher 944b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 945b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 946b411b363SPhilipp Reisner 947b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 948b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 949b411b363SPhilipp Reisner 950b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 951b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 952b411b363SPhilipp Reisner 953b411b363SPhilipp Reisner /* NOT YET ... 954907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 955b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9566038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 957b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 95844ed167dSPhilipp Reisner rcu_read_lock(); 95944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 960b411b363SPhilipp Reisner 96144ed167dSPhilipp Reisner sock->sk->sk_sndtimeo = 96244ed167dSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 96344ed167dSPhilipp Reisner 96444ed167dSPhilipp Reisner msock->sk->sk_rcvtimeo = nc->ping_int*HZ; 96544ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 96644ed167dSPhilipp Reisner rcu_read_unlock(); 96744ed167dSPhilipp Reisner 96844ed167dSPhilipp Reisner msock->sk->sk_sndtimeo = timeout; 969b411b363SPhilipp Reisner 970b411b363SPhilipp Reisner /* we don't want delays. 97125985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 972b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 973b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 974b411b363SPhilipp Reisner 975907599e0SPhilipp Reisner tconn->last_received = jiffies; 976b411b363SPhilipp Reisner 9776038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 978b411b363SPhilipp Reisner if (h <= 0) 979b411b363SPhilipp Reisner return h; 980b411b363SPhilipp Reisner 981907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 982b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 983907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 984b10d96cbSJohannes Thoma case -1: 985907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 986b411b363SPhilipp Reisner return -1; 987b10d96cbSJohannes Thoma case 0: 988907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 989b10d96cbSJohannes Thoma return 0; 990b411b363SPhilipp Reisner } 991b411b363SPhilipp Reisner } 992b411b363SPhilipp Reisner 993bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 994b411b363SPhilipp Reisner return 0; 995b411b363SPhilipp Reisner 99644ed167dSPhilipp Reisner sock->sk->sk_sndtimeo = timeout; 997b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 998b411b363SPhilipp Reisner 999907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 1000b411b363SPhilipp Reisner 1001387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 10027e2455c1SPhilipp Reisner return -1; 1003b411b363SPhilipp Reisner 1004c141ebdaSPhilipp Reisner rcu_read_lock(); 1005c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1006c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 1007c141ebdaSPhilipp Reisner rcu_read_unlock(); 1008c141ebdaSPhilipp Reisner drbd_connected(mdev); 1009c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 1010c141ebdaSPhilipp Reisner rcu_read_lock(); 1011c141ebdaSPhilipp Reisner } 1012c141ebdaSPhilipp Reisner rcu_read_unlock(); 1013c141ebdaSPhilipp Reisner 1014d3fcb490SPhilipp Reisner return h; 1015b411b363SPhilipp Reisner 1016b411b363SPhilipp Reisner out_release_sockets: 10172bf89621SAndreas Gruenbacher if (tconn->data.socket) { 10182bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 10192bf89621SAndreas Gruenbacher tconn->data.socket = NULL; 10202bf89621SAndreas Gruenbacher } 10212bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 10222bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 10232bf89621SAndreas Gruenbacher tconn->meta.socket = NULL; 10242bf89621SAndreas Gruenbacher } 1025b411b363SPhilipp Reisner return -1; 1026b411b363SPhilipp Reisner } 1027b411b363SPhilipp Reisner 1028e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1029b411b363SPhilipp Reisner { 1030e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1031e658983aSAndreas Gruenbacher 10320c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10330c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 10340c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 10350c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 10360c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 10370c8e36d9SAndreas Gruenbacher return -EINVAL; 10380c8e36d9SAndreas Gruenbacher } 10390c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 10400c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 10410c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 10420c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1043e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1044e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1045e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1046b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1047eefc2f7dSPhilipp Reisner pi->vnr = 0; 1048e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1049e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1050e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1051e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1052e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 105377351055SPhilipp Reisner pi->vnr = 0; 105402918be2SPhilipp Reisner } else { 1055e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1056e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1057e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 10588172f3e9SAndreas Gruenbacher return -EINVAL; 1059b411b363SPhilipp Reisner } 1060e658983aSAndreas Gruenbacher pi->data = header + header_size; 10618172f3e9SAndreas Gruenbacher return 0; 1062257d0af6SPhilipp Reisner } 1063257d0af6SPhilipp Reisner 10649ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1065257d0af6SPhilipp Reisner { 1066e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 106769bc7bc3SAndreas Gruenbacher int err; 1068257d0af6SPhilipp Reisner 1069e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1070a5c31904SAndreas Gruenbacher if (err) 107169bc7bc3SAndreas Gruenbacher return err; 1072257d0af6SPhilipp Reisner 1073e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 10749ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1075b411b363SPhilipp Reisner 107669bc7bc3SAndreas Gruenbacher return err; 1077b411b363SPhilipp Reisner } 1078b411b363SPhilipp Reisner 10792451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 1080b411b363SPhilipp Reisner { 1081b411b363SPhilipp Reisner int rv; 1082b411b363SPhilipp Reisner 1083b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 1084fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 1085dd3932edSChristoph Hellwig NULL); 1086b411b363SPhilipp Reisner if (rv) { 1087b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 1088b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1089b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1090b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1091b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 1092b411b363SPhilipp Reisner } 1093b411b363SPhilipp Reisner put_ldev(mdev); 1094b411b363SPhilipp Reisner } 1095b411b363SPhilipp Reisner } 1096b411b363SPhilipp Reisner 1097b411b363SPhilipp Reisner /** 1098b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1099b411b363SPhilipp Reisner * @mdev: DRBD device. 1100b411b363SPhilipp Reisner * @epoch: Epoch object. 1101b411b363SPhilipp Reisner * @ev: Epoch event. 1102b411b363SPhilipp Reisner */ 1103b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1104b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1105b411b363SPhilipp Reisner enum epoch_event ev) 1106b411b363SPhilipp Reisner { 11072451fc3bSPhilipp Reisner int epoch_size; 1108b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1109b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1110b411b363SPhilipp Reisner 1111b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1112b411b363SPhilipp Reisner do { 1113b411b363SPhilipp Reisner next_epoch = NULL; 1114b411b363SPhilipp Reisner 1115b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1116b411b363SPhilipp Reisner 1117b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1118b411b363SPhilipp Reisner case EV_PUT: 1119b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1120b411b363SPhilipp Reisner break; 1121b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1122b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1123b411b363SPhilipp Reisner break; 1124b411b363SPhilipp Reisner case EV_BECAME_LAST: 1125b411b363SPhilipp Reisner /* nothing to do*/ 1126b411b363SPhilipp Reisner break; 1127b411b363SPhilipp Reisner } 1128b411b363SPhilipp Reisner 1129b411b363SPhilipp Reisner if (epoch_size != 0 && 1130b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 11312451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1132b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1133b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1134b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1135b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1136b411b363SPhilipp Reisner } 1137b411b363SPhilipp Reisner dec_unacked(mdev); 1138b411b363SPhilipp Reisner 1139b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1140b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1141b411b363SPhilipp Reisner list_del(&epoch->list); 1142b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1143b411b363SPhilipp Reisner mdev->epochs--; 1144b411b363SPhilipp Reisner kfree(epoch); 1145b411b363SPhilipp Reisner 1146b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1147b411b363SPhilipp Reisner rv = FE_DESTROYED; 1148b411b363SPhilipp Reisner } else { 1149b411b363SPhilipp Reisner epoch->flags = 0; 1150b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1151698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1152b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1153b411b363SPhilipp Reisner rv = FE_RECYCLED; 11542451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1155b411b363SPhilipp Reisner } 1156b411b363SPhilipp Reisner } 1157b411b363SPhilipp Reisner 1158b411b363SPhilipp Reisner if (!next_epoch) 1159b411b363SPhilipp Reisner break; 1160b411b363SPhilipp Reisner 1161b411b363SPhilipp Reisner epoch = next_epoch; 1162b411b363SPhilipp Reisner } while (1); 1163b411b363SPhilipp Reisner 1164b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1165b411b363SPhilipp Reisner 1166b411b363SPhilipp Reisner return rv; 1167b411b363SPhilipp Reisner } 1168b411b363SPhilipp Reisner 1169b411b363SPhilipp Reisner /** 1170b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1171b411b363SPhilipp Reisner * @mdev: DRBD device. 1172b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1173b411b363SPhilipp Reisner */ 1174b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1175b411b363SPhilipp Reisner { 1176daeda1ccSPhilipp Reisner struct disk_conf *dc; 1177b411b363SPhilipp Reisner enum write_ordering_e pwo; 1178b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1179b411b363SPhilipp Reisner [WO_none] = "none", 1180b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1181b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1182b411b363SPhilipp Reisner }; 1183b411b363SPhilipp Reisner 1184b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1185b411b363SPhilipp Reisner wo = min(pwo, wo); 1186daeda1ccSPhilipp Reisner rcu_read_lock(); 1187daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1188daeda1ccSPhilipp Reisner 118966b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1190b411b363SPhilipp Reisner wo = WO_drain_io; 1191d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1192b411b363SPhilipp Reisner wo = WO_none; 1193daeda1ccSPhilipp Reisner rcu_read_unlock(); 1194b411b363SPhilipp Reisner mdev->write_ordering = wo; 11952451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1196b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1197b411b363SPhilipp Reisner } 1198b411b363SPhilipp Reisner 1199b411b363SPhilipp Reisner /** 1200fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 120145bb912bSLars Ellenberg * @mdev: DRBD device. 1202db830c46SAndreas Gruenbacher * @peer_req: peer request 120345bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 120410f6d992SLars Ellenberg * 120510f6d992SLars Ellenberg * May spread the pages to multiple bios, 120610f6d992SLars Ellenberg * depending on bio_add_page restrictions. 120710f6d992SLars Ellenberg * 120810f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 120910f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 121010f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 121110f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 121210f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 121310f6d992SLars Ellenberg * on certain Xen deployments. 121445bb912bSLars Ellenberg */ 121545bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1216fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1217fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 121845bb912bSLars Ellenberg const unsigned rw, const int fault_type) 121945bb912bSLars Ellenberg { 122045bb912bSLars Ellenberg struct bio *bios = NULL; 122145bb912bSLars Ellenberg struct bio *bio; 1222db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1223db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1224db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 122545bb912bSLars Ellenberg unsigned n_bios = 0; 122645bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 122710f6d992SLars Ellenberg int err = -ENOMEM; 122845bb912bSLars Ellenberg 122945bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 123045bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 123145bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1232da4a75d2SLars Ellenberg * request in more than one bio. 1233da4a75d2SLars Ellenberg * 1234da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1235da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1236da4a75d2SLars Ellenberg */ 123745bb912bSLars Ellenberg next_bio: 123845bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 123945bb912bSLars Ellenberg if (!bio) { 124045bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 124145bb912bSLars Ellenberg goto fail; 124245bb912bSLars Ellenberg } 1243db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 124445bb912bSLars Ellenberg bio->bi_sector = sector; 124545bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 124645bb912bSLars Ellenberg bio->bi_rw = rw; 1247db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1248fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 124945bb912bSLars Ellenberg 125045bb912bSLars Ellenberg bio->bi_next = bios; 125145bb912bSLars Ellenberg bios = bio; 125245bb912bSLars Ellenberg ++n_bios; 125345bb912bSLars Ellenberg 125445bb912bSLars Ellenberg page_chain_for_each(page) { 125545bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 125645bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 125710f6d992SLars Ellenberg /* A single page must always be possible! 125810f6d992SLars Ellenberg * But in case it fails anyways, 125910f6d992SLars Ellenberg * we deal with it, and complain (below). */ 126010f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 126110f6d992SLars Ellenberg dev_err(DEV, 126210f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 126310f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 126410f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 126510f6d992SLars Ellenberg err = -ENOSPC; 126610f6d992SLars Ellenberg goto fail; 126710f6d992SLars Ellenberg } 126845bb912bSLars Ellenberg goto next_bio; 126945bb912bSLars Ellenberg } 127045bb912bSLars Ellenberg ds -= len; 127145bb912bSLars Ellenberg sector += len >> 9; 127245bb912bSLars Ellenberg --nr_pages; 127345bb912bSLars Ellenberg } 127445bb912bSLars Ellenberg D_ASSERT(page == NULL); 127545bb912bSLars Ellenberg D_ASSERT(ds == 0); 127645bb912bSLars Ellenberg 1277db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 127845bb912bSLars Ellenberg do { 127945bb912bSLars Ellenberg bio = bios; 128045bb912bSLars Ellenberg bios = bios->bi_next; 128145bb912bSLars Ellenberg bio->bi_next = NULL; 128245bb912bSLars Ellenberg 128345bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 128445bb912bSLars Ellenberg } while (bios); 128545bb912bSLars Ellenberg return 0; 128645bb912bSLars Ellenberg 128745bb912bSLars Ellenberg fail: 128845bb912bSLars Ellenberg while (bios) { 128945bb912bSLars Ellenberg bio = bios; 129045bb912bSLars Ellenberg bios = bios->bi_next; 129145bb912bSLars Ellenberg bio_put(bio); 129245bb912bSLars Ellenberg } 129310f6d992SLars Ellenberg return err; 129445bb912bSLars Ellenberg } 129545bb912bSLars Ellenberg 129653840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1297db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 129853840641SAndreas Gruenbacher { 1299db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 130053840641SAndreas Gruenbacher 130153840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 130253840641SAndreas Gruenbacher drbd_clear_interval(i); 130353840641SAndreas Gruenbacher 13046c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 130553840641SAndreas Gruenbacher if (i->waiting) 130653840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 130753840641SAndreas Gruenbacher } 130853840641SAndreas Gruenbacher 13094a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1310b411b363SPhilipp Reisner { 13114a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 13122451fc3bSPhilipp Reisner int rv; 1313e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1314b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1315b411b363SPhilipp Reisner 13164a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 13174a76b161SAndreas Gruenbacher if (!mdev) 13184a76b161SAndreas Gruenbacher return -EIO; 13194a76b161SAndreas Gruenbacher 1320b411b363SPhilipp Reisner inc_unacked(mdev); 1321b411b363SPhilipp Reisner 1322b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1323b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1324b411b363SPhilipp Reisner 1325b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1326b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1327b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1328b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1329b411b363SPhilipp Reisner * completed. */ 1330b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1331b411b363SPhilipp Reisner case WO_none: 1332b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 133382bc0194SAndreas Gruenbacher return 0; 1334b411b363SPhilipp Reisner 1335b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1336b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1337b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 13382451fc3bSPhilipp Reisner if (epoch) 13392451fc3bSPhilipp Reisner break; 13402451fc3bSPhilipp Reisner else 1341b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 13422451fc3bSPhilipp Reisner /* Fall through */ 13432451fc3bSPhilipp Reisner 13442451fc3bSPhilipp Reisner case WO_bdev_flush: 13452451fc3bSPhilipp Reisner case WO_drain_io: 1346b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 13472451fc3bSPhilipp Reisner drbd_flush(mdev); 13482451fc3bSPhilipp Reisner 13492451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 13502451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 13512451fc3bSPhilipp Reisner if (epoch) 13522451fc3bSPhilipp Reisner break; 1353b411b363SPhilipp Reisner } 1354b411b363SPhilipp Reisner 13552451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 13562451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 13572451fc3bSPhilipp Reisner 13582451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 13592451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1360b411b363SPhilipp Reisner 136182bc0194SAndreas Gruenbacher return 0; 13622451fc3bSPhilipp Reisner default: 13632451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 136482bc0194SAndreas Gruenbacher return -EIO; 1365b411b363SPhilipp Reisner } 1366b411b363SPhilipp Reisner 1367b411b363SPhilipp Reisner epoch->flags = 0; 1368b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1369b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1370b411b363SPhilipp Reisner 1371b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1372b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1373b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1374b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1375b411b363SPhilipp Reisner mdev->epochs++; 1376b411b363SPhilipp Reisner } else { 1377b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1378b411b363SPhilipp Reisner kfree(epoch); 1379b411b363SPhilipp Reisner } 1380b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1381b411b363SPhilipp Reisner 138282bc0194SAndreas Gruenbacher return 0; 1383b411b363SPhilipp Reisner } 1384b411b363SPhilipp Reisner 1385b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1386b411b363SPhilipp Reisner * and from receive_Data */ 1387f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1388f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1389f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1390b411b363SPhilipp Reisner { 13916666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1392db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1393b411b363SPhilipp Reisner struct page *page; 1394a5c31904SAndreas Gruenbacher int dgs, ds, err; 1395a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1396a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 13976b4388acSPhilipp Reisner unsigned long *data; 1398b411b363SPhilipp Reisner 139988104ca4SAndreas Gruenbacher dgs = 0; 140088104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 140188104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 14029f5bdc33SAndreas Gruenbacher /* 14039f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 14049f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 14059f5bdc33SAndreas Gruenbacher */ 1406a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1407a5c31904SAndreas Gruenbacher if (err) 1408b411b363SPhilipp Reisner return NULL; 1409b411b363SPhilipp Reisner data_size -= dgs; 141088104ca4SAndreas Gruenbacher } 1411b411b363SPhilipp Reisner 1412841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1413841ce241SAndreas Gruenbacher return NULL; 1414841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1415841ce241SAndreas Gruenbacher return NULL; 1416841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1417841ce241SAndreas Gruenbacher return NULL; 1418b411b363SPhilipp Reisner 14196666032aSLars Ellenberg /* even though we trust out peer, 14206666032aSLars Ellenberg * we sometimes have to double check. */ 14216666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1422fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1423fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 14246666032aSLars Ellenberg (unsigned long long)capacity, 14256666032aSLars Ellenberg (unsigned long long)sector, data_size); 14266666032aSLars Ellenberg return NULL; 14276666032aSLars Ellenberg } 14286666032aSLars Ellenberg 1429b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1430b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1431b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 14320db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1433db830c46SAndreas Gruenbacher if (!peer_req) 1434b411b363SPhilipp Reisner return NULL; 143545bb912bSLars Ellenberg 1436b411b363SPhilipp Reisner ds = data_size; 1437db830c46SAndreas Gruenbacher page = peer_req->pages; 143845bb912bSLars Ellenberg page_chain_for_each(page) { 143945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 14406b4388acSPhilipp Reisner data = kmap(page); 1441a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 14420cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 14436b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 14446b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 14456b4388acSPhilipp Reisner } 1446b411b363SPhilipp Reisner kunmap(page); 1447a5c31904SAndreas Gruenbacher if (err) { 14483967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1449b411b363SPhilipp Reisner return NULL; 1450b411b363SPhilipp Reisner } 1451a5c31904SAndreas Gruenbacher ds -= len; 1452b411b363SPhilipp Reisner } 1453b411b363SPhilipp Reisner 1454b411b363SPhilipp Reisner if (dgs) { 14555b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1456b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1457470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1458470be44aSLars Ellenberg (unsigned long long)sector, data_size); 14593967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1460b411b363SPhilipp Reisner return NULL; 1461b411b363SPhilipp Reisner } 1462b411b363SPhilipp Reisner } 1463b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1464db830c46SAndreas Gruenbacher return peer_req; 1465b411b363SPhilipp Reisner } 1466b411b363SPhilipp Reisner 1467b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1468b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1469b411b363SPhilipp Reisner */ 1470b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1471b411b363SPhilipp Reisner { 1472b411b363SPhilipp Reisner struct page *page; 1473a5c31904SAndreas Gruenbacher int err = 0; 1474b411b363SPhilipp Reisner void *data; 1475b411b363SPhilipp Reisner 1476c3470cdeSLars Ellenberg if (!data_size) 1477fc5be839SAndreas Gruenbacher return 0; 1478c3470cdeSLars Ellenberg 1479c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1480b411b363SPhilipp Reisner 1481b411b363SPhilipp Reisner data = kmap(page); 1482b411b363SPhilipp Reisner while (data_size) { 1483fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1484fc5be839SAndreas Gruenbacher 1485a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1486a5c31904SAndreas Gruenbacher if (err) 1487b411b363SPhilipp Reisner break; 1488a5c31904SAndreas Gruenbacher data_size -= len; 1489b411b363SPhilipp Reisner } 1490b411b363SPhilipp Reisner kunmap(page); 14915cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1492fc5be839SAndreas Gruenbacher return err; 1493b411b363SPhilipp Reisner } 1494b411b363SPhilipp Reisner 1495b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1496b411b363SPhilipp Reisner sector_t sector, int data_size) 1497b411b363SPhilipp Reisner { 1498b411b363SPhilipp Reisner struct bio_vec *bvec; 1499b411b363SPhilipp Reisner struct bio *bio; 1500a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1501a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1502a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1503b411b363SPhilipp Reisner 150488104ca4SAndreas Gruenbacher dgs = 0; 150588104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 150688104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1507a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1508a5c31904SAndreas Gruenbacher if (err) 1509a5c31904SAndreas Gruenbacher return err; 1510b411b363SPhilipp Reisner data_size -= dgs; 151188104ca4SAndreas Gruenbacher } 1512b411b363SPhilipp Reisner 1513b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1514b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1515b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1516b411b363SPhilipp Reisner 1517b411b363SPhilipp Reisner bio = req->master_bio; 1518b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1519b411b363SPhilipp Reisner 1520b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1521a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1522b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1523a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1524b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1525a5c31904SAndreas Gruenbacher if (err) 1526a5c31904SAndreas Gruenbacher return err; 1527a5c31904SAndreas Gruenbacher data_size -= expect; 1528b411b363SPhilipp Reisner } 1529b411b363SPhilipp Reisner 1530b411b363SPhilipp Reisner if (dgs) { 15315b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1532b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1533b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 153428284cefSAndreas Gruenbacher return -EINVAL; 1535b411b363SPhilipp Reisner } 1536b411b363SPhilipp Reisner } 1537b411b363SPhilipp Reisner 1538b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 153928284cefSAndreas Gruenbacher return 0; 1540b411b363SPhilipp Reisner } 1541b411b363SPhilipp Reisner 1542a990be46SAndreas Gruenbacher /* 1543a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1544a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1545a990be46SAndreas Gruenbacher */ 154699920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1547b411b363SPhilipp Reisner { 15488050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 15498050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 155000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1551db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 155299920dc5SAndreas Gruenbacher int err; 1553b411b363SPhilipp Reisner 1554db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1555b411b363SPhilipp Reisner 1556db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1557db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 155899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1559b411b363SPhilipp Reisner } else { 1560b411b363SPhilipp Reisner /* Record failure to sync */ 1561db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1562b411b363SPhilipp Reisner 156399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1564b411b363SPhilipp Reisner } 1565b411b363SPhilipp Reisner dec_unacked(mdev); 1566b411b363SPhilipp Reisner 156799920dc5SAndreas Gruenbacher return err; 1568b411b363SPhilipp Reisner } 1569b411b363SPhilipp Reisner 1570b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1571b411b363SPhilipp Reisner { 1572db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1573b411b363SPhilipp Reisner 1574db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1575db830c46SAndreas Gruenbacher if (!peer_req) 157645bb912bSLars Ellenberg goto fail; 1577b411b363SPhilipp Reisner 1578b411b363SPhilipp Reisner dec_rs_pending(mdev); 1579b411b363SPhilipp Reisner 1580b411b363SPhilipp Reisner inc_unacked(mdev); 1581b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1582b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1583b411b363SPhilipp Reisner 1584db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 158545bb912bSLars Ellenberg 158687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1587db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 158887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1589b411b363SPhilipp Reisner 15900f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1591fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1592e1c1b0fcSAndreas Gruenbacher return 0; 159345bb912bSLars Ellenberg 159410f6d992SLars Ellenberg /* don't care for the reason here */ 159510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 159687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1597db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 159887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 159922cc37a9SLars Ellenberg 16003967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 160145bb912bSLars Ellenberg fail: 160245bb912bSLars Ellenberg put_ldev(mdev); 1603e1c1b0fcSAndreas Gruenbacher return -EIO; 1604b411b363SPhilipp Reisner } 1605b411b363SPhilipp Reisner 1606668eebc6SAndreas Gruenbacher static struct drbd_request * 1607bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1608bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1609668eebc6SAndreas Gruenbacher { 1610668eebc6SAndreas Gruenbacher struct drbd_request *req; 1611668eebc6SAndreas Gruenbacher 1612bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1613bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 16145e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1615668eebc6SAndreas Gruenbacher return req; 1616c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1617c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1618c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1619c3afd8f5SAndreas Gruenbacher } 1620668eebc6SAndreas Gruenbacher return NULL; 1621668eebc6SAndreas Gruenbacher } 1622668eebc6SAndreas Gruenbacher 16234a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1624b411b363SPhilipp Reisner { 16254a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1626b411b363SPhilipp Reisner struct drbd_request *req; 1627b411b363SPhilipp Reisner sector_t sector; 162882bc0194SAndreas Gruenbacher int err; 1629e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16304a76b161SAndreas Gruenbacher 16314a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16324a76b161SAndreas Gruenbacher if (!mdev) 16334a76b161SAndreas Gruenbacher return -EIO; 1634b411b363SPhilipp Reisner 1635b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1636b411b363SPhilipp Reisner 163787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1638bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 163987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1640c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 164182bc0194SAndreas Gruenbacher return -EIO; 1642b411b363SPhilipp Reisner 164324c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1644b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1645b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1646e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 164782bc0194SAndreas Gruenbacher if (!err) 16488554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1649b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1650b411b363SPhilipp Reisner * I don't think we may complete this just yet 1651b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1652b411b363SPhilipp Reisner 165382bc0194SAndreas Gruenbacher return err; 1654b411b363SPhilipp Reisner } 1655b411b363SPhilipp Reisner 16564a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1657b411b363SPhilipp Reisner { 16584a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1659b411b363SPhilipp Reisner sector_t sector; 166082bc0194SAndreas Gruenbacher int err; 1661e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16624a76b161SAndreas Gruenbacher 16634a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16644a76b161SAndreas Gruenbacher if (!mdev) 16654a76b161SAndreas Gruenbacher return -EIO; 1666b411b363SPhilipp Reisner 1667b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1668b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1669b411b363SPhilipp Reisner 1670b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1671b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1672b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1673fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1674e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1675b411b363SPhilipp Reisner } else { 1676b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1677b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1678b411b363SPhilipp Reisner 1679e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1680b411b363SPhilipp Reisner 1681e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1682b411b363SPhilipp Reisner } 1683b411b363SPhilipp Reisner 1684e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1685778f271dSPhilipp Reisner 168682bc0194SAndreas Gruenbacher return err; 1687b411b363SPhilipp Reisner } 1688b411b363SPhilipp Reisner 168999920dc5SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 16907be8da07SAndreas Gruenbacher { 16917be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 16927be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16937be8da07SAndreas Gruenbacher struct bio *bio; 16947be8da07SAndreas Gruenbacher unsigned long start_time; 16957be8da07SAndreas Gruenbacher unsigned long flags; 16967be8da07SAndreas Gruenbacher 16977be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16987be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16997be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 170099920dc5SAndreas Gruenbacher return -EIO; 17017be8da07SAndreas Gruenbacher } 17027be8da07SAndreas Gruenbacher bio = req->master_bio; 17037be8da07SAndreas Gruenbacher start_time = req->start_time; 17047be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 17057be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 17067be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 17077be8da07SAndreas Gruenbacher 17087be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 17097be8da07SAndreas Gruenbacher /* retry */ ; 171099920dc5SAndreas Gruenbacher return 0; 17117be8da07SAndreas Gruenbacher } 17127be8da07SAndreas Gruenbacher 17137be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17147be8da07SAndreas Gruenbacher sector_t sector, int size) 17157be8da07SAndreas Gruenbacher { 17167be8da07SAndreas Gruenbacher struct drbd_interval *i; 17177be8da07SAndreas Gruenbacher struct drbd_request *req; 17187be8da07SAndreas Gruenbacher 17197be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17207be8da07SAndreas Gruenbacher if (!i->local) 17217be8da07SAndreas Gruenbacher continue; 17227be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 17237be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 17247be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 17257be8da07SAndreas Gruenbacher continue; 17267be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 17277be8da07SAndreas Gruenbacher req->w.mdev = mdev; 17287be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 17297be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 17307be8da07SAndreas Gruenbacher } 17317be8da07SAndreas Gruenbacher } 17327be8da07SAndreas Gruenbacher } 17337be8da07SAndreas Gruenbacher 1734a990be46SAndreas Gruenbacher /* 1735a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1736b411b363SPhilipp Reisner */ 173799920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1738b411b363SPhilipp Reisner { 17398050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17408050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 174100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1742db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 174399920dc5SAndreas Gruenbacher int err = 0, pcmd; 1744b411b363SPhilipp Reisner 1745303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1746db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1747b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1748b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1749db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1750b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 175199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1752b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1753db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1754b411b363SPhilipp Reisner } else { 175599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1756b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1757b411b363SPhilipp Reisner * maybe assert this? */ 1758b411b363SPhilipp Reisner } 1759b411b363SPhilipp Reisner dec_unacked(mdev); 1760b411b363SPhilipp Reisner } 1761b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1762b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1763302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 176487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1765db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1766db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 17677be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 17687be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 176987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1770bb3bfe96SAndreas Gruenbacher } else 1771db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1772b411b363SPhilipp Reisner 1773db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1774b411b363SPhilipp Reisner 177599920dc5SAndreas Gruenbacher return err; 1776b411b363SPhilipp Reisner } 1777b411b363SPhilipp Reisner 17787be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1779b411b363SPhilipp Reisner { 17807be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 17818050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17828050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 178399920dc5SAndreas Gruenbacher int err; 1784b411b363SPhilipp Reisner 178599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1786b411b363SPhilipp Reisner dec_unacked(mdev); 1787b411b363SPhilipp Reisner 178899920dc5SAndreas Gruenbacher return err; 1789b411b363SPhilipp Reisner } 1790b411b363SPhilipp Reisner 179199920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 17927be8da07SAndreas Gruenbacher { 17937be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17947be8da07SAndreas Gruenbacher } 17957be8da07SAndreas Gruenbacher 179699920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17977be8da07SAndreas Gruenbacher { 17987be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17997be8da07SAndreas Gruenbacher 18007be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 18017be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 18027be8da07SAndreas Gruenbacher } 18037be8da07SAndreas Gruenbacher 18043e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18053e394da1SAndreas Gruenbacher { 18063e394da1SAndreas Gruenbacher /* 18073e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18083e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18093e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18103e394da1SAndreas Gruenbacher */ 18113e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18123e394da1SAndreas Gruenbacher } 18133e394da1SAndreas Gruenbacher 18143e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18153e394da1SAndreas Gruenbacher { 18163e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18173e394da1SAndreas Gruenbacher } 18183e394da1SAndreas Gruenbacher 18197be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 18207be8da07SAndreas Gruenbacher { 18217be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 1822302bdeaeSPhilipp Reisner int tp; 18237be8da07SAndreas Gruenbacher 18247be8da07SAndreas Gruenbacher /* 18257be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 18267be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 18277be8da07SAndreas Gruenbacher * handle_write_conflicts(). 18287be8da07SAndreas Gruenbacher */ 1829302bdeaeSPhilipp Reisner 1830302bdeaeSPhilipp Reisner rcu_read_lock(); 1831302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1832302bdeaeSPhilipp Reisner rcu_read_unlock(); 1833302bdeaeSPhilipp Reisner 1834302bdeaeSPhilipp Reisner return tp && test_bit(DISCARD_CONCURRENT, &tconn->flags); 18357be8da07SAndreas Gruenbacher } 18367be8da07SAndreas Gruenbacher 183743ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 18383e394da1SAndreas Gruenbacher { 18393c13b680SLars Ellenberg unsigned int newest_peer_seq; 18403e394da1SAndreas Gruenbacher 18417be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 18423e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 18433c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 18443c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 18453e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 18463c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 18473c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 18483e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 18493e394da1SAndreas Gruenbacher } 18507be8da07SAndreas Gruenbacher } 18513e394da1SAndreas Gruenbacher 1852b411b363SPhilipp Reisner /* Called from receive_Data. 1853b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1854b411b363SPhilipp Reisner * 1855b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1856b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1857b411b363SPhilipp Reisner * been sent. 1858b411b363SPhilipp Reisner * 1859b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1860b411b363SPhilipp Reisner * 1861b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1862b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1863b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1864b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1865b411b363SPhilipp Reisner * 1866b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1867b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1868b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1869b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1870b411b363SPhilipp Reisner * 1871b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1872b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 18737be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1874b411b363SPhilipp Reisner { 1875b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1876b411b363SPhilipp Reisner long timeout; 18777be8da07SAndreas Gruenbacher int ret; 18787be8da07SAndreas Gruenbacher 18797be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 18807be8da07SAndreas Gruenbacher return 0; 18817be8da07SAndreas Gruenbacher 1882b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1883b411b363SPhilipp Reisner for (;;) { 18847be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 18857be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 18867be8da07SAndreas Gruenbacher ret = 0; 1887b411b363SPhilipp Reisner break; 18887be8da07SAndreas Gruenbacher } 1889b411b363SPhilipp Reisner if (signal_pending(current)) { 1890b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1891b411b363SPhilipp Reisner break; 1892b411b363SPhilipp Reisner } 18937be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1894b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 189544ed167dSPhilipp Reisner rcu_read_lock(); 189644ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 189744ed167dSPhilipp Reisner rcu_read_unlock(); 189871b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1899b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 19007be8da07SAndreas Gruenbacher if (!timeout) { 1901b411b363SPhilipp Reisner ret = -ETIMEDOUT; 190271b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1903b411b363SPhilipp Reisner break; 1904b411b363SPhilipp Reisner } 1905b411b363SPhilipp Reisner } 1906b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 19077be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1908b411b363SPhilipp Reisner return ret; 1909b411b363SPhilipp Reisner } 1910b411b363SPhilipp Reisner 1911688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1912688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1913688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1914688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 191576d2e7ecSPhilipp Reisner { 191676d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 191776d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1918688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 191976d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 192076d2e7ecSPhilipp Reisner } 192176d2e7ecSPhilipp Reisner 19227be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 19237be8da07SAndreas Gruenbacher unsigned int size) 19247be8da07SAndreas Gruenbacher { 19257be8da07SAndreas Gruenbacher struct drbd_interval *i; 19267be8da07SAndreas Gruenbacher 19277be8da07SAndreas Gruenbacher repeat: 19287be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19297be8da07SAndreas Gruenbacher struct drbd_request *req; 19307be8da07SAndreas Gruenbacher struct bio_and_error m; 19317be8da07SAndreas Gruenbacher 19327be8da07SAndreas Gruenbacher if (!i->local) 19337be8da07SAndreas Gruenbacher continue; 19347be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 19357be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 19367be8da07SAndreas Gruenbacher continue; 19377be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 19387be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 19397be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 19407be8da07SAndreas Gruenbacher if (m.bio) 19417be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 19427be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 19437be8da07SAndreas Gruenbacher goto repeat; 19447be8da07SAndreas Gruenbacher } 19457be8da07SAndreas Gruenbacher } 19467be8da07SAndreas Gruenbacher 19477be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 19487be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 19497be8da07SAndreas Gruenbacher { 19507be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 19517be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 19527be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 19537be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 19547be8da07SAndreas Gruenbacher struct drbd_interval *i; 19557be8da07SAndreas Gruenbacher bool equal; 19567be8da07SAndreas Gruenbacher int err; 19577be8da07SAndreas Gruenbacher 19587be8da07SAndreas Gruenbacher /* 19597be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 19607be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 19617be8da07SAndreas Gruenbacher */ 19627be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 19637be8da07SAndreas Gruenbacher 19647be8da07SAndreas Gruenbacher repeat: 19657be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19667be8da07SAndreas Gruenbacher if (i == &peer_req->i) 19677be8da07SAndreas Gruenbacher continue; 19687be8da07SAndreas Gruenbacher 19697be8da07SAndreas Gruenbacher if (!i->local) { 19707be8da07SAndreas Gruenbacher /* 19717be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 19727be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 19737be8da07SAndreas Gruenbacher * earlier peer request to complete. 19747be8da07SAndreas Gruenbacher */ 19757be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 19767be8da07SAndreas Gruenbacher if (err) 19777be8da07SAndreas Gruenbacher goto out; 19787be8da07SAndreas Gruenbacher goto repeat; 19797be8da07SAndreas Gruenbacher } 19807be8da07SAndreas Gruenbacher 19817be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 19827be8da07SAndreas Gruenbacher if (resolve_conflicts) { 19837be8da07SAndreas Gruenbacher /* 19847be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 19857be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 19867be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 19877be8da07SAndreas Gruenbacher * have completed. 19887be8da07SAndreas Gruenbacher */ 19897be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 19907be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 19917be8da07SAndreas Gruenbacher 19927be8da07SAndreas Gruenbacher if (!equal) 19937be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19947be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 19957be8da07SAndreas Gruenbacher "assuming %s came first\n", 19967be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19977be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 19987be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 19997be8da07SAndreas Gruenbacher 20007be8da07SAndreas Gruenbacher inc_unacked(mdev); 20017be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 20027be8da07SAndreas Gruenbacher e_send_retry_write; 20037be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 20047be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 20057be8da07SAndreas Gruenbacher 20067be8da07SAndreas Gruenbacher err = -ENOENT; 20077be8da07SAndreas Gruenbacher goto out; 20087be8da07SAndreas Gruenbacher } else { 20097be8da07SAndreas Gruenbacher struct drbd_request *req = 20107be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 20117be8da07SAndreas Gruenbacher 20127be8da07SAndreas Gruenbacher if (!equal) 20137be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20147be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 20157be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20167be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 20177be8da07SAndreas Gruenbacher 20187be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 20197be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 20207be8da07SAndreas Gruenbacher /* 20217be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 20227be8da07SAndreas Gruenbacher * decide if this request will be discarded or 20237be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 20247be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 20257be8da07SAndreas Gruenbacher * 20267be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 20277be8da07SAndreas Gruenbacher * request to finish locally before submitting 20287be8da07SAndreas Gruenbacher * the conflicting peer request. 20297be8da07SAndreas Gruenbacher */ 20307be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 20317be8da07SAndreas Gruenbacher if (err) { 20327be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 20337be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 20347be8da07SAndreas Gruenbacher CS_HARD); 20357be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 20367be8da07SAndreas Gruenbacher goto out; 20377be8da07SAndreas Gruenbacher } 20387be8da07SAndreas Gruenbacher goto repeat; 20397be8da07SAndreas Gruenbacher } 20407be8da07SAndreas Gruenbacher /* 20417be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 20427be8da07SAndreas Gruenbacher * the new peer request has completed. 20437be8da07SAndreas Gruenbacher */ 20447be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 20457be8da07SAndreas Gruenbacher } 20467be8da07SAndreas Gruenbacher } 20477be8da07SAndreas Gruenbacher err = 0; 20487be8da07SAndreas Gruenbacher 20497be8da07SAndreas Gruenbacher out: 20507be8da07SAndreas Gruenbacher if (err) 20517be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 20527be8da07SAndreas Gruenbacher return err; 20537be8da07SAndreas Gruenbacher } 20547be8da07SAndreas Gruenbacher 2055b411b363SPhilipp Reisner /* mirrored write */ 20564a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2057b411b363SPhilipp Reisner { 20584a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2059b411b363SPhilipp Reisner sector_t sector; 2060db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2061e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20627be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2063b411b363SPhilipp Reisner int rw = WRITE; 2064b411b363SPhilipp Reisner u32 dp_flags; 2065302bdeaeSPhilipp Reisner int err, tp; 20667be8da07SAndreas Gruenbacher 20674a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 20684a76b161SAndreas Gruenbacher if (!mdev) 20694a76b161SAndreas Gruenbacher return -EIO; 20704a76b161SAndreas Gruenbacher 2071b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 207282bc0194SAndreas Gruenbacher int err2; 207382bc0194SAndreas Gruenbacher 20747be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2075e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 2076b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 2077e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 207882bc0194SAndreas Gruenbacher if (!err) 207982bc0194SAndreas Gruenbacher err = err2; 208082bc0194SAndreas Gruenbacher return err; 2081b411b363SPhilipp Reisner } 2082b411b363SPhilipp Reisner 2083fcefa62eSAndreas Gruenbacher /* 2084fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2085fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2086fcefa62eSAndreas Gruenbacher * end of this function. 2087fcefa62eSAndreas Gruenbacher */ 2088b411b363SPhilipp Reisner 2089b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2090e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2091db830c46SAndreas Gruenbacher if (!peer_req) { 2092b411b363SPhilipp Reisner put_ldev(mdev); 209382bc0194SAndreas Gruenbacher return -EIO; 2094b411b363SPhilipp Reisner } 2095b411b363SPhilipp Reisner 2096db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2097b411b363SPhilipp Reisner 2098688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2099688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2100688593c5SLars Ellenberg 2101688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2102db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2103688593c5SLars Ellenberg 2104b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2105db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2106db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2107db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2108b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2109b411b363SPhilipp Reisner 2110302bdeaeSPhilipp Reisner rcu_read_lock(); 2111302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2112302bdeaeSPhilipp Reisner rcu_read_unlock(); 2113302bdeaeSPhilipp Reisner if (tp) { 2114302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 21157be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 21167be8da07SAndreas Gruenbacher if (err) 2117b411b363SPhilipp Reisner goto out_interrupted; 211887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 21197be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 21207be8da07SAndreas Gruenbacher if (err) { 212187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 21227be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2123b411b363SPhilipp Reisner put_ldev(mdev); 212482bc0194SAndreas Gruenbacher return 0; 2125b411b363SPhilipp Reisner } 2126b411b363SPhilipp Reisner goto out_interrupted; 2127b411b363SPhilipp Reisner } 21287be8da07SAndreas Gruenbacher } else 212987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2130db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 213187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2132b411b363SPhilipp Reisner 2133303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 213444ed167dSPhilipp Reisner rcu_read_lock(); 213544ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2136b411b363SPhilipp Reisner case DRBD_PROT_C: 2137303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2138303d1448SPhilipp Reisner break; 2139303d1448SPhilipp Reisner case DRBD_PROT_B: 2140303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2141303d1448SPhilipp Reisner break; 2142303d1448SPhilipp Reisner } 214344ed167dSPhilipp Reisner rcu_read_unlock(); 2144303d1448SPhilipp Reisner } 2145303d1448SPhilipp Reisner 2146303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2147303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2148b411b363SPhilipp Reisner inc_unacked(mdev); 2149b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2150b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2151303d1448SPhilipp Reisner } 2152303d1448SPhilipp Reisner 2153303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2154b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2155b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2156db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2157b411b363SPhilipp Reisner } 2158b411b363SPhilipp Reisner 21596719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2160b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2161db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2162db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2163db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2164181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2165b411b363SPhilipp Reisner } 2166b411b363SPhilipp Reisner 216782bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 216882bc0194SAndreas Gruenbacher if (!err) 216982bc0194SAndreas Gruenbacher return 0; 2170b411b363SPhilipp Reisner 217110f6d992SLars Ellenberg /* don't care for the reason here */ 217210f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 217387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2174db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2175db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 217687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2177db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2178181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 217922cc37a9SLars Ellenberg 2180b411b363SPhilipp Reisner out_interrupted: 2181db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2182b411b363SPhilipp Reisner put_ldev(mdev); 21833967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 218482bc0194SAndreas Gruenbacher return err; 2185b411b363SPhilipp Reisner } 2186b411b363SPhilipp Reisner 21870f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 21880f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 21890f0601f4SLars Ellenberg * 21900f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 21910f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 21920f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 21930f0601f4SLars Ellenberg * activity, it obviously is "busy". 21940f0601f4SLars Ellenberg * 21950f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 21960f0601f4SLars Ellenberg * to have a short time average so we can react faster. 21970f0601f4SLars Ellenberg */ 2198e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 21990f0601f4SLars Ellenberg { 22000f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 22010f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2202e3555d85SPhilipp Reisner struct lc_element *tmp; 22030f0601f4SLars Ellenberg int curr_events; 22040f0601f4SLars Ellenberg int throttle = 0; 2205daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2206daeda1ccSPhilipp Reisner 2207daeda1ccSPhilipp Reisner rcu_read_lock(); 2208daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2209daeda1ccSPhilipp Reisner rcu_read_unlock(); 22100f0601f4SLars Ellenberg 22110f0601f4SLars Ellenberg /* feature disabled? */ 2212daeda1ccSPhilipp Reisner if (c_min_rate == 0) 22130f0601f4SLars Ellenberg return 0; 22140f0601f4SLars Ellenberg 2215e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2216e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2217e3555d85SPhilipp Reisner if (tmp) { 2218e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2219e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2220e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2221e3555d85SPhilipp Reisner return 0; 2222e3555d85SPhilipp Reisner } 2223e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2224e3555d85SPhilipp Reisner } 2225e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2226e3555d85SPhilipp Reisner 22270f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 22280f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 22290f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2230e3555d85SPhilipp Reisner 22310f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 22320f0601f4SLars Ellenberg unsigned long rs_left; 22330f0601f4SLars Ellenberg int i; 22340f0601f4SLars Ellenberg 22350f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 22360f0601f4SLars Ellenberg 22370f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 22380f0601f4SLars Ellenberg * approx. */ 22392649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 22402649f080SLars Ellenberg 22412649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 22422649f080SLars Ellenberg rs_left = mdev->ov_left; 22432649f080SLars Ellenberg else 22440f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 22450f0601f4SLars Ellenberg 22460f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 22470f0601f4SLars Ellenberg if (!dt) 22480f0601f4SLars Ellenberg dt++; 22490f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 22500f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 22510f0601f4SLars Ellenberg 2252daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 22530f0601f4SLars Ellenberg throttle = 1; 22540f0601f4SLars Ellenberg } 22550f0601f4SLars Ellenberg return throttle; 22560f0601f4SLars Ellenberg } 22570f0601f4SLars Ellenberg 22580f0601f4SLars Ellenberg 22594a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2260b411b363SPhilipp Reisner { 22614a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2262b411b363SPhilipp Reisner sector_t sector; 22634a76b161SAndreas Gruenbacher sector_t capacity; 2264db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2265b411b363SPhilipp Reisner struct digest_info *di = NULL; 2266b18b37beSPhilipp Reisner int size, verb; 2267b411b363SPhilipp Reisner unsigned int fault_type; 2268e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 22694a76b161SAndreas Gruenbacher 22704a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 22714a76b161SAndreas Gruenbacher if (!mdev) 22724a76b161SAndreas Gruenbacher return -EIO; 22734a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2274b411b363SPhilipp Reisner 2275b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2276b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2277b411b363SPhilipp Reisner 2278c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2279b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2280b411b363SPhilipp Reisner (unsigned long long)sector, size); 228182bc0194SAndreas Gruenbacher return -EINVAL; 2282b411b363SPhilipp Reisner } 2283b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2284b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2285b411b363SPhilipp Reisner (unsigned long long)sector, size); 228682bc0194SAndreas Gruenbacher return -EINVAL; 2287b411b363SPhilipp Reisner } 2288b411b363SPhilipp Reisner 2289b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2290b18b37beSPhilipp Reisner verb = 1; 2291e2857216SAndreas Gruenbacher switch (pi->cmd) { 2292b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2293b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2294b18b37beSPhilipp Reisner break; 2295b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2296b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2297b18b37beSPhilipp Reisner case P_OV_REQUEST: 2298b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2299b18b37beSPhilipp Reisner break; 2300b18b37beSPhilipp Reisner case P_OV_REPLY: 2301b18b37beSPhilipp Reisner verb = 0; 2302b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2303b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2304b18b37beSPhilipp Reisner break; 2305b18b37beSPhilipp Reisner default: 230649ba9b1bSAndreas Gruenbacher BUG(); 2307b18b37beSPhilipp Reisner } 2308b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2309b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2310b411b363SPhilipp Reisner "no local data.\n"); 2311b18b37beSPhilipp Reisner 2312a821cc4aSLars Ellenberg /* drain possibly payload */ 2313e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2314b411b363SPhilipp Reisner } 2315b411b363SPhilipp Reisner 2316b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2317b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2318b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 23190db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2320db830c46SAndreas Gruenbacher if (!peer_req) { 2321b411b363SPhilipp Reisner put_ldev(mdev); 232282bc0194SAndreas Gruenbacher return -ENOMEM; 2323b411b363SPhilipp Reisner } 2324b411b363SPhilipp Reisner 2325e2857216SAndreas Gruenbacher switch (pi->cmd) { 2326b411b363SPhilipp Reisner case P_DATA_REQUEST: 2327db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2328b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 232980a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 233080a40e43SLars Ellenberg goto submit; 233180a40e43SLars Ellenberg 2332b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2333db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2334b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 23355f9915bbSLars Ellenberg /* used in the sector offset progress display */ 23365f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2337b411b363SPhilipp Reisner break; 2338b411b363SPhilipp Reisner 2339b411b363SPhilipp Reisner case P_OV_REPLY: 2340b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2341b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2342e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2343b411b363SPhilipp Reisner if (!di) 2344b411b363SPhilipp Reisner goto out_free_e; 2345b411b363SPhilipp Reisner 2346e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2347b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2348b411b363SPhilipp Reisner 2349db830c46SAndreas Gruenbacher peer_req->digest = di; 2350db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2351c36c3cedSLars Ellenberg 2352e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2353b411b363SPhilipp Reisner goto out_free_e; 2354b411b363SPhilipp Reisner 2355e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 235631890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2357db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 23585f9915bbSLars Ellenberg /* used in the sector offset progress display */ 23595f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2360e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 23612649f080SLars Ellenberg /* track progress, we may need to throttle */ 23622649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2363db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2364b411b363SPhilipp Reisner dec_rs_pending(mdev); 23650f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 23660f0601f4SLars Ellenberg * but accounting still needs to be done. */ 23670f0601f4SLars Ellenberg goto submit_for_resync; 2368b411b363SPhilipp Reisner } 2369b411b363SPhilipp Reisner break; 2370b411b363SPhilipp Reisner 2371b411b363SPhilipp Reisner case P_OV_REQUEST: 2372b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 237331890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2374de228bbaSLars Ellenberg unsigned long now = jiffies; 2375de228bbaSLars Ellenberg int i; 2376b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2377b411b363SPhilipp Reisner mdev->ov_position = sector; 237830b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 237930b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2380de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2381de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2382de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2383de228bbaSLars Ellenberg } 2384b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2385b411b363SPhilipp Reisner (unsigned long long)sector); 2386b411b363SPhilipp Reisner } 2387db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2388b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2389b411b363SPhilipp Reisner break; 2390b411b363SPhilipp Reisner 2391b411b363SPhilipp Reisner default: 239249ba9b1bSAndreas Gruenbacher BUG(); 2393b411b363SPhilipp Reisner } 2394b411b363SPhilipp Reisner 23950f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 23960f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 23970f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 23980f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 23990f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 24000f0601f4SLars Ellenberg * 24010f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 24020f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 24030f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 24040f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 24050f0601f4SLars Ellenberg * a while, anyways. 24060f0601f4SLars Ellenberg */ 2407b411b363SPhilipp Reisner 24080f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 24090f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 24100f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 24110f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 24120f0601f4SLars Ellenberg * 24130f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 24140f0601f4SLars Ellenberg * we would also throttle its application reads. 24150f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 24160f0601f4SLars Ellenberg */ 2417e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2418e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2419e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 242080a40e43SLars Ellenberg goto out_free_e; 2421b411b363SPhilipp Reisner 24220f0601f4SLars Ellenberg submit_for_resync: 24230f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 24240f0601f4SLars Ellenberg 242580a40e43SLars Ellenberg submit: 2426b411b363SPhilipp Reisner inc_unacked(mdev); 242787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2428db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 242987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2430b411b363SPhilipp Reisner 2431fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 243282bc0194SAndreas Gruenbacher return 0; 2433b411b363SPhilipp Reisner 243410f6d992SLars Ellenberg /* don't care for the reason here */ 243510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 243687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2437db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 243887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 243922cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 244022cc37a9SLars Ellenberg 2441b411b363SPhilipp Reisner out_free_e: 2442b411b363SPhilipp Reisner put_ldev(mdev); 24433967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 244482bc0194SAndreas Gruenbacher return -EIO; 2445b411b363SPhilipp Reisner } 2446b411b363SPhilipp Reisner 2447b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2448b411b363SPhilipp Reisner { 2449b411b363SPhilipp Reisner int self, peer, rv = -100; 2450b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 245144ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2452b411b363SPhilipp Reisner 2453b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2454b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2455b411b363SPhilipp Reisner 2456b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2457b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2458b411b363SPhilipp Reisner 245944ed167dSPhilipp Reisner rcu_read_lock(); 246044ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 246144ed167dSPhilipp Reisner rcu_read_unlock(); 246244ed167dSPhilipp Reisner switch (after_sb_0p) { 2463b411b363SPhilipp Reisner case ASB_CONSENSUS: 2464b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2465b411b363SPhilipp Reisner case ASB_CALL_HELPER: 246644ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2467b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2468b411b363SPhilipp Reisner break; 2469b411b363SPhilipp Reisner case ASB_DISCONNECT: 2470b411b363SPhilipp Reisner break; 2471b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2472b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2473b411b363SPhilipp Reisner rv = -1; 2474b411b363SPhilipp Reisner break; 2475b411b363SPhilipp Reisner } 2476b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2477b411b363SPhilipp Reisner rv = 1; 2478b411b363SPhilipp Reisner break; 2479b411b363SPhilipp Reisner } 2480b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2481b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2482b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2483b411b363SPhilipp Reisner rv = 1; 2484b411b363SPhilipp Reisner break; 2485b411b363SPhilipp Reisner } 2486b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2487b411b363SPhilipp Reisner rv = -1; 2488b411b363SPhilipp Reisner break; 2489b411b363SPhilipp Reisner } 2490b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2491ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2492b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2493b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2494b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 249525703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2496b411b363SPhilipp Reisner ? -1 : 1; 2497b411b363SPhilipp Reisner break; 2498b411b363SPhilipp Reisner } else { 2499b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2500b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2501b411b363SPhilipp Reisner } 250244ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2503b411b363SPhilipp Reisner break; 2504b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2505b411b363SPhilipp Reisner if (ch_self < ch_peer) 2506b411b363SPhilipp Reisner rv = -1; 2507b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2508b411b363SPhilipp Reisner rv = 1; 2509b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2510b411b363SPhilipp Reisner /* Well, then use something else. */ 251125703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2512b411b363SPhilipp Reisner ? -1 : 1; 2513b411b363SPhilipp Reisner break; 2514b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2515b411b363SPhilipp Reisner rv = -1; 2516b411b363SPhilipp Reisner break; 2517b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2518b411b363SPhilipp Reisner rv = 1; 2519b411b363SPhilipp Reisner } 2520b411b363SPhilipp Reisner 2521b411b363SPhilipp Reisner return rv; 2522b411b363SPhilipp Reisner } 2523b411b363SPhilipp Reisner 2524b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2525b411b363SPhilipp Reisner { 25266184ea21SAndreas Gruenbacher int hg, rv = -100; 252744ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2528b411b363SPhilipp Reisner 252944ed167dSPhilipp Reisner rcu_read_lock(); 253044ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 253144ed167dSPhilipp Reisner rcu_read_unlock(); 253244ed167dSPhilipp Reisner switch (after_sb_1p) { 2533b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2534b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2535b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2536b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2537b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 253844ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2539b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2540b411b363SPhilipp Reisner break; 2541b411b363SPhilipp Reisner case ASB_DISCONNECT: 2542b411b363SPhilipp Reisner break; 2543b411b363SPhilipp Reisner case ASB_CONSENSUS: 2544b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2545b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2546b411b363SPhilipp Reisner rv = hg; 2547b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2548b411b363SPhilipp Reisner rv = hg; 2549b411b363SPhilipp Reisner break; 2550b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2551b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2552b411b363SPhilipp Reisner break; 2553b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2554b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2555b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2556b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2557b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2558bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2559bb437946SAndreas Gruenbacher 2560bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2561b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2562b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2563b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2564bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2565bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2566b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2567b411b363SPhilipp Reisner } else { 2568b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2569b411b363SPhilipp Reisner rv = hg; 2570b411b363SPhilipp Reisner } 2571b411b363SPhilipp Reisner } else 2572b411b363SPhilipp Reisner rv = hg; 2573b411b363SPhilipp Reisner } 2574b411b363SPhilipp Reisner 2575b411b363SPhilipp Reisner return rv; 2576b411b363SPhilipp Reisner } 2577b411b363SPhilipp Reisner 2578b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2579b411b363SPhilipp Reisner { 25806184ea21SAndreas Gruenbacher int hg, rv = -100; 258144ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2582b411b363SPhilipp Reisner 258344ed167dSPhilipp Reisner rcu_read_lock(); 258444ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 258544ed167dSPhilipp Reisner rcu_read_unlock(); 258644ed167dSPhilipp Reisner switch (after_sb_2p) { 2587b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2588b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2589b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2590b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2591b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2592b411b363SPhilipp Reisner case ASB_CONSENSUS: 2593b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 259444ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2595b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2596b411b363SPhilipp Reisner break; 2597b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2598b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2599b411b363SPhilipp Reisner break; 2600b411b363SPhilipp Reisner case ASB_DISCONNECT: 2601b411b363SPhilipp Reisner break; 2602b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2603b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2604b411b363SPhilipp Reisner if (hg == -1) { 2605bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2606bb437946SAndreas Gruenbacher 2607b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2608b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2609b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2610bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2611bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2612b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2613b411b363SPhilipp Reisner } else { 2614b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2615b411b363SPhilipp Reisner rv = hg; 2616b411b363SPhilipp Reisner } 2617b411b363SPhilipp Reisner } else 2618b411b363SPhilipp Reisner rv = hg; 2619b411b363SPhilipp Reisner } 2620b411b363SPhilipp Reisner 2621b411b363SPhilipp Reisner return rv; 2622b411b363SPhilipp Reisner } 2623b411b363SPhilipp Reisner 2624b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2625b411b363SPhilipp Reisner u64 bits, u64 flags) 2626b411b363SPhilipp Reisner { 2627b411b363SPhilipp Reisner if (!uuid) { 2628b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2629b411b363SPhilipp Reisner return; 2630b411b363SPhilipp Reisner } 2631b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2632b411b363SPhilipp Reisner text, 2633b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2634b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2635b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2636b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2637b411b363SPhilipp Reisner (unsigned long long)bits, 2638b411b363SPhilipp Reisner (unsigned long long)flags); 2639b411b363SPhilipp Reisner } 2640b411b363SPhilipp Reisner 2641b411b363SPhilipp Reisner /* 2642b411b363SPhilipp Reisner 100 after split brain try auto recover 2643b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2644b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2645b411b363SPhilipp Reisner 0 no Sync 2646b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2647b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2648b411b363SPhilipp Reisner -100 after split brain, disconnect 2649b411b363SPhilipp Reisner -1000 unrelated data 26504a23f264SPhilipp Reisner -1091 requires proto 91 26514a23f264SPhilipp Reisner -1096 requires proto 96 2652b411b363SPhilipp Reisner */ 2653b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2654b411b363SPhilipp Reisner { 2655b411b363SPhilipp Reisner u64 self, peer; 2656b411b363SPhilipp Reisner int i, j; 2657b411b363SPhilipp Reisner 2658b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2659b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2660b411b363SPhilipp Reisner 2661b411b363SPhilipp Reisner *rule_nr = 10; 2662b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2663b411b363SPhilipp Reisner return 0; 2664b411b363SPhilipp Reisner 2665b411b363SPhilipp Reisner *rule_nr = 20; 2666b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2667b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2668b411b363SPhilipp Reisner return -2; 2669b411b363SPhilipp Reisner 2670b411b363SPhilipp Reisner *rule_nr = 30; 2671b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2672b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2673b411b363SPhilipp Reisner return 2; 2674b411b363SPhilipp Reisner 2675b411b363SPhilipp Reisner if (self == peer) { 2676b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2677b411b363SPhilipp Reisner 2678b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2679b411b363SPhilipp Reisner 268031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26814a23f264SPhilipp Reisner return -1091; 2682b411b363SPhilipp Reisner 2683b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2684b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2685b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2686b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2687b411b363SPhilipp Reisner 2688b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2689b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2690b411b363SPhilipp Reisner *rule_nr = 34; 2691b411b363SPhilipp Reisner } else { 2692b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2693b411b363SPhilipp Reisner *rule_nr = 36; 2694b411b363SPhilipp Reisner } 2695b411b363SPhilipp Reisner 2696b411b363SPhilipp Reisner return 1; 2697b411b363SPhilipp Reisner } 2698b411b363SPhilipp Reisner 2699b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2700b411b363SPhilipp Reisner 270131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27024a23f264SPhilipp Reisner return -1091; 2703b411b363SPhilipp Reisner 2704b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2705b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2706b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2707b411b363SPhilipp Reisner 2708b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2709b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2710b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2711b411b363SPhilipp Reisner 2712b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2713b411b363SPhilipp Reisner *rule_nr = 35; 2714b411b363SPhilipp Reisner } else { 2715b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2716b411b363SPhilipp Reisner *rule_nr = 37; 2717b411b363SPhilipp Reisner } 2718b411b363SPhilipp Reisner 2719b411b363SPhilipp Reisner return -1; 2720b411b363SPhilipp Reisner } 2721b411b363SPhilipp Reisner 2722b411b363SPhilipp Reisner /* Common power [off|failure] */ 2723b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2724b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2725b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2726b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2727b411b363SPhilipp Reisner *rule_nr = 40; 2728b411b363SPhilipp Reisner 2729b411b363SPhilipp Reisner switch (rct) { 2730b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2731b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2732b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2733b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 273425703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2735b411b363SPhilipp Reisner return dc ? -1 : 1; 2736b411b363SPhilipp Reisner } 2737b411b363SPhilipp Reisner } 2738b411b363SPhilipp Reisner 2739b411b363SPhilipp Reisner *rule_nr = 50; 2740b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2741b411b363SPhilipp Reisner if (self == peer) 2742b411b363SPhilipp Reisner return -1; 2743b411b363SPhilipp Reisner 2744b411b363SPhilipp Reisner *rule_nr = 51; 2745b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2746b411b363SPhilipp Reisner if (self == peer) { 274731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 27484a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 27494a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 27504a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2751b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2752b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2753b411b363SPhilipp Reisner 275431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27554a23f264SPhilipp Reisner return -1091; 2756b411b363SPhilipp Reisner 2757b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2758b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 27594a23f264SPhilipp Reisner 27604a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 27614a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 27624a23f264SPhilipp Reisner 2763b411b363SPhilipp Reisner return -1; 2764b411b363SPhilipp Reisner } 2765b411b363SPhilipp Reisner } 2766b411b363SPhilipp Reisner 2767b411b363SPhilipp Reisner *rule_nr = 60; 2768b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2769b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2770b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2771b411b363SPhilipp Reisner if (self == peer) 2772b411b363SPhilipp Reisner return -2; 2773b411b363SPhilipp Reisner } 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner *rule_nr = 70; 2776b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2777b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2778b411b363SPhilipp Reisner if (self == peer) 2779b411b363SPhilipp Reisner return 1; 2780b411b363SPhilipp Reisner 2781b411b363SPhilipp Reisner *rule_nr = 71; 2782b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2783b411b363SPhilipp Reisner if (self == peer) { 278431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 27854a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 27864a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 27874a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2788b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2789b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2790b411b363SPhilipp Reisner 279131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27924a23f264SPhilipp Reisner return -1091; 2793b411b363SPhilipp Reisner 2794b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2795b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2796b411b363SPhilipp Reisner 27974a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2798b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2799b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2800b411b363SPhilipp Reisner 2801b411b363SPhilipp Reisner return 1; 2802b411b363SPhilipp Reisner } 2803b411b363SPhilipp Reisner } 2804b411b363SPhilipp Reisner 2805b411b363SPhilipp Reisner 2806b411b363SPhilipp Reisner *rule_nr = 80; 2807d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2808b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2809b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2810b411b363SPhilipp Reisner if (self == peer) 2811b411b363SPhilipp Reisner return 2; 2812b411b363SPhilipp Reisner } 2813b411b363SPhilipp Reisner 2814b411b363SPhilipp Reisner *rule_nr = 90; 2815b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2816b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2817b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2818b411b363SPhilipp Reisner return 100; 2819b411b363SPhilipp Reisner 2820b411b363SPhilipp Reisner *rule_nr = 100; 2821b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2822b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2823b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2824b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2825b411b363SPhilipp Reisner if (self == peer) 2826b411b363SPhilipp Reisner return -100; 2827b411b363SPhilipp Reisner } 2828b411b363SPhilipp Reisner } 2829b411b363SPhilipp Reisner 2830b411b363SPhilipp Reisner return -1000; 2831b411b363SPhilipp Reisner } 2832b411b363SPhilipp Reisner 2833b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2834b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2835b411b363SPhilipp Reisner */ 2836b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2837b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2838b411b363SPhilipp Reisner { 2839b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2840b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 284144ed167dSPhilipp Reisner struct net_conf *nc; 284244ed167dSPhilipp Reisner int hg, rule_nr, rr_conflict, dry_run; 2843b411b363SPhilipp Reisner 2844b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2845b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2846b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2847b411b363SPhilipp Reisner 2848b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2849b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2850b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2851b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2852b411b363SPhilipp Reisner 2853b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2854b411b363SPhilipp Reisner 2855b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2856b411b363SPhilipp Reisner 2857b411b363SPhilipp Reisner if (hg == -1000) { 2858b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2859b411b363SPhilipp Reisner return C_MASK; 2860b411b363SPhilipp Reisner } 28614a23f264SPhilipp Reisner if (hg < -1000) { 28624a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2863b411b363SPhilipp Reisner return C_MASK; 2864b411b363SPhilipp Reisner } 2865b411b363SPhilipp Reisner 2866b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2867b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2868b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2869b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2870b411b363SPhilipp Reisner if (f) 2871b411b363SPhilipp Reisner hg = hg*2; 2872b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2873b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2874b411b363SPhilipp Reisner } 2875b411b363SPhilipp Reisner 28763a11a487SAdam Gandelman if (abs(hg) == 100) 28773a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 28783a11a487SAdam Gandelman 287944ed167dSPhilipp Reisner rcu_read_lock(); 288044ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 288144ed167dSPhilipp Reisner 288244ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2883b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2884b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2885b411b363SPhilipp Reisner int forced = (hg == -100); 2886b411b363SPhilipp Reisner 2887b411b363SPhilipp Reisner switch (pcount) { 2888b411b363SPhilipp Reisner case 0: 2889b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2890b411b363SPhilipp Reisner break; 2891b411b363SPhilipp Reisner case 1: 2892b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2893b411b363SPhilipp Reisner break; 2894b411b363SPhilipp Reisner case 2: 2895b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2896b411b363SPhilipp Reisner break; 2897b411b363SPhilipp Reisner } 2898b411b363SPhilipp Reisner if (abs(hg) < 100) { 2899b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2900b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2901b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2902b411b363SPhilipp Reisner if (forced) { 2903b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2904b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2905b411b363SPhilipp Reisner hg = hg*2; 2906b411b363SPhilipp Reisner } 2907b411b363SPhilipp Reisner } 2908b411b363SPhilipp Reisner } 2909b411b363SPhilipp Reisner 2910b411b363SPhilipp Reisner if (hg == -100) { 29116139f60dSAndreas Gruenbacher if (nc->discard_my_data && !(mdev->p_uuid[UI_FLAGS]&1)) 2912b411b363SPhilipp Reisner hg = -1; 29136139f60dSAndreas Gruenbacher if (!nc->discard_my_data && (mdev->p_uuid[UI_FLAGS]&1)) 2914b411b363SPhilipp Reisner hg = 1; 2915b411b363SPhilipp Reisner 2916b411b363SPhilipp Reisner if (abs(hg) < 100) 2917b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2918b411b363SPhilipp Reisner "Sync from %s node\n", 2919b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2920b411b363SPhilipp Reisner } 292144ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 292244ed167dSPhilipp Reisner dry_run = nc->dry_run; 292344ed167dSPhilipp Reisner rcu_read_unlock(); 2924b411b363SPhilipp Reisner 2925b411b363SPhilipp Reisner if (hg == -100) { 2926580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2927580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2928580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2929580b9767SLars Ellenberg * to that disk, in a way... */ 29303a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2931b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2932b411b363SPhilipp Reisner return C_MASK; 2933b411b363SPhilipp Reisner } 2934b411b363SPhilipp Reisner 2935b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2936b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2937b411b363SPhilipp Reisner return C_MASK; 2938b411b363SPhilipp Reisner } 2939b411b363SPhilipp Reisner 2940b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2941b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 294244ed167dSPhilipp Reisner switch (rr_conflict) { 2943b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2944b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2945b411b363SPhilipp Reisner /* fall through */ 2946b411b363SPhilipp Reisner case ASB_DISCONNECT: 2947b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2948b411b363SPhilipp Reisner return C_MASK; 2949b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2950b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2951b411b363SPhilipp Reisner "assumption\n"); 2952b411b363SPhilipp Reisner } 2953b411b363SPhilipp Reisner } 2954b411b363SPhilipp Reisner 295544ed167dSPhilipp Reisner if (dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2956cf14c2e9SPhilipp Reisner if (hg == 0) 2957cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2958cf14c2e9SPhilipp Reisner else 2959cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2960cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2961cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2962cf14c2e9SPhilipp Reisner return C_MASK; 2963cf14c2e9SPhilipp Reisner } 2964cf14c2e9SPhilipp Reisner 2965b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2966b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 296720ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 296820ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2969b411b363SPhilipp Reisner return C_MASK; 2970b411b363SPhilipp Reisner } 2971b411b363SPhilipp Reisner 2972b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2973b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2974b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2975b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2976b411b363SPhilipp Reisner } else { 2977b411b363SPhilipp Reisner rv = C_CONNECTED; 2978b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2979b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2980b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2981b411b363SPhilipp Reisner } 2982b411b363SPhilipp Reisner } 2983b411b363SPhilipp Reisner 2984b411b363SPhilipp Reisner return rv; 2985b411b363SPhilipp Reisner } 2986b411b363SPhilipp Reisner 2987f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 2988b411b363SPhilipp Reisner { 2989b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2990f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 2991f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 2992b411b363SPhilipp Reisner 2993b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2994f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 2995f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 2996b411b363SPhilipp Reisner 2997b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2998f179d76dSPhilipp Reisner return peer; 2999b411b363SPhilipp Reisner } 3000b411b363SPhilipp Reisner 3001e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3002b411b363SPhilipp Reisner { 3003e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3004036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3005036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3006036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3007036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3008036b17eaSPhilipp Reisner struct crypto_hash *peer_tfm = NULL, *tfm = NULL; 30097aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3010b411b363SPhilipp Reisner 3011b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3012b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3013b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3014b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3015b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3016cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 30176139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3018cf14c2e9SPhilipp Reisner 301986db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 302086db0618SAndreas Gruenbacher int err; 302186db0618SAndreas Gruenbacher 302288104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 302386db0618SAndreas Gruenbacher return -EIO; 302488104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 302586db0618SAndreas Gruenbacher if (err) 302686db0618SAndreas Gruenbacher return err; 302788104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3028036b17eaSPhilipp Reisner } 302986db0618SAndreas Gruenbacher 3030036b17eaSPhilipp Reisner if (pi->cmd == P_PROTOCOL_UPDATE) { 303188104ca4SAndreas Gruenbacher if (integrity_alg[0]) { 30327aca6c75SPhilipp Reisner int hash_size; 30337aca6c75SPhilipp Reisner 3034036b17eaSPhilipp Reisner peer_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 303588104ca4SAndreas Gruenbacher tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 3036036b17eaSPhilipp Reisner if (!(peer_tfm && tfm)) { 303788104ca4SAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 303888104ca4SAndreas Gruenbacher integrity_alg); 303988104ca4SAndreas Gruenbacher goto disconnect; 304088104ca4SAndreas Gruenbacher } 30417aca6c75SPhilipp Reisner 30427aca6c75SPhilipp Reisner hash_size = crypto_hash_digestsize(tfm); 30437aca6c75SPhilipp Reisner int_dig_in = kmalloc(hash_size, GFP_KERNEL); 30447aca6c75SPhilipp Reisner int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 30457aca6c75SPhilipp Reisner if (!(int_dig_in && int_dig_vv)) { 3046036b17eaSPhilipp Reisner conn_err(tconn, "Allocation of buffers for data integrity checking failed\n"); 30477aca6c75SPhilipp Reisner goto disconnect; 30487aca6c75SPhilipp Reisner } 304988104ca4SAndreas Gruenbacher } 305088104ca4SAndreas Gruenbacher 3051036b17eaSPhilipp Reisner new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 3052036b17eaSPhilipp Reisner if (!new_net_conf) { 3053036b17eaSPhilipp Reisner conn_err(tconn, "Allocation of new net_conf failed\n"); 3054036b17eaSPhilipp Reisner goto disconnect; 3055036b17eaSPhilipp Reisner } 3056036b17eaSPhilipp Reisner 3057036b17eaSPhilipp Reisner mutex_lock(&tconn->data.mutex); 3058036b17eaSPhilipp Reisner mutex_lock(&tconn->conf_update); 3059036b17eaSPhilipp Reisner old_net_conf = tconn->net_conf; 3060036b17eaSPhilipp Reisner *new_net_conf = *old_net_conf; 3061036b17eaSPhilipp Reisner 3062036b17eaSPhilipp Reisner new_net_conf->wire_protocol = p_proto; 3063036b17eaSPhilipp Reisner new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 3064036b17eaSPhilipp Reisner new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 3065036b17eaSPhilipp Reisner new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 3066036b17eaSPhilipp Reisner new_net_conf->two_primaries = p_two_primaries; 3067036b17eaSPhilipp Reisner strcpy(new_net_conf->integrity_alg, integrity_alg); 3068036b17eaSPhilipp Reisner new_net_conf->integrity_alg_len = strlen(integrity_alg) + 1; 3069036b17eaSPhilipp Reisner 3070036b17eaSPhilipp Reisner crypto_free_hash(tconn->integrity_tfm); 3071036b17eaSPhilipp Reisner tconn->integrity_tfm = tfm; 3072036b17eaSPhilipp Reisner 3073036b17eaSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 3074036b17eaSPhilipp Reisner mutex_unlock(&tconn->conf_update); 3075036b17eaSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 3076036b17eaSPhilipp Reisner 307788104ca4SAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 30787aca6c75SPhilipp Reisner kfree(tconn->int_dig_in); 30797aca6c75SPhilipp Reisner kfree(tconn->int_dig_vv); 3080036b17eaSPhilipp Reisner tconn->peer_integrity_tfm = peer_tfm; 30817aca6c75SPhilipp Reisner tconn->int_dig_in = int_dig_in; 30827aca6c75SPhilipp Reisner tconn->int_dig_vv = int_dig_vv; 3083036b17eaSPhilipp Reisner 3084036b17eaSPhilipp Reisner if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 3085036b17eaSPhilipp Reisner conn_info(tconn, "peer data-integrity-alg: %s\n", integrity_alg); 3086036b17eaSPhilipp Reisner 3087036b17eaSPhilipp Reisner synchronize_rcu(); 3088036b17eaSPhilipp Reisner kfree(old_net_conf); 3089036b17eaSPhilipp Reisner 3090036b17eaSPhilipp Reisner return 0; 309186db0618SAndreas Gruenbacher } 309286db0618SAndreas Gruenbacher 30937204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3094cf14c2e9SPhilipp Reisner 3095cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 30967204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3097b411b363SPhilipp Reisner 309844ed167dSPhilipp Reisner rcu_read_lock(); 309944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 310044ed167dSPhilipp Reisner 3101036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 31027204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 310344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3104b411b363SPhilipp Reisner } 3105b411b363SPhilipp Reisner 3106f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 31077204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 310844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3109b411b363SPhilipp Reisner } 3110b411b363SPhilipp Reisner 3111f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 31127204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 311344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3114b411b363SPhilipp Reisner } 3115b411b363SPhilipp Reisner 3116f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 31177204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 311844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3119b411b363SPhilipp Reisner } 3120b411b363SPhilipp Reisner 31216139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 31226139f60dSAndreas Gruenbacher conn_err(tconn, "both sides have the 'discard_my_data' flag set\n"); 312344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3124b411b363SPhilipp Reisner } 3125b411b363SPhilipp Reisner 312644ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 31277204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 312844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3129b411b363SPhilipp Reisner } 3130b411b363SPhilipp Reisner 3131036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 3132036b17eaSPhilipp Reisner conn_err(tconn, "incompatible setting of the data-integrity-alg\n"); 3133036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3134036b17eaSPhilipp Reisner } 3135036b17eaSPhilipp Reisner 313686db0618SAndreas Gruenbacher rcu_read_unlock(); 313786db0618SAndreas Gruenbacher 313882bc0194SAndreas Gruenbacher return 0; 3139b411b363SPhilipp Reisner 314044ed167dSPhilipp Reisner disconnect_rcu_unlock: 314144ed167dSPhilipp Reisner rcu_read_unlock(); 3142b411b363SPhilipp Reisner disconnect: 3143036b17eaSPhilipp Reisner crypto_free_hash(peer_tfm); 3144036b17eaSPhilipp Reisner crypto_free_hash(tfm); 3145036b17eaSPhilipp Reisner kfree(int_dig_in); 3146036b17eaSPhilipp Reisner kfree(int_dig_vv); 31477204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 314882bc0194SAndreas Gruenbacher return -EIO; 3149b411b363SPhilipp Reisner } 3150b411b363SPhilipp Reisner 3151b411b363SPhilipp Reisner /* helper function 3152b411b363SPhilipp Reisner * input: alg name, feature name 3153b411b363SPhilipp Reisner * return: NULL (alg name was "") 3154b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3155b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3156b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3157b411b363SPhilipp Reisner const char *alg, const char *name) 3158b411b363SPhilipp Reisner { 3159b411b363SPhilipp Reisner struct crypto_hash *tfm; 3160b411b363SPhilipp Reisner 3161b411b363SPhilipp Reisner if (!alg[0]) 3162b411b363SPhilipp Reisner return NULL; 3163b411b363SPhilipp Reisner 3164b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3165b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3166b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3167b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3168b411b363SPhilipp Reisner return tfm; 3169b411b363SPhilipp Reisner } 3170b411b363SPhilipp Reisner return tfm; 3171b411b363SPhilipp Reisner } 3172b411b363SPhilipp Reisner 31734a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3174b411b363SPhilipp Reisner { 31754a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 31764a76b161SAndreas Gruenbacher int size = pi->size; 31774a76b161SAndreas Gruenbacher 31784a76b161SAndreas Gruenbacher while (size) { 31794a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 31804a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 31814a76b161SAndreas Gruenbacher if (s <= 0) { 31824a76b161SAndreas Gruenbacher if (s < 0) 31834a76b161SAndreas Gruenbacher return s; 31844a76b161SAndreas Gruenbacher break; 31854a76b161SAndreas Gruenbacher } 31864a76b161SAndreas Gruenbacher size -= s; 31874a76b161SAndreas Gruenbacher } 31884a76b161SAndreas Gruenbacher if (size) 31894a76b161SAndreas Gruenbacher return -EIO; 31904a76b161SAndreas Gruenbacher return 0; 31914a76b161SAndreas Gruenbacher } 31924a76b161SAndreas Gruenbacher 31934a76b161SAndreas Gruenbacher /* 31944a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 31954a76b161SAndreas Gruenbacher * 31964a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 31974a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 31984a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 31994a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 32004a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 32014a76b161SAndreas Gruenbacher * 32024a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 32034a76b161SAndreas Gruenbacher */ 32044a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 32054a76b161SAndreas Gruenbacher { 32064a76b161SAndreas Gruenbacher conn_warn(tconn, "Volume %u unknown; ignoring %s packet\n", 32074a76b161SAndreas Gruenbacher pi->vnr, cmdname(pi->cmd)); 32084a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 32094a76b161SAndreas Gruenbacher } 32104a76b161SAndreas Gruenbacher 32114a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 32124a76b161SAndreas Gruenbacher { 32134a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3214e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3215b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3216b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3217b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 32182ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3219813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 32204a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3221813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3222778f271dSPhilipp Reisner int fifo_size = 0; 322382bc0194SAndreas Gruenbacher int err; 3224b411b363SPhilipp Reisner 32254a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 32264a76b161SAndreas Gruenbacher if (!mdev) 32274a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 32284a76b161SAndreas Gruenbacher 3229b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3230b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3231b411b363SPhilipp Reisner + SHARED_SECRET_MAX 32328e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 32338e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3234b411b363SPhilipp Reisner 3235e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3236b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3237e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 323882bc0194SAndreas Gruenbacher return -EIO; 3239b411b363SPhilipp Reisner } 3240b411b363SPhilipp Reisner 3241b411b363SPhilipp Reisner if (apv <= 88) { 3242e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3243e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 32448e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3245e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3246e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3247b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 32488e26f9ccSPhilipp Reisner } else { 3249e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3250e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3251b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3252b411b363SPhilipp Reisner } 3253b411b363SPhilipp Reisner 3254b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3255e658983aSAndreas Gruenbacher p = pi->data; 3256b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3257b411b363SPhilipp Reisner 3258e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 325982bc0194SAndreas Gruenbacher if (err) 326082bc0194SAndreas Gruenbacher return err; 3261b411b363SPhilipp Reisner 3262813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3263813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3264813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3265daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3266daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3267813472ceSPhilipp Reisner put_ldev(mdev); 3268813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3269daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3270daeda1ccSPhilipp Reisner return -ENOMEM; 3271f399002eSLars Ellenberg } 3272b411b363SPhilipp Reisner 3273daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3274daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3275daeda1ccSPhilipp Reisner 32766394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3277813472ceSPhilipp Reisner } 3278daeda1ccSPhilipp Reisner 3279b411b363SPhilipp Reisner if (apv >= 88) { 3280b411b363SPhilipp Reisner if (apv == 88) { 3281b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3282b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3283b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3284b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3285813472ceSPhilipp Reisner err = -EIO; 3286813472ceSPhilipp Reisner goto reconnect; 3287b411b363SPhilipp Reisner } 3288b411b363SPhilipp Reisner 328982bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3290813472ceSPhilipp Reisner if (err) 3291813472ceSPhilipp Reisner goto reconnect; 3292b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3293b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3294b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3295b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3296b411b363SPhilipp Reisner 3297b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3298b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3299b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3300b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3301b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3302b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3303b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3304b411b363SPhilipp Reisner } 3305b411b363SPhilipp Reisner 33062ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3307b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3308b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 33092ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3310b411b363SPhilipp Reisner goto disconnect; 3311b411b363SPhilipp Reisner } 3312b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3313b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3314b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3315b411b363SPhilipp Reisner verify_tfm = NULL; 3316b411b363SPhilipp Reisner goto disconnect; 3317b411b363SPhilipp Reisner } 3318b411b363SPhilipp Reisner } 3319b411b363SPhilipp Reisner 33202ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3321b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3322b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 33232ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3324b411b363SPhilipp Reisner goto disconnect; 3325b411b363SPhilipp Reisner } 3326b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3327b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3328b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3329b411b363SPhilipp Reisner csums_tfm = NULL; 3330b411b363SPhilipp Reisner goto disconnect; 3331b411b363SPhilipp Reisner } 3332b411b363SPhilipp Reisner } 3333b411b363SPhilipp Reisner 3334813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3335daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3336daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3337daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3338daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3339778f271dSPhilipp Reisner 3340daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 33419958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3342813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3343813472ceSPhilipp Reisner if (!new_plan) { 3344778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3345f399002eSLars Ellenberg put_ldev(mdev); 3346778f271dSPhilipp Reisner goto disconnect; 3347778f271dSPhilipp Reisner } 3348778f271dSPhilipp Reisner } 33498e26f9ccSPhilipp Reisner } 3350b411b363SPhilipp Reisner 335191fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 33522ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 33532ec91e0eSPhilipp Reisner if (!new_net_conf) { 335491fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 335591fd4dadSPhilipp Reisner goto disconnect; 335691fd4dadSPhilipp Reisner } 335791fd4dadSPhilipp Reisner 33582ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 335991fd4dadSPhilipp Reisner 3360b411b363SPhilipp Reisner if (verify_tfm) { 33612ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 33622ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3363f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3364f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3365b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3366b411b363SPhilipp Reisner } 3367b411b363SPhilipp Reisner if (csums_tfm) { 33682ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 33692ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3370f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3371f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3372b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3373b411b363SPhilipp Reisner } 33742ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 337591fd4dadSPhilipp Reisner } 337691fd4dadSPhilipp Reisner } 337791fd4dadSPhilipp Reisner 3378813472ceSPhilipp Reisner if (new_disk_conf) { 3379daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3380813472ceSPhilipp Reisner put_ldev(mdev); 3381778f271dSPhilipp Reisner } 3382813472ceSPhilipp Reisner 3383813472ceSPhilipp Reisner if (new_plan) { 3384813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3385813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3386813472ceSPhilipp Reisner } 3387daeda1ccSPhilipp Reisner 3388daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3389daeda1ccSPhilipp Reisner synchronize_rcu(); 3390daeda1ccSPhilipp Reisner if (new_net_conf) 3391daeda1ccSPhilipp Reisner kfree(old_net_conf); 3392daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3393813472ceSPhilipp Reisner kfree(old_plan); 3394daeda1ccSPhilipp Reisner 339582bc0194SAndreas Gruenbacher return 0; 3396b411b363SPhilipp Reisner 3397813472ceSPhilipp Reisner reconnect: 3398813472ceSPhilipp Reisner if (new_disk_conf) { 3399813472ceSPhilipp Reisner put_ldev(mdev); 3400813472ceSPhilipp Reisner kfree(new_disk_conf); 3401813472ceSPhilipp Reisner } 3402813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3403813472ceSPhilipp Reisner return -EIO; 3404813472ceSPhilipp Reisner 3405b411b363SPhilipp Reisner disconnect: 3406813472ceSPhilipp Reisner kfree(new_plan); 3407813472ceSPhilipp Reisner if (new_disk_conf) { 3408813472ceSPhilipp Reisner put_ldev(mdev); 3409813472ceSPhilipp Reisner kfree(new_disk_conf); 3410813472ceSPhilipp Reisner } 3411a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3412b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3413b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3414b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3415b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3416b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 341738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 341882bc0194SAndreas Gruenbacher return -EIO; 3419b411b363SPhilipp Reisner } 3420b411b363SPhilipp Reisner 3421b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3422b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3423b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3424b411b363SPhilipp Reisner { 3425b411b363SPhilipp Reisner sector_t d; 3426b411b363SPhilipp Reisner if (a == 0 || b == 0) 3427b411b363SPhilipp Reisner return; 3428b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3429b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3430b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3431b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3432b411b363SPhilipp Reisner } 3433b411b363SPhilipp Reisner 34344a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3435b411b363SPhilipp Reisner { 34364a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3437e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3438b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3439b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3440b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3441e89b591cSPhilipp Reisner enum dds_flags ddsf; 3442b411b363SPhilipp Reisner 34434a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 34444a76b161SAndreas Gruenbacher if (!mdev) 34454a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 34464a76b161SAndreas Gruenbacher 3447b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3448b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3449b411b363SPhilipp Reisner 3450b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3451b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3452b411b363SPhilipp Reisner mdev->p_size = p_size; 3453b411b363SPhilipp Reisner 3454b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3455daeda1ccSPhilipp Reisner rcu_read_lock(); 3456daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3457daeda1ccSPhilipp Reisner rcu_read_unlock(); 3458daeda1ccSPhilipp Reisner 3459b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3460b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3461b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3462daeda1ccSPhilipp Reisner p_usize, my_usize); 3463b411b363SPhilipp Reisner 3464b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3465b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3466b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3467daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3468b411b363SPhilipp Reisner 3469b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3470b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3471ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3472b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3473b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3474b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3475b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 347638fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3477b411b363SPhilipp Reisner put_ldev(mdev); 347882bc0194SAndreas Gruenbacher return -EIO; 3479b411b363SPhilipp Reisner } 3480daeda1ccSPhilipp Reisner 3481daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3482daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3483daeda1ccSPhilipp Reisner 3484daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3485daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3486daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3487daeda1ccSPhilipp Reisner put_ldev(mdev); 3488daeda1ccSPhilipp Reisner return -ENOMEM; 3489daeda1ccSPhilipp Reisner } 3490daeda1ccSPhilipp Reisner 3491daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3492daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3493daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3494daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3495daeda1ccSPhilipp Reisner 3496daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3497daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3498daeda1ccSPhilipp Reisner synchronize_rcu(); 3499daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3500daeda1ccSPhilipp Reisner 3501daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3502daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3503daeda1ccSPhilipp Reisner } 3504daeda1ccSPhilipp Reisner 3505b411b363SPhilipp Reisner put_ldev(mdev); 3506b411b363SPhilipp Reisner } 3507b411b363SPhilipp Reisner 3508e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3509b411b363SPhilipp Reisner if (get_ldev(mdev)) { 351024c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3511b411b363SPhilipp Reisner put_ldev(mdev); 3512b411b363SPhilipp Reisner if (dd == dev_size_error) 351382bc0194SAndreas Gruenbacher return -EIO; 3514b411b363SPhilipp Reisner drbd_md_sync(mdev); 3515b411b363SPhilipp Reisner } else { 3516b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3517b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3518b411b363SPhilipp Reisner } 3519b411b363SPhilipp Reisner 352099432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 352199432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 352299432fccSPhilipp Reisner 3523b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3524b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3525b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3526b411b363SPhilipp Reisner ldsc = 1; 3527b411b363SPhilipp Reisner } 3528b411b363SPhilipp Reisner 3529b411b363SPhilipp Reisner put_ldev(mdev); 3530b411b363SPhilipp Reisner } 3531b411b363SPhilipp Reisner 3532b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3533b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3534b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3535b411b363SPhilipp Reisner /* we have different sizes, probably peer 3536b411b363SPhilipp Reisner * needs to know my new size... */ 3537e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3538b411b363SPhilipp Reisner } 3539b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3540b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3541b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3542e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3543e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3544e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3545b411b363SPhilipp Reisner else 3546e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3547e89b591cSPhilipp Reisner } else 3548b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3549b411b363SPhilipp Reisner } 3550b411b363SPhilipp Reisner } 3551b411b363SPhilipp Reisner 355282bc0194SAndreas Gruenbacher return 0; 3553b411b363SPhilipp Reisner } 3554b411b363SPhilipp Reisner 35554a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3556b411b363SPhilipp Reisner { 35574a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3558e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3559b411b363SPhilipp Reisner u64 *p_uuid; 356062b0da3aSLars Ellenberg int i, updated_uuids = 0; 3561b411b363SPhilipp Reisner 35624a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35634a76b161SAndreas Gruenbacher if (!mdev) 35644a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35654a76b161SAndreas Gruenbacher 3566b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3567b411b363SPhilipp Reisner 3568b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3569b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3570b411b363SPhilipp Reisner 3571b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3572b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3573b411b363SPhilipp Reisner 3574b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3575b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3576b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3577b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3578b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3579b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 358038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 358182bc0194SAndreas Gruenbacher return -EIO; 3582b411b363SPhilipp Reisner } 3583b411b363SPhilipp Reisner 3584b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3585b411b363SPhilipp Reisner int skip_initial_sync = 3586b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 358731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3588b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3589b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3590b411b363SPhilipp Reisner if (skip_initial_sync) { 3591b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3592b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 359320ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 359420ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3595b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3596b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3597b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3598b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3599b411b363SPhilipp Reisner drbd_md_sync(mdev); 360062b0da3aSLars Ellenberg updated_uuids = 1; 3601b411b363SPhilipp Reisner } 3602b411b363SPhilipp Reisner put_ldev(mdev); 360318a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 360418a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 360518a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 360618a50fa2SPhilipp Reisner for me. */ 360762b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3608b411b363SPhilipp Reisner } 3609b411b363SPhilipp Reisner 3610b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3611b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3612b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3613b411b363SPhilipp Reisner new disk state... */ 36148410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 36158410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3616b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 361762b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 361862b0da3aSLars Ellenberg 361962b0da3aSLars Ellenberg if (updated_uuids) 362062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3621b411b363SPhilipp Reisner 362282bc0194SAndreas Gruenbacher return 0; 3623b411b363SPhilipp Reisner } 3624b411b363SPhilipp Reisner 3625b411b363SPhilipp Reisner /** 3626b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3627b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3628b411b363SPhilipp Reisner */ 3629b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3630b411b363SPhilipp Reisner { 3631b411b363SPhilipp Reisner union drbd_state ms; 3632b411b363SPhilipp Reisner 3633b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3634b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3635b411b363SPhilipp Reisner 3636b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3637b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3638b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3639b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3640b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3641b411b363SPhilipp Reisner }; 3642b411b363SPhilipp Reisner 3643b411b363SPhilipp Reisner ms.i = ps.i; 3644b411b363SPhilipp Reisner 3645b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3646b411b363SPhilipp Reisner ms.peer = ps.role; 3647b411b363SPhilipp Reisner ms.role = ps.peer; 3648b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3649b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3650b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3651b411b363SPhilipp Reisner 3652b411b363SPhilipp Reisner return ms; 3653b411b363SPhilipp Reisner } 3654b411b363SPhilipp Reisner 36554a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3656b411b363SPhilipp Reisner { 36574a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3658e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3659b411b363SPhilipp Reisner union drbd_state mask, val; 3660bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3661b411b363SPhilipp Reisner 36624a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36634a76b161SAndreas Gruenbacher if (!mdev) 36644a76b161SAndreas Gruenbacher return -EIO; 36654a76b161SAndreas Gruenbacher 3666b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3667b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3668b411b363SPhilipp Reisner 366925703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 36708410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3671b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 367282bc0194SAndreas Gruenbacher return 0; 3673b411b363SPhilipp Reisner } 3674b411b363SPhilipp Reisner 3675b411b363SPhilipp Reisner mask = convert_state(mask); 3676b411b363SPhilipp Reisner val = convert_state(val); 3677b411b363SPhilipp Reisner 3678b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3679b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3680047cd4a6SPhilipp Reisner 3681b411b363SPhilipp Reisner drbd_md_sync(mdev); 3682b411b363SPhilipp Reisner 368382bc0194SAndreas Gruenbacher return 0; 3684b411b363SPhilipp Reisner } 3685b411b363SPhilipp Reisner 3686e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3687dfafcc8aSPhilipp Reisner { 3688e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3689dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3690dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3691dfafcc8aSPhilipp Reisner 3692dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3693dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3694dfafcc8aSPhilipp Reisner 3695dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3696dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3697dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 369882bc0194SAndreas Gruenbacher return 0; 3699dfafcc8aSPhilipp Reisner } 3700dfafcc8aSPhilipp Reisner 3701dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3702dfafcc8aSPhilipp Reisner val = convert_state(val); 3703dfafcc8aSPhilipp Reisner 3704778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3705dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3706dfafcc8aSPhilipp Reisner 370782bc0194SAndreas Gruenbacher return 0; 3708dfafcc8aSPhilipp Reisner } 3709dfafcc8aSPhilipp Reisner 37104a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3711b411b363SPhilipp Reisner { 37124a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3713e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 37144ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3715b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 371665d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3717b411b363SPhilipp Reisner int rv; 3718b411b363SPhilipp Reisner 37194a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37204a76b161SAndreas Gruenbacher if (!mdev) 37214a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 37224a76b161SAndreas Gruenbacher 3723b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3724b411b363SPhilipp Reisner 3725b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3726b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3727b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3728b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3729b411b363SPhilipp Reisner } 3730b411b363SPhilipp Reisner 373187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3732b411b363SPhilipp Reisner retry: 373378bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 373487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3735b411b363SPhilipp Reisner 3736e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3737e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3738e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3739e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3740e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3741e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3742e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3743e9ef7bb6SLars Ellenberg * syncing states. 3744e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3745e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3746e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3747e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3748e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3749e9ef7bb6SLars Ellenberg 3750e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3751e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3752e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3753e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3754e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3755e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3756e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 375782bc0194SAndreas Gruenbacher return 0; 3758e9ef7bb6SLars Ellenberg } 3759e9ef7bb6SLars Ellenberg } 3760e9ef7bb6SLars Ellenberg 3761e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3762e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3763e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3764e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3765e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3766e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3767e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3768e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3769e9ef7bb6SLars Ellenberg 37704ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 37714ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3772b411b363SPhilipp Reisner 377367531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 377467531718SPhilipp Reisner ns.conn = C_BEHIND; 377567531718SPhilipp Reisner 3776b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3777b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3778b411b363SPhilipp Reisner int cr; /* consider resync */ 3779b411b363SPhilipp Reisner 3780b411b363SPhilipp Reisner /* if we established a new connection */ 37814ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3782b411b363SPhilipp Reisner /* if we had an established connection 3783b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 37844ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3785b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 37864ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3787b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3788b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3789b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3790b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3791b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 37924ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3793b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3794b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3795b411b363SPhilipp Reisner 3796b411b363SPhilipp Reisner if (cr) 37974ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3798b411b363SPhilipp Reisner 3799b411b363SPhilipp Reisner put_ldev(mdev); 38004ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 38014ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3802b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 380382f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3804b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3805b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3806b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3807580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3808b411b363SPhilipp Reisner } else { 38098169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 381082bc0194SAndreas Gruenbacher return -EIO; 38114ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 381238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 381382bc0194SAndreas Gruenbacher return -EIO; 3814b411b363SPhilipp Reisner } 3815b411b363SPhilipp Reisner } 3816b411b363SPhilipp Reisner } 3817b411b363SPhilipp Reisner 381887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 381978bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3820b411b363SPhilipp Reisner goto retry; 3821b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3822b411b363SPhilipp Reisner ns.peer = peer_state.role; 3823b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3824b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 38254ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3826b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 38274ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 38282aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3829481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 38308554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3831481c6f50SPhilipp Reisner for temporal network outages! */ 383287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3833481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 38342f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3835481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3836481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 383738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 383882bc0194SAndreas Gruenbacher return -EIO; 3839481c6f50SPhilipp Reisner } 384065d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 384178bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 384287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3843b411b363SPhilipp Reisner 3844b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 384538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 384682bc0194SAndreas Gruenbacher return -EIO; 3847b411b363SPhilipp Reisner } 3848b411b363SPhilipp Reisner 38494ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 38504ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3851b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3852b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3853b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3854b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3855b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3856b411b363SPhilipp Reisner drbd_send_state(mdev); 3857b411b363SPhilipp Reisner } 3858b411b363SPhilipp Reisner } 3859b411b363SPhilipp Reisner 3860a0095508SPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 38616139f60dSAndreas Gruenbacher mdev->tconn->net_conf->discard_my_data = 0; /* without copy; single bit op is atomic */ 3862a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3863b411b363SPhilipp Reisner 3864b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3865b411b363SPhilipp Reisner 386682bc0194SAndreas Gruenbacher return 0; 3867b411b363SPhilipp Reisner } 3868b411b363SPhilipp Reisner 38694a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3870b411b363SPhilipp Reisner { 38714a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3872e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 38734a76b161SAndreas Gruenbacher 38744a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38754a76b161SAndreas Gruenbacher if (!mdev) 38764a76b161SAndreas Gruenbacher return -EIO; 3877b411b363SPhilipp Reisner 3878b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3879b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3880c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3881b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3882b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3883b411b363SPhilipp Reisner 3884b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3885b411b363SPhilipp Reisner 3886b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3887b411b363SPhilipp Reisner _not_ be rotated into the history */ 3888b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3889b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3890b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3891b411b363SPhilipp Reisner 389262b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3893b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3894b411b363SPhilipp Reisner 3895b411b363SPhilipp Reisner put_ldev(mdev); 3896b411b363SPhilipp Reisner } else 3897b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3898b411b363SPhilipp Reisner 389982bc0194SAndreas Gruenbacher return 0; 3900b411b363SPhilipp Reisner } 3901b411b363SPhilipp Reisner 39022c46407dSAndreas Gruenbacher /** 39032c46407dSAndreas Gruenbacher * receive_bitmap_plain 39042c46407dSAndreas Gruenbacher * 39052c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 39062c46407dSAndreas Gruenbacher * code upon failure. 39072c46407dSAndreas Gruenbacher */ 39082c46407dSAndreas Gruenbacher static int 390950d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 3910e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 3911b411b363SPhilipp Reisner { 391250d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 391350d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 3914e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 391550d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 3916e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 39172c46407dSAndreas Gruenbacher int err; 3918b411b363SPhilipp Reisner 391950d0b1adSAndreas Gruenbacher if (want != size) { 392050d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 39212c46407dSAndreas Gruenbacher return -EIO; 3922b411b363SPhilipp Reisner } 3923b411b363SPhilipp Reisner if (want == 0) 39242c46407dSAndreas Gruenbacher return 0; 3925e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 392682bc0194SAndreas Gruenbacher if (err) 39272c46407dSAndreas Gruenbacher return err; 3928b411b363SPhilipp Reisner 3929e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 3930b411b363SPhilipp Reisner 3931b411b363SPhilipp Reisner c->word_offset += num_words; 3932b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3933b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3934b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3935b411b363SPhilipp Reisner 39362c46407dSAndreas Gruenbacher return 1; 3937b411b363SPhilipp Reisner } 3938b411b363SPhilipp Reisner 3939a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 3940a02d1240SAndreas Gruenbacher { 3941a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 3942a02d1240SAndreas Gruenbacher } 3943a02d1240SAndreas Gruenbacher 3944a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 3945a02d1240SAndreas Gruenbacher { 3946a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 3947a02d1240SAndreas Gruenbacher } 3948a02d1240SAndreas Gruenbacher 3949a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 3950a02d1240SAndreas Gruenbacher { 3951a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 3952a02d1240SAndreas Gruenbacher } 3953a02d1240SAndreas Gruenbacher 39542c46407dSAndreas Gruenbacher /** 39552c46407dSAndreas Gruenbacher * recv_bm_rle_bits 39562c46407dSAndreas Gruenbacher * 39572c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 39582c46407dSAndreas Gruenbacher * code upon failure. 39592c46407dSAndreas Gruenbacher */ 39602c46407dSAndreas Gruenbacher static int 3961b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3962b411b363SPhilipp Reisner struct p_compressed_bm *p, 3963c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3964c6d25cfeSPhilipp Reisner unsigned int len) 3965b411b363SPhilipp Reisner { 3966b411b363SPhilipp Reisner struct bitstream bs; 3967b411b363SPhilipp Reisner u64 look_ahead; 3968b411b363SPhilipp Reisner u64 rl; 3969b411b363SPhilipp Reisner u64 tmp; 3970b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3971b411b363SPhilipp Reisner unsigned long e; 3972a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 3973b411b363SPhilipp Reisner int have; 3974b411b363SPhilipp Reisner int bits; 3975b411b363SPhilipp Reisner 3976a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 3977b411b363SPhilipp Reisner 3978b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3979b411b363SPhilipp Reisner if (bits < 0) 39802c46407dSAndreas Gruenbacher return -EIO; 3981b411b363SPhilipp Reisner 3982b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3983b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3984b411b363SPhilipp Reisner if (bits <= 0) 39852c46407dSAndreas Gruenbacher return -EIO; 3986b411b363SPhilipp Reisner 3987b411b363SPhilipp Reisner if (toggle) { 3988b411b363SPhilipp Reisner e = s + rl -1; 3989b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3990b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 39912c46407dSAndreas Gruenbacher return -EIO; 3992b411b363SPhilipp Reisner } 3993b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3994b411b363SPhilipp Reisner } 3995b411b363SPhilipp Reisner 3996b411b363SPhilipp Reisner if (have < bits) { 3997b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3998b411b363SPhilipp Reisner have, bits, look_ahead, 3999b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4000b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 40012c46407dSAndreas Gruenbacher return -EIO; 4002b411b363SPhilipp Reisner } 4003b411b363SPhilipp Reisner look_ahead >>= bits; 4004b411b363SPhilipp Reisner have -= bits; 4005b411b363SPhilipp Reisner 4006b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4007b411b363SPhilipp Reisner if (bits < 0) 40082c46407dSAndreas Gruenbacher return -EIO; 4009b411b363SPhilipp Reisner look_ahead |= tmp << have; 4010b411b363SPhilipp Reisner have += bits; 4011b411b363SPhilipp Reisner } 4012b411b363SPhilipp Reisner 4013b411b363SPhilipp Reisner c->bit_offset = s; 4014b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4015b411b363SPhilipp Reisner 40162c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4017b411b363SPhilipp Reisner } 4018b411b363SPhilipp Reisner 40192c46407dSAndreas Gruenbacher /** 40202c46407dSAndreas Gruenbacher * decode_bitmap_c 40212c46407dSAndreas Gruenbacher * 40222c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40232c46407dSAndreas Gruenbacher * code upon failure. 40242c46407dSAndreas Gruenbacher */ 40252c46407dSAndreas Gruenbacher static int 4026b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 4027b411b363SPhilipp Reisner struct p_compressed_bm *p, 4028c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4029c6d25cfeSPhilipp Reisner unsigned int len) 4030b411b363SPhilipp Reisner { 4031a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4032e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 4033b411b363SPhilipp Reisner 4034b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4035b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4036b411b363SPhilipp Reisner * during all our tests. */ 4037b411b363SPhilipp Reisner 4038b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 403938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 40402c46407dSAndreas Gruenbacher return -EIO; 4041b411b363SPhilipp Reisner } 4042b411b363SPhilipp Reisner 4043b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 4044b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4045b411b363SPhilipp Reisner { 4046b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 404750d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 404850d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 404950d0b1adSAndreas Gruenbacher unsigned int plain = 405050d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 405150d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 405250d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 405350d0b1adSAndreas Gruenbacher unsigned int r; 4054b411b363SPhilipp Reisner 4055b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4056b411b363SPhilipp Reisner if (total == 0) 4057b411b363SPhilipp Reisner return; 4058b411b363SPhilipp Reisner 4059b411b363SPhilipp Reisner /* don't report if not compressed */ 4060b411b363SPhilipp Reisner if (total >= plain) 4061b411b363SPhilipp Reisner return; 4062b411b363SPhilipp Reisner 4063b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4064b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4065b411b363SPhilipp Reisner : (1000 * total / plain); 4066b411b363SPhilipp Reisner 4067b411b363SPhilipp Reisner if (r > 1000) 4068b411b363SPhilipp Reisner r = 1000; 4069b411b363SPhilipp Reisner 4070b411b363SPhilipp Reisner r = 1000 - r; 4071b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4072b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4073b411b363SPhilipp Reisner direction, 4074b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4075b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4076b411b363SPhilipp Reisner total, r/10, r % 10); 4077b411b363SPhilipp Reisner } 4078b411b363SPhilipp Reisner 4079b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4080b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4081b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4082b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4083b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4084b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4085b411b363SPhilipp Reisner 4086b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 40874a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4088b411b363SPhilipp Reisner { 40894a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4090b411b363SPhilipp Reisner struct bm_xfer_ctx c; 40912c46407dSAndreas Gruenbacher int err; 40924a76b161SAndreas Gruenbacher 40934a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 40944a76b161SAndreas Gruenbacher if (!mdev) 40954a76b161SAndreas Gruenbacher return -EIO; 4096b411b363SPhilipp Reisner 409720ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 409820ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 409920ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4100b411b363SPhilipp Reisner 4101b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4102b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4103b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4104b411b363SPhilipp Reisner }; 4105b411b363SPhilipp Reisner 41062c46407dSAndreas Gruenbacher for(;;) { 4107e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4108e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4109e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4110b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4111b411b363SPhilipp Reisner * and the feature is enabled! */ 4112e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4113b411b363SPhilipp Reisner 411450d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4115b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 411682bc0194SAndreas Gruenbacher err = -EIO; 4117b411b363SPhilipp Reisner goto out; 4118b411b363SPhilipp Reisner } 4119e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4120e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 412182bc0194SAndreas Gruenbacher err = -EIO; 412278fcbdaeSAndreas Gruenbacher goto out; 4123b411b363SPhilipp Reisner } 4124e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4125e658983aSAndreas Gruenbacher if (err) 4126e658983aSAndreas Gruenbacher goto out; 4127e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4128b411b363SPhilipp Reisner } else { 4129e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 413082bc0194SAndreas Gruenbacher err = -EIO; 4131b411b363SPhilipp Reisner goto out; 4132b411b363SPhilipp Reisner } 4133b411b363SPhilipp Reisner 4134e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 413550d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4136b411b363SPhilipp Reisner 41372c46407dSAndreas Gruenbacher if (err <= 0) { 41382c46407dSAndreas Gruenbacher if (err < 0) 41392c46407dSAndreas Gruenbacher goto out; 4140b411b363SPhilipp Reisner break; 41412c46407dSAndreas Gruenbacher } 4142e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 414382bc0194SAndreas Gruenbacher if (err) 4144b411b363SPhilipp Reisner goto out; 41452c46407dSAndreas Gruenbacher } 4146b411b363SPhilipp Reisner 4147b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4148b411b363SPhilipp Reisner 4149b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4150de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4151de1f8e4aSAndreas Gruenbacher 415282bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 415382bc0194SAndreas Gruenbacher if (err) 4154b411b363SPhilipp Reisner goto out; 4155b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4156de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4157de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4158b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4159b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4160b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4161b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4162b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4163b411b363SPhilipp Reisner } 416482bc0194SAndreas Gruenbacher err = 0; 4165b411b363SPhilipp Reisner 4166b411b363SPhilipp Reisner out: 416720ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 416882bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4169b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 417082bc0194SAndreas Gruenbacher return err; 4171b411b363SPhilipp Reisner } 4172b411b363SPhilipp Reisner 41734a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4174b411b363SPhilipp Reisner { 41754a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4176e2857216SAndreas Gruenbacher pi->cmd, pi->size); 41772de876efSPhilipp Reisner 41784a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 41792de876efSPhilipp Reisner } 41802de876efSPhilipp Reisner 41814a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4182b411b363SPhilipp Reisner { 4183b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4184b411b363SPhilipp Reisner * with the data requests being unplugged */ 41854a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4186b411b363SPhilipp Reisner 418782bc0194SAndreas Gruenbacher return 0; 4188b411b363SPhilipp Reisner } 4189b411b363SPhilipp Reisner 41904a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 419173a01a18SPhilipp Reisner { 41924a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4193e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 41944a76b161SAndreas Gruenbacher 41954a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 41964a76b161SAndreas Gruenbacher if (!mdev) 41974a76b161SAndreas Gruenbacher return -EIO; 419873a01a18SPhilipp Reisner 4199f735e363SLars Ellenberg switch (mdev->state.conn) { 4200f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4201f735e363SLars Ellenberg case C_WF_BITMAP_T: 4202f735e363SLars Ellenberg case C_BEHIND: 4203f735e363SLars Ellenberg break; 4204f735e363SLars Ellenberg default: 4205f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4206f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4207f735e363SLars Ellenberg } 4208f735e363SLars Ellenberg 420973a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 421073a01a18SPhilipp Reisner 421182bc0194SAndreas Gruenbacher return 0; 421273a01a18SPhilipp Reisner } 421373a01a18SPhilipp Reisner 421402918be2SPhilipp Reisner struct data_cmd { 421502918be2SPhilipp Reisner int expect_payload; 421602918be2SPhilipp Reisner size_t pkt_size; 42174a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4218b411b363SPhilipp Reisner }; 4219b411b363SPhilipp Reisner 422002918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 42214a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 42224a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 42234a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 42244a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4225e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4226e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4227e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 42284a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 42294a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4230e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4231e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 42324a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 42334a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 42344a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 42354a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 42364a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 42374a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 42384a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 42394a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 42404a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 42414a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 42424a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 42434a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4244036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 424502918be2SPhilipp Reisner }; 424602918be2SPhilipp Reisner 4247eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4248b411b363SPhilipp Reisner { 424977351055SPhilipp Reisner struct packet_info pi; 425002918be2SPhilipp Reisner size_t shs; /* sub header size */ 425182bc0194SAndreas Gruenbacher int err; 4252b411b363SPhilipp Reisner 4253eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4254deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4255deebe195SAndreas Gruenbacher 4256eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 425769bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 425802918be2SPhilipp Reisner goto err_out; 425902918be2SPhilipp Reisner 4260deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 42614a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 4262eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 426302918be2SPhilipp Reisner goto err_out; 42640b33a916SLars Ellenberg } 4265b411b363SPhilipp Reisner 4266e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4267e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 4268eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 4269c13f7e1aSLars Ellenberg goto err_out; 4270c13f7e1aSLars Ellenberg } 4271c13f7e1aSLars Ellenberg 4272c13f7e1aSLars Ellenberg if (shs) { 4273e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4274a5c31904SAndreas Gruenbacher if (err) 427502918be2SPhilipp Reisner goto err_out; 4276e2857216SAndreas Gruenbacher pi.size -= shs; 4277b411b363SPhilipp Reisner } 427802918be2SPhilipp Reisner 42794a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 42804a76b161SAndreas Gruenbacher if (err) { 42819f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 42829f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 428302918be2SPhilipp Reisner goto err_out; 4284b411b363SPhilipp Reisner } 4285b411b363SPhilipp Reisner } 428682bc0194SAndreas Gruenbacher return; 428702918be2SPhilipp Reisner 428802918be2SPhilipp Reisner err_out: 4289bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4290b411b363SPhilipp Reisner } 4291b411b363SPhilipp Reisner 42920e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4293b411b363SPhilipp Reisner { 4294b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4295b411b363SPhilipp Reisner 4296b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 42970e29d163SPhilipp Reisner barr.w.tconn = tconn; 4298b411b363SPhilipp Reisner init_completion(&barr.done); 42990e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4300b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4301b411b363SPhilipp Reisner } 4302b411b363SPhilipp Reisner 430381fa2e67SPhilipp Reisner static void conn_disconnect(struct drbd_tconn *tconn) 4304b411b363SPhilipp Reisner { 4305c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 4306bbeb641cSPhilipp Reisner enum drbd_conns oc; 4307c141ebdaSPhilipp Reisner int vnr, rv = SS_UNKNOWN_ERROR; 4308b411b363SPhilipp Reisner 4309bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4310b411b363SPhilipp Reisner return; 4311b411b363SPhilipp Reisner 4312b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4313360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4314360cc740SPhilipp Reisner drbd_free_sock(tconn); 4315360cc740SPhilipp Reisner 4316c141ebdaSPhilipp Reisner rcu_read_lock(); 4317c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 4318c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 4319c141ebdaSPhilipp Reisner rcu_read_unlock(); 4320c141ebdaSPhilipp Reisner drbd_disconnected(mdev); 4321c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 4322c141ebdaSPhilipp Reisner rcu_read_lock(); 4323c141ebdaSPhilipp Reisner } 4324c141ebdaSPhilipp Reisner rcu_read_unlock(); 4325c141ebdaSPhilipp Reisner 4326360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4327360cc740SPhilipp Reisner 4328cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4329cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4330cb703454SPhilipp Reisner 4331360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4332bbeb641cSPhilipp Reisner oc = tconn->cstate; 4333bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4334bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4335bbeb641cSPhilipp Reisner 4336360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4337360cc740SPhilipp Reisner 4338f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4339d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4340360cc740SPhilipp Reisner } 4341360cc740SPhilipp Reisner 4342c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev) 4343360cc740SPhilipp Reisner { 4344360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4345360cc740SPhilipp Reisner unsigned int i; 4346b411b363SPhilipp Reisner 434785719573SPhilipp Reisner /* wait for current activity to cease. */ 434887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4349b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4350b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4351b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 435287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4353b411b363SPhilipp Reisner 4354b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4355b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4356b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4357b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4358b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4359b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4360b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4361b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4362b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4363b411b363SPhilipp Reisner * on the fly. */ 4364b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4365b411b363SPhilipp Reisner mdev->rs_total = 0; 4366b411b363SPhilipp Reisner mdev->rs_failed = 0; 4367b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4368b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4369b411b363SPhilipp Reisner 43707fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 43717fde2be9SPhilipp Reisner 4372b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4373b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4374b411b363SPhilipp Reisner 4375b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4376b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4377b411b363SPhilipp Reisner * to be "canceled" */ 4378a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4379b411b363SPhilipp Reisner 4380a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4381b411b363SPhilipp Reisner 4382b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4383b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4384b411b363SPhilipp Reisner 43852aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 43862f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4387b411b363SPhilipp Reisner 4388b411b363SPhilipp Reisner drbd_md_sync(mdev); 4389b411b363SPhilipp Reisner 4390b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4391b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4392daeda1ccSPhilipp Reisner rcu_read_lock(); 4393daeda1ccSPhilipp Reisner fp = rcu_dereference(mdev->ldev->disk_conf)->fencing; 4394daeda1ccSPhilipp Reisner rcu_read_unlock(); 4395b411b363SPhilipp Reisner put_ldev(mdev); 4396b411b363SPhilipp Reisner } 4397b411b363SPhilipp Reisner 439820ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 439920ceb2b2SLars Ellenberg * if any. */ 440020ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 440120ceb2b2SLars Ellenberg 4402b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4403b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4404b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4405b411b363SPhilipp Reisner * 4406b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4407b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4408b411b363SPhilipp Reisner */ 44097721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4410b411b363SPhilipp Reisner if (i) 4411b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4412435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4413435f0740SLars Ellenberg if (i) 4414435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4415b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4416b411b363SPhilipp Reisner if (i) 441745bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4418b411b363SPhilipp Reisner 4419b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4420b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4421b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4422b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4423b411b363SPhilipp Reisner 4424b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4425b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4426b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4427360cc740SPhilipp Reisner 4428360cc740SPhilipp Reisner return 0; 4429b411b363SPhilipp Reisner } 4430b411b363SPhilipp Reisner 4431b411b363SPhilipp Reisner /* 4432b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4433b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4434b411b363SPhilipp Reisner * 4435b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4436b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4437b411b363SPhilipp Reisner * 4438b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4439b411b363SPhilipp Reisner */ 44406038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4441b411b363SPhilipp Reisner { 44429f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 44439f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4444b411b363SPhilipp Reisner 44459f5bdc33SAndreas Gruenbacher sock = &tconn->data; 44469f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 44479f5bdc33SAndreas Gruenbacher if (!p) 4448e8d17b01SAndreas Gruenbacher return -EIO; 4449b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4450b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4451b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 44529f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4453b411b363SPhilipp Reisner } 4454b411b363SPhilipp Reisner 4455b411b363SPhilipp Reisner /* 4456b411b363SPhilipp Reisner * return values: 4457b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4458b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4459b411b363SPhilipp Reisner * -1 peer talks different language, 4460b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4461b411b363SPhilipp Reisner */ 44626038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4463b411b363SPhilipp Reisner { 446465d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4465e658983aSAndreas Gruenbacher struct p_connection_features *p; 4466e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 446777351055SPhilipp Reisner struct packet_info pi; 4468a5c31904SAndreas Gruenbacher int err; 4469b411b363SPhilipp Reisner 44706038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4471e8d17b01SAndreas Gruenbacher if (err) 4472b411b363SPhilipp Reisner return 0; 4473b411b363SPhilipp Reisner 447469bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 447569bc7bc3SAndreas Gruenbacher if (err) 4476b411b363SPhilipp Reisner return 0; 4477b411b363SPhilipp Reisner 44786038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 44796038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 448077351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4481b411b363SPhilipp Reisner return -1; 4482b411b363SPhilipp Reisner } 4483b411b363SPhilipp Reisner 448477351055SPhilipp Reisner if (pi.size != expect) { 44856038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 448677351055SPhilipp Reisner expect, pi.size); 4487b411b363SPhilipp Reisner return -1; 4488b411b363SPhilipp Reisner } 4489b411b363SPhilipp Reisner 4490e658983aSAndreas Gruenbacher p = pi.data; 4491e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4492a5c31904SAndreas Gruenbacher if (err) 4493b411b363SPhilipp Reisner return 0; 4494b411b363SPhilipp Reisner 4495b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4496b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4497b411b363SPhilipp Reisner if (p->protocol_max == 0) 4498b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4499b411b363SPhilipp Reisner 4500b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4501b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4502b411b363SPhilipp Reisner goto incompat; 4503b411b363SPhilipp Reisner 450465d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4505b411b363SPhilipp Reisner 450665d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 450765d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4508b411b363SPhilipp Reisner 4509b411b363SPhilipp Reisner return 1; 4510b411b363SPhilipp Reisner 4511b411b363SPhilipp Reisner incompat: 451265d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4513b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4514b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4515b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4516b411b363SPhilipp Reisner return -1; 4517b411b363SPhilipp Reisner } 4518b411b363SPhilipp Reisner 4519b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 452013e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4521b411b363SPhilipp Reisner { 4522b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4523b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4524b10d96cbSJohannes Thoma return -1; 4525b411b363SPhilipp Reisner } 4526b411b363SPhilipp Reisner #else 4527b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4528b10d96cbSJohannes Thoma 4529b10d96cbSJohannes Thoma /* Return value: 4530b10d96cbSJohannes Thoma 1 - auth succeeded, 4531b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4532b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4533b10d96cbSJohannes Thoma */ 4534b10d96cbSJohannes Thoma 453513e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4536b411b363SPhilipp Reisner { 45379f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4538b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4539b411b363SPhilipp Reisner struct scatterlist sg; 4540b411b363SPhilipp Reisner char *response = NULL; 4541b411b363SPhilipp Reisner char *right_response = NULL; 4542b411b363SPhilipp Reisner char *peers_ch = NULL; 454344ed167dSPhilipp Reisner unsigned int key_len; 454444ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4545b411b363SPhilipp Reisner unsigned int resp_size; 4546b411b363SPhilipp Reisner struct hash_desc desc; 454777351055SPhilipp Reisner struct packet_info pi; 454844ed167dSPhilipp Reisner struct net_conf *nc; 454969bc7bc3SAndreas Gruenbacher int err, rv; 4550b411b363SPhilipp Reisner 45519f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 45529f5bdc33SAndreas Gruenbacher 455344ed167dSPhilipp Reisner rcu_read_lock(); 455444ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 455544ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 455644ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 455744ed167dSPhilipp Reisner rcu_read_unlock(); 455844ed167dSPhilipp Reisner 455913e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4560b411b363SPhilipp Reisner desc.flags = 0; 4561b411b363SPhilipp Reisner 456244ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4563b411b363SPhilipp Reisner if (rv) { 456413e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4565b10d96cbSJohannes Thoma rv = -1; 4566b411b363SPhilipp Reisner goto fail; 4567b411b363SPhilipp Reisner } 4568b411b363SPhilipp Reisner 4569b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4570b411b363SPhilipp Reisner 45719f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45729f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 45739f5bdc33SAndreas Gruenbacher rv = 0; 45749f5bdc33SAndreas Gruenbacher goto fail; 45759f5bdc33SAndreas Gruenbacher } 4576e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 45779f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4578b411b363SPhilipp Reisner if (!rv) 4579b411b363SPhilipp Reisner goto fail; 4580b411b363SPhilipp Reisner 458169bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 458269bc7bc3SAndreas Gruenbacher if (err) { 458369bc7bc3SAndreas Gruenbacher rv = 0; 4584b411b363SPhilipp Reisner goto fail; 458569bc7bc3SAndreas Gruenbacher } 4586b411b363SPhilipp Reisner 458777351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 458813e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 458977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4590b411b363SPhilipp Reisner rv = 0; 4591b411b363SPhilipp Reisner goto fail; 4592b411b363SPhilipp Reisner } 4593b411b363SPhilipp Reisner 459477351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 459513e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4596b10d96cbSJohannes Thoma rv = -1; 4597b411b363SPhilipp Reisner goto fail; 4598b411b363SPhilipp Reisner } 4599b411b363SPhilipp Reisner 460077351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4601b411b363SPhilipp Reisner if (peers_ch == NULL) { 460213e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4603b10d96cbSJohannes Thoma rv = -1; 4604b411b363SPhilipp Reisner goto fail; 4605b411b363SPhilipp Reisner } 4606b411b363SPhilipp Reisner 4607a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4608a5c31904SAndreas Gruenbacher if (err) { 4609b411b363SPhilipp Reisner rv = 0; 4610b411b363SPhilipp Reisner goto fail; 4611b411b363SPhilipp Reisner } 4612b411b363SPhilipp Reisner 461313e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4614b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4615b411b363SPhilipp Reisner if (response == NULL) { 461613e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4617b10d96cbSJohannes Thoma rv = -1; 4618b411b363SPhilipp Reisner goto fail; 4619b411b363SPhilipp Reisner } 4620b411b363SPhilipp Reisner 4621b411b363SPhilipp Reisner sg_init_table(&sg, 1); 462277351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4623b411b363SPhilipp Reisner 4624b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4625b411b363SPhilipp Reisner if (rv) { 462613e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4627b10d96cbSJohannes Thoma rv = -1; 4628b411b363SPhilipp Reisner goto fail; 4629b411b363SPhilipp Reisner } 4630b411b363SPhilipp Reisner 46319f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 46329f5bdc33SAndreas Gruenbacher rv = 0; 46339f5bdc33SAndreas Gruenbacher goto fail; 46349f5bdc33SAndreas Gruenbacher } 4635e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 46369f5bdc33SAndreas Gruenbacher response, resp_size); 4637b411b363SPhilipp Reisner if (!rv) 4638b411b363SPhilipp Reisner goto fail; 4639b411b363SPhilipp Reisner 464069bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 464169bc7bc3SAndreas Gruenbacher if (err) { 464269bc7bc3SAndreas Gruenbacher rv = 0; 4643b411b363SPhilipp Reisner goto fail; 464469bc7bc3SAndreas Gruenbacher } 4645b411b363SPhilipp Reisner 464677351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 464713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 464877351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4649b411b363SPhilipp Reisner rv = 0; 4650b411b363SPhilipp Reisner goto fail; 4651b411b363SPhilipp Reisner } 4652b411b363SPhilipp Reisner 465377351055SPhilipp Reisner if (pi.size != resp_size) { 465413e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4655b411b363SPhilipp Reisner rv = 0; 4656b411b363SPhilipp Reisner goto fail; 4657b411b363SPhilipp Reisner } 4658b411b363SPhilipp Reisner 4659a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4660a5c31904SAndreas Gruenbacher if (err) { 4661b411b363SPhilipp Reisner rv = 0; 4662b411b363SPhilipp Reisner goto fail; 4663b411b363SPhilipp Reisner } 4664b411b363SPhilipp Reisner 4665b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 46662d1ee87dSJulia Lawall if (right_response == NULL) { 466713e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4668b10d96cbSJohannes Thoma rv = -1; 4669b411b363SPhilipp Reisner goto fail; 4670b411b363SPhilipp Reisner } 4671b411b363SPhilipp Reisner 4672b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4673b411b363SPhilipp Reisner 4674b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4675b411b363SPhilipp Reisner if (rv) { 467613e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4677b10d96cbSJohannes Thoma rv = -1; 4678b411b363SPhilipp Reisner goto fail; 4679b411b363SPhilipp Reisner } 4680b411b363SPhilipp Reisner 4681b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4682b411b363SPhilipp Reisner 4683b411b363SPhilipp Reisner if (rv) 468444ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 468544ed167dSPhilipp Reisner resp_size); 4686b10d96cbSJohannes Thoma else 4687b10d96cbSJohannes Thoma rv = -1; 4688b411b363SPhilipp Reisner 4689b411b363SPhilipp Reisner fail: 4690b411b363SPhilipp Reisner kfree(peers_ch); 4691b411b363SPhilipp Reisner kfree(response); 4692b411b363SPhilipp Reisner kfree(right_response); 4693b411b363SPhilipp Reisner 4694b411b363SPhilipp Reisner return rv; 4695b411b363SPhilipp Reisner } 4696b411b363SPhilipp Reisner #endif 4697b411b363SPhilipp Reisner 4698b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4699b411b363SPhilipp Reisner { 4700392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4701b411b363SPhilipp Reisner int h; 4702b411b363SPhilipp Reisner 47034d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4704b411b363SPhilipp Reisner 4705b411b363SPhilipp Reisner do { 470681fa2e67SPhilipp Reisner h = conn_connect(tconn); 4707b411b363SPhilipp Reisner if (h == 0) { 470881fa2e67SPhilipp Reisner conn_disconnect(tconn); 470920ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4710b411b363SPhilipp Reisner } 4711b411b363SPhilipp Reisner if (h == -1) { 47124d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4713bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4714b411b363SPhilipp Reisner } 4715b411b363SPhilipp Reisner } while (h == 0); 4716b411b363SPhilipp Reisner 471791fd4dadSPhilipp Reisner if (h > 0) 47184d641dd7SPhilipp Reisner drbdd(tconn); 4719b411b363SPhilipp Reisner 472081fa2e67SPhilipp Reisner conn_disconnect(tconn); 4721b411b363SPhilipp Reisner 47224d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4723b411b363SPhilipp Reisner return 0; 4724b411b363SPhilipp Reisner } 4725b411b363SPhilipp Reisner 4726b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4727b411b363SPhilipp Reisner 4728e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4729b411b363SPhilipp Reisner { 4730e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4731b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4732b411b363SPhilipp Reisner 4733fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4734fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4735fc3b10a4SPhilipp Reisner } else { 4736fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4737fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4738fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4739fc3b10a4SPhilipp Reisner } 4740fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4741e4f78edeSPhilipp Reisner 47422735a594SAndreas Gruenbacher return 0; 4743fc3b10a4SPhilipp Reisner } 4744e4f78edeSPhilipp Reisner 47451952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4746e4f78edeSPhilipp Reisner { 47471952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4748e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4749e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4750e4f78edeSPhilipp Reisner 47511952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47521952e916SAndreas Gruenbacher if (!mdev) 47532735a594SAndreas Gruenbacher return -EIO; 47541952e916SAndreas Gruenbacher 4755e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4756e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4757e4f78edeSPhilipp Reisner } else { 4758e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4759e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4760e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4761e4f78edeSPhilipp Reisner } 4762e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4763e4f78edeSPhilipp Reisner 47642735a594SAndreas Gruenbacher return 0; 4765b411b363SPhilipp Reisner } 4766b411b363SPhilipp Reisner 4767e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4768b411b363SPhilipp Reisner { 47692735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4770b411b363SPhilipp Reisner 4771b411b363SPhilipp Reisner } 4772b411b363SPhilipp Reisner 4773e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4774b411b363SPhilipp Reisner { 4775b411b363SPhilipp Reisner /* restore idle timeout */ 47762a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 47772a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 47782a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4779b411b363SPhilipp Reisner 47802735a594SAndreas Gruenbacher return 0; 4781b411b363SPhilipp Reisner } 4782b411b363SPhilipp Reisner 47831952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4784b411b363SPhilipp Reisner { 47851952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4786e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4787b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4788b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4789b411b363SPhilipp Reisner 47901952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47911952e916SAndreas Gruenbacher if (!mdev) 47922735a594SAndreas Gruenbacher return -EIO; 47931952e916SAndreas Gruenbacher 479431890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4795b411b363SPhilipp Reisner 4796b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4797b411b363SPhilipp Reisner 47981d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4799b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4800b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4801b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4802b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 48031d53f09eSLars Ellenberg put_ldev(mdev); 48041d53f09eSLars Ellenberg } 4805b411b363SPhilipp Reisner dec_rs_pending(mdev); 4806778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4807b411b363SPhilipp Reisner 48082735a594SAndreas Gruenbacher return 0; 4809b411b363SPhilipp Reisner } 4810b411b363SPhilipp Reisner 4811bc9c5c41SAndreas Gruenbacher static int 4812bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4813bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4814bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4815b411b363SPhilipp Reisner { 4816b411b363SPhilipp Reisner struct drbd_request *req; 4817b411b363SPhilipp Reisner struct bio_and_error m; 4818b411b363SPhilipp Reisner 481987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4820bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4821b411b363SPhilipp Reisner if (unlikely(!req)) { 482287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 482385997675SAndreas Gruenbacher return -EIO; 4824b411b363SPhilipp Reisner } 4825b411b363SPhilipp Reisner __req_mod(req, what, &m); 482687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4827b411b363SPhilipp Reisner 4828b411b363SPhilipp Reisner if (m.bio) 4829b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 483085997675SAndreas Gruenbacher return 0; 4831b411b363SPhilipp Reisner } 4832b411b363SPhilipp Reisner 48331952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4834b411b363SPhilipp Reisner { 48351952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4836e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4837b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4838b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4839b411b363SPhilipp Reisner enum drbd_req_event what; 4840b411b363SPhilipp Reisner 48411952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48421952e916SAndreas Gruenbacher if (!mdev) 48432735a594SAndreas Gruenbacher return -EIO; 48441952e916SAndreas Gruenbacher 4845b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4846b411b363SPhilipp Reisner 4847579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4848b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4849b411b363SPhilipp Reisner dec_rs_pending(mdev); 48502735a594SAndreas Gruenbacher return 0; 4851b411b363SPhilipp Reisner } 4852e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4853b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 48548554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4855b411b363SPhilipp Reisner break; 4856b411b363SPhilipp Reisner case P_WRITE_ACK: 48578554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4858b411b363SPhilipp Reisner break; 4859b411b363SPhilipp Reisner case P_RECV_ACK: 48608554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4861b411b363SPhilipp Reisner break; 48627be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 48637be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 48647be8da07SAndreas Gruenbacher break; 48657be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 48667be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4867b411b363SPhilipp Reisner break; 4868b411b363SPhilipp Reisner default: 48692735a594SAndreas Gruenbacher BUG(); 4870b411b363SPhilipp Reisner } 4871b411b363SPhilipp Reisner 48722735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4873bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4874bc9c5c41SAndreas Gruenbacher what, false); 4875b411b363SPhilipp Reisner } 4876b411b363SPhilipp Reisner 48771952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 4878b411b363SPhilipp Reisner { 48791952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4880e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4881b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 48822deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 488385997675SAndreas Gruenbacher int err; 4884b411b363SPhilipp Reisner 48851952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48861952e916SAndreas Gruenbacher if (!mdev) 48872735a594SAndreas Gruenbacher return -EIO; 48881952e916SAndreas Gruenbacher 4889b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4890b411b363SPhilipp Reisner 4891579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4892b411b363SPhilipp Reisner dec_rs_pending(mdev); 4893b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 48942735a594SAndreas Gruenbacher return 0; 4895b411b363SPhilipp Reisner } 48962deb8336SPhilipp Reisner 489785997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 4898bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4899303d1448SPhilipp Reisner NEG_ACKED, true); 490085997675SAndreas Gruenbacher if (err) { 49012deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 49022deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4903c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 49042deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 49052deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4906c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 49072deb8336SPhilipp Reisner } 49082735a594SAndreas Gruenbacher return 0; 4909b411b363SPhilipp Reisner } 4910b411b363SPhilipp Reisner 49111952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4912b411b363SPhilipp Reisner { 49131952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4914e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4915b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4916b411b363SPhilipp Reisner 49171952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49181952e916SAndreas Gruenbacher if (!mdev) 49192735a594SAndreas Gruenbacher return -EIO; 49201952e916SAndreas Gruenbacher 4921b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 49227be8da07SAndreas Gruenbacher 4923b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4924b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4925b411b363SPhilipp Reisner 49262735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4927bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 49288554df1cSAndreas Gruenbacher NEG_ACKED, false); 4929b411b363SPhilipp Reisner } 4930b411b363SPhilipp Reisner 49311952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4932b411b363SPhilipp Reisner { 49331952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4934b411b363SPhilipp Reisner sector_t sector; 4935b411b363SPhilipp Reisner int size; 4936e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 49371952e916SAndreas Gruenbacher 49381952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49391952e916SAndreas Gruenbacher if (!mdev) 49402735a594SAndreas Gruenbacher return -EIO; 4941b411b363SPhilipp Reisner 4942b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4943b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4944b411b363SPhilipp Reisner 4945b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4946b411b363SPhilipp Reisner 4947b411b363SPhilipp Reisner dec_rs_pending(mdev); 4948b411b363SPhilipp Reisner 4949b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4950b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4951e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4952d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4953b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4954d612d309SPhilipp Reisner case P_RS_CANCEL: 4955d612d309SPhilipp Reisner break; 4956d612d309SPhilipp Reisner default: 49572735a594SAndreas Gruenbacher BUG(); 4958d612d309SPhilipp Reisner } 4959b411b363SPhilipp Reisner put_ldev(mdev); 4960b411b363SPhilipp Reisner } 4961b411b363SPhilipp Reisner 49622735a594SAndreas Gruenbacher return 0; 4963b411b363SPhilipp Reisner } 4964b411b363SPhilipp Reisner 49651952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 4966b411b363SPhilipp Reisner { 49671952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4968e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 49691952e916SAndreas Gruenbacher 49701952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49711952e916SAndreas Gruenbacher if (!mdev) 49722735a594SAndreas Gruenbacher return -EIO; 4973b411b363SPhilipp Reisner 49742f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4975b411b363SPhilipp Reisner 4976c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4977c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4978370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4979370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4980370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4981c4752ef1SPhilipp Reisner } 4982c4752ef1SPhilipp Reisner 49832735a594SAndreas Gruenbacher return 0; 4984b411b363SPhilipp Reisner } 4985b411b363SPhilipp Reisner 49861952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 4987b411b363SPhilipp Reisner { 49881952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4989e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4990b411b363SPhilipp Reisner struct drbd_work *w; 4991b411b363SPhilipp Reisner sector_t sector; 4992b411b363SPhilipp Reisner int size; 4993b411b363SPhilipp Reisner 49941952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49951952e916SAndreas Gruenbacher if (!mdev) 49962735a594SAndreas Gruenbacher return -EIO; 49971952e916SAndreas Gruenbacher 4998b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4999b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5000b411b363SPhilipp Reisner 5001b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5002b411b363SPhilipp Reisner 5003b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 50048f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 5005b411b363SPhilipp Reisner else 50068f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5007b411b363SPhilipp Reisner 50081d53f09eSLars Ellenberg if (!get_ldev(mdev)) 50092735a594SAndreas Gruenbacher return 0; 50101d53f09eSLars Ellenberg 5011b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5012b411b363SPhilipp Reisner dec_rs_pending(mdev); 5013b411b363SPhilipp Reisner 5014ea5442afSLars Ellenberg --mdev->ov_left; 5015ea5442afSLars Ellenberg 5016ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5017ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 5018ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 5019ea5442afSLars Ellenberg 5020ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 5021b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5022b411b363SPhilipp Reisner if (w) { 5023b411b363SPhilipp Reisner w->cb = w_ov_finished; 5024a21e9298SPhilipp Reisner w->mdev = mdev; 5025e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 5026b411b363SPhilipp Reisner } else { 5027b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 50288f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5029b411b363SPhilipp Reisner drbd_resync_finished(mdev); 5030b411b363SPhilipp Reisner } 5031b411b363SPhilipp Reisner } 50321d53f09eSLars Ellenberg put_ldev(mdev); 50332735a594SAndreas Gruenbacher return 0; 5034b411b363SPhilipp Reisner } 5035b411b363SPhilipp Reisner 50361952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 50370ced55a3SPhilipp Reisner { 50382735a594SAndreas Gruenbacher return 0; 50390ced55a3SPhilipp Reisner } 50400ced55a3SPhilipp Reisner 5041a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 504232862ec7SPhilipp Reisner { 5043082a3439SPhilipp Reisner struct drbd_conf *mdev; 5044c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 504532862ec7SPhilipp Reisner 504632862ec7SPhilipp Reisner do { 504732862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 504832862ec7SPhilipp Reisner flush_signals(current); 5049c141ebdaSPhilipp Reisner 5050c141ebdaSPhilipp Reisner rcu_read_lock(); 5051c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5052c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 5053c141ebdaSPhilipp Reisner rcu_read_unlock(); 5054d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 5055c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5056c141ebdaSPhilipp Reisner return 1; 5057082a3439SPhilipp Reisner } 5058c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5059c141ebdaSPhilipp Reisner rcu_read_lock(); 5060d3fcb490SPhilipp Reisner } 506132862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 5062082a3439SPhilipp Reisner 5063082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 5064c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5065082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 5066082a3439SPhilipp Reisner if (not_empty) 5067082a3439SPhilipp Reisner break; 5068082a3439SPhilipp Reisner } 5069082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 5070c141ebdaSPhilipp Reisner rcu_read_unlock(); 507132862ec7SPhilipp Reisner } while (not_empty); 507232862ec7SPhilipp Reisner 507332862ec7SPhilipp Reisner return 0; 507432862ec7SPhilipp Reisner } 507532862ec7SPhilipp Reisner 50767201b972SAndreas Gruenbacher struct asender_cmd { 50777201b972SAndreas Gruenbacher size_t pkt_size; 50781952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 50797201b972SAndreas Gruenbacher }; 50807201b972SAndreas Gruenbacher 50817201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 5082e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5083e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 50841952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 50851952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 50861952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 50871952e916SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 50881952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 50891952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 50901952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 50911952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 50921952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 50931952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 50941952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 50951952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 50961952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 50971952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 50981952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 50997201b972SAndreas Gruenbacher }; 51007201b972SAndreas Gruenbacher 5101b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5102b411b363SPhilipp Reisner { 5103392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5104b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 510577351055SPhilipp Reisner struct packet_info pi; 5106257d0af6SPhilipp Reisner int rv; 5107e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5108b411b363SPhilipp Reisner int received = 0; 510952b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 511052b061a4SAndreas Gruenbacher int expect = header_size; 511144ed167dSPhilipp Reisner bool ping_timeout_active = false; 511244ed167dSPhilipp Reisner struct net_conf *nc; 5113bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 5114b411b363SPhilipp Reisner 5115b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 5116b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 5117b411b363SPhilipp Reisner 5118e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 511980822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 512044ed167dSPhilipp Reisner 512144ed167dSPhilipp Reisner rcu_read_lock(); 512244ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 512344ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5124bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 512544ed167dSPhilipp Reisner ping_int = nc->ping_int; 512644ed167dSPhilipp Reisner rcu_read_unlock(); 512744ed167dSPhilipp Reisner 512832862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5129a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 513032862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5131841ce241SAndreas Gruenbacher goto reconnect; 5132841ce241SAndreas Gruenbacher } 513344ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 513444ed167dSPhilipp Reisner ping_timeout_active = true; 5135b411b363SPhilipp Reisner } 5136b411b363SPhilipp Reisner 513732862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 513832862ec7SPhilipp Reisner much to send */ 5139bb77d34eSAndreas Gruenbacher if (tcp_cork) 514032862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5141a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5142a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5143b411b363SPhilipp Reisner goto reconnect; 5144082a3439SPhilipp Reisner } 5145b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5146bb77d34eSAndreas Gruenbacher if (tcp_cork) 514732862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5148b411b363SPhilipp Reisner 5149b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5150b411b363SPhilipp Reisner if (signal_pending(current)) 5151b411b363SPhilipp Reisner continue; 5152b411b363SPhilipp Reisner 515332862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 515432862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5155b411b363SPhilipp Reisner 5156b411b363SPhilipp Reisner flush_signals(current); 5157b411b363SPhilipp Reisner 5158b411b363SPhilipp Reisner /* Note: 5159b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5160b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5161b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5162b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5163b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5164b411b363SPhilipp Reisner * rv == expected: full header or command 5165b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5166b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5167b411b363SPhilipp Reisner */ 5168b411b363SPhilipp Reisner if (likely(rv > 0)) { 5169b411b363SPhilipp Reisner received += rv; 5170b411b363SPhilipp Reisner buf += rv; 5171b411b363SPhilipp Reisner } else if (rv == 0) { 517232862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5173b411b363SPhilipp Reisner goto reconnect; 5174b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5175cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5176cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 517732862ec7SPhilipp Reisner if (time_after(tconn->last_received, 517832862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5179cb6518cbSLars Ellenberg continue; 5180f36af18cSLars Ellenberg if (ping_timeout_active) { 518132862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5182b411b363SPhilipp Reisner goto reconnect; 5183b411b363SPhilipp Reisner } 518432862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5185b411b363SPhilipp Reisner continue; 5186b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5187b411b363SPhilipp Reisner continue; 5188b411b363SPhilipp Reisner } else { 518932862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5190b411b363SPhilipp Reisner goto reconnect; 5191b411b363SPhilipp Reisner } 5192b411b363SPhilipp Reisner 5193b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5194e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5195b411b363SPhilipp Reisner goto reconnect; 51967201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 51971952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 519832862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 519977351055SPhilipp Reisner pi.cmd, pi.size); 5200b411b363SPhilipp Reisner goto disconnect; 5201b411b363SPhilipp Reisner } 5202e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 520352b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 520432862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 520577351055SPhilipp Reisner pi.cmd, pi.size); 5206b411b363SPhilipp Reisner goto reconnect; 5207b411b363SPhilipp Reisner } 5208257d0af6SPhilipp Reisner } 5209b411b363SPhilipp Reisner if (received == expect) { 52102735a594SAndreas Gruenbacher bool err; 5211a4fbda8eSPhilipp Reisner 52122735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 52132735a594SAndreas Gruenbacher if (err) { 52141952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5215b411b363SPhilipp Reisner goto reconnect; 52161952e916SAndreas Gruenbacher } 5217b411b363SPhilipp Reisner 5218a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5219a4fbda8eSPhilipp Reisner 522044ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 522144ed167dSPhilipp Reisner /* restore idle timeout */ 522244ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 522344ed167dSPhilipp Reisner ping_timeout_active = false; 522444ed167dSPhilipp Reisner } 5225f36af18cSLars Ellenberg 5226e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5227b411b363SPhilipp Reisner received = 0; 522852b061a4SAndreas Gruenbacher expect = header_size; 5229b411b363SPhilipp Reisner cmd = NULL; 5230b411b363SPhilipp Reisner } 5231b411b363SPhilipp Reisner } 5232b411b363SPhilipp Reisner 5233b411b363SPhilipp Reisner if (0) { 5234b411b363SPhilipp Reisner reconnect: 5235bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5236b411b363SPhilipp Reisner } 5237b411b363SPhilipp Reisner if (0) { 5238b411b363SPhilipp Reisner disconnect: 5239bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5240b411b363SPhilipp Reisner } 524132862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5242b411b363SPhilipp Reisner 524332862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5244b411b363SPhilipp Reisner 5245b411b363SPhilipp Reisner return 0; 5246b411b363SPhilipp Reisner } 5247