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 sndbuf_size = nc->sndbuf_size; 63044ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 63169ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 632089c075dSAndreas Gruenbacher rcu_read_unlock(); 63344ed167dSPhilipp Reisner 634089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(src_in6)); 635089c075dSAndreas Gruenbacher memcpy(&src_in6, &tconn->my_addr, my_addr_len); 63644ed167dSPhilipp Reisner 637089c075dSAndreas Gruenbacher if (((struct sockaddr *)&tconn->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 642089c075dSAndreas Gruenbacher peer_addr_len = min_t(int, tconn->peer_addr_len, sizeof(src_in6)); 643089c075dSAndreas Gruenbacher memcpy(&peer_in6, &tconn->peer_addr, peer_addr_len); 644b411b363SPhilipp Reisner 645b411b363SPhilipp Reisner what = "sock_create_kern"; 64644ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 647b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 648b411b363SPhilipp Reisner if (err < 0) { 649b411b363SPhilipp Reisner sock = NULL; 650b411b363SPhilipp Reisner goto out; 651b411b363SPhilipp Reisner } 652b411b363SPhilipp Reisner 653b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 65469ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 65544ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 656b411b363SPhilipp Reisner 657b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 658b411b363SPhilipp Reisner * for the outgoing connections. 659b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 660b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 661b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 662b411b363SPhilipp Reisner * a free one dynamically. 663b411b363SPhilipp Reisner */ 664b411b363SPhilipp Reisner what = "bind before connect"; 66544ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 666b411b363SPhilipp Reisner if (err < 0) 667b411b363SPhilipp Reisner goto out; 668b411b363SPhilipp Reisner 669b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 670b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 671b411b363SPhilipp Reisner disconnect_on_error = 0; 672b411b363SPhilipp Reisner what = "connect"; 67344ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 674b411b363SPhilipp Reisner 675b411b363SPhilipp Reisner out: 676b411b363SPhilipp Reisner if (err < 0) { 677b411b363SPhilipp Reisner if (sock) { 678b411b363SPhilipp Reisner sock_release(sock); 679b411b363SPhilipp Reisner sock = NULL; 680b411b363SPhilipp Reisner } 681b411b363SPhilipp Reisner switch (-err) { 682b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 683b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 684b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 685b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 686b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 687b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 688b411b363SPhilipp Reisner disconnect_on_error = 0; 689b411b363SPhilipp Reisner break; 690b411b363SPhilipp Reisner default: 691eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 692b411b363SPhilipp Reisner } 693b411b363SPhilipp Reisner if (disconnect_on_error) 694bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 695b411b363SPhilipp Reisner } 69644ed167dSPhilipp Reisner 697b411b363SPhilipp Reisner return sock; 698b411b363SPhilipp Reisner } 699b411b363SPhilipp Reisner 7007653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 701b411b363SPhilipp Reisner { 70244ed167dSPhilipp Reisner int timeo, err, my_addr_len; 70369ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 704b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 70544ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 70644ed167dSPhilipp Reisner struct net_conf *nc; 707b411b363SPhilipp Reisner const char *what; 708b411b363SPhilipp Reisner 70944ed167dSPhilipp Reisner rcu_read_lock(); 71044ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 71144ed167dSPhilipp Reisner if (!nc) { 71244ed167dSPhilipp Reisner rcu_read_unlock(); 713b411b363SPhilipp Reisner return NULL; 71444ed167dSPhilipp Reisner } 71544ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71644ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 71769ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 71844ed167dSPhilipp Reisner rcu_read_unlock(); 719b411b363SPhilipp Reisner 720089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(struct sockaddr_in6)); 721089c075dSAndreas Gruenbacher memcpy(&my_addr, &tconn->my_addr, my_addr_len); 722089c075dSAndreas Gruenbacher 723b411b363SPhilipp Reisner what = "sock_create_kern"; 72444ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 725b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 726b411b363SPhilipp Reisner if (err) { 727b411b363SPhilipp Reisner s_listen = NULL; 728b411b363SPhilipp Reisner goto out; 729b411b363SPhilipp Reisner } 730b411b363SPhilipp Reisner 73169ef82deSAndreas Gruenbacher timeo = connect_int * HZ; 732b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 733b411b363SPhilipp Reisner 734b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 735b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 736b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 73744ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 738b411b363SPhilipp Reisner 739b411b363SPhilipp Reisner what = "bind before listen"; 74044ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 741b411b363SPhilipp Reisner if (err < 0) 742b411b363SPhilipp Reisner goto out; 743b411b363SPhilipp Reisner 7447653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 745b411b363SPhilipp Reisner 746b411b363SPhilipp Reisner out: 747b411b363SPhilipp Reisner if (s_listen) 748b411b363SPhilipp Reisner sock_release(s_listen); 749b411b363SPhilipp Reisner if (err < 0) { 750b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7517653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 752bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 753b411b363SPhilipp Reisner } 754b411b363SPhilipp Reisner } 755b411b363SPhilipp Reisner 756b411b363SPhilipp Reisner return s_estab; 757b411b363SPhilipp Reisner } 758b411b363SPhilipp Reisner 759e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 760b411b363SPhilipp Reisner 7619f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7629f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7639f5bdc33SAndreas Gruenbacher { 7649f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7659f5bdc33SAndreas Gruenbacher return -EIO; 766e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 767b411b363SPhilipp Reisner } 768b411b363SPhilipp Reisner 7699f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 770b411b363SPhilipp Reisner { 7719f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7729f5bdc33SAndreas Gruenbacher struct packet_info pi; 7739f5bdc33SAndreas Gruenbacher int err; 774b411b363SPhilipp Reisner 7759f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7769f5bdc33SAndreas Gruenbacher if (err != header_size) { 7779f5bdc33SAndreas Gruenbacher if (err >= 0) 7789f5bdc33SAndreas Gruenbacher err = -EIO; 7799f5bdc33SAndreas Gruenbacher return err; 7809f5bdc33SAndreas Gruenbacher } 7819f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 7829f5bdc33SAndreas Gruenbacher if (err) 7839f5bdc33SAndreas Gruenbacher return err; 7849f5bdc33SAndreas Gruenbacher return pi.cmd; 785b411b363SPhilipp Reisner } 786b411b363SPhilipp Reisner 787b411b363SPhilipp Reisner /** 788b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 789b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 790b411b363SPhilipp Reisner */ 791dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 792b411b363SPhilipp Reisner { 793b411b363SPhilipp Reisner int rr; 794b411b363SPhilipp Reisner char tb[4]; 795b411b363SPhilipp Reisner 796b411b363SPhilipp Reisner if (!*sock) 79781e84650SAndreas Gruenbacher return false; 798b411b363SPhilipp Reisner 799dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 800b411b363SPhilipp Reisner 801b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 80281e84650SAndreas Gruenbacher return true; 803b411b363SPhilipp Reisner } else { 804b411b363SPhilipp Reisner sock_release(*sock); 805b411b363SPhilipp Reisner *sock = NULL; 80681e84650SAndreas Gruenbacher return false; 807b411b363SPhilipp Reisner } 808b411b363SPhilipp Reisner } 8092325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8102325eb66SPhilipp Reisner in a connection */ 811c141ebdaSPhilipp Reisner int drbd_connected(struct drbd_conf *mdev) 812907599e0SPhilipp Reisner { 8130829f5edSAndreas Gruenbacher int err; 814907599e0SPhilipp Reisner 815907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 816907599e0SPhilipp Reisner mdev->peer_seq = 0; 817907599e0SPhilipp Reisner 8188410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8198410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8208410da8fSPhilipp Reisner &mdev->own_state_mutex; 8218410da8fSPhilipp Reisner 8220829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8230829f5edSAndreas Gruenbacher if (!err) 8240829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8250829f5edSAndreas Gruenbacher if (!err) 8260829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8270829f5edSAndreas Gruenbacher if (!err) 82843de7c85SPhilipp Reisner err = drbd_send_current_state(mdev); 829907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 830907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8318b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8320829f5edSAndreas Gruenbacher return err; 833907599e0SPhilipp Reisner } 834907599e0SPhilipp Reisner 835b411b363SPhilipp Reisner /* 836b411b363SPhilipp Reisner * return values: 837b411b363SPhilipp Reisner * 1 yes, we have a valid connection 838b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 839b411b363SPhilipp Reisner * -1 peer talks different language, 840b411b363SPhilipp Reisner * no point in trying again, please go standalone. 841b411b363SPhilipp Reisner * -2 We do not have a network config... 842b411b363SPhilipp Reisner */ 84381fa2e67SPhilipp Reisner static int conn_connect(struct drbd_tconn *tconn) 844b411b363SPhilipp Reisner { 8452bf89621SAndreas Gruenbacher struct socket *sock, *msock; 846c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 84744ed167dSPhilipp Reisner struct net_conf *nc; 848c141ebdaSPhilipp Reisner int vnr, timeout, try, h, ok; 84908b165baSPhilipp Reisner bool discard_my_data; 850b411b363SPhilipp Reisner 851bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 852b411b363SPhilipp Reisner return -2; 853b411b363SPhilipp Reisner 854907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 8550916e0e3SAndreas Gruenbacher 8560916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8570916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 858b411b363SPhilipp Reisner 859b411b363SPhilipp Reisner do { 8602bf89621SAndreas Gruenbacher struct socket *s; 8612bf89621SAndreas Gruenbacher 862b411b363SPhilipp Reisner for (try = 0;;) { 863b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 864907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 865b411b363SPhilipp Reisner if (s || ++try >= 3) 866b411b363SPhilipp Reisner break; 867b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 86820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 869b411b363SPhilipp Reisner } 870b411b363SPhilipp Reisner 871b411b363SPhilipp Reisner if (s) { 8722bf89621SAndreas Gruenbacher if (!tconn->data.socket) { 8732bf89621SAndreas Gruenbacher tconn->data.socket = s; 8749f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->data, P_INITIAL_DATA); 8752bf89621SAndreas Gruenbacher } else if (!tconn->meta.socket) { 8762bf89621SAndreas Gruenbacher tconn->meta.socket = s; 8779f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->meta, P_INITIAL_META); 878b411b363SPhilipp Reisner } else { 87981fa2e67SPhilipp Reisner conn_err(tconn, "Logic error in conn_connect()\n"); 880b411b363SPhilipp Reisner goto out_release_sockets; 881b411b363SPhilipp Reisner } 882b411b363SPhilipp Reisner } 883b411b363SPhilipp Reisner 8842bf89621SAndreas Gruenbacher if (tconn->data.socket && tconn->meta.socket) { 885907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 8862bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 8872bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 888b411b363SPhilipp Reisner if (ok) 889b411b363SPhilipp Reisner break; 890b411b363SPhilipp Reisner } 891b411b363SPhilipp Reisner 892b411b363SPhilipp Reisner retry: 893907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 894b411b363SPhilipp Reisner if (s) { 8959f5bdc33SAndreas Gruenbacher try = receive_first_packet(tconn, s); 8962bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->data.socket); 8972bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->meta.socket); 898b411b363SPhilipp Reisner switch (try) { 899e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9002bf89621SAndreas Gruenbacher if (tconn->data.socket) { 901907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9022bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 903b411b363SPhilipp Reisner } 9042bf89621SAndreas Gruenbacher tconn->data.socket = s; 905b411b363SPhilipp Reisner break; 906e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 9072bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 908907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9092bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 910b411b363SPhilipp Reisner } 9112bf89621SAndreas Gruenbacher tconn->meta.socket = s; 912907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 913b411b363SPhilipp Reisner break; 914b411b363SPhilipp Reisner default: 915907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 916b411b363SPhilipp Reisner sock_release(s); 917b411b363SPhilipp Reisner if (random32() & 1) 918b411b363SPhilipp Reisner goto retry; 919b411b363SPhilipp Reisner } 920b411b363SPhilipp Reisner } 921b411b363SPhilipp Reisner 922bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 923b411b363SPhilipp Reisner goto out_release_sockets; 924b411b363SPhilipp Reisner if (signal_pending(current)) { 925b411b363SPhilipp Reisner flush_signals(current); 926b411b363SPhilipp Reisner smp_rmb(); 927907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 928b411b363SPhilipp Reisner goto out_release_sockets; 929b411b363SPhilipp Reisner } 930b411b363SPhilipp Reisner 9312bf89621SAndreas Gruenbacher if (tconn->data.socket && &tconn->meta.socket) { 9322bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 9332bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 934b411b363SPhilipp Reisner if (ok) 935b411b363SPhilipp Reisner break; 936b411b363SPhilipp Reisner } 937b411b363SPhilipp Reisner } while (1); 938b411b363SPhilipp Reisner 9392bf89621SAndreas Gruenbacher sock = tconn->data.socket; 9402bf89621SAndreas Gruenbacher msock = tconn->meta.socket; 9412bf89621SAndreas Gruenbacher 942b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 943b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 944b411b363SPhilipp Reisner 945b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 946b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 947b411b363SPhilipp Reisner 948b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 949b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 950b411b363SPhilipp Reisner 951b411b363SPhilipp Reisner /* NOT YET ... 952907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 953b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9546038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 955b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 95644ed167dSPhilipp Reisner rcu_read_lock(); 95744ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 958b411b363SPhilipp Reisner 95944ed167dSPhilipp Reisner sock->sk->sk_sndtimeo = 96044ed167dSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 96144ed167dSPhilipp Reisner 96244ed167dSPhilipp Reisner msock->sk->sk_rcvtimeo = nc->ping_int*HZ; 96344ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 96408b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 96544ed167dSPhilipp Reisner rcu_read_unlock(); 96644ed167dSPhilipp Reisner 96744ed167dSPhilipp Reisner msock->sk->sk_sndtimeo = timeout; 968b411b363SPhilipp Reisner 969b411b363SPhilipp Reisner /* we don't want delays. 97025985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 971b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 972b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 973b411b363SPhilipp Reisner 974907599e0SPhilipp Reisner tconn->last_received = jiffies; 975b411b363SPhilipp Reisner 9766038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 977b411b363SPhilipp Reisner if (h <= 0) 978b411b363SPhilipp Reisner return h; 979b411b363SPhilipp Reisner 980907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 981b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 982907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 983b10d96cbSJohannes Thoma case -1: 984907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 985b411b363SPhilipp Reisner return -1; 986b10d96cbSJohannes Thoma case 0: 987907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 988b10d96cbSJohannes Thoma return 0; 989b411b363SPhilipp Reisner } 990b411b363SPhilipp Reisner } 991b411b363SPhilipp Reisner 99244ed167dSPhilipp Reisner sock->sk->sk_sndtimeo = timeout; 993b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 994b411b363SPhilipp Reisner 995387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 9967e2455c1SPhilipp Reisner return -1; 997b411b363SPhilipp Reisner 998c141ebdaSPhilipp Reisner rcu_read_lock(); 999c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1000c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 1001c141ebdaSPhilipp Reisner rcu_read_unlock(); 100208b165baSPhilipp Reisner 100308b165baSPhilipp Reisner if (discard_my_data) 100408b165baSPhilipp Reisner set_bit(DISCARD_MY_DATA, &mdev->flags); 100508b165baSPhilipp Reisner else 100608b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 100708b165baSPhilipp Reisner 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 1014823bd832SPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 1015823bd832SPhilipp Reisner return 0; 1016823bd832SPhilipp Reisner 1017823bd832SPhilipp Reisner drbd_thread_start(&tconn->asender); 1018823bd832SPhilipp Reisner 101908b165baSPhilipp Reisner mutex_lock(&tconn->conf_update); 102008b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 102108b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 102208b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 102308b165baSPhilipp Reisner * just to clear a single value. */ 102408b165baSPhilipp Reisner tconn->net_conf->discard_my_data = 0; 102508b165baSPhilipp Reisner mutex_unlock(&tconn->conf_update); 102608b165baSPhilipp Reisner 1027d3fcb490SPhilipp Reisner return h; 1028b411b363SPhilipp Reisner 1029b411b363SPhilipp Reisner out_release_sockets: 10302bf89621SAndreas Gruenbacher if (tconn->data.socket) { 10312bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 10322bf89621SAndreas Gruenbacher tconn->data.socket = NULL; 10332bf89621SAndreas Gruenbacher } 10342bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 10352bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 10362bf89621SAndreas Gruenbacher tconn->meta.socket = NULL; 10372bf89621SAndreas Gruenbacher } 1038b411b363SPhilipp Reisner return -1; 1039b411b363SPhilipp Reisner } 1040b411b363SPhilipp Reisner 1041e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1042b411b363SPhilipp Reisner { 1043e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1044e658983aSAndreas Gruenbacher 10450c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10460c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 10470c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 10480c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 10490c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 10500c8e36d9SAndreas Gruenbacher return -EINVAL; 10510c8e36d9SAndreas Gruenbacher } 10520c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 10530c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 10540c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 10550c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1056e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1057e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1058e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1059b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1060eefc2f7dSPhilipp Reisner pi->vnr = 0; 1061e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1062e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1063e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1064e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1065e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 106677351055SPhilipp Reisner pi->vnr = 0; 106702918be2SPhilipp Reisner } else { 1068e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1069e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1070e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 10718172f3e9SAndreas Gruenbacher return -EINVAL; 1072b411b363SPhilipp Reisner } 1073e658983aSAndreas Gruenbacher pi->data = header + header_size; 10748172f3e9SAndreas Gruenbacher return 0; 1075257d0af6SPhilipp Reisner } 1076257d0af6SPhilipp Reisner 10779ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1078257d0af6SPhilipp Reisner { 1079e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 108069bc7bc3SAndreas Gruenbacher int err; 1081257d0af6SPhilipp Reisner 1082e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1083a5c31904SAndreas Gruenbacher if (err) 108469bc7bc3SAndreas Gruenbacher return err; 1085257d0af6SPhilipp Reisner 1086e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 10879ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1088b411b363SPhilipp Reisner 108969bc7bc3SAndreas Gruenbacher return err; 1090b411b363SPhilipp Reisner } 1091b411b363SPhilipp Reisner 10924b0007c0SPhilipp Reisner static void drbd_flush(struct drbd_tconn *tconn) 1093b411b363SPhilipp Reisner { 1094b411b363SPhilipp Reisner int rv; 10954b0007c0SPhilipp Reisner struct drbd_conf *mdev; 10964b0007c0SPhilipp Reisner int vnr; 1097b411b363SPhilipp Reisner 10984b0007c0SPhilipp Reisner if (tconn->write_ordering >= WO_bdev_flush) { 10994b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 11004b0007c0SPhilipp Reisner if (get_ldev(mdev)) { 1101fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 1102dd3932edSChristoph Hellwig NULL); 11034b0007c0SPhilipp Reisner put_ldev(mdev); 11044b0007c0SPhilipp Reisner 1105b411b363SPhilipp Reisner if (rv) { 1106a67b813cSPhilipp Reisner dev_info(DEV, "local disk flush failed with status %d\n", rv); 1107b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1108b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1109b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11104b0007c0SPhilipp Reisner drbd_bump_write_ordering(tconn, WO_drain_io); 11114b0007c0SPhilipp Reisner break; 1112b411b363SPhilipp Reisner } 11134b0007c0SPhilipp Reisner } 11144b0007c0SPhilipp Reisner } 1115b411b363SPhilipp Reisner } 1116b411b363SPhilipp Reisner } 1117b411b363SPhilipp Reisner 1118b411b363SPhilipp Reisner /** 1119b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1120b411b363SPhilipp Reisner * @mdev: DRBD device. 1121b411b363SPhilipp Reisner * @epoch: Epoch object. 1122b411b363SPhilipp Reisner * @ev: Epoch event. 1123b411b363SPhilipp Reisner */ 1124b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1125b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1126b411b363SPhilipp Reisner enum epoch_event ev) 1127b411b363SPhilipp Reisner { 11282451fc3bSPhilipp Reisner int epoch_size; 1129b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1130b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1131b411b363SPhilipp Reisner 1132b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1133b411b363SPhilipp Reisner do { 1134b411b363SPhilipp Reisner next_epoch = NULL; 1135b411b363SPhilipp Reisner 1136b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1137b411b363SPhilipp Reisner 1138b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1139b411b363SPhilipp Reisner case EV_PUT: 1140b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1141b411b363SPhilipp Reisner break; 1142b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1143b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1144b411b363SPhilipp Reisner break; 1145b411b363SPhilipp Reisner case EV_BECAME_LAST: 1146b411b363SPhilipp Reisner /* nothing to do*/ 1147b411b363SPhilipp Reisner break; 1148b411b363SPhilipp Reisner } 1149b411b363SPhilipp Reisner 1150b411b363SPhilipp Reisner if (epoch_size != 0 && 1151b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 115285d73513SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1153b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1154b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 11551d2783d5SPhilipp Reisner drbd_send_b_ack(epoch->mdev, epoch->barrier_nr, epoch_size); 1156b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1157b411b363SPhilipp Reisner } 115885d73513SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 11591d2783d5SPhilipp Reisner dec_unacked(epoch->mdev); 1160b411b363SPhilipp Reisner 1161b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1162b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1163b411b363SPhilipp Reisner list_del(&epoch->list); 1164b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1165b411b363SPhilipp Reisner mdev->epochs--; 1166b411b363SPhilipp Reisner kfree(epoch); 1167b411b363SPhilipp Reisner 1168b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1169b411b363SPhilipp Reisner rv = FE_DESTROYED; 1170b411b363SPhilipp Reisner } else { 1171b411b363SPhilipp Reisner epoch->flags = 0; 1172b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1173698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1174b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1175b411b363SPhilipp Reisner rv = FE_RECYCLED; 11762451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1177b411b363SPhilipp Reisner } 1178b411b363SPhilipp Reisner } 1179b411b363SPhilipp Reisner 1180b411b363SPhilipp Reisner if (!next_epoch) 1181b411b363SPhilipp Reisner break; 1182b411b363SPhilipp Reisner 1183b411b363SPhilipp Reisner epoch = next_epoch; 1184b411b363SPhilipp Reisner } while (1); 1185b411b363SPhilipp Reisner 1186b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1187b411b363SPhilipp Reisner 1188b411b363SPhilipp Reisner return rv; 1189b411b363SPhilipp Reisner } 1190b411b363SPhilipp Reisner 1191b411b363SPhilipp Reisner /** 1192b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 11934b0007c0SPhilipp Reisner * @tconn: DRBD connection. 1194b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1195b411b363SPhilipp Reisner */ 11964b0007c0SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_tconn *tconn, enum write_ordering_e wo) 1197b411b363SPhilipp Reisner { 1198daeda1ccSPhilipp Reisner struct disk_conf *dc; 11994b0007c0SPhilipp Reisner struct drbd_conf *mdev; 1200b411b363SPhilipp Reisner enum write_ordering_e pwo; 12014b0007c0SPhilipp Reisner int vnr; 1202b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1203b411b363SPhilipp Reisner [WO_none] = "none", 1204b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1205b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1206b411b363SPhilipp Reisner }; 1207b411b363SPhilipp Reisner 12084b0007c0SPhilipp Reisner pwo = tconn->write_ordering; 1209b411b363SPhilipp Reisner wo = min(pwo, wo); 1210daeda1ccSPhilipp Reisner rcu_read_lock(); 12114b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 12124b0007c0SPhilipp Reisner if (!get_ldev(mdev)) 12134b0007c0SPhilipp Reisner continue; 1214daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1215daeda1ccSPhilipp Reisner 121666b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1217b411b363SPhilipp Reisner wo = WO_drain_io; 1218d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1219b411b363SPhilipp Reisner wo = WO_none; 12204b0007c0SPhilipp Reisner put_ldev(mdev); 12214b0007c0SPhilipp Reisner } 1222daeda1ccSPhilipp Reisner rcu_read_unlock(); 12234b0007c0SPhilipp Reisner tconn->write_ordering = wo; 12244b0007c0SPhilipp Reisner if (pwo != tconn->write_ordering || wo == WO_bdev_flush) 12254b0007c0SPhilipp Reisner conn_info(tconn, "Method to ensure write ordering: %s\n", write_ordering_str[tconn->write_ordering]); 1226b411b363SPhilipp Reisner } 1227b411b363SPhilipp Reisner 1228b411b363SPhilipp Reisner /** 1229fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 123045bb912bSLars Ellenberg * @mdev: DRBD device. 1231db830c46SAndreas Gruenbacher * @peer_req: peer request 123245bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 123310f6d992SLars Ellenberg * 123410f6d992SLars Ellenberg * May spread the pages to multiple bios, 123510f6d992SLars Ellenberg * depending on bio_add_page restrictions. 123610f6d992SLars Ellenberg * 123710f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 123810f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 123910f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 124010f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 124110f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 124210f6d992SLars Ellenberg * on certain Xen deployments. 124345bb912bSLars Ellenberg */ 124445bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1245fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1246fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 124745bb912bSLars Ellenberg const unsigned rw, const int fault_type) 124845bb912bSLars Ellenberg { 124945bb912bSLars Ellenberg struct bio *bios = NULL; 125045bb912bSLars Ellenberg struct bio *bio; 1251db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1252db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1253db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 125445bb912bSLars Ellenberg unsigned n_bios = 0; 125545bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 125610f6d992SLars Ellenberg int err = -ENOMEM; 125745bb912bSLars Ellenberg 125845bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 125945bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 126045bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1261da4a75d2SLars Ellenberg * request in more than one bio. 1262da4a75d2SLars Ellenberg * 1263da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1264da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1265da4a75d2SLars Ellenberg */ 126645bb912bSLars Ellenberg next_bio: 126745bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 126845bb912bSLars Ellenberg if (!bio) { 126945bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 127045bb912bSLars Ellenberg goto fail; 127145bb912bSLars Ellenberg } 1272db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 127345bb912bSLars Ellenberg bio->bi_sector = sector; 127445bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 127545bb912bSLars Ellenberg bio->bi_rw = rw; 1276db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1277fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 127845bb912bSLars Ellenberg 127945bb912bSLars Ellenberg bio->bi_next = bios; 128045bb912bSLars Ellenberg bios = bio; 128145bb912bSLars Ellenberg ++n_bios; 128245bb912bSLars Ellenberg 128345bb912bSLars Ellenberg page_chain_for_each(page) { 128445bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 128545bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 128610f6d992SLars Ellenberg /* A single page must always be possible! 128710f6d992SLars Ellenberg * But in case it fails anyways, 128810f6d992SLars Ellenberg * we deal with it, and complain (below). */ 128910f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 129010f6d992SLars Ellenberg dev_err(DEV, 129110f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 129210f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 129310f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 129410f6d992SLars Ellenberg err = -ENOSPC; 129510f6d992SLars Ellenberg goto fail; 129610f6d992SLars Ellenberg } 129745bb912bSLars Ellenberg goto next_bio; 129845bb912bSLars Ellenberg } 129945bb912bSLars Ellenberg ds -= len; 130045bb912bSLars Ellenberg sector += len >> 9; 130145bb912bSLars Ellenberg --nr_pages; 130245bb912bSLars Ellenberg } 130345bb912bSLars Ellenberg D_ASSERT(page == NULL); 130445bb912bSLars Ellenberg D_ASSERT(ds == 0); 130545bb912bSLars Ellenberg 1306db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 130745bb912bSLars Ellenberg do { 130845bb912bSLars Ellenberg bio = bios; 130945bb912bSLars Ellenberg bios = bios->bi_next; 131045bb912bSLars Ellenberg bio->bi_next = NULL; 131145bb912bSLars Ellenberg 131245bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 131345bb912bSLars Ellenberg } while (bios); 131445bb912bSLars Ellenberg return 0; 131545bb912bSLars Ellenberg 131645bb912bSLars Ellenberg fail: 131745bb912bSLars Ellenberg while (bios) { 131845bb912bSLars Ellenberg bio = bios; 131945bb912bSLars Ellenberg bios = bios->bi_next; 132045bb912bSLars Ellenberg bio_put(bio); 132145bb912bSLars Ellenberg } 132210f6d992SLars Ellenberg return err; 132345bb912bSLars Ellenberg } 132445bb912bSLars Ellenberg 132553840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1326db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 132753840641SAndreas Gruenbacher { 1328db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 132953840641SAndreas Gruenbacher 133053840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 133153840641SAndreas Gruenbacher drbd_clear_interval(i); 133253840641SAndreas Gruenbacher 13336c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 133453840641SAndreas Gruenbacher if (i->waiting) 133553840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 133653840641SAndreas Gruenbacher } 133753840641SAndreas Gruenbacher 13384a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1339b411b363SPhilipp Reisner { 13404a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 13412451fc3bSPhilipp Reisner int rv; 1342e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1343b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1344b411b363SPhilipp Reisner 13454a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 13464a76b161SAndreas Gruenbacher if (!mdev) 13474a76b161SAndreas Gruenbacher return -EIO; 13484a76b161SAndreas Gruenbacher 1349b411b363SPhilipp Reisner inc_unacked(mdev); 1350b411b363SPhilipp Reisner 1351b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 13521d2783d5SPhilipp Reisner mdev->current_epoch->mdev = mdev; 1353b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1354b411b363SPhilipp Reisner 1355b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1356b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1357b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1358b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1359b411b363SPhilipp Reisner * completed. */ 13604b0007c0SPhilipp Reisner switch (tconn->write_ordering) { 1361b411b363SPhilipp Reisner case WO_none: 1362b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 136382bc0194SAndreas Gruenbacher return 0; 1364b411b363SPhilipp Reisner 1365b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1366b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1367b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 13682451fc3bSPhilipp Reisner if (epoch) 13692451fc3bSPhilipp Reisner break; 13702451fc3bSPhilipp Reisner else 1371b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 13722451fc3bSPhilipp Reisner /* Fall through */ 13732451fc3bSPhilipp Reisner 13742451fc3bSPhilipp Reisner case WO_bdev_flush: 13752451fc3bSPhilipp Reisner case WO_drain_io: 1376b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 13774b0007c0SPhilipp Reisner drbd_flush(tconn); 13782451fc3bSPhilipp Reisner 13792451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 13802451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 13812451fc3bSPhilipp Reisner if (epoch) 13822451fc3bSPhilipp Reisner break; 1383b411b363SPhilipp Reisner } 1384b411b363SPhilipp Reisner 13852451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 13862451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 13872451fc3bSPhilipp Reisner 13882451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 13892451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1390b411b363SPhilipp Reisner 139182bc0194SAndreas Gruenbacher return 0; 13922451fc3bSPhilipp Reisner default: 13934b0007c0SPhilipp Reisner dev_err(DEV, "Strangeness in tconn->write_ordering %d\n", tconn->write_ordering); 139482bc0194SAndreas Gruenbacher return -EIO; 1395b411b363SPhilipp Reisner } 1396b411b363SPhilipp Reisner 1397b411b363SPhilipp Reisner epoch->flags = 0; 1398b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1399b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1400b411b363SPhilipp Reisner 1401b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1402b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1403b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1404b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1405b411b363SPhilipp Reisner mdev->epochs++; 1406b411b363SPhilipp Reisner } else { 1407b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1408b411b363SPhilipp Reisner kfree(epoch); 1409b411b363SPhilipp Reisner } 1410b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1411b411b363SPhilipp Reisner 141282bc0194SAndreas Gruenbacher return 0; 1413b411b363SPhilipp Reisner } 1414b411b363SPhilipp Reisner 1415b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1416b411b363SPhilipp Reisner * and from receive_Data */ 1417f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1418f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1419f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1420b411b363SPhilipp Reisner { 14216666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1422db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1423b411b363SPhilipp Reisner struct page *page; 1424a5c31904SAndreas Gruenbacher int dgs, ds, err; 1425a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1426a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 14276b4388acSPhilipp Reisner unsigned long *data; 1428b411b363SPhilipp Reisner 142988104ca4SAndreas Gruenbacher dgs = 0; 143088104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 143188104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 14329f5bdc33SAndreas Gruenbacher /* 14339f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 14349f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 14359f5bdc33SAndreas Gruenbacher */ 1436a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1437a5c31904SAndreas Gruenbacher if (err) 1438b411b363SPhilipp Reisner return NULL; 1439b411b363SPhilipp Reisner data_size -= dgs; 144088104ca4SAndreas Gruenbacher } 1441b411b363SPhilipp Reisner 1442841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1443841ce241SAndreas Gruenbacher return NULL; 1444841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1445841ce241SAndreas Gruenbacher return NULL; 1446841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1447841ce241SAndreas Gruenbacher return NULL; 1448b411b363SPhilipp Reisner 14496666032aSLars Ellenberg /* even though we trust out peer, 14506666032aSLars Ellenberg * we sometimes have to double check. */ 14516666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1452fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1453fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 14546666032aSLars Ellenberg (unsigned long long)capacity, 14556666032aSLars Ellenberg (unsigned long long)sector, data_size); 14566666032aSLars Ellenberg return NULL; 14576666032aSLars Ellenberg } 14586666032aSLars Ellenberg 1459b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1460b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1461b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 14620db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1463db830c46SAndreas Gruenbacher if (!peer_req) 1464b411b363SPhilipp Reisner return NULL; 146545bb912bSLars Ellenberg 1466b411b363SPhilipp Reisner ds = data_size; 1467db830c46SAndreas Gruenbacher page = peer_req->pages; 146845bb912bSLars Ellenberg page_chain_for_each(page) { 146945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 14706b4388acSPhilipp Reisner data = kmap(page); 1471a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 14720cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 14736b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 14746b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 14756b4388acSPhilipp Reisner } 1476b411b363SPhilipp Reisner kunmap(page); 1477a5c31904SAndreas Gruenbacher if (err) { 14783967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1479b411b363SPhilipp Reisner return NULL; 1480b411b363SPhilipp Reisner } 1481a5c31904SAndreas Gruenbacher ds -= len; 1482b411b363SPhilipp Reisner } 1483b411b363SPhilipp Reisner 1484b411b363SPhilipp Reisner if (dgs) { 14855b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1486b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1487470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1488470be44aSLars Ellenberg (unsigned long long)sector, data_size); 14893967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1490b411b363SPhilipp Reisner return NULL; 1491b411b363SPhilipp Reisner } 1492b411b363SPhilipp Reisner } 1493b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1494db830c46SAndreas Gruenbacher return peer_req; 1495b411b363SPhilipp Reisner } 1496b411b363SPhilipp Reisner 1497b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1498b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1499b411b363SPhilipp Reisner */ 1500b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1501b411b363SPhilipp Reisner { 1502b411b363SPhilipp Reisner struct page *page; 1503a5c31904SAndreas Gruenbacher int err = 0; 1504b411b363SPhilipp Reisner void *data; 1505b411b363SPhilipp Reisner 1506c3470cdeSLars Ellenberg if (!data_size) 1507fc5be839SAndreas Gruenbacher return 0; 1508c3470cdeSLars Ellenberg 1509c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1510b411b363SPhilipp Reisner 1511b411b363SPhilipp Reisner data = kmap(page); 1512b411b363SPhilipp Reisner while (data_size) { 1513fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1514fc5be839SAndreas Gruenbacher 1515a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1516a5c31904SAndreas Gruenbacher if (err) 1517b411b363SPhilipp Reisner break; 1518a5c31904SAndreas Gruenbacher data_size -= len; 1519b411b363SPhilipp Reisner } 1520b411b363SPhilipp Reisner kunmap(page); 15215cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1522fc5be839SAndreas Gruenbacher return err; 1523b411b363SPhilipp Reisner } 1524b411b363SPhilipp Reisner 1525b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1526b411b363SPhilipp Reisner sector_t sector, int data_size) 1527b411b363SPhilipp Reisner { 1528b411b363SPhilipp Reisner struct bio_vec *bvec; 1529b411b363SPhilipp Reisner struct bio *bio; 1530a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1531a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1532a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1533b411b363SPhilipp Reisner 153488104ca4SAndreas Gruenbacher dgs = 0; 153588104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 153688104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1537a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1538a5c31904SAndreas Gruenbacher if (err) 1539a5c31904SAndreas Gruenbacher return err; 1540b411b363SPhilipp Reisner data_size -= dgs; 154188104ca4SAndreas Gruenbacher } 1542b411b363SPhilipp Reisner 1543b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1544b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1545b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1546b411b363SPhilipp Reisner 1547b411b363SPhilipp Reisner bio = req->master_bio; 1548b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1549b411b363SPhilipp Reisner 1550b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1551a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1552b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1553a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1554b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1555a5c31904SAndreas Gruenbacher if (err) 1556a5c31904SAndreas Gruenbacher return err; 1557a5c31904SAndreas Gruenbacher data_size -= expect; 1558b411b363SPhilipp Reisner } 1559b411b363SPhilipp Reisner 1560b411b363SPhilipp Reisner if (dgs) { 15615b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1562b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1563b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 156428284cefSAndreas Gruenbacher return -EINVAL; 1565b411b363SPhilipp Reisner } 1566b411b363SPhilipp Reisner } 1567b411b363SPhilipp Reisner 1568b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 156928284cefSAndreas Gruenbacher return 0; 1570b411b363SPhilipp Reisner } 1571b411b363SPhilipp Reisner 1572a990be46SAndreas Gruenbacher /* 1573a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1574a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1575a990be46SAndreas Gruenbacher */ 157699920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1577b411b363SPhilipp Reisner { 15788050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 15798050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 158000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1581db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 158299920dc5SAndreas Gruenbacher int err; 1583b411b363SPhilipp Reisner 1584db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1585b411b363SPhilipp Reisner 1586db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1587db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 158899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1589b411b363SPhilipp Reisner } else { 1590b411b363SPhilipp Reisner /* Record failure to sync */ 1591db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1592b411b363SPhilipp Reisner 159399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1594b411b363SPhilipp Reisner } 1595b411b363SPhilipp Reisner dec_unacked(mdev); 1596b411b363SPhilipp Reisner 159799920dc5SAndreas Gruenbacher return err; 1598b411b363SPhilipp Reisner } 1599b411b363SPhilipp Reisner 1600b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1601b411b363SPhilipp Reisner { 1602db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1603b411b363SPhilipp Reisner 1604db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1605db830c46SAndreas Gruenbacher if (!peer_req) 160645bb912bSLars Ellenberg goto fail; 1607b411b363SPhilipp Reisner 1608b411b363SPhilipp Reisner dec_rs_pending(mdev); 1609b411b363SPhilipp Reisner 1610b411b363SPhilipp Reisner inc_unacked(mdev); 1611b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1612b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1613b411b363SPhilipp Reisner 1614db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 161545bb912bSLars Ellenberg 161687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1617db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 161887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1619b411b363SPhilipp Reisner 16200f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1621fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1622e1c1b0fcSAndreas Gruenbacher return 0; 162345bb912bSLars Ellenberg 162410f6d992SLars Ellenberg /* don't care for the reason here */ 162510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 162687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1627db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 162887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 162922cc37a9SLars Ellenberg 16303967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 163145bb912bSLars Ellenberg fail: 163245bb912bSLars Ellenberg put_ldev(mdev); 1633e1c1b0fcSAndreas Gruenbacher return -EIO; 1634b411b363SPhilipp Reisner } 1635b411b363SPhilipp Reisner 1636668eebc6SAndreas Gruenbacher static struct drbd_request * 1637bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1638bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1639668eebc6SAndreas Gruenbacher { 1640668eebc6SAndreas Gruenbacher struct drbd_request *req; 1641668eebc6SAndreas Gruenbacher 1642bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1643bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 16445e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1645668eebc6SAndreas Gruenbacher return req; 1646c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 16475af172edSAndreas Gruenbacher dev_err(DEV, "%s: failed to find request 0x%lx, sector %llus\n", func, 1648c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1649c3afd8f5SAndreas Gruenbacher } 1650668eebc6SAndreas Gruenbacher return NULL; 1651668eebc6SAndreas Gruenbacher } 1652668eebc6SAndreas Gruenbacher 16534a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1654b411b363SPhilipp Reisner { 16554a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1656b411b363SPhilipp Reisner struct drbd_request *req; 1657b411b363SPhilipp Reisner sector_t sector; 165882bc0194SAndreas Gruenbacher int err; 1659e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16604a76b161SAndreas Gruenbacher 16614a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16624a76b161SAndreas Gruenbacher if (!mdev) 16634a76b161SAndreas Gruenbacher return -EIO; 1664b411b363SPhilipp Reisner 1665b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1666b411b363SPhilipp Reisner 166787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1668bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 166987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1670c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 167182bc0194SAndreas Gruenbacher return -EIO; 1672b411b363SPhilipp Reisner 167324c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1674b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1675b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1676e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 167782bc0194SAndreas Gruenbacher if (!err) 16788554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1679b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1680b411b363SPhilipp Reisner * I don't think we may complete this just yet 1681b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1682b411b363SPhilipp Reisner 168382bc0194SAndreas Gruenbacher return err; 1684b411b363SPhilipp Reisner } 1685b411b363SPhilipp Reisner 16864a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1687b411b363SPhilipp Reisner { 16884a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1689b411b363SPhilipp Reisner sector_t sector; 169082bc0194SAndreas Gruenbacher int err; 1691e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16924a76b161SAndreas Gruenbacher 16934a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16944a76b161SAndreas Gruenbacher if (!mdev) 16954a76b161SAndreas Gruenbacher return -EIO; 1696b411b363SPhilipp Reisner 1697b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1698b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1699b411b363SPhilipp Reisner 1700b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1701b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1702b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1703fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1704e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1705b411b363SPhilipp Reisner } else { 1706b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1707b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1708b411b363SPhilipp Reisner 1709e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1710b411b363SPhilipp Reisner 1711e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1712b411b363SPhilipp Reisner } 1713b411b363SPhilipp Reisner 1714e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1715778f271dSPhilipp Reisner 171682bc0194SAndreas Gruenbacher return err; 1717b411b363SPhilipp Reisner } 1718b411b363SPhilipp Reisner 171999920dc5SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 17207be8da07SAndreas Gruenbacher { 17217be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 17227be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 17237be8da07SAndreas Gruenbacher struct bio *bio; 17247be8da07SAndreas Gruenbacher unsigned long start_time; 17257be8da07SAndreas Gruenbacher unsigned long flags; 17267be8da07SAndreas Gruenbacher 17277be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 17287be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 17297be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 173099920dc5SAndreas Gruenbacher return -EIO; 17317be8da07SAndreas Gruenbacher } 17327be8da07SAndreas Gruenbacher bio = req->master_bio; 17337be8da07SAndreas Gruenbacher start_time = req->start_time; 17347be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 17357be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 17367be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 17377be8da07SAndreas Gruenbacher 17387be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 17397be8da07SAndreas Gruenbacher /* retry */ ; 174099920dc5SAndreas Gruenbacher return 0; 17417be8da07SAndreas Gruenbacher } 17427be8da07SAndreas Gruenbacher 17437be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17447be8da07SAndreas Gruenbacher sector_t sector, int size) 17457be8da07SAndreas Gruenbacher { 17467be8da07SAndreas Gruenbacher struct drbd_interval *i; 17477be8da07SAndreas Gruenbacher struct drbd_request *req; 17487be8da07SAndreas Gruenbacher 17497be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17507be8da07SAndreas Gruenbacher if (!i->local) 17517be8da07SAndreas Gruenbacher continue; 17527be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 17537be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 17547be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 17557be8da07SAndreas Gruenbacher continue; 17567be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 17577be8da07SAndreas Gruenbacher req->w.mdev = mdev; 17587be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 17597be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 17607be8da07SAndreas Gruenbacher } 17617be8da07SAndreas Gruenbacher } 17627be8da07SAndreas Gruenbacher } 17637be8da07SAndreas Gruenbacher 1764a990be46SAndreas Gruenbacher /* 1765a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1766b411b363SPhilipp Reisner */ 176799920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1768b411b363SPhilipp Reisner { 17698050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17708050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 177100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1772db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 177399920dc5SAndreas Gruenbacher int err = 0, pcmd; 1774b411b363SPhilipp Reisner 1775303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1776db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1777b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1778b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1779db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1780b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 178199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1782b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1783db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1784b411b363SPhilipp Reisner } else { 178599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1786b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1787b411b363SPhilipp Reisner * maybe assert this? */ 1788b411b363SPhilipp Reisner } 1789b411b363SPhilipp Reisner dec_unacked(mdev); 1790b411b363SPhilipp Reisner } 1791b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1792b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1793302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 179487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1795db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1796db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 17977be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 17987be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 179987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1800bb3bfe96SAndreas Gruenbacher } else 1801db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1802b411b363SPhilipp Reisner 1803db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1804b411b363SPhilipp Reisner 180599920dc5SAndreas Gruenbacher return err; 1806b411b363SPhilipp Reisner } 1807b411b363SPhilipp Reisner 18087be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1809b411b363SPhilipp Reisner { 18107be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 18118050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18128050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 181399920dc5SAndreas Gruenbacher int err; 1814b411b363SPhilipp Reisner 181599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1816b411b363SPhilipp Reisner dec_unacked(mdev); 1817b411b363SPhilipp Reisner 181899920dc5SAndreas Gruenbacher return err; 1819b411b363SPhilipp Reisner } 1820b411b363SPhilipp Reisner 182199920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 18227be8da07SAndreas Gruenbacher { 18237be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 18247be8da07SAndreas Gruenbacher } 18257be8da07SAndreas Gruenbacher 182699920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18277be8da07SAndreas Gruenbacher { 18287be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 18297be8da07SAndreas Gruenbacher 18307be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 18317be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 18327be8da07SAndreas Gruenbacher } 18337be8da07SAndreas Gruenbacher 18343e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18353e394da1SAndreas Gruenbacher { 18363e394da1SAndreas Gruenbacher /* 18373e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18383e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18393e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18403e394da1SAndreas Gruenbacher */ 18413e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18423e394da1SAndreas Gruenbacher } 18433e394da1SAndreas Gruenbacher 18443e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18453e394da1SAndreas Gruenbacher { 18463e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18473e394da1SAndreas Gruenbacher } 18483e394da1SAndreas Gruenbacher 18497be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 18507be8da07SAndreas Gruenbacher { 18517be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 1852302bdeaeSPhilipp Reisner int tp; 18537be8da07SAndreas Gruenbacher 18547be8da07SAndreas Gruenbacher /* 18557be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 18567be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 18577be8da07SAndreas Gruenbacher * handle_write_conflicts(). 18587be8da07SAndreas Gruenbacher */ 1859302bdeaeSPhilipp Reisner 1860302bdeaeSPhilipp Reisner rcu_read_lock(); 1861302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1862302bdeaeSPhilipp Reisner rcu_read_unlock(); 1863302bdeaeSPhilipp Reisner 1864302bdeaeSPhilipp Reisner return tp && test_bit(DISCARD_CONCURRENT, &tconn->flags); 18657be8da07SAndreas Gruenbacher } 18667be8da07SAndreas Gruenbacher 186743ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 18683e394da1SAndreas Gruenbacher { 18693c13b680SLars Ellenberg unsigned int newest_peer_seq; 18703e394da1SAndreas Gruenbacher 18717be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 18723e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 18733c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 18743c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 18753e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 18763c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 18773c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 18783e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 18793e394da1SAndreas Gruenbacher } 18807be8da07SAndreas Gruenbacher } 18813e394da1SAndreas Gruenbacher 1882b411b363SPhilipp Reisner /* Called from receive_Data. 1883b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1884b411b363SPhilipp Reisner * 1885b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1886b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1887b411b363SPhilipp Reisner * been sent. 1888b411b363SPhilipp Reisner * 1889b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1890b411b363SPhilipp Reisner * 1891b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1892b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1893b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1894b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1895b411b363SPhilipp Reisner * 1896b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1897b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1898b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1899b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1900b411b363SPhilipp Reisner * 1901b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1902b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 19037be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1904b411b363SPhilipp Reisner { 1905b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1906b411b363SPhilipp Reisner long timeout; 19077be8da07SAndreas Gruenbacher int ret; 19087be8da07SAndreas Gruenbacher 19097be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 19107be8da07SAndreas Gruenbacher return 0; 19117be8da07SAndreas Gruenbacher 1912b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1913b411b363SPhilipp Reisner for (;;) { 19147be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 19157be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 19167be8da07SAndreas Gruenbacher ret = 0; 1917b411b363SPhilipp Reisner break; 19187be8da07SAndreas Gruenbacher } 1919b411b363SPhilipp Reisner if (signal_pending(current)) { 1920b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1921b411b363SPhilipp Reisner break; 1922b411b363SPhilipp Reisner } 19237be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1924b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 192544ed167dSPhilipp Reisner rcu_read_lock(); 192644ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 192744ed167dSPhilipp Reisner rcu_read_unlock(); 192871b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1929b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 19307be8da07SAndreas Gruenbacher if (!timeout) { 1931b411b363SPhilipp Reisner ret = -ETIMEDOUT; 193271b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1933b411b363SPhilipp Reisner break; 1934b411b363SPhilipp Reisner } 1935b411b363SPhilipp Reisner } 1936b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 19377be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1938b411b363SPhilipp Reisner return ret; 1939b411b363SPhilipp Reisner } 1940b411b363SPhilipp Reisner 1941688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1942688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1943688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1944688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 194576d2e7ecSPhilipp Reisner { 194676d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 194776d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1948688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 194976d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 195076d2e7ecSPhilipp Reisner } 195176d2e7ecSPhilipp Reisner 19527be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 19537be8da07SAndreas Gruenbacher unsigned int size) 19547be8da07SAndreas Gruenbacher { 19557be8da07SAndreas Gruenbacher struct drbd_interval *i; 19567be8da07SAndreas Gruenbacher 19577be8da07SAndreas Gruenbacher repeat: 19587be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19597be8da07SAndreas Gruenbacher struct drbd_request *req; 19607be8da07SAndreas Gruenbacher struct bio_and_error m; 19617be8da07SAndreas Gruenbacher 19627be8da07SAndreas Gruenbacher if (!i->local) 19637be8da07SAndreas Gruenbacher continue; 19647be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 19657be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 19667be8da07SAndreas Gruenbacher continue; 19677be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 19687be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 19697be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 19707be8da07SAndreas Gruenbacher if (m.bio) 19717be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 19727be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 19737be8da07SAndreas Gruenbacher goto repeat; 19747be8da07SAndreas Gruenbacher } 19757be8da07SAndreas Gruenbacher } 19767be8da07SAndreas Gruenbacher 19777be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 19787be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 19797be8da07SAndreas Gruenbacher { 19807be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 19817be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 19827be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 19837be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 19847be8da07SAndreas Gruenbacher struct drbd_interval *i; 19857be8da07SAndreas Gruenbacher bool equal; 19867be8da07SAndreas Gruenbacher int err; 19877be8da07SAndreas Gruenbacher 19887be8da07SAndreas Gruenbacher /* 19897be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 19907be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 19917be8da07SAndreas Gruenbacher */ 19927be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 19937be8da07SAndreas Gruenbacher 19947be8da07SAndreas Gruenbacher repeat: 19957be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19967be8da07SAndreas Gruenbacher if (i == &peer_req->i) 19977be8da07SAndreas Gruenbacher continue; 19987be8da07SAndreas Gruenbacher 19997be8da07SAndreas Gruenbacher if (!i->local) { 20007be8da07SAndreas Gruenbacher /* 20017be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20027be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20037be8da07SAndreas Gruenbacher * earlier peer request to complete. 20047be8da07SAndreas Gruenbacher */ 20057be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 20067be8da07SAndreas Gruenbacher if (err) 20077be8da07SAndreas Gruenbacher goto out; 20087be8da07SAndreas Gruenbacher goto repeat; 20097be8da07SAndreas Gruenbacher } 20107be8da07SAndreas Gruenbacher 20117be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20127be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20137be8da07SAndreas Gruenbacher /* 20147be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 20157be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 20167be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 20177be8da07SAndreas Gruenbacher * have completed. 20187be8da07SAndreas Gruenbacher */ 20197be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 20207be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 20217be8da07SAndreas Gruenbacher 20227be8da07SAndreas Gruenbacher if (!equal) 20237be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20247be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 20257be8da07SAndreas Gruenbacher "assuming %s came first\n", 20267be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20277be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 20287be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 20297be8da07SAndreas Gruenbacher 20307be8da07SAndreas Gruenbacher inc_unacked(mdev); 20317be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 20327be8da07SAndreas Gruenbacher e_send_retry_write; 20337be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 20347be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 20357be8da07SAndreas Gruenbacher 20367be8da07SAndreas Gruenbacher err = -ENOENT; 20377be8da07SAndreas Gruenbacher goto out; 20387be8da07SAndreas Gruenbacher } else { 20397be8da07SAndreas Gruenbacher struct drbd_request *req = 20407be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 20417be8da07SAndreas Gruenbacher 20427be8da07SAndreas Gruenbacher if (!equal) 20437be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20447be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 20457be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20467be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 20477be8da07SAndreas Gruenbacher 20487be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 20497be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 20507be8da07SAndreas Gruenbacher /* 20517be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 20527be8da07SAndreas Gruenbacher * decide if this request will be discarded or 20537be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 20547be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 20557be8da07SAndreas Gruenbacher * 20567be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 20577be8da07SAndreas Gruenbacher * request to finish locally before submitting 20587be8da07SAndreas Gruenbacher * the conflicting peer request. 20597be8da07SAndreas Gruenbacher */ 20607be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 20617be8da07SAndreas Gruenbacher if (err) { 20627be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 20637be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 20647be8da07SAndreas Gruenbacher CS_HARD); 20657be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 20667be8da07SAndreas Gruenbacher goto out; 20677be8da07SAndreas Gruenbacher } 20687be8da07SAndreas Gruenbacher goto repeat; 20697be8da07SAndreas Gruenbacher } 20707be8da07SAndreas Gruenbacher /* 20717be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 20727be8da07SAndreas Gruenbacher * the new peer request has completed. 20737be8da07SAndreas Gruenbacher */ 20747be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 20757be8da07SAndreas Gruenbacher } 20767be8da07SAndreas Gruenbacher } 20777be8da07SAndreas Gruenbacher err = 0; 20787be8da07SAndreas Gruenbacher 20797be8da07SAndreas Gruenbacher out: 20807be8da07SAndreas Gruenbacher if (err) 20817be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 20827be8da07SAndreas Gruenbacher return err; 20837be8da07SAndreas Gruenbacher } 20847be8da07SAndreas Gruenbacher 2085b411b363SPhilipp Reisner /* mirrored write */ 20864a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2087b411b363SPhilipp Reisner { 20884a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2089b411b363SPhilipp Reisner sector_t sector; 2090db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2091e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20927be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2093b411b363SPhilipp Reisner int rw = WRITE; 2094b411b363SPhilipp Reisner u32 dp_flags; 2095302bdeaeSPhilipp Reisner int err, tp; 20967be8da07SAndreas Gruenbacher 20974a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 20984a76b161SAndreas Gruenbacher if (!mdev) 20994a76b161SAndreas Gruenbacher return -EIO; 21004a76b161SAndreas Gruenbacher 2101b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 210282bc0194SAndreas Gruenbacher int err2; 210382bc0194SAndreas Gruenbacher 21047be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2105e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 2106b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 2107e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 210882bc0194SAndreas Gruenbacher if (!err) 210982bc0194SAndreas Gruenbacher err = err2; 211082bc0194SAndreas Gruenbacher return err; 2111b411b363SPhilipp Reisner } 2112b411b363SPhilipp Reisner 2113fcefa62eSAndreas Gruenbacher /* 2114fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2115fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2116fcefa62eSAndreas Gruenbacher * end of this function. 2117fcefa62eSAndreas Gruenbacher */ 2118b411b363SPhilipp Reisner 2119b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2120e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2121db830c46SAndreas Gruenbacher if (!peer_req) { 2122b411b363SPhilipp Reisner put_ldev(mdev); 212382bc0194SAndreas Gruenbacher return -EIO; 2124b411b363SPhilipp Reisner } 2125b411b363SPhilipp Reisner 2126db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2127b411b363SPhilipp Reisner 2128688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2129688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2130688593c5SLars Ellenberg 2131688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2132db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2133688593c5SLars Ellenberg 2134b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2135db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2136db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2137db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2138b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2139b411b363SPhilipp Reisner 2140302bdeaeSPhilipp Reisner rcu_read_lock(); 2141302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2142302bdeaeSPhilipp Reisner rcu_read_unlock(); 2143302bdeaeSPhilipp Reisner if (tp) { 2144302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 21457be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 21467be8da07SAndreas Gruenbacher if (err) 2147b411b363SPhilipp Reisner goto out_interrupted; 214887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 21497be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 21507be8da07SAndreas Gruenbacher if (err) { 215187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 21527be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2153b411b363SPhilipp Reisner put_ldev(mdev); 215482bc0194SAndreas Gruenbacher return 0; 2155b411b363SPhilipp Reisner } 2156b411b363SPhilipp Reisner goto out_interrupted; 2157b411b363SPhilipp Reisner } 21587be8da07SAndreas Gruenbacher } else 215987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2160db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 216187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2162b411b363SPhilipp Reisner 2163303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 216444ed167dSPhilipp Reisner rcu_read_lock(); 216544ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2166b411b363SPhilipp Reisner case DRBD_PROT_C: 2167303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2168303d1448SPhilipp Reisner break; 2169303d1448SPhilipp Reisner case DRBD_PROT_B: 2170303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2171303d1448SPhilipp Reisner break; 2172303d1448SPhilipp Reisner } 217344ed167dSPhilipp Reisner rcu_read_unlock(); 2174303d1448SPhilipp Reisner } 2175303d1448SPhilipp Reisner 2176303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2177303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2178b411b363SPhilipp Reisner inc_unacked(mdev); 2179b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2180b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2181303d1448SPhilipp Reisner } 2182303d1448SPhilipp Reisner 2183303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2184b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2185b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2186db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2187b411b363SPhilipp Reisner } 2188b411b363SPhilipp Reisner 21896719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2190b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2191db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2192db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2193db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2194181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2195b411b363SPhilipp Reisner } 2196b411b363SPhilipp Reisner 219782bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 219882bc0194SAndreas Gruenbacher if (!err) 219982bc0194SAndreas Gruenbacher return 0; 2200b411b363SPhilipp Reisner 220110f6d992SLars Ellenberg /* don't care for the reason here */ 220210f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 220387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2204db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2205db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 220687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2207db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2208181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 220922cc37a9SLars Ellenberg 2210b411b363SPhilipp Reisner out_interrupted: 2211db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2212b411b363SPhilipp Reisner put_ldev(mdev); 22133967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 221482bc0194SAndreas Gruenbacher return err; 2215b411b363SPhilipp Reisner } 2216b411b363SPhilipp Reisner 22170f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 22180f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 22190f0601f4SLars Ellenberg * 22200f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 22210f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 22220f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 22230f0601f4SLars Ellenberg * activity, it obviously is "busy". 22240f0601f4SLars Ellenberg * 22250f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 22260f0601f4SLars Ellenberg * to have a short time average so we can react faster. 22270f0601f4SLars Ellenberg */ 2228e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 22290f0601f4SLars Ellenberg { 22300f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 22310f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2232e3555d85SPhilipp Reisner struct lc_element *tmp; 22330f0601f4SLars Ellenberg int curr_events; 22340f0601f4SLars Ellenberg int throttle = 0; 2235daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2236daeda1ccSPhilipp Reisner 2237daeda1ccSPhilipp Reisner rcu_read_lock(); 2238daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2239daeda1ccSPhilipp Reisner rcu_read_unlock(); 22400f0601f4SLars Ellenberg 22410f0601f4SLars Ellenberg /* feature disabled? */ 2242daeda1ccSPhilipp Reisner if (c_min_rate == 0) 22430f0601f4SLars Ellenberg return 0; 22440f0601f4SLars Ellenberg 2245e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2246e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2247e3555d85SPhilipp Reisner if (tmp) { 2248e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2249e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2250e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2251e3555d85SPhilipp Reisner return 0; 2252e3555d85SPhilipp Reisner } 2253e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2254e3555d85SPhilipp Reisner } 2255e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2256e3555d85SPhilipp Reisner 22570f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 22580f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 22590f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2260e3555d85SPhilipp Reisner 22610f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 22620f0601f4SLars Ellenberg unsigned long rs_left; 22630f0601f4SLars Ellenberg int i; 22640f0601f4SLars Ellenberg 22650f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 22660f0601f4SLars Ellenberg 22670f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 22680f0601f4SLars Ellenberg * approx. */ 22692649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 22702649f080SLars Ellenberg 22712649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 22722649f080SLars Ellenberg rs_left = mdev->ov_left; 22732649f080SLars Ellenberg else 22740f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 22750f0601f4SLars Ellenberg 22760f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 22770f0601f4SLars Ellenberg if (!dt) 22780f0601f4SLars Ellenberg dt++; 22790f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 22800f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 22810f0601f4SLars Ellenberg 2282daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 22830f0601f4SLars Ellenberg throttle = 1; 22840f0601f4SLars Ellenberg } 22850f0601f4SLars Ellenberg return throttle; 22860f0601f4SLars Ellenberg } 22870f0601f4SLars Ellenberg 22880f0601f4SLars Ellenberg 22894a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2290b411b363SPhilipp Reisner { 22914a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2292b411b363SPhilipp Reisner sector_t sector; 22934a76b161SAndreas Gruenbacher sector_t capacity; 2294db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2295b411b363SPhilipp Reisner struct digest_info *di = NULL; 2296b18b37beSPhilipp Reisner int size, verb; 2297b411b363SPhilipp Reisner unsigned int fault_type; 2298e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 22994a76b161SAndreas Gruenbacher 23004a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 23014a76b161SAndreas Gruenbacher if (!mdev) 23024a76b161SAndreas Gruenbacher return -EIO; 23034a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2304b411b363SPhilipp Reisner 2305b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2306b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2307b411b363SPhilipp Reisner 2308c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2309b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2310b411b363SPhilipp Reisner (unsigned long long)sector, size); 231182bc0194SAndreas Gruenbacher return -EINVAL; 2312b411b363SPhilipp Reisner } 2313b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2314b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2315b411b363SPhilipp Reisner (unsigned long long)sector, size); 231682bc0194SAndreas Gruenbacher return -EINVAL; 2317b411b363SPhilipp Reisner } 2318b411b363SPhilipp Reisner 2319b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2320b18b37beSPhilipp Reisner verb = 1; 2321e2857216SAndreas Gruenbacher switch (pi->cmd) { 2322b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2323b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2324b18b37beSPhilipp Reisner break; 2325b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2326b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2327b18b37beSPhilipp Reisner case P_OV_REQUEST: 2328b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2329b18b37beSPhilipp Reisner break; 2330b18b37beSPhilipp Reisner case P_OV_REPLY: 2331b18b37beSPhilipp Reisner verb = 0; 2332b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2333b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2334b18b37beSPhilipp Reisner break; 2335b18b37beSPhilipp Reisner default: 233649ba9b1bSAndreas Gruenbacher BUG(); 2337b18b37beSPhilipp Reisner } 2338b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2339b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2340b411b363SPhilipp Reisner "no local data.\n"); 2341b18b37beSPhilipp Reisner 2342a821cc4aSLars Ellenberg /* drain possibly payload */ 2343e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2344b411b363SPhilipp Reisner } 2345b411b363SPhilipp Reisner 2346b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2347b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2348b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 23490db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2350db830c46SAndreas Gruenbacher if (!peer_req) { 2351b411b363SPhilipp Reisner put_ldev(mdev); 235282bc0194SAndreas Gruenbacher return -ENOMEM; 2353b411b363SPhilipp Reisner } 2354b411b363SPhilipp Reisner 2355e2857216SAndreas Gruenbacher switch (pi->cmd) { 2356b411b363SPhilipp Reisner case P_DATA_REQUEST: 2357db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2358b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 235980a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 236080a40e43SLars Ellenberg goto submit; 236180a40e43SLars Ellenberg 2362b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2363db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2364b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 23655f9915bbSLars Ellenberg /* used in the sector offset progress display */ 23665f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2367b411b363SPhilipp Reisner break; 2368b411b363SPhilipp Reisner 2369b411b363SPhilipp Reisner case P_OV_REPLY: 2370b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2371b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2372e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2373b411b363SPhilipp Reisner if (!di) 2374b411b363SPhilipp Reisner goto out_free_e; 2375b411b363SPhilipp Reisner 2376e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2377b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2378b411b363SPhilipp Reisner 2379db830c46SAndreas Gruenbacher peer_req->digest = di; 2380db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2381c36c3cedSLars Ellenberg 2382e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2383b411b363SPhilipp Reisner goto out_free_e; 2384b411b363SPhilipp Reisner 2385e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 238631890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2387db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 23885f9915bbSLars Ellenberg /* used in the sector offset progress display */ 23895f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2390e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 23912649f080SLars Ellenberg /* track progress, we may need to throttle */ 23922649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2393db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2394b411b363SPhilipp Reisner dec_rs_pending(mdev); 23950f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 23960f0601f4SLars Ellenberg * but accounting still needs to be done. */ 23970f0601f4SLars Ellenberg goto submit_for_resync; 2398b411b363SPhilipp Reisner } 2399b411b363SPhilipp Reisner break; 2400b411b363SPhilipp Reisner 2401b411b363SPhilipp Reisner case P_OV_REQUEST: 2402b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 240331890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2404de228bbaSLars Ellenberg unsigned long now = jiffies; 2405de228bbaSLars Ellenberg int i; 2406b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2407b411b363SPhilipp Reisner mdev->ov_position = sector; 240830b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 240930b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2410de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2411de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2412de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2413de228bbaSLars Ellenberg } 2414b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2415b411b363SPhilipp Reisner (unsigned long long)sector); 2416b411b363SPhilipp Reisner } 2417db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2418b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2419b411b363SPhilipp Reisner break; 2420b411b363SPhilipp Reisner 2421b411b363SPhilipp Reisner default: 242249ba9b1bSAndreas Gruenbacher BUG(); 2423b411b363SPhilipp Reisner } 2424b411b363SPhilipp Reisner 24250f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 24260f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 24270f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 24280f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 24290f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 24300f0601f4SLars Ellenberg * 24310f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 24320f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 24330f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 24340f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 24350f0601f4SLars Ellenberg * a while, anyways. 24360f0601f4SLars Ellenberg */ 2437b411b363SPhilipp Reisner 24380f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 24390f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 24400f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 24410f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 24420f0601f4SLars Ellenberg * 24430f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 24440f0601f4SLars Ellenberg * we would also throttle its application reads. 24450f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 24460f0601f4SLars Ellenberg */ 2447e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2448e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2449e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 245080a40e43SLars Ellenberg goto out_free_e; 2451b411b363SPhilipp Reisner 24520f0601f4SLars Ellenberg submit_for_resync: 24530f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 24540f0601f4SLars Ellenberg 245580a40e43SLars Ellenberg submit: 2456b411b363SPhilipp Reisner inc_unacked(mdev); 245787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2458db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 245987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2460b411b363SPhilipp Reisner 2461fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 246282bc0194SAndreas Gruenbacher return 0; 2463b411b363SPhilipp Reisner 246410f6d992SLars Ellenberg /* don't care for the reason here */ 246510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 246687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2467db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 246887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 246922cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 247022cc37a9SLars Ellenberg 2471b411b363SPhilipp Reisner out_free_e: 2472b411b363SPhilipp Reisner put_ldev(mdev); 24733967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 247482bc0194SAndreas Gruenbacher return -EIO; 2475b411b363SPhilipp Reisner } 2476b411b363SPhilipp Reisner 2477b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2478b411b363SPhilipp Reisner { 2479b411b363SPhilipp Reisner int self, peer, rv = -100; 2480b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 248144ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2482b411b363SPhilipp Reisner 2483b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2484b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2485b411b363SPhilipp Reisner 2486b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2487b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2488b411b363SPhilipp Reisner 248944ed167dSPhilipp Reisner rcu_read_lock(); 249044ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 249144ed167dSPhilipp Reisner rcu_read_unlock(); 249244ed167dSPhilipp Reisner switch (after_sb_0p) { 2493b411b363SPhilipp Reisner case ASB_CONSENSUS: 2494b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2495b411b363SPhilipp Reisner case ASB_CALL_HELPER: 249644ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2497b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2498b411b363SPhilipp Reisner break; 2499b411b363SPhilipp Reisner case ASB_DISCONNECT: 2500b411b363SPhilipp Reisner break; 2501b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2502b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2503b411b363SPhilipp Reisner rv = -1; 2504b411b363SPhilipp Reisner break; 2505b411b363SPhilipp Reisner } 2506b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2507b411b363SPhilipp Reisner rv = 1; 2508b411b363SPhilipp Reisner break; 2509b411b363SPhilipp Reisner } 2510b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2511b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2512b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2513b411b363SPhilipp Reisner rv = 1; 2514b411b363SPhilipp Reisner break; 2515b411b363SPhilipp Reisner } 2516b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2517b411b363SPhilipp Reisner rv = -1; 2518b411b363SPhilipp Reisner break; 2519b411b363SPhilipp Reisner } 2520b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2521ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2522b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2523b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2524b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 252525703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2526b411b363SPhilipp Reisner ? -1 : 1; 2527b411b363SPhilipp Reisner break; 2528b411b363SPhilipp Reisner } else { 2529b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2530b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2531b411b363SPhilipp Reisner } 253244ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2533b411b363SPhilipp Reisner break; 2534b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2535b411b363SPhilipp Reisner if (ch_self < ch_peer) 2536b411b363SPhilipp Reisner rv = -1; 2537b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2538b411b363SPhilipp Reisner rv = 1; 2539b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2540b411b363SPhilipp Reisner /* Well, then use something else. */ 254125703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2542b411b363SPhilipp Reisner ? -1 : 1; 2543b411b363SPhilipp Reisner break; 2544b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2545b411b363SPhilipp Reisner rv = -1; 2546b411b363SPhilipp Reisner break; 2547b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2548b411b363SPhilipp Reisner rv = 1; 2549b411b363SPhilipp Reisner } 2550b411b363SPhilipp Reisner 2551b411b363SPhilipp Reisner return rv; 2552b411b363SPhilipp Reisner } 2553b411b363SPhilipp Reisner 2554b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2555b411b363SPhilipp Reisner { 25566184ea21SAndreas Gruenbacher int hg, rv = -100; 255744ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2558b411b363SPhilipp Reisner 255944ed167dSPhilipp Reisner rcu_read_lock(); 256044ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 256144ed167dSPhilipp Reisner rcu_read_unlock(); 256244ed167dSPhilipp Reisner switch (after_sb_1p) { 2563b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2564b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2565b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2566b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2567b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 256844ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2569b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2570b411b363SPhilipp Reisner break; 2571b411b363SPhilipp Reisner case ASB_DISCONNECT: 2572b411b363SPhilipp Reisner break; 2573b411b363SPhilipp Reisner case ASB_CONSENSUS: 2574b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2575b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2576b411b363SPhilipp Reisner rv = hg; 2577b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2578b411b363SPhilipp Reisner rv = hg; 2579b411b363SPhilipp Reisner break; 2580b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2581b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2582b411b363SPhilipp Reisner break; 2583b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2584b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2585b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2586b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2587b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2588bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2589bb437946SAndreas Gruenbacher 2590bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2591b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2592b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2593b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2594bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2595bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2596b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2597b411b363SPhilipp Reisner } else { 2598b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2599b411b363SPhilipp Reisner rv = hg; 2600b411b363SPhilipp Reisner } 2601b411b363SPhilipp Reisner } else 2602b411b363SPhilipp Reisner rv = hg; 2603b411b363SPhilipp Reisner } 2604b411b363SPhilipp Reisner 2605b411b363SPhilipp Reisner return rv; 2606b411b363SPhilipp Reisner } 2607b411b363SPhilipp Reisner 2608b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2609b411b363SPhilipp Reisner { 26106184ea21SAndreas Gruenbacher int hg, rv = -100; 261144ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2612b411b363SPhilipp Reisner 261344ed167dSPhilipp Reisner rcu_read_lock(); 261444ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 261544ed167dSPhilipp Reisner rcu_read_unlock(); 261644ed167dSPhilipp Reisner switch (after_sb_2p) { 2617b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2618b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2619b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2620b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2621b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2622b411b363SPhilipp Reisner case ASB_CONSENSUS: 2623b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 262444ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2625b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2626b411b363SPhilipp Reisner break; 2627b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2628b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2629b411b363SPhilipp Reisner break; 2630b411b363SPhilipp Reisner case ASB_DISCONNECT: 2631b411b363SPhilipp Reisner break; 2632b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2633b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2634b411b363SPhilipp Reisner if (hg == -1) { 2635bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2636bb437946SAndreas Gruenbacher 2637b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2638b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2639b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2640bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2641bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2642b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2643b411b363SPhilipp Reisner } else { 2644b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2645b411b363SPhilipp Reisner rv = hg; 2646b411b363SPhilipp Reisner } 2647b411b363SPhilipp Reisner } else 2648b411b363SPhilipp Reisner rv = hg; 2649b411b363SPhilipp Reisner } 2650b411b363SPhilipp Reisner 2651b411b363SPhilipp Reisner return rv; 2652b411b363SPhilipp Reisner } 2653b411b363SPhilipp Reisner 2654b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2655b411b363SPhilipp Reisner u64 bits, u64 flags) 2656b411b363SPhilipp Reisner { 2657b411b363SPhilipp Reisner if (!uuid) { 2658b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2659b411b363SPhilipp Reisner return; 2660b411b363SPhilipp Reisner } 2661b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2662b411b363SPhilipp Reisner text, 2663b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2664b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2665b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2666b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2667b411b363SPhilipp Reisner (unsigned long long)bits, 2668b411b363SPhilipp Reisner (unsigned long long)flags); 2669b411b363SPhilipp Reisner } 2670b411b363SPhilipp Reisner 2671b411b363SPhilipp Reisner /* 2672b411b363SPhilipp Reisner 100 after split brain try auto recover 2673b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2674b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2675b411b363SPhilipp Reisner 0 no Sync 2676b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2677b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2678b411b363SPhilipp Reisner -100 after split brain, disconnect 2679b411b363SPhilipp Reisner -1000 unrelated data 26804a23f264SPhilipp Reisner -1091 requires proto 91 26814a23f264SPhilipp Reisner -1096 requires proto 96 2682b411b363SPhilipp Reisner */ 2683b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2684b411b363SPhilipp Reisner { 2685b411b363SPhilipp Reisner u64 self, peer; 2686b411b363SPhilipp Reisner int i, j; 2687b411b363SPhilipp Reisner 2688b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2689b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2690b411b363SPhilipp Reisner 2691b411b363SPhilipp Reisner *rule_nr = 10; 2692b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2693b411b363SPhilipp Reisner return 0; 2694b411b363SPhilipp Reisner 2695b411b363SPhilipp Reisner *rule_nr = 20; 2696b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2697b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2698b411b363SPhilipp Reisner return -2; 2699b411b363SPhilipp Reisner 2700b411b363SPhilipp Reisner *rule_nr = 30; 2701b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2702b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2703b411b363SPhilipp Reisner return 2; 2704b411b363SPhilipp Reisner 2705b411b363SPhilipp Reisner if (self == peer) { 2706b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2707b411b363SPhilipp Reisner 2708b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2709b411b363SPhilipp Reisner 271031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27114a23f264SPhilipp Reisner return -1091; 2712b411b363SPhilipp Reisner 2713b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2714b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2715b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2716b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2717b411b363SPhilipp Reisner 2718b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2719b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2720b411b363SPhilipp Reisner *rule_nr = 34; 2721b411b363SPhilipp Reisner } else { 2722b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2723b411b363SPhilipp Reisner *rule_nr = 36; 2724b411b363SPhilipp Reisner } 2725b411b363SPhilipp Reisner 2726b411b363SPhilipp Reisner return 1; 2727b411b363SPhilipp Reisner } 2728b411b363SPhilipp Reisner 2729b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2730b411b363SPhilipp Reisner 273131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27324a23f264SPhilipp Reisner return -1091; 2733b411b363SPhilipp Reisner 2734b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2735b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2736b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2737b411b363SPhilipp Reisner 2738b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2739b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2740b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2741b411b363SPhilipp Reisner 2742b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2743b411b363SPhilipp Reisner *rule_nr = 35; 2744b411b363SPhilipp Reisner } else { 2745b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2746b411b363SPhilipp Reisner *rule_nr = 37; 2747b411b363SPhilipp Reisner } 2748b411b363SPhilipp Reisner 2749b411b363SPhilipp Reisner return -1; 2750b411b363SPhilipp Reisner } 2751b411b363SPhilipp Reisner 2752b411b363SPhilipp Reisner /* Common power [off|failure] */ 2753b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2754b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2755b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2756b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2757b411b363SPhilipp Reisner *rule_nr = 40; 2758b411b363SPhilipp Reisner 2759b411b363SPhilipp Reisner switch (rct) { 2760b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2761b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2762b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2763b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 276425703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2765b411b363SPhilipp Reisner return dc ? -1 : 1; 2766b411b363SPhilipp Reisner } 2767b411b363SPhilipp Reisner } 2768b411b363SPhilipp Reisner 2769b411b363SPhilipp Reisner *rule_nr = 50; 2770b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2771b411b363SPhilipp Reisner if (self == peer) 2772b411b363SPhilipp Reisner return -1; 2773b411b363SPhilipp Reisner 2774b411b363SPhilipp Reisner *rule_nr = 51; 2775b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2776b411b363SPhilipp Reisner if (self == peer) { 277731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 27784a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 27794a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 27804a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2781b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2782b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2783b411b363SPhilipp Reisner 278431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27854a23f264SPhilipp Reisner return -1091; 2786b411b363SPhilipp Reisner 2787b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2788b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 27894a23f264SPhilipp Reisner 27904a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 27914a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 27924a23f264SPhilipp Reisner 2793b411b363SPhilipp Reisner return -1; 2794b411b363SPhilipp Reisner } 2795b411b363SPhilipp Reisner } 2796b411b363SPhilipp Reisner 2797b411b363SPhilipp Reisner *rule_nr = 60; 2798b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2799b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2800b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2801b411b363SPhilipp Reisner if (self == peer) 2802b411b363SPhilipp Reisner return -2; 2803b411b363SPhilipp Reisner } 2804b411b363SPhilipp Reisner 2805b411b363SPhilipp Reisner *rule_nr = 70; 2806b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2807b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2808b411b363SPhilipp Reisner if (self == peer) 2809b411b363SPhilipp Reisner return 1; 2810b411b363SPhilipp Reisner 2811b411b363SPhilipp Reisner *rule_nr = 71; 2812b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2813b411b363SPhilipp Reisner if (self == peer) { 281431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28154a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 28164a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 28174a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2818b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2819b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2820b411b363SPhilipp Reisner 282131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28224a23f264SPhilipp Reisner return -1091; 2823b411b363SPhilipp Reisner 2824b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2825b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2826b411b363SPhilipp Reisner 28274a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2828b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2829b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2830b411b363SPhilipp Reisner 2831b411b363SPhilipp Reisner return 1; 2832b411b363SPhilipp Reisner } 2833b411b363SPhilipp Reisner } 2834b411b363SPhilipp Reisner 2835b411b363SPhilipp Reisner 2836b411b363SPhilipp Reisner *rule_nr = 80; 2837d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2838b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2839b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2840b411b363SPhilipp Reisner if (self == peer) 2841b411b363SPhilipp Reisner return 2; 2842b411b363SPhilipp Reisner } 2843b411b363SPhilipp Reisner 2844b411b363SPhilipp Reisner *rule_nr = 90; 2845b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2846b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2847b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2848b411b363SPhilipp Reisner return 100; 2849b411b363SPhilipp Reisner 2850b411b363SPhilipp Reisner *rule_nr = 100; 2851b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2852b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2853b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2854b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2855b411b363SPhilipp Reisner if (self == peer) 2856b411b363SPhilipp Reisner return -100; 2857b411b363SPhilipp Reisner } 2858b411b363SPhilipp Reisner } 2859b411b363SPhilipp Reisner 2860b411b363SPhilipp Reisner return -1000; 2861b411b363SPhilipp Reisner } 2862b411b363SPhilipp Reisner 2863b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2864b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2865b411b363SPhilipp Reisner */ 2866b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2867b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2868b411b363SPhilipp Reisner { 2869b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2870b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 287144ed167dSPhilipp Reisner struct net_conf *nc; 28726dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2873b411b363SPhilipp Reisner 2874b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2875b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2876b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2877b411b363SPhilipp Reisner 2878b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2879b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2880b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2881b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2882b411b363SPhilipp Reisner 2883b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2884b411b363SPhilipp Reisner 2885b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2886b411b363SPhilipp Reisner 2887b411b363SPhilipp Reisner if (hg == -1000) { 2888b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2889b411b363SPhilipp Reisner return C_MASK; 2890b411b363SPhilipp Reisner } 28914a23f264SPhilipp Reisner if (hg < -1000) { 28924a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2893b411b363SPhilipp Reisner return C_MASK; 2894b411b363SPhilipp Reisner } 2895b411b363SPhilipp Reisner 2896b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2897b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2898b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2899b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2900b411b363SPhilipp Reisner if (f) 2901b411b363SPhilipp Reisner hg = hg*2; 2902b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2903b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2904b411b363SPhilipp Reisner } 2905b411b363SPhilipp Reisner 29063a11a487SAdam Gandelman if (abs(hg) == 100) 29073a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 29083a11a487SAdam Gandelman 290944ed167dSPhilipp Reisner rcu_read_lock(); 291044ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 291144ed167dSPhilipp Reisner 291244ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2913b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2914b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2915b411b363SPhilipp Reisner int forced = (hg == -100); 2916b411b363SPhilipp Reisner 2917b411b363SPhilipp Reisner switch (pcount) { 2918b411b363SPhilipp Reisner case 0: 2919b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2920b411b363SPhilipp Reisner break; 2921b411b363SPhilipp Reisner case 1: 2922b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2923b411b363SPhilipp Reisner break; 2924b411b363SPhilipp Reisner case 2: 2925b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2926b411b363SPhilipp Reisner break; 2927b411b363SPhilipp Reisner } 2928b411b363SPhilipp Reisner if (abs(hg) < 100) { 2929b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2930b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2931b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2932b411b363SPhilipp Reisner if (forced) { 2933b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2934b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2935b411b363SPhilipp Reisner hg = hg*2; 2936b411b363SPhilipp Reisner } 2937b411b363SPhilipp Reisner } 2938b411b363SPhilipp Reisner } 2939b411b363SPhilipp Reisner 2940b411b363SPhilipp Reisner if (hg == -100) { 294108b165baSPhilipp Reisner if (test_bit(DISCARD_MY_DATA, &mdev->flags) && !(mdev->p_uuid[UI_FLAGS]&1)) 2942b411b363SPhilipp Reisner hg = -1; 294308b165baSPhilipp Reisner if (!test_bit(DISCARD_MY_DATA, &mdev->flags) && (mdev->p_uuid[UI_FLAGS]&1)) 2944b411b363SPhilipp Reisner hg = 1; 2945b411b363SPhilipp Reisner 2946b411b363SPhilipp Reisner if (abs(hg) < 100) 2947b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2948b411b363SPhilipp Reisner "Sync from %s node\n", 2949b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2950b411b363SPhilipp Reisner } 295144ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 29526dff2902SAndreas Gruenbacher tentative = nc->tentative; 295344ed167dSPhilipp Reisner rcu_read_unlock(); 2954b411b363SPhilipp Reisner 2955b411b363SPhilipp Reisner if (hg == -100) { 2956580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2957580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2958580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2959580b9767SLars Ellenberg * to that disk, in a way... */ 29603a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2961b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2962b411b363SPhilipp Reisner return C_MASK; 2963b411b363SPhilipp Reisner } 2964b411b363SPhilipp Reisner 2965b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2966b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2967b411b363SPhilipp Reisner return C_MASK; 2968b411b363SPhilipp Reisner } 2969b411b363SPhilipp Reisner 2970b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2971b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 297244ed167dSPhilipp Reisner switch (rr_conflict) { 2973b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2974b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2975b411b363SPhilipp Reisner /* fall through */ 2976b411b363SPhilipp Reisner case ASB_DISCONNECT: 2977b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2978b411b363SPhilipp Reisner return C_MASK; 2979b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2980b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2981b411b363SPhilipp Reisner "assumption\n"); 2982b411b363SPhilipp Reisner } 2983b411b363SPhilipp Reisner } 2984b411b363SPhilipp Reisner 29856dff2902SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2986cf14c2e9SPhilipp Reisner if (hg == 0) 2987cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2988cf14c2e9SPhilipp Reisner else 2989cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2990cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2991cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2992cf14c2e9SPhilipp Reisner return C_MASK; 2993cf14c2e9SPhilipp Reisner } 2994cf14c2e9SPhilipp Reisner 2995b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2996b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 299720ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 299820ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2999b411b363SPhilipp Reisner return C_MASK; 3000b411b363SPhilipp Reisner } 3001b411b363SPhilipp Reisner 3002b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3003b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3004b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3005b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3006b411b363SPhilipp Reisner } else { 3007b411b363SPhilipp Reisner rv = C_CONNECTED; 3008b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 3009b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 3010b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 3011b411b363SPhilipp Reisner } 3012b411b363SPhilipp Reisner } 3013b411b363SPhilipp Reisner 3014b411b363SPhilipp Reisner return rv; 3015b411b363SPhilipp Reisner } 3016b411b363SPhilipp Reisner 3017f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3018b411b363SPhilipp Reisner { 3019b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3020f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3021f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3022b411b363SPhilipp Reisner 3023b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3024f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3025f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3026b411b363SPhilipp Reisner 3027b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3028f179d76dSPhilipp Reisner return peer; 3029b411b363SPhilipp Reisner } 3030b411b363SPhilipp Reisner 3031e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3032b411b363SPhilipp Reisner { 3033e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3034036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3035036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3036036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3037036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3038accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 30397aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3040b411b363SPhilipp Reisner 3041b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3042b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3043b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3044b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3045b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3046cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 30476139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3048cf14c2e9SPhilipp Reisner 304986db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 305086db0618SAndreas Gruenbacher int err; 305186db0618SAndreas Gruenbacher 305288104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 305386db0618SAndreas Gruenbacher return -EIO; 305488104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 305586db0618SAndreas Gruenbacher if (err) 305686db0618SAndreas Gruenbacher return err; 305788104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3058036b17eaSPhilipp Reisner } 305986db0618SAndreas Gruenbacher 30607d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 30617204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3062cf14c2e9SPhilipp Reisner 3063cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 30647204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3065b411b363SPhilipp Reisner 306644ed167dSPhilipp Reisner rcu_read_lock(); 306744ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 306844ed167dSPhilipp Reisner 3069036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 3070d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "protocol"); 307144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3072b411b363SPhilipp Reisner } 3073b411b363SPhilipp Reisner 3074f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 3075d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-0pri"); 307644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3077b411b363SPhilipp Reisner } 3078b411b363SPhilipp Reisner 3079f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 3080d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-1pri"); 308144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3082b411b363SPhilipp Reisner } 3083b411b363SPhilipp Reisner 3084f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 3085d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-2pri"); 308644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3087b411b363SPhilipp Reisner } 3088b411b363SPhilipp Reisner 30896139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 3090d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "discard-my-data"); 309144ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3092b411b363SPhilipp Reisner } 3093b411b363SPhilipp Reisner 309444ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 3095d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "allow-two-primaries"); 309644ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3097b411b363SPhilipp Reisner } 3098b411b363SPhilipp Reisner 3099036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 3100d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "data-integrity-alg"); 3101036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3102036b17eaSPhilipp Reisner } 3103036b17eaSPhilipp Reisner 310486db0618SAndreas Gruenbacher rcu_read_unlock(); 3105fbc12f45SAndreas Gruenbacher } 31067d4c782cSAndreas Gruenbacher 31077d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 31087d4c782cSAndreas Gruenbacher int hash_size; 31097d4c782cSAndreas Gruenbacher 31107d4c782cSAndreas Gruenbacher /* 31117d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 31127d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 31137d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 31147d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 31157d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 31167d4c782cSAndreas Gruenbacher * change. 31177d4c782cSAndreas Gruenbacher */ 31187d4c782cSAndreas Gruenbacher 31197d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 31207d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 31217d4c782cSAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 31227d4c782cSAndreas Gruenbacher integrity_alg); 31237d4c782cSAndreas Gruenbacher goto disconnect; 31247d4c782cSAndreas Gruenbacher } 31257d4c782cSAndreas Gruenbacher 31267d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 31277d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 31287d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 31297d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 31307d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of buffers for data integrity checking failed\n"); 31317d4c782cSAndreas Gruenbacher goto disconnect; 31327d4c782cSAndreas Gruenbacher } 31337d4c782cSAndreas Gruenbacher } 31347d4c782cSAndreas Gruenbacher 31357d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 31367d4c782cSAndreas Gruenbacher if (!new_net_conf) { 31377d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of new net_conf failed\n"); 31387d4c782cSAndreas Gruenbacher goto disconnect; 31397d4c782cSAndreas Gruenbacher } 31407d4c782cSAndreas Gruenbacher 31417d4c782cSAndreas Gruenbacher mutex_lock(&tconn->data.mutex); 31427d4c782cSAndreas Gruenbacher mutex_lock(&tconn->conf_update); 31437d4c782cSAndreas Gruenbacher old_net_conf = tconn->net_conf; 31447d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 31457d4c782cSAndreas Gruenbacher 31467d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 31477d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 31487d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 31497d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 31507d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 31517d4c782cSAndreas Gruenbacher 31527d4c782cSAndreas Gruenbacher rcu_assign_pointer(tconn->net_conf, new_net_conf); 31537d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->conf_update); 31547d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->data.mutex); 31557d4c782cSAndreas Gruenbacher 31567d4c782cSAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 31577d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_in); 31587d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_vv); 31597d4c782cSAndreas Gruenbacher tconn->peer_integrity_tfm = peer_integrity_tfm; 31607d4c782cSAndreas Gruenbacher tconn->int_dig_in = int_dig_in; 31617d4c782cSAndreas Gruenbacher tconn->int_dig_vv = int_dig_vv; 31627d4c782cSAndreas Gruenbacher 31637d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 31647d4c782cSAndreas Gruenbacher conn_info(tconn, "peer data-integrity-alg: %s\n", 31657d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 31667d4c782cSAndreas Gruenbacher 31677d4c782cSAndreas Gruenbacher synchronize_rcu(); 31687d4c782cSAndreas Gruenbacher kfree(old_net_conf); 316982bc0194SAndreas Gruenbacher return 0; 3170b411b363SPhilipp Reisner 317144ed167dSPhilipp Reisner disconnect_rcu_unlock: 317244ed167dSPhilipp Reisner rcu_read_unlock(); 3173b411b363SPhilipp Reisner disconnect: 3174b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3175036b17eaSPhilipp Reisner kfree(int_dig_in); 3176036b17eaSPhilipp Reisner kfree(int_dig_vv); 31777204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 317882bc0194SAndreas Gruenbacher return -EIO; 3179b411b363SPhilipp Reisner } 3180b411b363SPhilipp Reisner 3181b411b363SPhilipp Reisner /* helper function 3182b411b363SPhilipp Reisner * input: alg name, feature name 3183b411b363SPhilipp Reisner * return: NULL (alg name was "") 3184b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3185b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3186b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3187b411b363SPhilipp Reisner const char *alg, const char *name) 3188b411b363SPhilipp Reisner { 3189b411b363SPhilipp Reisner struct crypto_hash *tfm; 3190b411b363SPhilipp Reisner 3191b411b363SPhilipp Reisner if (!alg[0]) 3192b411b363SPhilipp Reisner return NULL; 3193b411b363SPhilipp Reisner 3194b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3195b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3196b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3197b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3198b411b363SPhilipp Reisner return tfm; 3199b411b363SPhilipp Reisner } 3200b411b363SPhilipp Reisner return tfm; 3201b411b363SPhilipp Reisner } 3202b411b363SPhilipp Reisner 32034a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3204b411b363SPhilipp Reisner { 32054a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 32064a76b161SAndreas Gruenbacher int size = pi->size; 32074a76b161SAndreas Gruenbacher 32084a76b161SAndreas Gruenbacher while (size) { 32094a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 32104a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 32114a76b161SAndreas Gruenbacher if (s <= 0) { 32124a76b161SAndreas Gruenbacher if (s < 0) 32134a76b161SAndreas Gruenbacher return s; 32144a76b161SAndreas Gruenbacher break; 32154a76b161SAndreas Gruenbacher } 32164a76b161SAndreas Gruenbacher size -= s; 32174a76b161SAndreas Gruenbacher } 32184a76b161SAndreas Gruenbacher if (size) 32194a76b161SAndreas Gruenbacher return -EIO; 32204a76b161SAndreas Gruenbacher return 0; 32214a76b161SAndreas Gruenbacher } 32224a76b161SAndreas Gruenbacher 32234a76b161SAndreas Gruenbacher /* 32244a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 32254a76b161SAndreas Gruenbacher * 32264a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 32274a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 32284a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 32294a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 32304a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 32314a76b161SAndreas Gruenbacher * 32324a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 32334a76b161SAndreas Gruenbacher */ 32344a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 32354a76b161SAndreas Gruenbacher { 32362fcb8f30SAndreas Gruenbacher conn_warn(tconn, "%s packet received for volume %u, which is not configured locally\n", 32372fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 32384a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 32394a76b161SAndreas Gruenbacher } 32404a76b161SAndreas Gruenbacher 32414a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 32424a76b161SAndreas Gruenbacher { 32434a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3244e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3245b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3246b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3247b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 32482ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3249813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 32504a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3251813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3252778f271dSPhilipp Reisner int fifo_size = 0; 325382bc0194SAndreas Gruenbacher int err; 3254b411b363SPhilipp Reisner 32554a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 32564a76b161SAndreas Gruenbacher if (!mdev) 32574a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 32584a76b161SAndreas Gruenbacher 3259b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3260b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3261b411b363SPhilipp Reisner + SHARED_SECRET_MAX 32628e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 32638e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3264b411b363SPhilipp Reisner 3265e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3266b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3267e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 326882bc0194SAndreas Gruenbacher return -EIO; 3269b411b363SPhilipp Reisner } 3270b411b363SPhilipp Reisner 3271b411b363SPhilipp Reisner if (apv <= 88) { 3272e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3273e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 32748e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3275e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3276e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3277b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 32788e26f9ccSPhilipp Reisner } else { 3279e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3280e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3281b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3282b411b363SPhilipp Reisner } 3283b411b363SPhilipp Reisner 3284b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3285e658983aSAndreas Gruenbacher p = pi->data; 3286b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3287b411b363SPhilipp Reisner 3288e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 328982bc0194SAndreas Gruenbacher if (err) 329082bc0194SAndreas Gruenbacher return err; 3291b411b363SPhilipp Reisner 3292813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3293813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3294813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3295daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3296daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3297813472ceSPhilipp Reisner put_ldev(mdev); 3298813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3299daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3300daeda1ccSPhilipp Reisner return -ENOMEM; 3301f399002eSLars Ellenberg } 3302b411b363SPhilipp Reisner 3303daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3304daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3305daeda1ccSPhilipp Reisner 33066394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3307813472ceSPhilipp Reisner } 3308daeda1ccSPhilipp Reisner 3309b411b363SPhilipp Reisner if (apv >= 88) { 3310b411b363SPhilipp Reisner if (apv == 88) { 3311b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3312b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3313b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3314b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3315813472ceSPhilipp Reisner err = -EIO; 3316813472ceSPhilipp Reisner goto reconnect; 3317b411b363SPhilipp Reisner } 3318b411b363SPhilipp Reisner 331982bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3320813472ceSPhilipp Reisner if (err) 3321813472ceSPhilipp Reisner goto reconnect; 3322b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3323b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3324b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3325b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3326b411b363SPhilipp Reisner 3327b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3328b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3329b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3330b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3331b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3332b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3333b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3334b411b363SPhilipp Reisner } 3335b411b363SPhilipp Reisner 33362ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3337b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3338b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 33392ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3340b411b363SPhilipp Reisner goto disconnect; 3341b411b363SPhilipp Reisner } 3342b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3343b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3344b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3345b411b363SPhilipp Reisner verify_tfm = NULL; 3346b411b363SPhilipp Reisner goto disconnect; 3347b411b363SPhilipp Reisner } 3348b411b363SPhilipp Reisner } 3349b411b363SPhilipp Reisner 33502ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3351b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3352b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 33532ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3354b411b363SPhilipp Reisner goto disconnect; 3355b411b363SPhilipp Reisner } 3356b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3357b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3358b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3359b411b363SPhilipp Reisner csums_tfm = NULL; 3360b411b363SPhilipp Reisner goto disconnect; 3361b411b363SPhilipp Reisner } 3362b411b363SPhilipp Reisner } 3363b411b363SPhilipp Reisner 3364813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3365daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3366daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3367daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3368daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3369778f271dSPhilipp Reisner 3370daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 33719958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3372813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3373813472ceSPhilipp Reisner if (!new_plan) { 3374778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3375f399002eSLars Ellenberg put_ldev(mdev); 3376778f271dSPhilipp Reisner goto disconnect; 3377778f271dSPhilipp Reisner } 3378778f271dSPhilipp Reisner } 33798e26f9ccSPhilipp Reisner } 3380b411b363SPhilipp Reisner 338191fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 33822ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 33832ec91e0eSPhilipp Reisner if (!new_net_conf) { 338491fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 338591fd4dadSPhilipp Reisner goto disconnect; 338691fd4dadSPhilipp Reisner } 338791fd4dadSPhilipp Reisner 33882ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 338991fd4dadSPhilipp Reisner 3390b411b363SPhilipp Reisner if (verify_tfm) { 33912ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 33922ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3393f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3394f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3395b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3396b411b363SPhilipp Reisner } 3397b411b363SPhilipp Reisner if (csums_tfm) { 33982ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 33992ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3400f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3401f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3402b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3403b411b363SPhilipp Reisner } 34042ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 340591fd4dadSPhilipp Reisner } 340691fd4dadSPhilipp Reisner } 340791fd4dadSPhilipp Reisner 3408813472ceSPhilipp Reisner if (new_disk_conf) { 3409daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3410813472ceSPhilipp Reisner put_ldev(mdev); 3411778f271dSPhilipp Reisner } 3412813472ceSPhilipp Reisner 3413813472ceSPhilipp Reisner if (new_plan) { 3414813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3415813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3416813472ceSPhilipp Reisner } 3417daeda1ccSPhilipp Reisner 3418daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3419daeda1ccSPhilipp Reisner synchronize_rcu(); 3420daeda1ccSPhilipp Reisner if (new_net_conf) 3421daeda1ccSPhilipp Reisner kfree(old_net_conf); 3422daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3423813472ceSPhilipp Reisner kfree(old_plan); 3424daeda1ccSPhilipp Reisner 342582bc0194SAndreas Gruenbacher return 0; 3426b411b363SPhilipp Reisner 3427813472ceSPhilipp Reisner reconnect: 3428813472ceSPhilipp Reisner if (new_disk_conf) { 3429813472ceSPhilipp Reisner put_ldev(mdev); 3430813472ceSPhilipp Reisner kfree(new_disk_conf); 3431813472ceSPhilipp Reisner } 3432813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3433813472ceSPhilipp Reisner return -EIO; 3434813472ceSPhilipp Reisner 3435b411b363SPhilipp Reisner disconnect: 3436813472ceSPhilipp Reisner kfree(new_plan); 3437813472ceSPhilipp Reisner if (new_disk_conf) { 3438813472ceSPhilipp Reisner put_ldev(mdev); 3439813472ceSPhilipp Reisner kfree(new_disk_conf); 3440813472ceSPhilipp Reisner } 3441a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3442b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3443b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3444b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3445b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3446b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 344738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 344882bc0194SAndreas Gruenbacher return -EIO; 3449b411b363SPhilipp Reisner } 3450b411b363SPhilipp Reisner 3451b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3452b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3453b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3454b411b363SPhilipp Reisner { 3455b411b363SPhilipp Reisner sector_t d; 3456b411b363SPhilipp Reisner if (a == 0 || b == 0) 3457b411b363SPhilipp Reisner return; 3458b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3459b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3460b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3461b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3462b411b363SPhilipp Reisner } 3463b411b363SPhilipp Reisner 34644a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3465b411b363SPhilipp Reisner { 34664a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3467e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3468b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3469b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3470b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3471e89b591cSPhilipp Reisner enum dds_flags ddsf; 3472b411b363SPhilipp Reisner 34734a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 34744a76b161SAndreas Gruenbacher if (!mdev) 34754a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 34764a76b161SAndreas Gruenbacher 3477b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3478b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3479b411b363SPhilipp Reisner 3480b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3481b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3482b411b363SPhilipp Reisner mdev->p_size = p_size; 3483b411b363SPhilipp Reisner 3484b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3485daeda1ccSPhilipp Reisner rcu_read_lock(); 3486daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3487daeda1ccSPhilipp Reisner rcu_read_unlock(); 3488daeda1ccSPhilipp Reisner 3489b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3490b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3491b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3492daeda1ccSPhilipp Reisner p_usize, my_usize); 3493b411b363SPhilipp Reisner 3494b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3495b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3496b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3497daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3498b411b363SPhilipp Reisner 3499b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3500b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3501ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3502b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3503b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3504b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3505b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 350638fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3507b411b363SPhilipp Reisner put_ldev(mdev); 350882bc0194SAndreas Gruenbacher return -EIO; 3509b411b363SPhilipp Reisner } 3510daeda1ccSPhilipp Reisner 3511daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3512daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3513daeda1ccSPhilipp Reisner 3514daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3515daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3516daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3517daeda1ccSPhilipp Reisner put_ldev(mdev); 3518daeda1ccSPhilipp Reisner return -ENOMEM; 3519daeda1ccSPhilipp Reisner } 3520daeda1ccSPhilipp Reisner 3521daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3522daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3523daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3524daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3525daeda1ccSPhilipp Reisner 3526daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3527daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3528daeda1ccSPhilipp Reisner synchronize_rcu(); 3529daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3530daeda1ccSPhilipp Reisner 3531daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3532daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3533daeda1ccSPhilipp Reisner } 3534daeda1ccSPhilipp Reisner 3535b411b363SPhilipp Reisner put_ldev(mdev); 3536b411b363SPhilipp Reisner } 3537b411b363SPhilipp Reisner 3538e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3539b411b363SPhilipp Reisner if (get_ldev(mdev)) { 354024c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3541b411b363SPhilipp Reisner put_ldev(mdev); 3542b411b363SPhilipp Reisner if (dd == dev_size_error) 354382bc0194SAndreas Gruenbacher return -EIO; 3544b411b363SPhilipp Reisner drbd_md_sync(mdev); 3545b411b363SPhilipp Reisner } else { 3546b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3547b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3548b411b363SPhilipp Reisner } 3549b411b363SPhilipp Reisner 355099432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 355199432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 355299432fccSPhilipp Reisner 3553b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3554b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3555b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3556b411b363SPhilipp Reisner ldsc = 1; 3557b411b363SPhilipp Reisner } 3558b411b363SPhilipp Reisner 3559b411b363SPhilipp Reisner put_ldev(mdev); 3560b411b363SPhilipp Reisner } 3561b411b363SPhilipp Reisner 3562b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3563b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3564b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3565b411b363SPhilipp Reisner /* we have different sizes, probably peer 3566b411b363SPhilipp Reisner * needs to know my new size... */ 3567e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3568b411b363SPhilipp Reisner } 3569b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3570b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3571b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3572e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3573e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3574e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3575b411b363SPhilipp Reisner else 3576e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3577e89b591cSPhilipp Reisner } else 3578b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3579b411b363SPhilipp Reisner } 3580b411b363SPhilipp Reisner } 3581b411b363SPhilipp Reisner 358282bc0194SAndreas Gruenbacher return 0; 3583b411b363SPhilipp Reisner } 3584b411b363SPhilipp Reisner 35854a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3586b411b363SPhilipp Reisner { 35874a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3588e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3589b411b363SPhilipp Reisner u64 *p_uuid; 359062b0da3aSLars Ellenberg int i, updated_uuids = 0; 3591b411b363SPhilipp Reisner 35924a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35934a76b161SAndreas Gruenbacher if (!mdev) 35944a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35954a76b161SAndreas Gruenbacher 3596b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3597b411b363SPhilipp Reisner 3598b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3599b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3600b411b363SPhilipp Reisner 3601b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3602b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3603b411b363SPhilipp Reisner 3604b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3605b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3606b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3607b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3608b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3609b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 361038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 361182bc0194SAndreas Gruenbacher return -EIO; 3612b411b363SPhilipp Reisner } 3613b411b363SPhilipp Reisner 3614b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3615b411b363SPhilipp Reisner int skip_initial_sync = 3616b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 361731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3618b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3619b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3620b411b363SPhilipp Reisner if (skip_initial_sync) { 3621b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3622b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 362320ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 362420ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3625b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3626b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3627b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3628b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3629b411b363SPhilipp Reisner drbd_md_sync(mdev); 363062b0da3aSLars Ellenberg updated_uuids = 1; 3631b411b363SPhilipp Reisner } 3632b411b363SPhilipp Reisner put_ldev(mdev); 363318a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 363418a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 363518a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 363618a50fa2SPhilipp Reisner for me. */ 363762b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3638b411b363SPhilipp Reisner } 3639b411b363SPhilipp Reisner 3640b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3641b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3642b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3643b411b363SPhilipp Reisner new disk state... */ 36448410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 36458410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3646b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 364762b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 364862b0da3aSLars Ellenberg 364962b0da3aSLars Ellenberg if (updated_uuids) 365062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3651b411b363SPhilipp Reisner 365282bc0194SAndreas Gruenbacher return 0; 3653b411b363SPhilipp Reisner } 3654b411b363SPhilipp Reisner 3655b411b363SPhilipp Reisner /** 3656b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3657b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3658b411b363SPhilipp Reisner */ 3659b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3660b411b363SPhilipp Reisner { 3661b411b363SPhilipp Reisner union drbd_state ms; 3662b411b363SPhilipp Reisner 3663b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3664369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3665b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3666b411b363SPhilipp Reisner 3667b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3668b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3669b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3670b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3671b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3672b411b363SPhilipp Reisner }; 3673b411b363SPhilipp Reisner 3674b411b363SPhilipp Reisner ms.i = ps.i; 3675b411b363SPhilipp Reisner 3676b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3677b411b363SPhilipp Reisner ms.peer = ps.role; 3678b411b363SPhilipp Reisner ms.role = ps.peer; 3679b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3680b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3681b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3682b411b363SPhilipp Reisner 3683b411b363SPhilipp Reisner return ms; 3684b411b363SPhilipp Reisner } 3685b411b363SPhilipp Reisner 36864a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3687b411b363SPhilipp Reisner { 36884a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3689e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3690b411b363SPhilipp Reisner union drbd_state mask, val; 3691bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3692b411b363SPhilipp Reisner 36934a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36944a76b161SAndreas Gruenbacher if (!mdev) 36954a76b161SAndreas Gruenbacher return -EIO; 36964a76b161SAndreas Gruenbacher 3697b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3698b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3699b411b363SPhilipp Reisner 370025703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 37018410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3702b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 370382bc0194SAndreas Gruenbacher return 0; 3704b411b363SPhilipp Reisner } 3705b411b363SPhilipp Reisner 3706b411b363SPhilipp Reisner mask = convert_state(mask); 3707b411b363SPhilipp Reisner val = convert_state(val); 3708b411b363SPhilipp Reisner 3709b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3710b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3711047cd4a6SPhilipp Reisner 3712b411b363SPhilipp Reisner drbd_md_sync(mdev); 3713b411b363SPhilipp Reisner 371482bc0194SAndreas Gruenbacher return 0; 3715b411b363SPhilipp Reisner } 3716b411b363SPhilipp Reisner 3717e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3718dfafcc8aSPhilipp Reisner { 3719e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3720dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3721dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3722dfafcc8aSPhilipp Reisner 3723dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3724dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3725dfafcc8aSPhilipp Reisner 3726dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3727dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3728dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 372982bc0194SAndreas Gruenbacher return 0; 3730dfafcc8aSPhilipp Reisner } 3731dfafcc8aSPhilipp Reisner 3732dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3733dfafcc8aSPhilipp Reisner val = convert_state(val); 3734dfafcc8aSPhilipp Reisner 3735778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3736dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3737dfafcc8aSPhilipp Reisner 373882bc0194SAndreas Gruenbacher return 0; 3739dfafcc8aSPhilipp Reisner } 3740dfafcc8aSPhilipp Reisner 37414a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3742b411b363SPhilipp Reisner { 37434a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3744e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 37454ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3746b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 374765d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3748b411b363SPhilipp Reisner int rv; 3749b411b363SPhilipp Reisner 37504a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37514a76b161SAndreas Gruenbacher if (!mdev) 37524a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 37534a76b161SAndreas Gruenbacher 3754b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3755b411b363SPhilipp Reisner 3756b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3757b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3758b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3759b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3760b411b363SPhilipp Reisner } 3761b411b363SPhilipp Reisner 376287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3763b411b363SPhilipp Reisner retry: 376478bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 376587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3766b411b363SPhilipp Reisner 37679bcd2521SPhilipp Reisner /* If this is the "end of sync" confirmation, usually the peer disk 37689bcd2521SPhilipp Reisner * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 37699bcd2521SPhilipp Reisner * set) resync started in PausedSyncT, or if the timing of pause-/ 37709bcd2521SPhilipp Reisner * unpause-sync events has been "just right", the peer disk may 37719bcd2521SPhilipp Reisner * transition from D_CONSISTENT to D_UP_TO_DATE as well. 37729bcd2521SPhilipp Reisner */ 37739bcd2521SPhilipp Reisner if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 37749bcd2521SPhilipp Reisner real_peer_disk == D_UP_TO_DATE && 3775e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3776e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3777e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3778e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3779e9ef7bb6SLars Ellenberg * syncing states. 3780e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3781e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3782e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3783e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3784e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3785e9ef7bb6SLars Ellenberg 3786e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3787e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3788e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3789e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3790e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3791e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3792e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 379382bc0194SAndreas Gruenbacher return 0; 3794e9ef7bb6SLars Ellenberg } 3795e9ef7bb6SLars Ellenberg } 3796e9ef7bb6SLars Ellenberg 3797e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3798e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3799e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3800e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3801e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3802e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3803e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3804e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3805e9ef7bb6SLars Ellenberg 38064ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 38074ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3808b411b363SPhilipp Reisner 380967531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 381067531718SPhilipp Reisner ns.conn = C_BEHIND; 381167531718SPhilipp Reisner 3812b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3813b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3814b411b363SPhilipp Reisner int cr; /* consider resync */ 3815b411b363SPhilipp Reisner 3816b411b363SPhilipp Reisner /* if we established a new connection */ 38174ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3818b411b363SPhilipp Reisner /* if we had an established connection 3819b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 38204ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3821b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 38224ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3823b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3824b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3825b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3826b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3827b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 38284ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3829b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3830b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3831b411b363SPhilipp Reisner 3832b411b363SPhilipp Reisner if (cr) 38334ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3834b411b363SPhilipp Reisner 3835b411b363SPhilipp Reisner put_ldev(mdev); 38364ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 38374ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3838b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 383982f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3840b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3841b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3842b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3843580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3844b411b363SPhilipp Reisner } else { 38458169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 384682bc0194SAndreas Gruenbacher return -EIO; 38474ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 384838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 384982bc0194SAndreas Gruenbacher return -EIO; 3850b411b363SPhilipp Reisner } 3851b411b363SPhilipp Reisner } 3852b411b363SPhilipp Reisner } 3853b411b363SPhilipp Reisner 385487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 385578bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3856b411b363SPhilipp Reisner goto retry; 3857b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3858b411b363SPhilipp Reisner ns.peer = peer_state.role; 3859b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3860b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 38614ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3862b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 38634ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 38642aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3865481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 38668554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3867481c6f50SPhilipp Reisner for temporal network outages! */ 386887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3869481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 38702f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3871481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3872481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 387338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 387482bc0194SAndreas Gruenbacher return -EIO; 3875481c6f50SPhilipp Reisner } 387665d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 387778bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 387887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3879b411b363SPhilipp Reisner 3880b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 388138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 388282bc0194SAndreas Gruenbacher return -EIO; 3883b411b363SPhilipp Reisner } 3884b411b363SPhilipp Reisner 38854ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 38864ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3887b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3888b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3889b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3890b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3891b411b363SPhilipp Reisner drbd_send_uuids(mdev); 389243de7c85SPhilipp Reisner drbd_send_current_state(mdev); 3893b411b363SPhilipp Reisner } 3894b411b363SPhilipp Reisner } 3895b411b363SPhilipp Reisner 389608b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 3897b411b363SPhilipp Reisner 3898b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3899b411b363SPhilipp Reisner 390082bc0194SAndreas Gruenbacher return 0; 3901b411b363SPhilipp Reisner } 3902b411b363SPhilipp Reisner 39034a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3904b411b363SPhilipp Reisner { 39054a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3906e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 39074a76b161SAndreas Gruenbacher 39084a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 39094a76b161SAndreas Gruenbacher if (!mdev) 39104a76b161SAndreas Gruenbacher return -EIO; 3911b411b363SPhilipp Reisner 3912b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3913b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3914c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3915b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3916b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3917b411b363SPhilipp Reisner 3918b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3919b411b363SPhilipp Reisner 3920b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3921b411b363SPhilipp Reisner _not_ be rotated into the history */ 3922b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3923b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3924b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3925b411b363SPhilipp Reisner 392662b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3927b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3928b411b363SPhilipp Reisner 3929b411b363SPhilipp Reisner put_ldev(mdev); 3930b411b363SPhilipp Reisner } else 3931b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3932b411b363SPhilipp Reisner 393382bc0194SAndreas Gruenbacher return 0; 3934b411b363SPhilipp Reisner } 3935b411b363SPhilipp Reisner 39362c46407dSAndreas Gruenbacher /** 39372c46407dSAndreas Gruenbacher * receive_bitmap_plain 39382c46407dSAndreas Gruenbacher * 39392c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 39402c46407dSAndreas Gruenbacher * code upon failure. 39412c46407dSAndreas Gruenbacher */ 39422c46407dSAndreas Gruenbacher static int 394350d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 3944e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 3945b411b363SPhilipp Reisner { 394650d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 394750d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 3948e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 394950d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 3950e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 39512c46407dSAndreas Gruenbacher int err; 3952b411b363SPhilipp Reisner 395350d0b1adSAndreas Gruenbacher if (want != size) { 395450d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 39552c46407dSAndreas Gruenbacher return -EIO; 3956b411b363SPhilipp Reisner } 3957b411b363SPhilipp Reisner if (want == 0) 39582c46407dSAndreas Gruenbacher return 0; 3959e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 396082bc0194SAndreas Gruenbacher if (err) 39612c46407dSAndreas Gruenbacher return err; 3962b411b363SPhilipp Reisner 3963e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 3964b411b363SPhilipp Reisner 3965b411b363SPhilipp Reisner c->word_offset += num_words; 3966b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3967b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3968b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3969b411b363SPhilipp Reisner 39702c46407dSAndreas Gruenbacher return 1; 3971b411b363SPhilipp Reisner } 3972b411b363SPhilipp Reisner 3973a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 3974a02d1240SAndreas Gruenbacher { 3975a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 3976a02d1240SAndreas Gruenbacher } 3977a02d1240SAndreas Gruenbacher 3978a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 3979a02d1240SAndreas Gruenbacher { 3980a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 3981a02d1240SAndreas Gruenbacher } 3982a02d1240SAndreas Gruenbacher 3983a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 3984a02d1240SAndreas Gruenbacher { 3985a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 3986a02d1240SAndreas Gruenbacher } 3987a02d1240SAndreas Gruenbacher 39882c46407dSAndreas Gruenbacher /** 39892c46407dSAndreas Gruenbacher * recv_bm_rle_bits 39902c46407dSAndreas Gruenbacher * 39912c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 39922c46407dSAndreas Gruenbacher * code upon failure. 39932c46407dSAndreas Gruenbacher */ 39942c46407dSAndreas Gruenbacher static int 3995b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3996b411b363SPhilipp Reisner struct p_compressed_bm *p, 3997c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3998c6d25cfeSPhilipp Reisner unsigned int len) 3999b411b363SPhilipp Reisner { 4000b411b363SPhilipp Reisner struct bitstream bs; 4001b411b363SPhilipp Reisner u64 look_ahead; 4002b411b363SPhilipp Reisner u64 rl; 4003b411b363SPhilipp Reisner u64 tmp; 4004b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4005b411b363SPhilipp Reisner unsigned long e; 4006a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4007b411b363SPhilipp Reisner int have; 4008b411b363SPhilipp Reisner int bits; 4009b411b363SPhilipp Reisner 4010a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4011b411b363SPhilipp Reisner 4012b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4013b411b363SPhilipp Reisner if (bits < 0) 40142c46407dSAndreas Gruenbacher return -EIO; 4015b411b363SPhilipp Reisner 4016b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4017b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4018b411b363SPhilipp Reisner if (bits <= 0) 40192c46407dSAndreas Gruenbacher return -EIO; 4020b411b363SPhilipp Reisner 4021b411b363SPhilipp Reisner if (toggle) { 4022b411b363SPhilipp Reisner e = s + rl -1; 4023b411b363SPhilipp Reisner if (e >= c->bm_bits) { 4024b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 40252c46407dSAndreas Gruenbacher return -EIO; 4026b411b363SPhilipp Reisner } 4027b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 4028b411b363SPhilipp Reisner } 4029b411b363SPhilipp Reisner 4030b411b363SPhilipp Reisner if (have < bits) { 4031b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4032b411b363SPhilipp Reisner have, bits, look_ahead, 4033b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4034b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 40352c46407dSAndreas Gruenbacher return -EIO; 4036b411b363SPhilipp Reisner } 4037b411b363SPhilipp Reisner look_ahead >>= bits; 4038b411b363SPhilipp Reisner have -= bits; 4039b411b363SPhilipp Reisner 4040b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4041b411b363SPhilipp Reisner if (bits < 0) 40422c46407dSAndreas Gruenbacher return -EIO; 4043b411b363SPhilipp Reisner look_ahead |= tmp << have; 4044b411b363SPhilipp Reisner have += bits; 4045b411b363SPhilipp Reisner } 4046b411b363SPhilipp Reisner 4047b411b363SPhilipp Reisner c->bit_offset = s; 4048b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4049b411b363SPhilipp Reisner 40502c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4051b411b363SPhilipp Reisner } 4052b411b363SPhilipp Reisner 40532c46407dSAndreas Gruenbacher /** 40542c46407dSAndreas Gruenbacher * decode_bitmap_c 40552c46407dSAndreas Gruenbacher * 40562c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40572c46407dSAndreas Gruenbacher * code upon failure. 40582c46407dSAndreas Gruenbacher */ 40592c46407dSAndreas Gruenbacher static int 4060b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 4061b411b363SPhilipp Reisner struct p_compressed_bm *p, 4062c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4063c6d25cfeSPhilipp Reisner unsigned int len) 4064b411b363SPhilipp Reisner { 4065a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4066e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 4067b411b363SPhilipp Reisner 4068b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4069b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4070b411b363SPhilipp Reisner * during all our tests. */ 4071b411b363SPhilipp Reisner 4072b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 407338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 40742c46407dSAndreas Gruenbacher return -EIO; 4075b411b363SPhilipp Reisner } 4076b411b363SPhilipp Reisner 4077b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 4078b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4079b411b363SPhilipp Reisner { 4080b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 408150d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 408250d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 408350d0b1adSAndreas Gruenbacher unsigned int plain = 408450d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 408550d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 408650d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 408750d0b1adSAndreas Gruenbacher unsigned int r; 4088b411b363SPhilipp Reisner 4089b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4090b411b363SPhilipp Reisner if (total == 0) 4091b411b363SPhilipp Reisner return; 4092b411b363SPhilipp Reisner 4093b411b363SPhilipp Reisner /* don't report if not compressed */ 4094b411b363SPhilipp Reisner if (total >= plain) 4095b411b363SPhilipp Reisner return; 4096b411b363SPhilipp Reisner 4097b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4098b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4099b411b363SPhilipp Reisner : (1000 * total / plain); 4100b411b363SPhilipp Reisner 4101b411b363SPhilipp Reisner if (r > 1000) 4102b411b363SPhilipp Reisner r = 1000; 4103b411b363SPhilipp Reisner 4104b411b363SPhilipp Reisner r = 1000 - r; 4105b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4106b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4107b411b363SPhilipp Reisner direction, 4108b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4109b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4110b411b363SPhilipp Reisner total, r/10, r % 10); 4111b411b363SPhilipp Reisner } 4112b411b363SPhilipp Reisner 4113b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4114b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4115b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4116b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4117b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4118b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4119b411b363SPhilipp Reisner 4120b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 41214a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4122b411b363SPhilipp Reisner { 41234a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4124b411b363SPhilipp Reisner struct bm_xfer_ctx c; 41252c46407dSAndreas Gruenbacher int err; 41264a76b161SAndreas Gruenbacher 41274a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 41284a76b161SAndreas Gruenbacher if (!mdev) 41294a76b161SAndreas Gruenbacher return -EIO; 4130b411b363SPhilipp Reisner 413120ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 413220ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 413320ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4134b411b363SPhilipp Reisner 4135b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4136b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4137b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4138b411b363SPhilipp Reisner }; 4139b411b363SPhilipp Reisner 41402c46407dSAndreas Gruenbacher for(;;) { 4141e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4142e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4143e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4144b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4145b411b363SPhilipp Reisner * and the feature is enabled! */ 4146e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4147b411b363SPhilipp Reisner 414850d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4149b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 415082bc0194SAndreas Gruenbacher err = -EIO; 4151b411b363SPhilipp Reisner goto out; 4152b411b363SPhilipp Reisner } 4153e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4154e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 415582bc0194SAndreas Gruenbacher err = -EIO; 415678fcbdaeSAndreas Gruenbacher goto out; 4157b411b363SPhilipp Reisner } 4158e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4159e658983aSAndreas Gruenbacher if (err) 4160e658983aSAndreas Gruenbacher goto out; 4161e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4162b411b363SPhilipp Reisner } else { 4163e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 416482bc0194SAndreas Gruenbacher err = -EIO; 4165b411b363SPhilipp Reisner goto out; 4166b411b363SPhilipp Reisner } 4167b411b363SPhilipp Reisner 4168e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 416950d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4170b411b363SPhilipp Reisner 41712c46407dSAndreas Gruenbacher if (err <= 0) { 41722c46407dSAndreas Gruenbacher if (err < 0) 41732c46407dSAndreas Gruenbacher goto out; 4174b411b363SPhilipp Reisner break; 41752c46407dSAndreas Gruenbacher } 4176e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 417782bc0194SAndreas Gruenbacher if (err) 4178b411b363SPhilipp Reisner goto out; 41792c46407dSAndreas Gruenbacher } 4180b411b363SPhilipp Reisner 4181b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4182b411b363SPhilipp Reisner 4183b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4184de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4185de1f8e4aSAndreas Gruenbacher 418682bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 418782bc0194SAndreas Gruenbacher if (err) 4188b411b363SPhilipp Reisner goto out; 4189b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4190de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4191de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4192b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4193b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4194b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4195b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4196b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4197b411b363SPhilipp Reisner } 419882bc0194SAndreas Gruenbacher err = 0; 4199b411b363SPhilipp Reisner 4200b411b363SPhilipp Reisner out: 420120ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 420282bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4203b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 420482bc0194SAndreas Gruenbacher return err; 4205b411b363SPhilipp Reisner } 4206b411b363SPhilipp Reisner 42074a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4208b411b363SPhilipp Reisner { 42094a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4210e2857216SAndreas Gruenbacher pi->cmd, pi->size); 42112de876efSPhilipp Reisner 42124a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 42132de876efSPhilipp Reisner } 42142de876efSPhilipp Reisner 42154a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4216b411b363SPhilipp Reisner { 4217b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4218b411b363SPhilipp Reisner * with the data requests being unplugged */ 42194a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4220b411b363SPhilipp Reisner 422182bc0194SAndreas Gruenbacher return 0; 4222b411b363SPhilipp Reisner } 4223b411b363SPhilipp Reisner 42244a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 422573a01a18SPhilipp Reisner { 42264a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4227e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 42284a76b161SAndreas Gruenbacher 42294a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 42304a76b161SAndreas Gruenbacher if (!mdev) 42314a76b161SAndreas Gruenbacher return -EIO; 423273a01a18SPhilipp Reisner 4233f735e363SLars Ellenberg switch (mdev->state.conn) { 4234f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4235f735e363SLars Ellenberg case C_WF_BITMAP_T: 4236f735e363SLars Ellenberg case C_BEHIND: 4237f735e363SLars Ellenberg break; 4238f735e363SLars Ellenberg default: 4239f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4240f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4241f735e363SLars Ellenberg } 4242f735e363SLars Ellenberg 424373a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 424473a01a18SPhilipp Reisner 424582bc0194SAndreas Gruenbacher return 0; 424673a01a18SPhilipp Reisner } 424773a01a18SPhilipp Reisner 424802918be2SPhilipp Reisner struct data_cmd { 424902918be2SPhilipp Reisner int expect_payload; 425002918be2SPhilipp Reisner size_t pkt_size; 42514a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4252b411b363SPhilipp Reisner }; 4253b411b363SPhilipp Reisner 425402918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 42554a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 42564a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 42574a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 42584a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4259e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4260e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4261e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 42624a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 42634a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4264e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4265e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 42664a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 42674a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 42684a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 42694a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 42704a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 42714a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 42724a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 42734a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 42744a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 42754a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 42764a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 42774a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4278036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 427902918be2SPhilipp Reisner }; 428002918be2SPhilipp Reisner 4281eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4282b411b363SPhilipp Reisner { 428377351055SPhilipp Reisner struct packet_info pi; 428402918be2SPhilipp Reisner size_t shs; /* sub header size */ 428582bc0194SAndreas Gruenbacher int err; 4286b411b363SPhilipp Reisner 4287eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4288deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4289deebe195SAndreas Gruenbacher 4290eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 429169bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 429202918be2SPhilipp Reisner goto err_out; 429302918be2SPhilipp Reisner 4294deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 42954a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 42962fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected data packet %s (0x%04x)", 42972fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 429802918be2SPhilipp Reisner goto err_out; 42990b33a916SLars Ellenberg } 4300b411b363SPhilipp Reisner 4301e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4302e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 43032fcb8f30SAndreas Gruenbacher conn_err(tconn, "No payload expected %s l:%d\n", 43042fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4305c13f7e1aSLars Ellenberg goto err_out; 4306c13f7e1aSLars Ellenberg } 4307c13f7e1aSLars Ellenberg 4308c13f7e1aSLars Ellenberg if (shs) { 4309e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4310a5c31904SAndreas Gruenbacher if (err) 431102918be2SPhilipp Reisner goto err_out; 4312e2857216SAndreas Gruenbacher pi.size -= shs; 4313b411b363SPhilipp Reisner } 431402918be2SPhilipp Reisner 43154a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 43164a76b161SAndreas Gruenbacher if (err) { 43179f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 43189f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 431902918be2SPhilipp Reisner goto err_out; 4320b411b363SPhilipp Reisner } 4321b411b363SPhilipp Reisner } 432282bc0194SAndreas Gruenbacher return; 432302918be2SPhilipp Reisner 432402918be2SPhilipp Reisner err_out: 4325bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4326b411b363SPhilipp Reisner } 4327b411b363SPhilipp Reisner 43280e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4329b411b363SPhilipp Reisner { 4330b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4331b411b363SPhilipp Reisner 4332b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 43330e29d163SPhilipp Reisner barr.w.tconn = tconn; 4334b411b363SPhilipp Reisner init_completion(&barr.done); 43350e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4336b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4337b411b363SPhilipp Reisner } 4338b411b363SPhilipp Reisner 433981fa2e67SPhilipp Reisner static void conn_disconnect(struct drbd_tconn *tconn) 4340b411b363SPhilipp Reisner { 4341c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 4342bbeb641cSPhilipp Reisner enum drbd_conns oc; 4343376694a0SPhilipp Reisner int vnr; 4344b411b363SPhilipp Reisner 4345bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4346b411b363SPhilipp Reisner return; 4347b411b363SPhilipp Reisner 4348b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4349360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4350360cc740SPhilipp Reisner drbd_free_sock(tconn); 4351360cc740SPhilipp Reisner 4352c141ebdaSPhilipp Reisner rcu_read_lock(); 4353c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 4354c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 4355c141ebdaSPhilipp Reisner rcu_read_unlock(); 4356c141ebdaSPhilipp Reisner drbd_disconnected(mdev); 4357c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 4358c141ebdaSPhilipp Reisner rcu_read_lock(); 4359c141ebdaSPhilipp Reisner } 4360c141ebdaSPhilipp Reisner rcu_read_unlock(); 4361c141ebdaSPhilipp Reisner 4362360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4363360cc740SPhilipp Reisner 4364cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4365cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4366cb703454SPhilipp Reisner 4367360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4368bbeb641cSPhilipp Reisner oc = tconn->cstate; 4369bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4370376694a0SPhilipp Reisner _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4371bbeb641cSPhilipp Reisner 4372360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4373360cc740SPhilipp Reisner 4374f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4375d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4376360cc740SPhilipp Reisner } 4377360cc740SPhilipp Reisner 4378c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev) 4379360cc740SPhilipp Reisner { 4380360cc740SPhilipp Reisner unsigned int i; 4381b411b363SPhilipp Reisner 438285719573SPhilipp Reisner /* wait for current activity to cease. */ 438387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4384b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4385b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4386b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 438787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4388b411b363SPhilipp Reisner 4389b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4390b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4391b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4392b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4393b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4394b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4395b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4396b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4397b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4398b411b363SPhilipp Reisner * on the fly. */ 4399b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4400b411b363SPhilipp Reisner mdev->rs_total = 0; 4401b411b363SPhilipp Reisner mdev->rs_failed = 0; 4402b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4403b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4404b411b363SPhilipp Reisner 4405b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4406b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4407b411b363SPhilipp Reisner 4408b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4409b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4410b411b363SPhilipp Reisner * to be "canceled" */ 4411a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4412b411b363SPhilipp Reisner 4413a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4414b411b363SPhilipp Reisner 4415b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4416b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4417b411b363SPhilipp Reisner 44182aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 44192f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4420b411b363SPhilipp Reisner 4421b411b363SPhilipp Reisner drbd_md_sync(mdev); 4422b411b363SPhilipp Reisner 442320ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 442420ceb2b2SLars Ellenberg * if any. */ 442520ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 442620ceb2b2SLars Ellenberg 4427b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4428b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4429b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4430b411b363SPhilipp Reisner * 4431b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4432b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4433b411b363SPhilipp Reisner */ 44347721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4435b411b363SPhilipp Reisner if (i) 4436b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4437435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4438435f0740SLars Ellenberg if (i) 4439435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4440b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4441b411b363SPhilipp Reisner if (i) 444245bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4443b411b363SPhilipp Reisner 4444b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4445b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4446b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4447b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4448b411b363SPhilipp Reisner 4449b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4450b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4451b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4452360cc740SPhilipp Reisner 4453360cc740SPhilipp Reisner return 0; 4454b411b363SPhilipp Reisner } 4455b411b363SPhilipp Reisner 4456b411b363SPhilipp Reisner /* 4457b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4458b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4459b411b363SPhilipp Reisner * 4460b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4461b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4462b411b363SPhilipp Reisner * 4463b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4464b411b363SPhilipp Reisner */ 44656038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4466b411b363SPhilipp Reisner { 44679f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 44689f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4469b411b363SPhilipp Reisner 44709f5bdc33SAndreas Gruenbacher sock = &tconn->data; 44719f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 44729f5bdc33SAndreas Gruenbacher if (!p) 4473e8d17b01SAndreas Gruenbacher return -EIO; 4474b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4475b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4476b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 44779f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4478b411b363SPhilipp Reisner } 4479b411b363SPhilipp Reisner 4480b411b363SPhilipp Reisner /* 4481b411b363SPhilipp Reisner * return values: 4482b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4483b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4484b411b363SPhilipp Reisner * -1 peer talks different language, 4485b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4486b411b363SPhilipp Reisner */ 44876038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4488b411b363SPhilipp Reisner { 448965d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4490e658983aSAndreas Gruenbacher struct p_connection_features *p; 4491e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 449277351055SPhilipp Reisner struct packet_info pi; 4493a5c31904SAndreas Gruenbacher int err; 4494b411b363SPhilipp Reisner 44956038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4496e8d17b01SAndreas Gruenbacher if (err) 4497b411b363SPhilipp Reisner return 0; 4498b411b363SPhilipp Reisner 449969bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 450069bc7bc3SAndreas Gruenbacher if (err) 4501b411b363SPhilipp Reisner return 0; 4502b411b363SPhilipp Reisner 45036038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 45046038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 450577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4506b411b363SPhilipp Reisner return -1; 4507b411b363SPhilipp Reisner } 4508b411b363SPhilipp Reisner 450977351055SPhilipp Reisner if (pi.size != expect) { 45106038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 451177351055SPhilipp Reisner expect, pi.size); 4512b411b363SPhilipp Reisner return -1; 4513b411b363SPhilipp Reisner } 4514b411b363SPhilipp Reisner 4515e658983aSAndreas Gruenbacher p = pi.data; 4516e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4517a5c31904SAndreas Gruenbacher if (err) 4518b411b363SPhilipp Reisner return 0; 4519b411b363SPhilipp Reisner 4520b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4521b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4522b411b363SPhilipp Reisner if (p->protocol_max == 0) 4523b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4524b411b363SPhilipp Reisner 4525b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4526b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4527b411b363SPhilipp Reisner goto incompat; 4528b411b363SPhilipp Reisner 452965d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4530b411b363SPhilipp Reisner 453165d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 453265d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4533b411b363SPhilipp Reisner 4534b411b363SPhilipp Reisner return 1; 4535b411b363SPhilipp Reisner 4536b411b363SPhilipp Reisner incompat: 453765d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4538b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4539b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4540b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4541b411b363SPhilipp Reisner return -1; 4542b411b363SPhilipp Reisner } 4543b411b363SPhilipp Reisner 4544b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 454513e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4546b411b363SPhilipp Reisner { 4547b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4548b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4549b10d96cbSJohannes Thoma return -1; 4550b411b363SPhilipp Reisner } 4551b411b363SPhilipp Reisner #else 4552b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4553b10d96cbSJohannes Thoma 4554b10d96cbSJohannes Thoma /* Return value: 4555b10d96cbSJohannes Thoma 1 - auth succeeded, 4556b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4557b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4558b10d96cbSJohannes Thoma */ 4559b10d96cbSJohannes Thoma 456013e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4561b411b363SPhilipp Reisner { 45629f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4563b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4564b411b363SPhilipp Reisner struct scatterlist sg; 4565b411b363SPhilipp Reisner char *response = NULL; 4566b411b363SPhilipp Reisner char *right_response = NULL; 4567b411b363SPhilipp Reisner char *peers_ch = NULL; 456844ed167dSPhilipp Reisner unsigned int key_len; 456944ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4570b411b363SPhilipp Reisner unsigned int resp_size; 4571b411b363SPhilipp Reisner struct hash_desc desc; 457277351055SPhilipp Reisner struct packet_info pi; 457344ed167dSPhilipp Reisner struct net_conf *nc; 457469bc7bc3SAndreas Gruenbacher int err, rv; 4575b411b363SPhilipp Reisner 45769f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 45779f5bdc33SAndreas Gruenbacher 457844ed167dSPhilipp Reisner rcu_read_lock(); 457944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 458044ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 458144ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 458244ed167dSPhilipp Reisner rcu_read_unlock(); 458344ed167dSPhilipp Reisner 458413e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4585b411b363SPhilipp Reisner desc.flags = 0; 4586b411b363SPhilipp Reisner 458744ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4588b411b363SPhilipp Reisner if (rv) { 458913e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4590b10d96cbSJohannes Thoma rv = -1; 4591b411b363SPhilipp Reisner goto fail; 4592b411b363SPhilipp Reisner } 4593b411b363SPhilipp Reisner 4594b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4595b411b363SPhilipp Reisner 45969f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45979f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 45989f5bdc33SAndreas Gruenbacher rv = 0; 45999f5bdc33SAndreas Gruenbacher goto fail; 46009f5bdc33SAndreas Gruenbacher } 4601e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 46029f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4603b411b363SPhilipp Reisner if (!rv) 4604b411b363SPhilipp Reisner goto fail; 4605b411b363SPhilipp Reisner 460669bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 460769bc7bc3SAndreas Gruenbacher if (err) { 460869bc7bc3SAndreas Gruenbacher rv = 0; 4609b411b363SPhilipp Reisner goto fail; 461069bc7bc3SAndreas Gruenbacher } 4611b411b363SPhilipp Reisner 461277351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 461313e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 461477351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4615b411b363SPhilipp Reisner rv = 0; 4616b411b363SPhilipp Reisner goto fail; 4617b411b363SPhilipp Reisner } 4618b411b363SPhilipp Reisner 461977351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 462013e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4621b10d96cbSJohannes Thoma rv = -1; 4622b411b363SPhilipp Reisner goto fail; 4623b411b363SPhilipp Reisner } 4624b411b363SPhilipp Reisner 462577351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4626b411b363SPhilipp Reisner if (peers_ch == NULL) { 462713e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4628b10d96cbSJohannes Thoma rv = -1; 4629b411b363SPhilipp Reisner goto fail; 4630b411b363SPhilipp Reisner } 4631b411b363SPhilipp Reisner 4632a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4633a5c31904SAndreas Gruenbacher if (err) { 4634b411b363SPhilipp Reisner rv = 0; 4635b411b363SPhilipp Reisner goto fail; 4636b411b363SPhilipp Reisner } 4637b411b363SPhilipp Reisner 463813e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4639b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4640b411b363SPhilipp Reisner if (response == NULL) { 464113e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4642b10d96cbSJohannes Thoma rv = -1; 4643b411b363SPhilipp Reisner goto fail; 4644b411b363SPhilipp Reisner } 4645b411b363SPhilipp Reisner 4646b411b363SPhilipp Reisner sg_init_table(&sg, 1); 464777351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4648b411b363SPhilipp Reisner 4649b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4650b411b363SPhilipp Reisner if (rv) { 465113e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4652b10d96cbSJohannes Thoma rv = -1; 4653b411b363SPhilipp Reisner goto fail; 4654b411b363SPhilipp Reisner } 4655b411b363SPhilipp Reisner 46569f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 46579f5bdc33SAndreas Gruenbacher rv = 0; 46589f5bdc33SAndreas Gruenbacher goto fail; 46599f5bdc33SAndreas Gruenbacher } 4660e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 46619f5bdc33SAndreas Gruenbacher response, resp_size); 4662b411b363SPhilipp Reisner if (!rv) 4663b411b363SPhilipp Reisner goto fail; 4664b411b363SPhilipp Reisner 466569bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 466669bc7bc3SAndreas Gruenbacher if (err) { 466769bc7bc3SAndreas Gruenbacher rv = 0; 4668b411b363SPhilipp Reisner goto fail; 466969bc7bc3SAndreas Gruenbacher } 4670b411b363SPhilipp Reisner 467177351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 467213e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 467377351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4674b411b363SPhilipp Reisner rv = 0; 4675b411b363SPhilipp Reisner goto fail; 4676b411b363SPhilipp Reisner } 4677b411b363SPhilipp Reisner 467877351055SPhilipp Reisner if (pi.size != resp_size) { 467913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4680b411b363SPhilipp Reisner rv = 0; 4681b411b363SPhilipp Reisner goto fail; 4682b411b363SPhilipp Reisner } 4683b411b363SPhilipp Reisner 4684a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4685a5c31904SAndreas Gruenbacher if (err) { 4686b411b363SPhilipp Reisner rv = 0; 4687b411b363SPhilipp Reisner goto fail; 4688b411b363SPhilipp Reisner } 4689b411b363SPhilipp Reisner 4690b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 46912d1ee87dSJulia Lawall if (right_response == NULL) { 469213e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4693b10d96cbSJohannes Thoma rv = -1; 4694b411b363SPhilipp Reisner goto fail; 4695b411b363SPhilipp Reisner } 4696b411b363SPhilipp Reisner 4697b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4698b411b363SPhilipp Reisner 4699b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4700b411b363SPhilipp Reisner if (rv) { 470113e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4702b10d96cbSJohannes Thoma rv = -1; 4703b411b363SPhilipp Reisner goto fail; 4704b411b363SPhilipp Reisner } 4705b411b363SPhilipp Reisner 4706b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4707b411b363SPhilipp Reisner 4708b411b363SPhilipp Reisner if (rv) 470944ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 471044ed167dSPhilipp Reisner resp_size); 4711b10d96cbSJohannes Thoma else 4712b10d96cbSJohannes Thoma rv = -1; 4713b411b363SPhilipp Reisner 4714b411b363SPhilipp Reisner fail: 4715b411b363SPhilipp Reisner kfree(peers_ch); 4716b411b363SPhilipp Reisner kfree(response); 4717b411b363SPhilipp Reisner kfree(right_response); 4718b411b363SPhilipp Reisner 4719b411b363SPhilipp Reisner return rv; 4720b411b363SPhilipp Reisner } 4721b411b363SPhilipp Reisner #endif 4722b411b363SPhilipp Reisner 4723b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4724b411b363SPhilipp Reisner { 4725392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4726b411b363SPhilipp Reisner int h; 4727b411b363SPhilipp Reisner 47284d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4729b411b363SPhilipp Reisner 4730b411b363SPhilipp Reisner do { 473181fa2e67SPhilipp Reisner h = conn_connect(tconn); 4732b411b363SPhilipp Reisner if (h == 0) { 473381fa2e67SPhilipp Reisner conn_disconnect(tconn); 473420ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4735b411b363SPhilipp Reisner } 4736b411b363SPhilipp Reisner if (h == -1) { 47374d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4738bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4739b411b363SPhilipp Reisner } 4740b411b363SPhilipp Reisner } while (h == 0); 4741b411b363SPhilipp Reisner 474291fd4dadSPhilipp Reisner if (h > 0) 47434d641dd7SPhilipp Reisner drbdd(tconn); 4744b411b363SPhilipp Reisner 474581fa2e67SPhilipp Reisner conn_disconnect(tconn); 4746b411b363SPhilipp Reisner 47474d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4748b411b363SPhilipp Reisner return 0; 4749b411b363SPhilipp Reisner } 4750b411b363SPhilipp Reisner 4751b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4752b411b363SPhilipp Reisner 4753e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4754b411b363SPhilipp Reisner { 4755e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4756b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4757b411b363SPhilipp Reisner 4758fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4759fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4760fc3b10a4SPhilipp Reisner } else { 4761fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4762fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4763fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4764fc3b10a4SPhilipp Reisner } 4765fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4766e4f78edeSPhilipp Reisner 47672735a594SAndreas Gruenbacher return 0; 4768fc3b10a4SPhilipp Reisner } 4769e4f78edeSPhilipp Reisner 47701952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4771e4f78edeSPhilipp Reisner { 47721952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4773e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4774e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4775e4f78edeSPhilipp Reisner 47761952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47771952e916SAndreas Gruenbacher if (!mdev) 47782735a594SAndreas Gruenbacher return -EIO; 47791952e916SAndreas Gruenbacher 4780e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4781e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4782e4f78edeSPhilipp Reisner } else { 4783e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4784e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4785e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4786e4f78edeSPhilipp Reisner } 4787e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4788e4f78edeSPhilipp Reisner 47892735a594SAndreas Gruenbacher return 0; 4790b411b363SPhilipp Reisner } 4791b411b363SPhilipp Reisner 4792e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4793b411b363SPhilipp Reisner { 47942735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4795b411b363SPhilipp Reisner 4796b411b363SPhilipp Reisner } 4797b411b363SPhilipp Reisner 4798e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4799b411b363SPhilipp Reisner { 4800b411b363SPhilipp Reisner /* restore idle timeout */ 48012a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 48022a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 48032a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4804b411b363SPhilipp Reisner 48052735a594SAndreas Gruenbacher return 0; 4806b411b363SPhilipp Reisner } 4807b411b363SPhilipp Reisner 48081952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4809b411b363SPhilipp Reisner { 48101952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4811e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4812b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4813b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4814b411b363SPhilipp Reisner 48151952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48161952e916SAndreas Gruenbacher if (!mdev) 48172735a594SAndreas Gruenbacher return -EIO; 48181952e916SAndreas Gruenbacher 481931890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4820b411b363SPhilipp Reisner 4821b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4822b411b363SPhilipp Reisner 48231d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4824b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4825b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4826b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4827b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 48281d53f09eSLars Ellenberg put_ldev(mdev); 48291d53f09eSLars Ellenberg } 4830b411b363SPhilipp Reisner dec_rs_pending(mdev); 4831778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4832b411b363SPhilipp Reisner 48332735a594SAndreas Gruenbacher return 0; 4834b411b363SPhilipp Reisner } 4835b411b363SPhilipp Reisner 4836bc9c5c41SAndreas Gruenbacher static int 4837bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4838bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4839bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4840b411b363SPhilipp Reisner { 4841b411b363SPhilipp Reisner struct drbd_request *req; 4842b411b363SPhilipp Reisner struct bio_and_error m; 4843b411b363SPhilipp Reisner 484487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4845bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4846b411b363SPhilipp Reisner if (unlikely(!req)) { 484787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 484885997675SAndreas Gruenbacher return -EIO; 4849b411b363SPhilipp Reisner } 4850b411b363SPhilipp Reisner __req_mod(req, what, &m); 485187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4852b411b363SPhilipp Reisner 4853b411b363SPhilipp Reisner if (m.bio) 4854b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 485585997675SAndreas Gruenbacher return 0; 4856b411b363SPhilipp Reisner } 4857b411b363SPhilipp Reisner 48581952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4859b411b363SPhilipp Reisner { 48601952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4861e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4862b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4863b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4864b411b363SPhilipp Reisner enum drbd_req_event what; 4865b411b363SPhilipp Reisner 48661952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48671952e916SAndreas Gruenbacher if (!mdev) 48682735a594SAndreas Gruenbacher return -EIO; 48691952e916SAndreas Gruenbacher 4870b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4871b411b363SPhilipp Reisner 4872579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4873b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4874b411b363SPhilipp Reisner dec_rs_pending(mdev); 48752735a594SAndreas Gruenbacher return 0; 4876b411b363SPhilipp Reisner } 4877e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4878b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 48798554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4880b411b363SPhilipp Reisner break; 4881b411b363SPhilipp Reisner case P_WRITE_ACK: 48828554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4883b411b363SPhilipp Reisner break; 4884b411b363SPhilipp Reisner case P_RECV_ACK: 48858554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4886b411b363SPhilipp Reisner break; 48877be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 48887be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 48897be8da07SAndreas Gruenbacher break; 48907be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 48917be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4892b411b363SPhilipp Reisner break; 4893b411b363SPhilipp Reisner default: 48942735a594SAndreas Gruenbacher BUG(); 4895b411b363SPhilipp Reisner } 4896b411b363SPhilipp Reisner 48972735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4898bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4899bc9c5c41SAndreas Gruenbacher what, false); 4900b411b363SPhilipp Reisner } 4901b411b363SPhilipp Reisner 49021952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 4903b411b363SPhilipp Reisner { 49041952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4905e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4906b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 49072deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 490885997675SAndreas Gruenbacher int err; 4909b411b363SPhilipp Reisner 49101952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49111952e916SAndreas Gruenbacher if (!mdev) 49122735a594SAndreas Gruenbacher return -EIO; 49131952e916SAndreas Gruenbacher 4914b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4915b411b363SPhilipp Reisner 4916579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4917b411b363SPhilipp Reisner dec_rs_pending(mdev); 4918b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 49192735a594SAndreas Gruenbacher return 0; 4920b411b363SPhilipp Reisner } 49212deb8336SPhilipp Reisner 492285997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 4923bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4924303d1448SPhilipp Reisner NEG_ACKED, true); 492585997675SAndreas Gruenbacher if (err) { 49262deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 49272deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4928c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 49292deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 49302deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4931c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 49322deb8336SPhilipp Reisner } 49332735a594SAndreas Gruenbacher return 0; 4934b411b363SPhilipp Reisner } 4935b411b363SPhilipp Reisner 49361952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4937b411b363SPhilipp Reisner { 49381952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4939e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4940b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4941b411b363SPhilipp Reisner 49421952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49431952e916SAndreas Gruenbacher if (!mdev) 49442735a594SAndreas Gruenbacher return -EIO; 49451952e916SAndreas Gruenbacher 4946b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 49477be8da07SAndreas Gruenbacher 4948b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4949b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4950b411b363SPhilipp Reisner 49512735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4952bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 49538554df1cSAndreas Gruenbacher NEG_ACKED, false); 4954b411b363SPhilipp Reisner } 4955b411b363SPhilipp Reisner 49561952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4957b411b363SPhilipp Reisner { 49581952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4959b411b363SPhilipp Reisner sector_t sector; 4960b411b363SPhilipp Reisner int size; 4961e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 49621952e916SAndreas Gruenbacher 49631952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49641952e916SAndreas Gruenbacher if (!mdev) 49652735a594SAndreas Gruenbacher return -EIO; 4966b411b363SPhilipp Reisner 4967b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4968b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4969b411b363SPhilipp Reisner 4970b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4971b411b363SPhilipp Reisner 4972b411b363SPhilipp Reisner dec_rs_pending(mdev); 4973b411b363SPhilipp Reisner 4974b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4975b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4976e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4977d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4978b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4979d612d309SPhilipp Reisner case P_RS_CANCEL: 4980d612d309SPhilipp Reisner break; 4981d612d309SPhilipp Reisner default: 49822735a594SAndreas Gruenbacher BUG(); 4983d612d309SPhilipp Reisner } 4984b411b363SPhilipp Reisner put_ldev(mdev); 4985b411b363SPhilipp Reisner } 4986b411b363SPhilipp Reisner 49872735a594SAndreas Gruenbacher return 0; 4988b411b363SPhilipp Reisner } 4989b411b363SPhilipp Reisner 49901952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 4991b411b363SPhilipp Reisner { 49921952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4993e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 49941952e916SAndreas Gruenbacher 49951952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49961952e916SAndreas Gruenbacher if (!mdev) 49972735a594SAndreas Gruenbacher return -EIO; 4998b411b363SPhilipp Reisner 49992f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 5000b411b363SPhilipp Reisner 5001c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 5002c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 500336baf611SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->flags)) { 5004370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 5005370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 5006c4752ef1SPhilipp Reisner } 5007c4752ef1SPhilipp Reisner 50082735a594SAndreas Gruenbacher return 0; 5009b411b363SPhilipp Reisner } 5010b411b363SPhilipp Reisner 50111952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 5012b411b363SPhilipp Reisner { 50131952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5014e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5015b411b363SPhilipp Reisner struct drbd_work *w; 5016b411b363SPhilipp Reisner sector_t sector; 5017b411b363SPhilipp Reisner int size; 5018b411b363SPhilipp Reisner 50191952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50201952e916SAndreas Gruenbacher if (!mdev) 50212735a594SAndreas Gruenbacher return -EIO; 50221952e916SAndreas Gruenbacher 5023b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5024b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5025b411b363SPhilipp Reisner 5026b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5027b411b363SPhilipp Reisner 5028b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 50298f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 5030b411b363SPhilipp Reisner else 50318f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5032b411b363SPhilipp Reisner 50331d53f09eSLars Ellenberg if (!get_ldev(mdev)) 50342735a594SAndreas Gruenbacher return 0; 50351d53f09eSLars Ellenberg 5036b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5037b411b363SPhilipp Reisner dec_rs_pending(mdev); 5038b411b363SPhilipp Reisner 5039ea5442afSLars Ellenberg --mdev->ov_left; 5040ea5442afSLars Ellenberg 5041ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5042ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 5043ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 5044ea5442afSLars Ellenberg 5045ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 5046b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5047b411b363SPhilipp Reisner if (w) { 5048b411b363SPhilipp Reisner w->cb = w_ov_finished; 5049a21e9298SPhilipp Reisner w->mdev = mdev; 5050e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 5051b411b363SPhilipp Reisner } else { 5052b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 50538f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5054b411b363SPhilipp Reisner drbd_resync_finished(mdev); 5055b411b363SPhilipp Reisner } 5056b411b363SPhilipp Reisner } 50571d53f09eSLars Ellenberg put_ldev(mdev); 50582735a594SAndreas Gruenbacher return 0; 5059b411b363SPhilipp Reisner } 5060b411b363SPhilipp Reisner 50611952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 50620ced55a3SPhilipp Reisner { 50632735a594SAndreas Gruenbacher return 0; 50640ced55a3SPhilipp Reisner } 50650ced55a3SPhilipp Reisner 5066a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 506732862ec7SPhilipp Reisner { 5068082a3439SPhilipp Reisner struct drbd_conf *mdev; 5069c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 507032862ec7SPhilipp Reisner 507132862ec7SPhilipp Reisner do { 507232862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 507332862ec7SPhilipp Reisner flush_signals(current); 5074c141ebdaSPhilipp Reisner 5075c141ebdaSPhilipp Reisner rcu_read_lock(); 5076c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5077c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 5078c141ebdaSPhilipp Reisner rcu_read_unlock(); 5079d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 5080c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5081c141ebdaSPhilipp Reisner return 1; 5082082a3439SPhilipp Reisner } 5083c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5084c141ebdaSPhilipp Reisner rcu_read_lock(); 5085d3fcb490SPhilipp Reisner } 508632862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 5087082a3439SPhilipp Reisner 5088082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 5089c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5090082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 5091082a3439SPhilipp Reisner if (not_empty) 5092082a3439SPhilipp Reisner break; 5093082a3439SPhilipp Reisner } 5094082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 5095c141ebdaSPhilipp Reisner rcu_read_unlock(); 509632862ec7SPhilipp Reisner } while (not_empty); 509732862ec7SPhilipp Reisner 509832862ec7SPhilipp Reisner return 0; 509932862ec7SPhilipp Reisner } 510032862ec7SPhilipp Reisner 51017201b972SAndreas Gruenbacher struct asender_cmd { 51027201b972SAndreas Gruenbacher size_t pkt_size; 51031952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 51047201b972SAndreas Gruenbacher }; 51057201b972SAndreas Gruenbacher 51067201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 5107e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5108e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 51091952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 51101952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 51111952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 51121952e916SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 51131952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 51141952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 51151952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 51161952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 51171952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 51181952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 51191952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 51201952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 51211952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 51221952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 51231952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 51247201b972SAndreas Gruenbacher }; 51257201b972SAndreas Gruenbacher 5126b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5127b411b363SPhilipp Reisner { 5128392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5129b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 513077351055SPhilipp Reisner struct packet_info pi; 5131257d0af6SPhilipp Reisner int rv; 5132e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5133b411b363SPhilipp Reisner int received = 0; 513452b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 513552b061a4SAndreas Gruenbacher int expect = header_size; 513644ed167dSPhilipp Reisner bool ping_timeout_active = false; 513744ed167dSPhilipp Reisner struct net_conf *nc; 5138bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 5139b411b363SPhilipp Reisner 5140b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 5141b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 5142b411b363SPhilipp Reisner 5143e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 514480822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 514544ed167dSPhilipp Reisner 514644ed167dSPhilipp Reisner rcu_read_lock(); 514744ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 514844ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5149bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 515044ed167dSPhilipp Reisner ping_int = nc->ping_int; 515144ed167dSPhilipp Reisner rcu_read_unlock(); 515244ed167dSPhilipp Reisner 515332862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5154a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 515532862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5156841ce241SAndreas Gruenbacher goto reconnect; 5157841ce241SAndreas Gruenbacher } 515844ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 515944ed167dSPhilipp Reisner ping_timeout_active = true; 5160b411b363SPhilipp Reisner } 5161b411b363SPhilipp Reisner 516232862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 516332862ec7SPhilipp Reisner much to send */ 5164bb77d34eSAndreas Gruenbacher if (tcp_cork) 516532862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5166a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5167a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5168b411b363SPhilipp Reisner goto reconnect; 5169082a3439SPhilipp Reisner } 5170b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5171bb77d34eSAndreas Gruenbacher if (tcp_cork) 517232862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5173b411b363SPhilipp Reisner 5174b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5175b411b363SPhilipp Reisner if (signal_pending(current)) 5176b411b363SPhilipp Reisner continue; 5177b411b363SPhilipp Reisner 517832862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 517932862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5180b411b363SPhilipp Reisner 5181b411b363SPhilipp Reisner flush_signals(current); 5182b411b363SPhilipp Reisner 5183b411b363SPhilipp Reisner /* Note: 5184b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5185b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5186b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5187b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5188b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5189b411b363SPhilipp Reisner * rv == expected: full header or command 5190b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5191b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5192b411b363SPhilipp Reisner */ 5193b411b363SPhilipp Reisner if (likely(rv > 0)) { 5194b411b363SPhilipp Reisner received += rv; 5195b411b363SPhilipp Reisner buf += rv; 5196b411b363SPhilipp Reisner } else if (rv == 0) { 519732862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5198b411b363SPhilipp Reisner goto reconnect; 5199b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5200cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5201cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 520232862ec7SPhilipp Reisner if (time_after(tconn->last_received, 520332862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5204cb6518cbSLars Ellenberg continue; 5205f36af18cSLars Ellenberg if (ping_timeout_active) { 520632862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5207b411b363SPhilipp Reisner goto reconnect; 5208b411b363SPhilipp Reisner } 520932862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5210b411b363SPhilipp Reisner continue; 5211b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5212b411b363SPhilipp Reisner continue; 5213b411b363SPhilipp Reisner } else { 521432862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5215b411b363SPhilipp Reisner goto reconnect; 5216b411b363SPhilipp Reisner } 5217b411b363SPhilipp Reisner 5218b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5219e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5220b411b363SPhilipp Reisner goto reconnect; 52217201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 52221952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 52232fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected meta packet %s (0x%04x)\n", 52242fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5225b411b363SPhilipp Reisner goto disconnect; 5226b411b363SPhilipp Reisner } 5227e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 522852b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 522932862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 523077351055SPhilipp Reisner pi.cmd, pi.size); 5231b411b363SPhilipp Reisner goto reconnect; 5232b411b363SPhilipp Reisner } 5233257d0af6SPhilipp Reisner } 5234b411b363SPhilipp Reisner if (received == expect) { 52352735a594SAndreas Gruenbacher bool err; 5236a4fbda8eSPhilipp Reisner 52372735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 52382735a594SAndreas Gruenbacher if (err) { 52391952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5240b411b363SPhilipp Reisner goto reconnect; 52411952e916SAndreas Gruenbacher } 5242b411b363SPhilipp Reisner 5243a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5244a4fbda8eSPhilipp Reisner 524544ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 524644ed167dSPhilipp Reisner /* restore idle timeout */ 524744ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 524844ed167dSPhilipp Reisner ping_timeout_active = false; 524944ed167dSPhilipp Reisner } 5250f36af18cSLars Ellenberg 5251e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5252b411b363SPhilipp Reisner received = 0; 525352b061a4SAndreas Gruenbacher expect = header_size; 5254b411b363SPhilipp Reisner cmd = NULL; 5255b411b363SPhilipp Reisner } 5256b411b363SPhilipp Reisner } 5257b411b363SPhilipp Reisner 5258b411b363SPhilipp Reisner if (0) { 5259b411b363SPhilipp Reisner reconnect: 5260bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5261b411b363SPhilipp Reisner } 5262b411b363SPhilipp Reisner if (0) { 5263b411b363SPhilipp Reisner disconnect: 5264bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5265b411b363SPhilipp Reisner } 526632862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5267b411b363SPhilipp Reisner 526832862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5269b411b363SPhilipp Reisner 5270b411b363SPhilipp Reisner return 0; 5271b411b363SPhilipp Reisner } 5272