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 681e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *, 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; 490dd9b3604SPhilipp Reisner __module_get((*newsock)->ops->owner); 491b411b363SPhilipp Reisner 492b411b363SPhilipp Reisner out: 493b411b363SPhilipp Reisner return err; 494b411b363SPhilipp Reisner } 495b411b363SPhilipp Reisner 496dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 497b411b363SPhilipp Reisner { 498b411b363SPhilipp Reisner mm_segment_t oldfs; 499b411b363SPhilipp Reisner struct kvec iov = { 500b411b363SPhilipp Reisner .iov_base = buf, 501b411b363SPhilipp Reisner .iov_len = size, 502b411b363SPhilipp Reisner }; 503b411b363SPhilipp Reisner struct msghdr msg = { 504b411b363SPhilipp Reisner .msg_iovlen = 1, 505b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 506b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 507b411b363SPhilipp Reisner }; 508b411b363SPhilipp Reisner int rv; 509b411b363SPhilipp Reisner 510b411b363SPhilipp Reisner oldfs = get_fs(); 511b411b363SPhilipp Reisner set_fs(KERNEL_DS); 512b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 513b411b363SPhilipp Reisner set_fs(oldfs); 514b411b363SPhilipp Reisner 515b411b363SPhilipp Reisner return rv; 516b411b363SPhilipp Reisner } 517b411b363SPhilipp Reisner 518de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 519b411b363SPhilipp Reisner { 520b411b363SPhilipp Reisner mm_segment_t oldfs; 521b411b363SPhilipp Reisner struct kvec iov = { 522b411b363SPhilipp Reisner .iov_base = buf, 523b411b363SPhilipp Reisner .iov_len = size, 524b411b363SPhilipp Reisner }; 525b411b363SPhilipp Reisner struct msghdr msg = { 526b411b363SPhilipp Reisner .msg_iovlen = 1, 527b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 528b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 529b411b363SPhilipp Reisner }; 530b411b363SPhilipp Reisner int rv; 531b411b363SPhilipp Reisner 532b411b363SPhilipp Reisner oldfs = get_fs(); 533b411b363SPhilipp Reisner set_fs(KERNEL_DS); 534b411b363SPhilipp Reisner 535b411b363SPhilipp Reisner for (;;) { 536de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 537b411b363SPhilipp Reisner if (rv == size) 538b411b363SPhilipp Reisner break; 539b411b363SPhilipp Reisner 540b411b363SPhilipp Reisner /* Note: 541b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 542b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 543b411b363SPhilipp Reisner */ 544b411b363SPhilipp Reisner 545b411b363SPhilipp Reisner if (rv < 0) { 546b411b363SPhilipp Reisner if (rv == -ECONNRESET) 547de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 548b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 549de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 550b411b363SPhilipp Reisner break; 551b411b363SPhilipp Reisner } else if (rv == 0) { 552de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 553b411b363SPhilipp Reisner break; 554b411b363SPhilipp Reisner } else { 555b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 556b411b363SPhilipp Reisner * after we read a partial message 557b411b363SPhilipp Reisner */ 558b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 559b411b363SPhilipp Reisner break; 560b411b363SPhilipp Reisner } 561b411b363SPhilipp Reisner }; 562b411b363SPhilipp Reisner 563b411b363SPhilipp Reisner set_fs(oldfs); 564b411b363SPhilipp Reisner 565b411b363SPhilipp Reisner if (rv != size) 566bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 567b411b363SPhilipp Reisner 568b411b363SPhilipp Reisner return rv; 569b411b363SPhilipp Reisner } 570b411b363SPhilipp Reisner 571c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 572c6967746SAndreas Gruenbacher { 573c6967746SAndreas Gruenbacher int err; 574c6967746SAndreas Gruenbacher 575c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 576c6967746SAndreas Gruenbacher if (err != size) { 577c6967746SAndreas Gruenbacher if (err >= 0) 578c6967746SAndreas Gruenbacher err = -EIO; 579c6967746SAndreas Gruenbacher } else 580c6967746SAndreas Gruenbacher err = 0; 581c6967746SAndreas Gruenbacher return err; 582c6967746SAndreas Gruenbacher } 583c6967746SAndreas Gruenbacher 584a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 585a5c31904SAndreas Gruenbacher { 586a5c31904SAndreas Gruenbacher int err; 587a5c31904SAndreas Gruenbacher 588a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 589a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 590a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 591a5c31904SAndreas Gruenbacher return err; 592a5c31904SAndreas Gruenbacher } 593a5c31904SAndreas Gruenbacher 5945dbf1673SLars Ellenberg /* quoting tcp(7): 5955dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5965dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5975dbf1673SLars Ellenberg * This is our wrapper to do so. 5985dbf1673SLars Ellenberg */ 5995dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 6005dbf1673SLars Ellenberg unsigned int rcv) 6015dbf1673SLars Ellenberg { 6025dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 6035dbf1673SLars Ellenberg if (snd) { 6045dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 6055dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 6065dbf1673SLars Ellenberg } 6075dbf1673SLars Ellenberg if (rcv) { 6085dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 6095dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 6105dbf1673SLars Ellenberg } 6115dbf1673SLars Ellenberg } 6125dbf1673SLars Ellenberg 613eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 614b411b363SPhilipp Reisner { 615b411b363SPhilipp Reisner const char *what; 616b411b363SPhilipp Reisner struct socket *sock; 617b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 61844ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 61944ed167dSPhilipp Reisner struct net_conf *nc; 62044ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 62169ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 622b411b363SPhilipp Reisner int disconnect_on_error = 1; 623b411b363SPhilipp Reisner 62444ed167dSPhilipp Reisner rcu_read_lock(); 62544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 62644ed167dSPhilipp Reisner if (!nc) { 62744ed167dSPhilipp Reisner rcu_read_unlock(); 628b411b363SPhilipp Reisner return NULL; 62944ed167dSPhilipp Reisner } 63044ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 63144ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 63269ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 633089c075dSAndreas Gruenbacher rcu_read_unlock(); 63444ed167dSPhilipp Reisner 635089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(src_in6)); 636089c075dSAndreas Gruenbacher memcpy(&src_in6, &tconn->my_addr, my_addr_len); 63744ed167dSPhilipp Reisner 638089c075dSAndreas Gruenbacher if (((struct sockaddr *)&tconn->my_addr)->sa_family == AF_INET6) 63944ed167dSPhilipp Reisner src_in6.sin6_port = 0; 64044ed167dSPhilipp Reisner else 64144ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 64244ed167dSPhilipp Reisner 643089c075dSAndreas Gruenbacher peer_addr_len = min_t(int, tconn->peer_addr_len, sizeof(src_in6)); 644089c075dSAndreas Gruenbacher memcpy(&peer_in6, &tconn->peer_addr, peer_addr_len); 645b411b363SPhilipp Reisner 646b411b363SPhilipp Reisner what = "sock_create_kern"; 64744ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 648b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 649b411b363SPhilipp Reisner if (err < 0) { 650b411b363SPhilipp Reisner sock = NULL; 651b411b363SPhilipp Reisner goto out; 652b411b363SPhilipp Reisner } 653b411b363SPhilipp Reisner 654b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 65569ef82deSAndreas Gruenbacher sock->sk->sk_sndtimeo = connect_int * HZ; 65644ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 657b411b363SPhilipp Reisner 658b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 659b411b363SPhilipp Reisner * for the outgoing connections. 660b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 661b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 662b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 663b411b363SPhilipp Reisner * a free one dynamically. 664b411b363SPhilipp Reisner */ 665b411b363SPhilipp Reisner what = "bind before connect"; 66644ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 667b411b363SPhilipp Reisner if (err < 0) 668b411b363SPhilipp Reisner goto out; 669b411b363SPhilipp Reisner 670b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 671b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 672b411b363SPhilipp Reisner disconnect_on_error = 0; 673b411b363SPhilipp Reisner what = "connect"; 67444ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 675b411b363SPhilipp Reisner 676b411b363SPhilipp Reisner out: 677b411b363SPhilipp Reisner if (err < 0) { 678b411b363SPhilipp Reisner if (sock) { 679b411b363SPhilipp Reisner sock_release(sock); 680b411b363SPhilipp Reisner sock = NULL; 681b411b363SPhilipp Reisner } 682b411b363SPhilipp Reisner switch (-err) { 683b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 684b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 685b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 686b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 687b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 688b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 689b411b363SPhilipp Reisner disconnect_on_error = 0; 690b411b363SPhilipp Reisner break; 691b411b363SPhilipp Reisner default: 692eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 693b411b363SPhilipp Reisner } 694b411b363SPhilipp Reisner if (disconnect_on_error) 695bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 696b411b363SPhilipp Reisner } 69744ed167dSPhilipp Reisner 698b411b363SPhilipp Reisner return sock; 699b411b363SPhilipp Reisner } 700b411b363SPhilipp Reisner 7017653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 702b411b363SPhilipp Reisner { 70344ed167dSPhilipp Reisner int timeo, err, my_addr_len; 70469ef82deSAndreas Gruenbacher int sndbuf_size, rcvbuf_size, connect_int; 705b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 70644ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 70744ed167dSPhilipp Reisner struct net_conf *nc; 708b411b363SPhilipp Reisner const char *what; 709b411b363SPhilipp Reisner 71044ed167dSPhilipp Reisner rcu_read_lock(); 71144ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 71244ed167dSPhilipp Reisner if (!nc) { 71344ed167dSPhilipp Reisner rcu_read_unlock(); 714b411b363SPhilipp Reisner return NULL; 71544ed167dSPhilipp Reisner } 71644ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71744ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 71869ef82deSAndreas Gruenbacher connect_int = nc->connect_int; 71944ed167dSPhilipp Reisner rcu_read_unlock(); 720b411b363SPhilipp Reisner 721089c075dSAndreas Gruenbacher my_addr_len = min_t(int, tconn->my_addr_len, sizeof(struct sockaddr_in6)); 722089c075dSAndreas Gruenbacher memcpy(&my_addr, &tconn->my_addr, my_addr_len); 723089c075dSAndreas Gruenbacher 724b411b363SPhilipp Reisner what = "sock_create_kern"; 72544ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 726b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 727b411b363SPhilipp Reisner if (err) { 728b411b363SPhilipp Reisner s_listen = NULL; 729b411b363SPhilipp Reisner goto out; 730b411b363SPhilipp Reisner } 731b411b363SPhilipp Reisner 73269ef82deSAndreas Gruenbacher timeo = connect_int * HZ; 733b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 734b411b363SPhilipp Reisner 735b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 736b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 737b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 73844ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 739b411b363SPhilipp Reisner 740b411b363SPhilipp Reisner what = "bind before listen"; 74144ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 742b411b363SPhilipp Reisner if (err < 0) 743b411b363SPhilipp Reisner goto out; 744b411b363SPhilipp Reisner 7457653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 746b411b363SPhilipp Reisner 747b411b363SPhilipp Reisner out: 748b411b363SPhilipp Reisner if (s_listen) 749b411b363SPhilipp Reisner sock_release(s_listen); 750b411b363SPhilipp Reisner if (err < 0) { 751b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7527653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 753bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 754b411b363SPhilipp Reisner } 755b411b363SPhilipp Reisner } 756b411b363SPhilipp Reisner 757b411b363SPhilipp Reisner return s_estab; 758b411b363SPhilipp Reisner } 759b411b363SPhilipp Reisner 760e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 761b411b363SPhilipp Reisner 7629f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7639f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7649f5bdc33SAndreas Gruenbacher { 7659f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7669f5bdc33SAndreas Gruenbacher return -EIO; 767e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 768b411b363SPhilipp Reisner } 769b411b363SPhilipp Reisner 7709f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 771b411b363SPhilipp Reisner { 7729f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7739f5bdc33SAndreas Gruenbacher struct packet_info pi; 7749f5bdc33SAndreas Gruenbacher int err; 775b411b363SPhilipp Reisner 7769f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7779f5bdc33SAndreas Gruenbacher if (err != header_size) { 7789f5bdc33SAndreas Gruenbacher if (err >= 0) 7799f5bdc33SAndreas Gruenbacher err = -EIO; 7809f5bdc33SAndreas Gruenbacher return err; 7819f5bdc33SAndreas Gruenbacher } 7829f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 7839f5bdc33SAndreas Gruenbacher if (err) 7849f5bdc33SAndreas Gruenbacher return err; 7859f5bdc33SAndreas Gruenbacher return pi.cmd; 786b411b363SPhilipp Reisner } 787b411b363SPhilipp Reisner 788b411b363SPhilipp Reisner /** 789b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 790b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 791b411b363SPhilipp Reisner */ 792dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 793b411b363SPhilipp Reisner { 794b411b363SPhilipp Reisner int rr; 795b411b363SPhilipp Reisner char tb[4]; 796b411b363SPhilipp Reisner 797b411b363SPhilipp Reisner if (!*sock) 79881e84650SAndreas Gruenbacher return false; 799b411b363SPhilipp Reisner 800dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 801b411b363SPhilipp Reisner 802b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 80381e84650SAndreas Gruenbacher return true; 804b411b363SPhilipp Reisner } else { 805b411b363SPhilipp Reisner sock_release(*sock); 806b411b363SPhilipp Reisner *sock = NULL; 80781e84650SAndreas Gruenbacher return false; 808b411b363SPhilipp Reisner } 809b411b363SPhilipp Reisner } 8102325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8112325eb66SPhilipp Reisner in a connection */ 812c141ebdaSPhilipp Reisner int drbd_connected(struct drbd_conf *mdev) 813907599e0SPhilipp Reisner { 8140829f5edSAndreas Gruenbacher int err; 815907599e0SPhilipp Reisner 816907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 817907599e0SPhilipp Reisner mdev->peer_seq = 0; 818907599e0SPhilipp Reisner 8198410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8208410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8218410da8fSPhilipp Reisner &mdev->own_state_mutex; 8228410da8fSPhilipp Reisner 8230829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8240829f5edSAndreas Gruenbacher if (!err) 8250829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8260829f5edSAndreas Gruenbacher if (!err) 8270829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8280829f5edSAndreas Gruenbacher if (!err) 82943de7c85SPhilipp Reisner err = drbd_send_current_state(mdev); 830907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 831907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8328b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8330829f5edSAndreas Gruenbacher return err; 834907599e0SPhilipp Reisner } 835907599e0SPhilipp Reisner 836b411b363SPhilipp Reisner /* 837b411b363SPhilipp Reisner * return values: 838b411b363SPhilipp Reisner * 1 yes, we have a valid connection 839b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 840b411b363SPhilipp Reisner * -1 peer talks different language, 841b411b363SPhilipp Reisner * no point in trying again, please go standalone. 842b411b363SPhilipp Reisner * -2 We do not have a network config... 843b411b363SPhilipp Reisner */ 84481fa2e67SPhilipp Reisner static int conn_connect(struct drbd_tconn *tconn) 845b411b363SPhilipp Reisner { 8467da35862SPhilipp Reisner struct drbd_socket sock, msock; 847c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 84844ed167dSPhilipp Reisner struct net_conf *nc; 849c141ebdaSPhilipp Reisner int vnr, timeout, try, h, ok; 85008b165baSPhilipp Reisner bool discard_my_data; 851a1096a6eSPhilipp Reisner enum drbd_state_rv rv; 852b411b363SPhilipp Reisner 853bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 854b411b363SPhilipp Reisner return -2; 855b411b363SPhilipp Reisner 8567da35862SPhilipp Reisner mutex_init(&sock.mutex); 8577da35862SPhilipp Reisner sock.sbuf = tconn->data.sbuf; 8587da35862SPhilipp Reisner sock.rbuf = tconn->data.rbuf; 8597da35862SPhilipp Reisner sock.socket = NULL; 8607da35862SPhilipp Reisner mutex_init(&msock.mutex); 8617da35862SPhilipp Reisner msock.sbuf = tconn->meta.sbuf; 8627da35862SPhilipp Reisner msock.rbuf = tconn->meta.rbuf; 8637da35862SPhilipp Reisner msock.socket = NULL; 8647da35862SPhilipp Reisner 865907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 8660916e0e3SAndreas Gruenbacher 8670916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8680916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 869b411b363SPhilipp Reisner 870b411b363SPhilipp Reisner do { 8712bf89621SAndreas Gruenbacher struct socket *s; 8722bf89621SAndreas Gruenbacher 873b411b363SPhilipp Reisner for (try = 0;;) { 874b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 875907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 876b411b363SPhilipp Reisner if (s || ++try >= 3) 877b411b363SPhilipp Reisner break; 878b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 87920ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 880b411b363SPhilipp Reisner } 881b411b363SPhilipp Reisner 882b411b363SPhilipp Reisner if (s) { 8837da35862SPhilipp Reisner if (!sock.socket) { 8847da35862SPhilipp Reisner sock.socket = s; 8857da35862SPhilipp Reisner send_first_packet(tconn, &sock, P_INITIAL_DATA); 8867da35862SPhilipp Reisner } else if (!msock.socket) { 8877da35862SPhilipp Reisner msock.socket = s; 8887da35862SPhilipp Reisner send_first_packet(tconn, &msock, P_INITIAL_META); 889b411b363SPhilipp Reisner } else { 89081fa2e67SPhilipp Reisner conn_err(tconn, "Logic error in conn_connect()\n"); 891b411b363SPhilipp Reisner goto out_release_sockets; 892b411b363SPhilipp Reisner } 893b411b363SPhilipp Reisner } 894b411b363SPhilipp Reisner 8957da35862SPhilipp Reisner if (sock.socket && msock.socket) { 8967da35862SPhilipp Reisner rcu_read_lock(); 8977da35862SPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 8987da35862SPhilipp Reisner timeout = nc->ping_timeo * HZ / 10; 8997da35862SPhilipp Reisner rcu_read_unlock(); 9007da35862SPhilipp Reisner schedule_timeout_interruptible(timeout); 9017da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9027da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 903b411b363SPhilipp Reisner if (ok) 904b411b363SPhilipp Reisner break; 905b411b363SPhilipp Reisner } 906b411b363SPhilipp Reisner 907b411b363SPhilipp Reisner retry: 908907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 909b411b363SPhilipp Reisner if (s) { 9109f5bdc33SAndreas Gruenbacher try = receive_first_packet(tconn, s); 9117da35862SPhilipp Reisner drbd_socket_okay(&sock.socket); 9127da35862SPhilipp Reisner drbd_socket_okay(&msock.socket); 913b411b363SPhilipp Reisner switch (try) { 914e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9157da35862SPhilipp Reisner if (sock.socket) { 916907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9177da35862SPhilipp Reisner sock_release(sock.socket); 918b411b363SPhilipp Reisner } 9197da35862SPhilipp Reisner sock.socket = s; 920b411b363SPhilipp Reisner break; 921e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 9227da35862SPhilipp Reisner if (msock.socket) { 923907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9247da35862SPhilipp Reisner sock_release(msock.socket); 925b411b363SPhilipp Reisner } 9267da35862SPhilipp Reisner msock.socket = s; 927907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 928b411b363SPhilipp Reisner break; 929b411b363SPhilipp Reisner default: 930907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 931b411b363SPhilipp Reisner sock_release(s); 932b411b363SPhilipp Reisner if (random32() & 1) 933b411b363SPhilipp Reisner goto retry; 934b411b363SPhilipp Reisner } 935b411b363SPhilipp Reisner } 936b411b363SPhilipp Reisner 937bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 938b411b363SPhilipp Reisner goto out_release_sockets; 939b411b363SPhilipp Reisner if (signal_pending(current)) { 940b411b363SPhilipp Reisner flush_signals(current); 941b411b363SPhilipp Reisner smp_rmb(); 942907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 943b411b363SPhilipp Reisner goto out_release_sockets; 944b411b363SPhilipp Reisner } 945b411b363SPhilipp Reisner 9467da35862SPhilipp Reisner if (sock.socket && &msock.socket) { 9477da35862SPhilipp Reisner ok = drbd_socket_okay(&sock.socket); 9487da35862SPhilipp Reisner ok = drbd_socket_okay(&msock.socket) && ok; 949b411b363SPhilipp Reisner if (ok) 950b411b363SPhilipp Reisner break; 951b411b363SPhilipp Reisner } 952b411b363SPhilipp Reisner } while (1); 953b411b363SPhilipp Reisner 9547da35862SPhilipp Reisner sock.socket->sk->sk_reuse = 1; /* SO_REUSEADDR */ 9557da35862SPhilipp Reisner msock.socket->sk->sk_reuse = 1; /* SO_REUSEADDR */ 9562bf89621SAndreas Gruenbacher 9577da35862SPhilipp Reisner sock.socket->sk->sk_allocation = GFP_NOIO; 9587da35862SPhilipp Reisner msock.socket->sk->sk_allocation = GFP_NOIO; 959b411b363SPhilipp Reisner 9607da35862SPhilipp Reisner sock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 9617da35862SPhilipp Reisner msock.socket->sk->sk_priority = TC_PRIO_INTERACTIVE; 962b411b363SPhilipp Reisner 963b411b363SPhilipp Reisner /* NOT YET ... 9647da35862SPhilipp Reisner * sock.socket->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 9657da35862SPhilipp Reisner * sock.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9666038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 967b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 96844ed167dSPhilipp Reisner rcu_read_lock(); 96944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 970b411b363SPhilipp Reisner 9717da35862SPhilipp Reisner sock.socket->sk->sk_sndtimeo = 9727da35862SPhilipp Reisner sock.socket->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 97344ed167dSPhilipp Reisner 9747da35862SPhilipp Reisner msock.socket->sk->sk_rcvtimeo = nc->ping_int*HZ; 97544ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 97608b165baSPhilipp Reisner discard_my_data = nc->discard_my_data; 97744ed167dSPhilipp Reisner rcu_read_unlock(); 97844ed167dSPhilipp Reisner 9797da35862SPhilipp Reisner msock.socket->sk->sk_sndtimeo = timeout; 980b411b363SPhilipp Reisner 981b411b363SPhilipp Reisner /* we don't want delays. 98225985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 9837da35862SPhilipp Reisner drbd_tcp_nodelay(sock.socket); 9847da35862SPhilipp Reisner drbd_tcp_nodelay(msock.socket); 985b411b363SPhilipp Reisner 9867da35862SPhilipp Reisner tconn->data.socket = sock.socket; 9877da35862SPhilipp Reisner tconn->meta.socket = msock.socket; 988907599e0SPhilipp Reisner tconn->last_received = jiffies; 989b411b363SPhilipp Reisner 9906038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 991b411b363SPhilipp Reisner if (h <= 0) 992b411b363SPhilipp Reisner return h; 993b411b363SPhilipp Reisner 994907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 995b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 996907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 997b10d96cbSJohannes Thoma case -1: 998907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 999b411b363SPhilipp Reisner return -1; 1000b10d96cbSJohannes Thoma case 0: 1001907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 1002b10d96cbSJohannes Thoma return 0; 1003b411b363SPhilipp Reisner } 1004b411b363SPhilipp Reisner } 1005b411b363SPhilipp Reisner 10067da35862SPhilipp Reisner tconn->data.socket->sk->sk_sndtimeo = timeout; 10077da35862SPhilipp Reisner tconn->data.socket->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 1008b411b363SPhilipp Reisner 1009387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 10107e2455c1SPhilipp Reisner return -1; 1011b411b363SPhilipp Reisner 1012a1096a6eSPhilipp Reisner set_bit(STATE_SENT, &tconn->flags); 1013a1096a6eSPhilipp Reisner 1014c141ebdaSPhilipp Reisner rcu_read_lock(); 1015c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1016c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 1017c141ebdaSPhilipp Reisner rcu_read_unlock(); 101808b165baSPhilipp Reisner 101908b165baSPhilipp Reisner if (discard_my_data) 102008b165baSPhilipp Reisner set_bit(DISCARD_MY_DATA, &mdev->flags); 102108b165baSPhilipp Reisner else 102208b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 102308b165baSPhilipp Reisner 1024c141ebdaSPhilipp Reisner drbd_connected(mdev); 1025c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 1026c141ebdaSPhilipp Reisner rcu_read_lock(); 1027c141ebdaSPhilipp Reisner } 1028c141ebdaSPhilipp Reisner rcu_read_unlock(); 1029c141ebdaSPhilipp Reisner 1030a1096a6eSPhilipp Reisner rv = conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE); 1031a1096a6eSPhilipp Reisner if (rv < SS_SUCCESS) { 1032a1096a6eSPhilipp Reisner clear_bit(STATE_SENT, &tconn->flags); 1033823bd832SPhilipp Reisner return 0; 1034a1096a6eSPhilipp Reisner } 1035823bd832SPhilipp Reisner 1036823bd832SPhilipp Reisner drbd_thread_start(&tconn->asender); 1037823bd832SPhilipp Reisner 103808b165baSPhilipp Reisner mutex_lock(&tconn->conf_update); 103908b165baSPhilipp Reisner /* The discard_my_data flag is a single-shot modifier to the next 104008b165baSPhilipp Reisner * connection attempt, the handshake of which is now well underway. 104108b165baSPhilipp Reisner * No need for rcu style copying of the whole struct 104208b165baSPhilipp Reisner * just to clear a single value. */ 104308b165baSPhilipp Reisner tconn->net_conf->discard_my_data = 0; 104408b165baSPhilipp Reisner mutex_unlock(&tconn->conf_update); 104508b165baSPhilipp Reisner 1046d3fcb490SPhilipp Reisner return h; 1047b411b363SPhilipp Reisner 1048b411b363SPhilipp Reisner out_release_sockets: 10497da35862SPhilipp Reisner if (sock.socket) 10507da35862SPhilipp Reisner sock_release(sock.socket); 10517da35862SPhilipp Reisner if (msock.socket) 10527da35862SPhilipp Reisner sock_release(msock.socket); 1053b411b363SPhilipp Reisner return -1; 1054b411b363SPhilipp Reisner } 1055b411b363SPhilipp Reisner 1056e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1057b411b363SPhilipp Reisner { 1058e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1059e658983aSAndreas Gruenbacher 10600c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10610c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 10620c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 10630c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 10640c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 10650c8e36d9SAndreas Gruenbacher return -EINVAL; 10660c8e36d9SAndreas Gruenbacher } 10670c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 10680c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 10690c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 10700c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1071e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1072e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1073e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1074b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1075eefc2f7dSPhilipp Reisner pi->vnr = 0; 1076e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1077e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1078e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1079e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1080e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 108177351055SPhilipp Reisner pi->vnr = 0; 108202918be2SPhilipp Reisner } else { 1083e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1084e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1085e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 10868172f3e9SAndreas Gruenbacher return -EINVAL; 1087b411b363SPhilipp Reisner } 1088e658983aSAndreas Gruenbacher pi->data = header + header_size; 10898172f3e9SAndreas Gruenbacher return 0; 1090257d0af6SPhilipp Reisner } 1091257d0af6SPhilipp Reisner 10929ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1093257d0af6SPhilipp Reisner { 1094e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 109569bc7bc3SAndreas Gruenbacher int err; 1096257d0af6SPhilipp Reisner 1097e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1098a5c31904SAndreas Gruenbacher if (err) 109969bc7bc3SAndreas Gruenbacher return err; 1100257d0af6SPhilipp Reisner 1101e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 11029ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1103b411b363SPhilipp Reisner 110469bc7bc3SAndreas Gruenbacher return err; 1105b411b363SPhilipp Reisner } 1106b411b363SPhilipp Reisner 11074b0007c0SPhilipp Reisner static void drbd_flush(struct drbd_tconn *tconn) 1108b411b363SPhilipp Reisner { 1109b411b363SPhilipp Reisner int rv; 11104b0007c0SPhilipp Reisner struct drbd_conf *mdev; 11114b0007c0SPhilipp Reisner int vnr; 1112b411b363SPhilipp Reisner 11134b0007c0SPhilipp Reisner if (tconn->write_ordering >= WO_bdev_flush) { 1114615e087fSLars Ellenberg rcu_read_lock(); 11154b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 1116615e087fSLars Ellenberg if (!get_ldev(mdev)) 1117615e087fSLars Ellenberg continue; 1118615e087fSLars Ellenberg kref_get(&mdev->kref); 1119615e087fSLars Ellenberg rcu_read_unlock(); 11204b0007c0SPhilipp Reisner 1121615e087fSLars Ellenberg rv = blkdev_issue_flush(mdev->ldev->backing_bdev, 1122615e087fSLars Ellenberg GFP_NOIO, NULL); 1123b411b363SPhilipp Reisner if (rv) { 1124a67b813cSPhilipp Reisner dev_info(DEV, "local disk flush failed with status %d\n", rv); 1125b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1126b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1127b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 11284b0007c0SPhilipp Reisner drbd_bump_write_ordering(tconn, WO_drain_io); 1129615e087fSLars Ellenberg } 1130615e087fSLars Ellenberg put_ldev(mdev); 1131615e087fSLars Ellenberg kref_put(&mdev->kref, &drbd_minor_destroy); 1132615e087fSLars Ellenberg 1133615e087fSLars Ellenberg rcu_read_lock(); 1134615e087fSLars Ellenberg if (rv) 11354b0007c0SPhilipp Reisner break; 1136b411b363SPhilipp Reisner } 1137615e087fSLars Ellenberg rcu_read_unlock(); 1138b411b363SPhilipp Reisner } 1139b411b363SPhilipp Reisner } 1140b411b363SPhilipp Reisner 1141b411b363SPhilipp Reisner /** 1142b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1143b411b363SPhilipp Reisner * @mdev: DRBD device. 1144b411b363SPhilipp Reisner * @epoch: Epoch object. 1145b411b363SPhilipp Reisner * @ev: Epoch event. 1146b411b363SPhilipp Reisner */ 11471e9dd291SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_tconn *tconn, 1148b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1149b411b363SPhilipp Reisner enum epoch_event ev) 1150b411b363SPhilipp Reisner { 11512451fc3bSPhilipp Reisner int epoch_size; 1152b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1153b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1154b411b363SPhilipp Reisner 115512038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1156b411b363SPhilipp Reisner do { 1157b411b363SPhilipp Reisner next_epoch = NULL; 1158b411b363SPhilipp Reisner 1159b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1160b411b363SPhilipp Reisner 1161b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1162b411b363SPhilipp Reisner case EV_PUT: 1163b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1164b411b363SPhilipp Reisner break; 1165b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1166b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1167b411b363SPhilipp Reisner break; 1168b411b363SPhilipp Reisner case EV_BECAME_LAST: 1169b411b363SPhilipp Reisner /* nothing to do*/ 1170b411b363SPhilipp Reisner break; 1171b411b363SPhilipp Reisner } 1172b411b363SPhilipp Reisner 1173b411b363SPhilipp Reisner if (epoch_size != 0 && 1174b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 117585d73513SPhilipp Reisner (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) || ev & EV_CLEANUP)) { 1176b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 117712038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 11789ed57dcbSLars Ellenberg drbd_send_b_ack(epoch->tconn, epoch->barrier_nr, epoch_size); 117912038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 1180b411b363SPhilipp Reisner } 11819ed57dcbSLars Ellenberg #if 0 11829ed57dcbSLars Ellenberg /* FIXME: dec unacked on connection, once we have 11839ed57dcbSLars Ellenberg * something to count pending connection packets in. */ 118485d73513SPhilipp Reisner if (test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) 11859ed57dcbSLars Ellenberg dec_unacked(epoch->tconn); 11869ed57dcbSLars Ellenberg #endif 1187b411b363SPhilipp Reisner 118812038a3aSPhilipp Reisner if (tconn->current_epoch != epoch) { 1189b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1190b411b363SPhilipp Reisner list_del(&epoch->list); 1191b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 119212038a3aSPhilipp Reisner tconn->epochs--; 1193b411b363SPhilipp Reisner kfree(epoch); 1194b411b363SPhilipp Reisner 1195b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1196b411b363SPhilipp Reisner rv = FE_DESTROYED; 1197b411b363SPhilipp Reisner } else { 1198b411b363SPhilipp Reisner epoch->flags = 0; 1199b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1200698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1201b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1202b411b363SPhilipp Reisner rv = FE_RECYCLED; 1203b411b363SPhilipp Reisner } 1204b411b363SPhilipp Reisner } 1205b411b363SPhilipp Reisner 1206b411b363SPhilipp Reisner if (!next_epoch) 1207b411b363SPhilipp Reisner break; 1208b411b363SPhilipp Reisner 1209b411b363SPhilipp Reisner epoch = next_epoch; 1210b411b363SPhilipp Reisner } while (1); 1211b411b363SPhilipp Reisner 121212038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1213b411b363SPhilipp Reisner 1214b411b363SPhilipp Reisner return rv; 1215b411b363SPhilipp Reisner } 1216b411b363SPhilipp Reisner 1217b411b363SPhilipp Reisner /** 1218b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 12194b0007c0SPhilipp Reisner * @tconn: DRBD connection. 1220b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1221b411b363SPhilipp Reisner */ 12224b0007c0SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_tconn *tconn, enum write_ordering_e wo) 1223b411b363SPhilipp Reisner { 1224daeda1ccSPhilipp Reisner struct disk_conf *dc; 12254b0007c0SPhilipp Reisner struct drbd_conf *mdev; 1226b411b363SPhilipp Reisner enum write_ordering_e pwo; 12274b0007c0SPhilipp Reisner int vnr; 1228b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1229b411b363SPhilipp Reisner [WO_none] = "none", 1230b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1231b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1232b411b363SPhilipp Reisner }; 1233b411b363SPhilipp Reisner 12344b0007c0SPhilipp Reisner pwo = tconn->write_ordering; 1235b411b363SPhilipp Reisner wo = min(pwo, wo); 1236daeda1ccSPhilipp Reisner rcu_read_lock(); 12374b0007c0SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 123827eb13e9SPhilipp Reisner if (!get_ldev_if_state(mdev, D_ATTACHING)) 12394b0007c0SPhilipp Reisner continue; 1240daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1241daeda1ccSPhilipp Reisner 124266b2f6b9SAndreas Gruenbacher if (wo == WO_bdev_flush && !dc->disk_flushes) 1243b411b363SPhilipp Reisner wo = WO_drain_io; 1244d0c980e2SAndreas Gruenbacher if (wo == WO_drain_io && !dc->disk_drain) 1245b411b363SPhilipp Reisner wo = WO_none; 12464b0007c0SPhilipp Reisner put_ldev(mdev); 12474b0007c0SPhilipp Reisner } 1248daeda1ccSPhilipp Reisner rcu_read_unlock(); 12494b0007c0SPhilipp Reisner tconn->write_ordering = wo; 12504b0007c0SPhilipp Reisner if (pwo != tconn->write_ordering || wo == WO_bdev_flush) 12514b0007c0SPhilipp Reisner conn_info(tconn, "Method to ensure write ordering: %s\n", write_ordering_str[tconn->write_ordering]); 1252b411b363SPhilipp Reisner } 1253b411b363SPhilipp Reisner 1254b411b363SPhilipp Reisner /** 1255fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 125645bb912bSLars Ellenberg * @mdev: DRBD device. 1257db830c46SAndreas Gruenbacher * @peer_req: peer request 125845bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 125910f6d992SLars Ellenberg * 126010f6d992SLars Ellenberg * May spread the pages to multiple bios, 126110f6d992SLars Ellenberg * depending on bio_add_page restrictions. 126210f6d992SLars Ellenberg * 126310f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 126410f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 126510f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 126610f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 126710f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 126810f6d992SLars Ellenberg * on certain Xen deployments. 126945bb912bSLars Ellenberg */ 127045bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1271fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1272fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 127345bb912bSLars Ellenberg const unsigned rw, const int fault_type) 127445bb912bSLars Ellenberg { 127545bb912bSLars Ellenberg struct bio *bios = NULL; 127645bb912bSLars Ellenberg struct bio *bio; 1277db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1278db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1279db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 128045bb912bSLars Ellenberg unsigned n_bios = 0; 128145bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 128210f6d992SLars Ellenberg int err = -ENOMEM; 128345bb912bSLars Ellenberg 128445bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 128545bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 128645bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1287da4a75d2SLars Ellenberg * request in more than one bio. 1288da4a75d2SLars Ellenberg * 1289da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1290da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1291da4a75d2SLars Ellenberg */ 129245bb912bSLars Ellenberg next_bio: 129345bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 129445bb912bSLars Ellenberg if (!bio) { 129545bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 129645bb912bSLars Ellenberg goto fail; 129745bb912bSLars Ellenberg } 1298db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 129945bb912bSLars Ellenberg bio->bi_sector = sector; 130045bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 130145bb912bSLars Ellenberg bio->bi_rw = rw; 1302db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1303fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 130445bb912bSLars Ellenberg 130545bb912bSLars Ellenberg bio->bi_next = bios; 130645bb912bSLars Ellenberg bios = bio; 130745bb912bSLars Ellenberg ++n_bios; 130845bb912bSLars Ellenberg 130945bb912bSLars Ellenberg page_chain_for_each(page) { 131045bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 131145bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 131210f6d992SLars Ellenberg /* A single page must always be possible! 131310f6d992SLars Ellenberg * But in case it fails anyways, 131410f6d992SLars Ellenberg * we deal with it, and complain (below). */ 131510f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 131610f6d992SLars Ellenberg dev_err(DEV, 131710f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 131810f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 131910f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 132010f6d992SLars Ellenberg err = -ENOSPC; 132110f6d992SLars Ellenberg goto fail; 132210f6d992SLars Ellenberg } 132345bb912bSLars Ellenberg goto next_bio; 132445bb912bSLars Ellenberg } 132545bb912bSLars Ellenberg ds -= len; 132645bb912bSLars Ellenberg sector += len >> 9; 132745bb912bSLars Ellenberg --nr_pages; 132845bb912bSLars Ellenberg } 132945bb912bSLars Ellenberg D_ASSERT(page == NULL); 133045bb912bSLars Ellenberg D_ASSERT(ds == 0); 133145bb912bSLars Ellenberg 1332db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 133345bb912bSLars Ellenberg do { 133445bb912bSLars Ellenberg bio = bios; 133545bb912bSLars Ellenberg bios = bios->bi_next; 133645bb912bSLars Ellenberg bio->bi_next = NULL; 133745bb912bSLars Ellenberg 133845bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 133945bb912bSLars Ellenberg } while (bios); 134045bb912bSLars Ellenberg return 0; 134145bb912bSLars Ellenberg 134245bb912bSLars Ellenberg fail: 134345bb912bSLars Ellenberg while (bios) { 134445bb912bSLars Ellenberg bio = bios; 134545bb912bSLars Ellenberg bios = bios->bi_next; 134645bb912bSLars Ellenberg bio_put(bio); 134745bb912bSLars Ellenberg } 134810f6d992SLars Ellenberg return err; 134945bb912bSLars Ellenberg } 135045bb912bSLars Ellenberg 135153840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1352db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 135353840641SAndreas Gruenbacher { 1354db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 135553840641SAndreas Gruenbacher 135653840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 135753840641SAndreas Gruenbacher drbd_clear_interval(i); 135853840641SAndreas Gruenbacher 13596c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 136053840641SAndreas Gruenbacher if (i->waiting) 136153840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 136253840641SAndreas Gruenbacher } 136353840641SAndreas Gruenbacher 136477fede51SPhilipp Reisner void conn_wait_active_ee_empty(struct drbd_tconn *tconn) 136577fede51SPhilipp Reisner { 136677fede51SPhilipp Reisner struct drbd_conf *mdev; 136777fede51SPhilipp Reisner int vnr; 136877fede51SPhilipp Reisner 136977fede51SPhilipp Reisner rcu_read_lock(); 137077fede51SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 137177fede51SPhilipp Reisner kref_get(&mdev->kref); 137277fede51SPhilipp Reisner rcu_read_unlock(); 137377fede51SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 137477fede51SPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 137577fede51SPhilipp Reisner rcu_read_lock(); 137677fede51SPhilipp Reisner } 137777fede51SPhilipp Reisner rcu_read_unlock(); 137877fede51SPhilipp Reisner } 137977fede51SPhilipp Reisner 13804a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1381b411b363SPhilipp Reisner { 13822451fc3bSPhilipp Reisner int rv; 1383e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1384b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1385b411b363SPhilipp Reisner 13869ed57dcbSLars Ellenberg /* FIXME these are unacked on connection, 13879ed57dcbSLars Ellenberg * not a specific (peer)device. 13889ed57dcbSLars Ellenberg */ 138912038a3aSPhilipp Reisner tconn->current_epoch->barrier_nr = p->barrier; 13909ed57dcbSLars Ellenberg tconn->current_epoch->tconn = tconn; 13911e9dd291SPhilipp Reisner rv = drbd_may_finish_epoch(tconn, tconn->current_epoch, EV_GOT_BARRIER_NR); 1392b411b363SPhilipp Reisner 1393b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1394b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1395b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1396b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1397b411b363SPhilipp Reisner * completed. */ 13984b0007c0SPhilipp Reisner switch (tconn->write_ordering) { 1399b411b363SPhilipp Reisner case WO_none: 1400b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 140182bc0194SAndreas Gruenbacher return 0; 1402b411b363SPhilipp Reisner 1403b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1404b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1405b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14062451fc3bSPhilipp Reisner if (epoch) 14072451fc3bSPhilipp Reisner break; 14082451fc3bSPhilipp Reisner else 14099ed57dcbSLars Ellenberg conn_warn(tconn, "Allocation of an epoch failed, slowing down\n"); 14102451fc3bSPhilipp Reisner /* Fall through */ 14112451fc3bSPhilipp Reisner 14122451fc3bSPhilipp Reisner case WO_bdev_flush: 14132451fc3bSPhilipp Reisner case WO_drain_io: 141477fede51SPhilipp Reisner conn_wait_active_ee_empty(tconn); 14154b0007c0SPhilipp Reisner drbd_flush(tconn); 14162451fc3bSPhilipp Reisner 141712038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 14182451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 14192451fc3bSPhilipp Reisner if (epoch) 14202451fc3bSPhilipp Reisner break; 1421b411b363SPhilipp Reisner } 1422b411b363SPhilipp Reisner 142382bc0194SAndreas Gruenbacher return 0; 14242451fc3bSPhilipp Reisner default: 14259ed57dcbSLars Ellenberg conn_err(tconn, "Strangeness in tconn->write_ordering %d\n", tconn->write_ordering); 142682bc0194SAndreas Gruenbacher return -EIO; 1427b411b363SPhilipp Reisner } 1428b411b363SPhilipp Reisner 1429b411b363SPhilipp Reisner epoch->flags = 0; 1430b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1431b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1432b411b363SPhilipp Reisner 143312038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 143412038a3aSPhilipp Reisner if (atomic_read(&tconn->current_epoch->epoch_size)) { 143512038a3aSPhilipp Reisner list_add(&epoch->list, &tconn->current_epoch->list); 143612038a3aSPhilipp Reisner tconn->current_epoch = epoch; 143712038a3aSPhilipp Reisner tconn->epochs++; 1438b411b363SPhilipp Reisner } else { 1439b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1440b411b363SPhilipp Reisner kfree(epoch); 1441b411b363SPhilipp Reisner } 144212038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 1443b411b363SPhilipp Reisner 144482bc0194SAndreas Gruenbacher return 0; 1445b411b363SPhilipp Reisner } 1446b411b363SPhilipp Reisner 1447b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1448b411b363SPhilipp Reisner * and from receive_Data */ 1449f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1450f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1451f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1452b411b363SPhilipp Reisner { 14536666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1454db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1455b411b363SPhilipp Reisner struct page *page; 1456a5c31904SAndreas Gruenbacher int dgs, ds, err; 1457a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1458a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 14596b4388acSPhilipp Reisner unsigned long *data; 1460b411b363SPhilipp Reisner 146188104ca4SAndreas Gruenbacher dgs = 0; 146288104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 146388104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 14649f5bdc33SAndreas Gruenbacher /* 14659f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 14669f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 14679f5bdc33SAndreas Gruenbacher */ 1468a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1469a5c31904SAndreas Gruenbacher if (err) 1470b411b363SPhilipp Reisner return NULL; 1471b411b363SPhilipp Reisner data_size -= dgs; 147288104ca4SAndreas Gruenbacher } 1473b411b363SPhilipp Reisner 1474841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1475841ce241SAndreas Gruenbacher return NULL; 1476841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1477841ce241SAndreas Gruenbacher return NULL; 1478841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1479841ce241SAndreas Gruenbacher return NULL; 1480b411b363SPhilipp Reisner 14816666032aSLars Ellenberg /* even though we trust out peer, 14826666032aSLars Ellenberg * we sometimes have to double check. */ 14836666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1484fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1485fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 14866666032aSLars Ellenberg (unsigned long long)capacity, 14876666032aSLars Ellenberg (unsigned long long)sector, data_size); 14886666032aSLars Ellenberg return NULL; 14896666032aSLars Ellenberg } 14906666032aSLars Ellenberg 1491b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1492b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1493b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 14940db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1495db830c46SAndreas Gruenbacher if (!peer_req) 1496b411b363SPhilipp Reisner return NULL; 149745bb912bSLars Ellenberg 1498b411b363SPhilipp Reisner ds = data_size; 1499db830c46SAndreas Gruenbacher page = peer_req->pages; 150045bb912bSLars Ellenberg page_chain_for_each(page) { 150145bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 15026b4388acSPhilipp Reisner data = kmap(page); 1503a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 15040cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 15056b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 15066b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 15076b4388acSPhilipp Reisner } 1508b411b363SPhilipp Reisner kunmap(page); 1509a5c31904SAndreas Gruenbacher if (err) { 15103967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1511b411b363SPhilipp Reisner return NULL; 1512b411b363SPhilipp Reisner } 1513a5c31904SAndreas Gruenbacher ds -= len; 1514b411b363SPhilipp Reisner } 1515b411b363SPhilipp Reisner 1516b411b363SPhilipp Reisner if (dgs) { 15175b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1518b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1519470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1520470be44aSLars Ellenberg (unsigned long long)sector, data_size); 15213967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1522b411b363SPhilipp Reisner return NULL; 1523b411b363SPhilipp Reisner } 1524b411b363SPhilipp Reisner } 1525b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1526db830c46SAndreas Gruenbacher return peer_req; 1527b411b363SPhilipp Reisner } 1528b411b363SPhilipp Reisner 1529b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1530b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1531b411b363SPhilipp Reisner */ 1532b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1533b411b363SPhilipp Reisner { 1534b411b363SPhilipp Reisner struct page *page; 1535a5c31904SAndreas Gruenbacher int err = 0; 1536b411b363SPhilipp Reisner void *data; 1537b411b363SPhilipp Reisner 1538c3470cdeSLars Ellenberg if (!data_size) 1539fc5be839SAndreas Gruenbacher return 0; 1540c3470cdeSLars Ellenberg 1541c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1542b411b363SPhilipp Reisner 1543b411b363SPhilipp Reisner data = kmap(page); 1544b411b363SPhilipp Reisner while (data_size) { 1545fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1546fc5be839SAndreas Gruenbacher 1547a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1548a5c31904SAndreas Gruenbacher if (err) 1549b411b363SPhilipp Reisner break; 1550a5c31904SAndreas Gruenbacher data_size -= len; 1551b411b363SPhilipp Reisner } 1552b411b363SPhilipp Reisner kunmap(page); 15535cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1554fc5be839SAndreas Gruenbacher return err; 1555b411b363SPhilipp Reisner } 1556b411b363SPhilipp Reisner 1557b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1558b411b363SPhilipp Reisner sector_t sector, int data_size) 1559b411b363SPhilipp Reisner { 1560b411b363SPhilipp Reisner struct bio_vec *bvec; 1561b411b363SPhilipp Reisner struct bio *bio; 1562a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1563a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1564a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1565b411b363SPhilipp Reisner 156688104ca4SAndreas Gruenbacher dgs = 0; 156788104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 156888104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1569a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1570a5c31904SAndreas Gruenbacher if (err) 1571a5c31904SAndreas Gruenbacher return err; 1572b411b363SPhilipp Reisner data_size -= dgs; 157388104ca4SAndreas Gruenbacher } 1574b411b363SPhilipp Reisner 1575b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1576b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1577b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1578b411b363SPhilipp Reisner 1579b411b363SPhilipp Reisner bio = req->master_bio; 1580b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1581b411b363SPhilipp Reisner 1582b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1583a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1584b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1585a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1586b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1587a5c31904SAndreas Gruenbacher if (err) 1588a5c31904SAndreas Gruenbacher return err; 1589a5c31904SAndreas Gruenbacher data_size -= expect; 1590b411b363SPhilipp Reisner } 1591b411b363SPhilipp Reisner 1592b411b363SPhilipp Reisner if (dgs) { 15935b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1594b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1595b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 159628284cefSAndreas Gruenbacher return -EINVAL; 1597b411b363SPhilipp Reisner } 1598b411b363SPhilipp Reisner } 1599b411b363SPhilipp Reisner 1600b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 160128284cefSAndreas Gruenbacher return 0; 1602b411b363SPhilipp Reisner } 1603b411b363SPhilipp Reisner 1604a990be46SAndreas Gruenbacher /* 1605a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1606a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1607a990be46SAndreas Gruenbacher */ 160899920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1609b411b363SPhilipp Reisner { 16108050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16118050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 161200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1613db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 161499920dc5SAndreas Gruenbacher int err; 1615b411b363SPhilipp Reisner 1616db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1617b411b363SPhilipp Reisner 1618db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1619db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 162099920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1621b411b363SPhilipp Reisner } else { 1622b411b363SPhilipp Reisner /* Record failure to sync */ 1623db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1624b411b363SPhilipp Reisner 162599920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1626b411b363SPhilipp Reisner } 1627b411b363SPhilipp Reisner dec_unacked(mdev); 1628b411b363SPhilipp Reisner 162999920dc5SAndreas Gruenbacher return err; 1630b411b363SPhilipp Reisner } 1631b411b363SPhilipp Reisner 1632b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1633b411b363SPhilipp Reisner { 1634db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1635b411b363SPhilipp Reisner 1636db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1637db830c46SAndreas Gruenbacher if (!peer_req) 163845bb912bSLars Ellenberg goto fail; 1639b411b363SPhilipp Reisner 1640b411b363SPhilipp Reisner dec_rs_pending(mdev); 1641b411b363SPhilipp Reisner 1642b411b363SPhilipp Reisner inc_unacked(mdev); 1643b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1644b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1645b411b363SPhilipp Reisner 1646db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 164745bb912bSLars Ellenberg 164887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1649db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 165087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1651b411b363SPhilipp Reisner 16520f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1653fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1654e1c1b0fcSAndreas Gruenbacher return 0; 165545bb912bSLars Ellenberg 165610f6d992SLars Ellenberg /* don't care for the reason here */ 165710f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 165887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1659db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 166087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 166122cc37a9SLars Ellenberg 16623967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 166345bb912bSLars Ellenberg fail: 166445bb912bSLars Ellenberg put_ldev(mdev); 1665e1c1b0fcSAndreas Gruenbacher return -EIO; 1666b411b363SPhilipp Reisner } 1667b411b363SPhilipp Reisner 1668668eebc6SAndreas Gruenbacher static struct drbd_request * 1669bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1670bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1671668eebc6SAndreas Gruenbacher { 1672668eebc6SAndreas Gruenbacher struct drbd_request *req; 1673668eebc6SAndreas Gruenbacher 1674bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1675bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 16765e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1677668eebc6SAndreas Gruenbacher return req; 1678c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 16795af172edSAndreas Gruenbacher dev_err(DEV, "%s: failed to find request 0x%lx, sector %llus\n", func, 1680c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1681c3afd8f5SAndreas Gruenbacher } 1682668eebc6SAndreas Gruenbacher return NULL; 1683668eebc6SAndreas Gruenbacher } 1684668eebc6SAndreas Gruenbacher 16854a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1686b411b363SPhilipp Reisner { 16874a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1688b411b363SPhilipp Reisner struct drbd_request *req; 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 169987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1700bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 170187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1702c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 170382bc0194SAndreas Gruenbacher return -EIO; 1704b411b363SPhilipp Reisner 170524c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1706b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1707b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1708e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 170982bc0194SAndreas Gruenbacher if (!err) 17108554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1711b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1712b411b363SPhilipp Reisner * I don't think we may complete this just yet 1713b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1714b411b363SPhilipp Reisner 171582bc0194SAndreas Gruenbacher return err; 1716b411b363SPhilipp Reisner } 1717b411b363SPhilipp Reisner 17184a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1719b411b363SPhilipp Reisner { 17204a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1721b411b363SPhilipp Reisner sector_t sector; 172282bc0194SAndreas Gruenbacher int err; 1723e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 17244a76b161SAndreas Gruenbacher 17254a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 17264a76b161SAndreas Gruenbacher if (!mdev) 17274a76b161SAndreas Gruenbacher return -EIO; 1728b411b363SPhilipp Reisner 1729b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1730b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1731b411b363SPhilipp Reisner 1732b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1733b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1734b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1735fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1736e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1737b411b363SPhilipp Reisner } else { 1738b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1739b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1740b411b363SPhilipp Reisner 1741e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1742b411b363SPhilipp Reisner 1743e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1744b411b363SPhilipp Reisner } 1745b411b363SPhilipp Reisner 1746e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1747778f271dSPhilipp Reisner 174882bc0194SAndreas Gruenbacher return err; 1749b411b363SPhilipp Reisner } 1750b411b363SPhilipp Reisner 17517be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17527be8da07SAndreas Gruenbacher sector_t sector, int size) 17537be8da07SAndreas Gruenbacher { 17547be8da07SAndreas Gruenbacher struct drbd_interval *i; 17557be8da07SAndreas Gruenbacher struct drbd_request *req; 17567be8da07SAndreas Gruenbacher 17577be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17587be8da07SAndreas Gruenbacher if (!i->local) 17597be8da07SAndreas Gruenbacher continue; 17607be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 17617be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 17627be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 17637be8da07SAndreas Gruenbacher continue; 17642312f0b3SLars Ellenberg /* as it is RQ_POSTPONED, this will cause it to 17652312f0b3SLars Ellenberg * be queued on the retry workqueue. */ 17662312f0b3SLars Ellenberg __req_mod(req, DISCARD_WRITE, NULL); 17677be8da07SAndreas Gruenbacher } 17687be8da07SAndreas Gruenbacher } 17697be8da07SAndreas Gruenbacher 1770a990be46SAndreas Gruenbacher /* 1771a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1772b411b363SPhilipp Reisner */ 177399920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1774b411b363SPhilipp Reisner { 17758050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17768050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 177700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1778db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 177999920dc5SAndreas Gruenbacher int err = 0, pcmd; 1780b411b363SPhilipp Reisner 1781303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1782db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1783b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1784b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1785db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1786b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 178799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1788b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1789db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1790b411b363SPhilipp Reisner } else { 179199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1792b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1793b411b363SPhilipp Reisner * maybe assert this? */ 1794b411b363SPhilipp Reisner } 1795b411b363SPhilipp Reisner dec_unacked(mdev); 1796b411b363SPhilipp Reisner } 1797b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1798b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1799302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 180087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1801db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1802db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 18037be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 18047be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 180587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1806bb3bfe96SAndreas Gruenbacher } else 1807db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1808b411b363SPhilipp Reisner 18091e9dd291SPhilipp Reisner drbd_may_finish_epoch(mdev->tconn, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1810b411b363SPhilipp Reisner 181199920dc5SAndreas Gruenbacher return err; 1812b411b363SPhilipp Reisner } 1813b411b363SPhilipp Reisner 18147be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1815b411b363SPhilipp Reisner { 18167be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 18178050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 18188050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 181999920dc5SAndreas Gruenbacher int err; 1820b411b363SPhilipp Reisner 182199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1822b411b363SPhilipp Reisner dec_unacked(mdev); 1823b411b363SPhilipp Reisner 182499920dc5SAndreas Gruenbacher return err; 1825b411b363SPhilipp Reisner } 1826b411b363SPhilipp Reisner 182799920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 18287be8da07SAndreas Gruenbacher { 18297be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 18307be8da07SAndreas Gruenbacher } 18317be8da07SAndreas Gruenbacher 183299920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 18337be8da07SAndreas Gruenbacher { 18347be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 18357be8da07SAndreas Gruenbacher 18367be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 18377be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 18387be8da07SAndreas Gruenbacher } 18397be8da07SAndreas Gruenbacher 18403e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 18413e394da1SAndreas Gruenbacher { 18423e394da1SAndreas Gruenbacher /* 18433e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18443e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18453e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18463e394da1SAndreas Gruenbacher */ 18473e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18483e394da1SAndreas Gruenbacher } 18493e394da1SAndreas Gruenbacher 18503e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18513e394da1SAndreas Gruenbacher { 18523e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18533e394da1SAndreas Gruenbacher } 18543e394da1SAndreas Gruenbacher 18557be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 18567be8da07SAndreas Gruenbacher { 18577be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 1858302bdeaeSPhilipp Reisner int tp; 18597be8da07SAndreas Gruenbacher 18607be8da07SAndreas Gruenbacher /* 18617be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 18627be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 18637be8da07SAndreas Gruenbacher * handle_write_conflicts(). 18647be8da07SAndreas Gruenbacher */ 1865302bdeaeSPhilipp Reisner 1866302bdeaeSPhilipp Reisner rcu_read_lock(); 1867302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1868302bdeaeSPhilipp Reisner rcu_read_unlock(); 1869302bdeaeSPhilipp Reisner 1870302bdeaeSPhilipp Reisner return tp && test_bit(DISCARD_CONCURRENT, &tconn->flags); 18717be8da07SAndreas Gruenbacher } 18727be8da07SAndreas Gruenbacher 187343ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 18743e394da1SAndreas Gruenbacher { 18753c13b680SLars Ellenberg unsigned int newest_peer_seq; 18763e394da1SAndreas Gruenbacher 18777be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 18783e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 18793c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 18803c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 18813e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 18823c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 18833c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 18843e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 18853e394da1SAndreas Gruenbacher } 18867be8da07SAndreas Gruenbacher } 18873e394da1SAndreas Gruenbacher 1888d93f6302SLars Ellenberg static inline int overlaps(sector_t s1, int l1, sector_t s2, int l2) 1889d93f6302SLars Ellenberg { 1890d93f6302SLars Ellenberg return !((s1 + (l1>>9) <= s2) || (s1 >= s2 + (l2>>9))); 1891d93f6302SLars Ellenberg } 1892d93f6302SLars Ellenberg 1893d93f6302SLars Ellenberg /* maybe change sync_ee into interval trees as well? */ 18943ea35df8SPhilipp Reisner static bool overlapping_resync_write(struct drbd_conf *mdev, struct drbd_peer_request *peer_req) 1895d93f6302SLars Ellenberg { 1896d93f6302SLars Ellenberg struct drbd_peer_request *rs_req; 1897d93f6302SLars Ellenberg bool rv = 0; 1898d93f6302SLars Ellenberg 1899d93f6302SLars Ellenberg spin_lock_irq(&mdev->tconn->req_lock); 1900d93f6302SLars Ellenberg list_for_each_entry(rs_req, &mdev->sync_ee, w.list) { 1901d93f6302SLars Ellenberg if (overlaps(peer_req->i.sector, peer_req->i.size, 1902d93f6302SLars Ellenberg rs_req->i.sector, rs_req->i.size)) { 1903d93f6302SLars Ellenberg rv = 1; 1904d93f6302SLars Ellenberg break; 1905d93f6302SLars Ellenberg } 1906d93f6302SLars Ellenberg } 1907d93f6302SLars Ellenberg spin_unlock_irq(&mdev->tconn->req_lock); 1908d93f6302SLars Ellenberg 1909d93f6302SLars Ellenberg return rv; 1910d93f6302SLars Ellenberg } 1911d93f6302SLars Ellenberg 1912b411b363SPhilipp Reisner /* Called from receive_Data. 1913b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1914b411b363SPhilipp Reisner * 1915b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1916b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1917b411b363SPhilipp Reisner * been sent. 1918b411b363SPhilipp Reisner * 1919b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1920b411b363SPhilipp Reisner * 1921b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1922b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1923b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1924b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1925b411b363SPhilipp Reisner * 1926b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1927b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1928b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1929b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1930b411b363SPhilipp Reisner * 1931b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1932b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 19337be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1934b411b363SPhilipp Reisner { 1935b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1936b411b363SPhilipp Reisner long timeout; 19377be8da07SAndreas Gruenbacher int ret; 19387be8da07SAndreas Gruenbacher 19397be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 19407be8da07SAndreas Gruenbacher return 0; 19417be8da07SAndreas Gruenbacher 1942b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1943b411b363SPhilipp Reisner for (;;) { 19447be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 19457be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 19467be8da07SAndreas Gruenbacher ret = 0; 1947b411b363SPhilipp Reisner break; 19487be8da07SAndreas Gruenbacher } 1949b411b363SPhilipp Reisner if (signal_pending(current)) { 1950b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1951b411b363SPhilipp Reisner break; 1952b411b363SPhilipp Reisner } 19537be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1954b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 195544ed167dSPhilipp Reisner rcu_read_lock(); 195644ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 195744ed167dSPhilipp Reisner rcu_read_unlock(); 195871b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1959b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 19607be8da07SAndreas Gruenbacher if (!timeout) { 1961b411b363SPhilipp Reisner ret = -ETIMEDOUT; 196271b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1963b411b363SPhilipp Reisner break; 1964b411b363SPhilipp Reisner } 1965b411b363SPhilipp Reisner } 1966b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 19677be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1968b411b363SPhilipp Reisner return ret; 1969b411b363SPhilipp Reisner } 1970b411b363SPhilipp Reisner 1971688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1972688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1973688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1974688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 197576d2e7ecSPhilipp Reisner { 197676d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 197776d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1978688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 197976d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 198076d2e7ecSPhilipp Reisner } 198176d2e7ecSPhilipp Reisner 19827be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 19837be8da07SAndreas Gruenbacher unsigned int size) 19847be8da07SAndreas Gruenbacher { 19857be8da07SAndreas Gruenbacher struct drbd_interval *i; 19867be8da07SAndreas Gruenbacher 19877be8da07SAndreas Gruenbacher repeat: 19887be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19897be8da07SAndreas Gruenbacher struct drbd_request *req; 19907be8da07SAndreas Gruenbacher struct bio_and_error m; 19917be8da07SAndreas Gruenbacher 19927be8da07SAndreas Gruenbacher if (!i->local) 19937be8da07SAndreas Gruenbacher continue; 19947be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 19957be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 19967be8da07SAndreas Gruenbacher continue; 19977be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 19987be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 19997be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 20007be8da07SAndreas Gruenbacher if (m.bio) 20017be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 20027be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 20037be8da07SAndreas Gruenbacher goto repeat; 20047be8da07SAndreas Gruenbacher } 20057be8da07SAndreas Gruenbacher } 20067be8da07SAndreas Gruenbacher 20077be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 20087be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 20097be8da07SAndreas Gruenbacher { 20107be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 20117be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 20127be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 20137be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 20147be8da07SAndreas Gruenbacher struct drbd_interval *i; 20157be8da07SAndreas Gruenbacher bool equal; 20167be8da07SAndreas Gruenbacher int err; 20177be8da07SAndreas Gruenbacher 20187be8da07SAndreas Gruenbacher /* 20197be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 20207be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 20217be8da07SAndreas Gruenbacher */ 20227be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 20237be8da07SAndreas Gruenbacher 20247be8da07SAndreas Gruenbacher repeat: 20257be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 20267be8da07SAndreas Gruenbacher if (i == &peer_req->i) 20277be8da07SAndreas Gruenbacher continue; 20287be8da07SAndreas Gruenbacher 20297be8da07SAndreas Gruenbacher if (!i->local) { 20307be8da07SAndreas Gruenbacher /* 20317be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 20327be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 20337be8da07SAndreas Gruenbacher * earlier peer request to complete. 20347be8da07SAndreas Gruenbacher */ 20357be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 20367be8da07SAndreas Gruenbacher if (err) 20377be8da07SAndreas Gruenbacher goto out; 20387be8da07SAndreas Gruenbacher goto repeat; 20397be8da07SAndreas Gruenbacher } 20407be8da07SAndreas Gruenbacher 20417be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 20427be8da07SAndreas Gruenbacher if (resolve_conflicts) { 20437be8da07SAndreas Gruenbacher /* 20447be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 20457be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 20467be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 20477be8da07SAndreas Gruenbacher * have completed. 20487be8da07SAndreas Gruenbacher */ 20497be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 20507be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 20517be8da07SAndreas Gruenbacher 20527be8da07SAndreas Gruenbacher if (!equal) 20537be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20547be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 20557be8da07SAndreas Gruenbacher "assuming %s came first\n", 20567be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20577be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 20587be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 20597be8da07SAndreas Gruenbacher 20607be8da07SAndreas Gruenbacher inc_unacked(mdev); 20617be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 20627be8da07SAndreas Gruenbacher e_send_retry_write; 20637be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 20647be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 20657be8da07SAndreas Gruenbacher 20667be8da07SAndreas Gruenbacher err = -ENOENT; 20677be8da07SAndreas Gruenbacher goto out; 20687be8da07SAndreas Gruenbacher } else { 20697be8da07SAndreas Gruenbacher struct drbd_request *req = 20707be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 20717be8da07SAndreas Gruenbacher 20727be8da07SAndreas Gruenbacher if (!equal) 20737be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20747be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 20757be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20767be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 20777be8da07SAndreas Gruenbacher 20787be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 20797be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 20807be8da07SAndreas Gruenbacher /* 20817be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 20827be8da07SAndreas Gruenbacher * decide if this request will be discarded or 20837be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 20847be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 20857be8da07SAndreas Gruenbacher * 20867be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 20877be8da07SAndreas Gruenbacher * request to finish locally before submitting 20887be8da07SAndreas Gruenbacher * the conflicting peer request. 20897be8da07SAndreas Gruenbacher */ 20907be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 20917be8da07SAndreas Gruenbacher if (err) { 20927be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 20937be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 20947be8da07SAndreas Gruenbacher CS_HARD); 20957be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 20967be8da07SAndreas Gruenbacher goto out; 20977be8da07SAndreas Gruenbacher } 20987be8da07SAndreas Gruenbacher goto repeat; 20997be8da07SAndreas Gruenbacher } 21007be8da07SAndreas Gruenbacher /* 21017be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 21027be8da07SAndreas Gruenbacher * the new peer request has completed. 21037be8da07SAndreas Gruenbacher */ 21047be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 21057be8da07SAndreas Gruenbacher } 21067be8da07SAndreas Gruenbacher } 21077be8da07SAndreas Gruenbacher err = 0; 21087be8da07SAndreas Gruenbacher 21097be8da07SAndreas Gruenbacher out: 21107be8da07SAndreas Gruenbacher if (err) 21117be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 21127be8da07SAndreas Gruenbacher return err; 21137be8da07SAndreas Gruenbacher } 21147be8da07SAndreas Gruenbacher 2115b411b363SPhilipp Reisner /* mirrored write */ 21164a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2117b411b363SPhilipp Reisner { 21184a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2119b411b363SPhilipp Reisner sector_t sector; 2120db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2121e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 21227be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2123b411b363SPhilipp Reisner int rw = WRITE; 2124b411b363SPhilipp Reisner u32 dp_flags; 2125302bdeaeSPhilipp Reisner int err, tp; 21267be8da07SAndreas Gruenbacher 21274a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 21284a76b161SAndreas Gruenbacher if (!mdev) 21294a76b161SAndreas Gruenbacher return -EIO; 21304a76b161SAndreas Gruenbacher 2131b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 213282bc0194SAndreas Gruenbacher int err2; 213382bc0194SAndreas Gruenbacher 21347be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2135e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 213612038a3aSPhilipp Reisner atomic_inc(&tconn->current_epoch->epoch_size); 2137e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 213882bc0194SAndreas Gruenbacher if (!err) 213982bc0194SAndreas Gruenbacher err = err2; 214082bc0194SAndreas Gruenbacher return err; 2141b411b363SPhilipp Reisner } 2142b411b363SPhilipp Reisner 2143fcefa62eSAndreas Gruenbacher /* 2144fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2145fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2146fcefa62eSAndreas Gruenbacher * end of this function. 2147fcefa62eSAndreas Gruenbacher */ 2148b411b363SPhilipp Reisner 2149b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2150e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2151db830c46SAndreas Gruenbacher if (!peer_req) { 2152b411b363SPhilipp Reisner put_ldev(mdev); 215382bc0194SAndreas Gruenbacher return -EIO; 2154b411b363SPhilipp Reisner } 2155b411b363SPhilipp Reisner 2156db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2157b411b363SPhilipp Reisner 2158688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2159688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2160688593c5SLars Ellenberg 2161688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2162db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2163688593c5SLars Ellenberg 216412038a3aSPhilipp Reisner spin_lock(&tconn->epoch_lock); 216512038a3aSPhilipp Reisner peer_req->epoch = tconn->current_epoch; 2166db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2167db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 216812038a3aSPhilipp Reisner spin_unlock(&tconn->epoch_lock); 2169b411b363SPhilipp Reisner 2170302bdeaeSPhilipp Reisner rcu_read_lock(); 2171302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2172302bdeaeSPhilipp Reisner rcu_read_unlock(); 2173302bdeaeSPhilipp Reisner if (tp) { 2174302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 21757be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 21767be8da07SAndreas Gruenbacher if (err) 2177b411b363SPhilipp Reisner goto out_interrupted; 217887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 21797be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 21807be8da07SAndreas Gruenbacher if (err) { 218187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 21827be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2183b411b363SPhilipp Reisner put_ldev(mdev); 218482bc0194SAndreas Gruenbacher return 0; 2185b411b363SPhilipp Reisner } 2186b411b363SPhilipp Reisner goto out_interrupted; 2187b411b363SPhilipp Reisner } 21887be8da07SAndreas Gruenbacher } else 218987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2190db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 219187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2192b411b363SPhilipp Reisner 2193d93f6302SLars Ellenberg if (mdev->state.conn == C_SYNC_TARGET) 21943ea35df8SPhilipp Reisner wait_event(mdev->ee_wait, !overlapping_resync_write(mdev, peer_req)); 2195d93f6302SLars Ellenberg 2196303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 219744ed167dSPhilipp Reisner rcu_read_lock(); 219844ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2199b411b363SPhilipp Reisner case DRBD_PROT_C: 2200303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2201303d1448SPhilipp Reisner break; 2202303d1448SPhilipp Reisner case DRBD_PROT_B: 2203303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2204303d1448SPhilipp Reisner break; 2205303d1448SPhilipp Reisner } 220644ed167dSPhilipp Reisner rcu_read_unlock(); 2207303d1448SPhilipp Reisner } 2208303d1448SPhilipp Reisner 2209303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2210303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2211b411b363SPhilipp Reisner inc_unacked(mdev); 2212b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2213b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2214303d1448SPhilipp Reisner } 2215303d1448SPhilipp Reisner 2216303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2217b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2218b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2219db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2220b411b363SPhilipp Reisner } 2221b411b363SPhilipp Reisner 22226719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2223b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2224db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2225db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2226db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2227181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2228b411b363SPhilipp Reisner } 2229b411b363SPhilipp Reisner 223082bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 223182bc0194SAndreas Gruenbacher if (!err) 223282bc0194SAndreas Gruenbacher return 0; 2233b411b363SPhilipp Reisner 223410f6d992SLars Ellenberg /* don't care for the reason here */ 223510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 223687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2237db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2238db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 223987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2240db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2241181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 224222cc37a9SLars Ellenberg 2243b411b363SPhilipp Reisner out_interrupted: 22441e9dd291SPhilipp Reisner drbd_may_finish_epoch(tconn, peer_req->epoch, EV_PUT + EV_CLEANUP); 2245b411b363SPhilipp Reisner put_ldev(mdev); 22463967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 224782bc0194SAndreas Gruenbacher return err; 2248b411b363SPhilipp Reisner } 2249b411b363SPhilipp Reisner 22500f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 22510f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 22520f0601f4SLars Ellenberg * 22530f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 22540f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 22550f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 22560f0601f4SLars Ellenberg * activity, it obviously is "busy". 22570f0601f4SLars Ellenberg * 22580f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 22590f0601f4SLars Ellenberg * to have a short time average so we can react faster. 22600f0601f4SLars Ellenberg */ 2261e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 22620f0601f4SLars Ellenberg { 22630f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 22640f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2265e3555d85SPhilipp Reisner struct lc_element *tmp; 22660f0601f4SLars Ellenberg int curr_events; 22670f0601f4SLars Ellenberg int throttle = 0; 2268daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2269daeda1ccSPhilipp Reisner 2270daeda1ccSPhilipp Reisner rcu_read_lock(); 2271daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2272daeda1ccSPhilipp Reisner rcu_read_unlock(); 22730f0601f4SLars Ellenberg 22740f0601f4SLars Ellenberg /* feature disabled? */ 2275daeda1ccSPhilipp Reisner if (c_min_rate == 0) 22760f0601f4SLars Ellenberg return 0; 22770f0601f4SLars Ellenberg 2278e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2279e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2280e3555d85SPhilipp Reisner if (tmp) { 2281e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2282e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2283e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2284e3555d85SPhilipp Reisner return 0; 2285e3555d85SPhilipp Reisner } 2286e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2287e3555d85SPhilipp Reisner } 2288e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2289e3555d85SPhilipp Reisner 22900f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 22910f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 22920f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2293e3555d85SPhilipp Reisner 22940f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 22950f0601f4SLars Ellenberg unsigned long rs_left; 22960f0601f4SLars Ellenberg int i; 22970f0601f4SLars Ellenberg 22980f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 22990f0601f4SLars Ellenberg 23000f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 23010f0601f4SLars Ellenberg * approx. */ 23022649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 23032649f080SLars Ellenberg 23042649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 23052649f080SLars Ellenberg rs_left = mdev->ov_left; 23062649f080SLars Ellenberg else 23070f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 23080f0601f4SLars Ellenberg 23090f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 23100f0601f4SLars Ellenberg if (!dt) 23110f0601f4SLars Ellenberg dt++; 23120f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 23130f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 23140f0601f4SLars Ellenberg 2315daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 23160f0601f4SLars Ellenberg throttle = 1; 23170f0601f4SLars Ellenberg } 23180f0601f4SLars Ellenberg return throttle; 23190f0601f4SLars Ellenberg } 23200f0601f4SLars Ellenberg 23210f0601f4SLars Ellenberg 23224a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2323b411b363SPhilipp Reisner { 23244a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2325b411b363SPhilipp Reisner sector_t sector; 23264a76b161SAndreas Gruenbacher sector_t capacity; 2327db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2328b411b363SPhilipp Reisner struct digest_info *di = NULL; 2329b18b37beSPhilipp Reisner int size, verb; 2330b411b363SPhilipp Reisner unsigned int fault_type; 2331e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 23324a76b161SAndreas Gruenbacher 23334a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 23344a76b161SAndreas Gruenbacher if (!mdev) 23354a76b161SAndreas Gruenbacher return -EIO; 23364a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2337b411b363SPhilipp Reisner 2338b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2339b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2340b411b363SPhilipp Reisner 2341c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2342b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2343b411b363SPhilipp Reisner (unsigned long long)sector, size); 234482bc0194SAndreas Gruenbacher return -EINVAL; 2345b411b363SPhilipp Reisner } 2346b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2347b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2348b411b363SPhilipp Reisner (unsigned long long)sector, size); 234982bc0194SAndreas Gruenbacher return -EINVAL; 2350b411b363SPhilipp Reisner } 2351b411b363SPhilipp Reisner 2352b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2353b18b37beSPhilipp Reisner verb = 1; 2354e2857216SAndreas Gruenbacher switch (pi->cmd) { 2355b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2356b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2357b18b37beSPhilipp Reisner break; 2358b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2359b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2360b18b37beSPhilipp Reisner case P_OV_REQUEST: 2361b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2362b18b37beSPhilipp Reisner break; 2363b18b37beSPhilipp Reisner case P_OV_REPLY: 2364b18b37beSPhilipp Reisner verb = 0; 2365b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2366b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2367b18b37beSPhilipp Reisner break; 2368b18b37beSPhilipp Reisner default: 236949ba9b1bSAndreas Gruenbacher BUG(); 2370b18b37beSPhilipp Reisner } 2371b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2372b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2373b411b363SPhilipp Reisner "no local data.\n"); 2374b18b37beSPhilipp Reisner 2375a821cc4aSLars Ellenberg /* drain possibly payload */ 2376e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2377b411b363SPhilipp Reisner } 2378b411b363SPhilipp Reisner 2379b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2380b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2381b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 23820db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2383db830c46SAndreas Gruenbacher if (!peer_req) { 2384b411b363SPhilipp Reisner put_ldev(mdev); 238582bc0194SAndreas Gruenbacher return -ENOMEM; 2386b411b363SPhilipp Reisner } 2387b411b363SPhilipp Reisner 2388e2857216SAndreas Gruenbacher switch (pi->cmd) { 2389b411b363SPhilipp Reisner case P_DATA_REQUEST: 2390db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2391b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 239280a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 239380a40e43SLars Ellenberg goto submit; 239480a40e43SLars Ellenberg 2395b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2396db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2397b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 23985f9915bbSLars Ellenberg /* used in the sector offset progress display */ 23995f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2400b411b363SPhilipp Reisner break; 2401b411b363SPhilipp Reisner 2402b411b363SPhilipp Reisner case P_OV_REPLY: 2403b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2404b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2405e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2406b411b363SPhilipp Reisner if (!di) 2407b411b363SPhilipp Reisner goto out_free_e; 2408b411b363SPhilipp Reisner 2409e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2410b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2411b411b363SPhilipp Reisner 2412db830c46SAndreas Gruenbacher peer_req->digest = di; 2413db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2414c36c3cedSLars Ellenberg 2415e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2416b411b363SPhilipp Reisner goto out_free_e; 2417b411b363SPhilipp Reisner 2418e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 241931890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2420db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 24215f9915bbSLars Ellenberg /* used in the sector offset progress display */ 24225f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2423e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 24242649f080SLars Ellenberg /* track progress, we may need to throttle */ 24252649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2426db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2427b411b363SPhilipp Reisner dec_rs_pending(mdev); 24280f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 24290f0601f4SLars Ellenberg * but accounting still needs to be done. */ 24300f0601f4SLars Ellenberg goto submit_for_resync; 2431b411b363SPhilipp Reisner } 2432b411b363SPhilipp Reisner break; 2433b411b363SPhilipp Reisner 2434b411b363SPhilipp Reisner case P_OV_REQUEST: 2435b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 243631890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2437de228bbaSLars Ellenberg unsigned long now = jiffies; 2438de228bbaSLars Ellenberg int i; 2439b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2440b411b363SPhilipp Reisner mdev->ov_position = sector; 244130b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 244230b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2443de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2444de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2445de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2446de228bbaSLars Ellenberg } 2447b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2448b411b363SPhilipp Reisner (unsigned long long)sector); 2449b411b363SPhilipp Reisner } 2450db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2451b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2452b411b363SPhilipp Reisner break; 2453b411b363SPhilipp Reisner 2454b411b363SPhilipp Reisner default: 245549ba9b1bSAndreas Gruenbacher BUG(); 2456b411b363SPhilipp Reisner } 2457b411b363SPhilipp Reisner 24580f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 24590f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 24600f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 24610f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 24620f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 24630f0601f4SLars Ellenberg * 24640f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 24650f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 24660f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 24670f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 24680f0601f4SLars Ellenberg * a while, anyways. 24690f0601f4SLars Ellenberg */ 2470b411b363SPhilipp Reisner 24710f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 24720f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 24730f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 24740f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 24750f0601f4SLars Ellenberg * 24760f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 24770f0601f4SLars Ellenberg * we would also throttle its application reads. 24780f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 24790f0601f4SLars Ellenberg */ 2480e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2481e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2482e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 248380a40e43SLars Ellenberg goto out_free_e; 2484b411b363SPhilipp Reisner 24850f0601f4SLars Ellenberg submit_for_resync: 24860f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 24870f0601f4SLars Ellenberg 248880a40e43SLars Ellenberg submit: 2489b411b363SPhilipp Reisner inc_unacked(mdev); 249087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2491db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 249287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2493b411b363SPhilipp Reisner 2494fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 249582bc0194SAndreas Gruenbacher return 0; 2496b411b363SPhilipp Reisner 249710f6d992SLars Ellenberg /* don't care for the reason here */ 249810f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 249987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2500db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 250187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 250222cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 250322cc37a9SLars Ellenberg 2504b411b363SPhilipp Reisner out_free_e: 2505b411b363SPhilipp Reisner put_ldev(mdev); 25063967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 250782bc0194SAndreas Gruenbacher return -EIO; 2508b411b363SPhilipp Reisner } 2509b411b363SPhilipp Reisner 2510b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2511b411b363SPhilipp Reisner { 2512b411b363SPhilipp Reisner int self, peer, rv = -100; 2513b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 251444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2515b411b363SPhilipp Reisner 2516b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2517b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2518b411b363SPhilipp Reisner 2519b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2520b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2521b411b363SPhilipp Reisner 252244ed167dSPhilipp Reisner rcu_read_lock(); 252344ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 252444ed167dSPhilipp Reisner rcu_read_unlock(); 252544ed167dSPhilipp Reisner switch (after_sb_0p) { 2526b411b363SPhilipp Reisner case ASB_CONSENSUS: 2527b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2528b411b363SPhilipp Reisner case ASB_CALL_HELPER: 252944ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2530b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2531b411b363SPhilipp Reisner break; 2532b411b363SPhilipp Reisner case ASB_DISCONNECT: 2533b411b363SPhilipp Reisner break; 2534b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2535b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2536b411b363SPhilipp Reisner rv = -1; 2537b411b363SPhilipp Reisner break; 2538b411b363SPhilipp Reisner } 2539b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2540b411b363SPhilipp Reisner rv = 1; 2541b411b363SPhilipp Reisner break; 2542b411b363SPhilipp Reisner } 2543b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2544b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2545b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2546b411b363SPhilipp Reisner rv = 1; 2547b411b363SPhilipp Reisner break; 2548b411b363SPhilipp Reisner } 2549b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2550b411b363SPhilipp Reisner rv = -1; 2551b411b363SPhilipp Reisner break; 2552b411b363SPhilipp Reisner } 2553b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2554ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2555b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2556b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2557b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 255825703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2559b411b363SPhilipp Reisner ? -1 : 1; 2560b411b363SPhilipp Reisner break; 2561b411b363SPhilipp Reisner } else { 2562b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2563b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2564b411b363SPhilipp Reisner } 256544ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2566b411b363SPhilipp Reisner break; 2567b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2568b411b363SPhilipp Reisner if (ch_self < ch_peer) 2569b411b363SPhilipp Reisner rv = -1; 2570b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2571b411b363SPhilipp Reisner rv = 1; 2572b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2573b411b363SPhilipp Reisner /* Well, then use something else. */ 257425703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2575b411b363SPhilipp Reisner ? -1 : 1; 2576b411b363SPhilipp Reisner break; 2577b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2578b411b363SPhilipp Reisner rv = -1; 2579b411b363SPhilipp Reisner break; 2580b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2581b411b363SPhilipp Reisner rv = 1; 2582b411b363SPhilipp Reisner } 2583b411b363SPhilipp Reisner 2584b411b363SPhilipp Reisner return rv; 2585b411b363SPhilipp Reisner } 2586b411b363SPhilipp Reisner 2587b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2588b411b363SPhilipp Reisner { 25896184ea21SAndreas Gruenbacher int hg, rv = -100; 259044ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2591b411b363SPhilipp Reisner 259244ed167dSPhilipp Reisner rcu_read_lock(); 259344ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 259444ed167dSPhilipp Reisner rcu_read_unlock(); 259544ed167dSPhilipp Reisner switch (after_sb_1p) { 2596b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2597b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2598b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2599b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2600b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 260144ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2602b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2603b411b363SPhilipp Reisner break; 2604b411b363SPhilipp Reisner case ASB_DISCONNECT: 2605b411b363SPhilipp Reisner break; 2606b411b363SPhilipp Reisner case ASB_CONSENSUS: 2607b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2608b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2609b411b363SPhilipp Reisner rv = hg; 2610b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2611b411b363SPhilipp Reisner rv = hg; 2612b411b363SPhilipp Reisner break; 2613b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2614b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2615b411b363SPhilipp Reisner break; 2616b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2617b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2618b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2619b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2620b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2621bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2622bb437946SAndreas Gruenbacher 2623bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2624b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2625b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2626b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2627bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2628bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2629b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2630b411b363SPhilipp Reisner } else { 2631b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2632b411b363SPhilipp Reisner rv = hg; 2633b411b363SPhilipp Reisner } 2634b411b363SPhilipp Reisner } else 2635b411b363SPhilipp Reisner rv = hg; 2636b411b363SPhilipp Reisner } 2637b411b363SPhilipp Reisner 2638b411b363SPhilipp Reisner return rv; 2639b411b363SPhilipp Reisner } 2640b411b363SPhilipp Reisner 2641b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2642b411b363SPhilipp Reisner { 26436184ea21SAndreas Gruenbacher int hg, rv = -100; 264444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2645b411b363SPhilipp Reisner 264644ed167dSPhilipp Reisner rcu_read_lock(); 264744ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 264844ed167dSPhilipp Reisner rcu_read_unlock(); 264944ed167dSPhilipp Reisner switch (after_sb_2p) { 2650b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2651b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2652b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2653b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2654b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2655b411b363SPhilipp Reisner case ASB_CONSENSUS: 2656b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 265744ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2658b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2659b411b363SPhilipp Reisner break; 2660b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2661b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2662b411b363SPhilipp Reisner break; 2663b411b363SPhilipp Reisner case ASB_DISCONNECT: 2664b411b363SPhilipp Reisner break; 2665b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2666b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2667b411b363SPhilipp Reisner if (hg == -1) { 2668bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2669bb437946SAndreas Gruenbacher 2670b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2671b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2672b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2673bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2674bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2675b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2676b411b363SPhilipp Reisner } else { 2677b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2678b411b363SPhilipp Reisner rv = hg; 2679b411b363SPhilipp Reisner } 2680b411b363SPhilipp Reisner } else 2681b411b363SPhilipp Reisner rv = hg; 2682b411b363SPhilipp Reisner } 2683b411b363SPhilipp Reisner 2684b411b363SPhilipp Reisner return rv; 2685b411b363SPhilipp Reisner } 2686b411b363SPhilipp Reisner 2687b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2688b411b363SPhilipp Reisner u64 bits, u64 flags) 2689b411b363SPhilipp Reisner { 2690b411b363SPhilipp Reisner if (!uuid) { 2691b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2692b411b363SPhilipp Reisner return; 2693b411b363SPhilipp Reisner } 2694b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2695b411b363SPhilipp Reisner text, 2696b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2697b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2698b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2699b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2700b411b363SPhilipp Reisner (unsigned long long)bits, 2701b411b363SPhilipp Reisner (unsigned long long)flags); 2702b411b363SPhilipp Reisner } 2703b411b363SPhilipp Reisner 2704b411b363SPhilipp Reisner /* 2705b411b363SPhilipp Reisner 100 after split brain try auto recover 2706b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2707b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2708b411b363SPhilipp Reisner 0 no Sync 2709b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2710b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2711b411b363SPhilipp Reisner -100 after split brain, disconnect 2712b411b363SPhilipp Reisner -1000 unrelated data 27134a23f264SPhilipp Reisner -1091 requires proto 91 27144a23f264SPhilipp Reisner -1096 requires proto 96 2715b411b363SPhilipp Reisner */ 2716b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2717b411b363SPhilipp Reisner { 2718b411b363SPhilipp Reisner u64 self, peer; 2719b411b363SPhilipp Reisner int i, j; 2720b411b363SPhilipp Reisner 2721b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2722b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2723b411b363SPhilipp Reisner 2724b411b363SPhilipp Reisner *rule_nr = 10; 2725b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2726b411b363SPhilipp Reisner return 0; 2727b411b363SPhilipp Reisner 2728b411b363SPhilipp Reisner *rule_nr = 20; 2729b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2730b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2731b411b363SPhilipp Reisner return -2; 2732b411b363SPhilipp Reisner 2733b411b363SPhilipp Reisner *rule_nr = 30; 2734b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2735b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2736b411b363SPhilipp Reisner return 2; 2737b411b363SPhilipp Reisner 2738b411b363SPhilipp Reisner if (self == peer) { 2739b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2740b411b363SPhilipp Reisner 2741b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2742b411b363SPhilipp Reisner 274331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27444a23f264SPhilipp Reisner return -1091; 2745b411b363SPhilipp Reisner 2746b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2747b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2748b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2749b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2750b411b363SPhilipp Reisner 2751b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2752b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2753b411b363SPhilipp Reisner *rule_nr = 34; 2754b411b363SPhilipp Reisner } else { 2755b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2756b411b363SPhilipp Reisner *rule_nr = 36; 2757b411b363SPhilipp Reisner } 2758b411b363SPhilipp Reisner 2759b411b363SPhilipp Reisner return 1; 2760b411b363SPhilipp Reisner } 2761b411b363SPhilipp Reisner 2762b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2763b411b363SPhilipp Reisner 276431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27654a23f264SPhilipp Reisner return -1091; 2766b411b363SPhilipp Reisner 2767b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2768b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2769b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2770b411b363SPhilipp Reisner 2771b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2772b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2773b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2776b411b363SPhilipp Reisner *rule_nr = 35; 2777b411b363SPhilipp Reisner } else { 2778b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2779b411b363SPhilipp Reisner *rule_nr = 37; 2780b411b363SPhilipp Reisner } 2781b411b363SPhilipp Reisner 2782b411b363SPhilipp Reisner return -1; 2783b411b363SPhilipp Reisner } 2784b411b363SPhilipp Reisner 2785b411b363SPhilipp Reisner /* Common power [off|failure] */ 2786b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2787b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2788b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2789b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2790b411b363SPhilipp Reisner *rule_nr = 40; 2791b411b363SPhilipp Reisner 2792b411b363SPhilipp Reisner switch (rct) { 2793b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2794b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2795b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2796b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 279725703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2798b411b363SPhilipp Reisner return dc ? -1 : 1; 2799b411b363SPhilipp Reisner } 2800b411b363SPhilipp Reisner } 2801b411b363SPhilipp Reisner 2802b411b363SPhilipp Reisner *rule_nr = 50; 2803b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2804b411b363SPhilipp Reisner if (self == peer) 2805b411b363SPhilipp Reisner return -1; 2806b411b363SPhilipp Reisner 2807b411b363SPhilipp Reisner *rule_nr = 51; 2808b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2809b411b363SPhilipp Reisner if (self == peer) { 281031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28114a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 28124a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 28134a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2814b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2815b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2816b411b363SPhilipp Reisner 281731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28184a23f264SPhilipp Reisner return -1091; 2819b411b363SPhilipp Reisner 2820b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2821b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 28224a23f264SPhilipp Reisner 28234a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 28244a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 28254a23f264SPhilipp Reisner 2826b411b363SPhilipp Reisner return -1; 2827b411b363SPhilipp Reisner } 2828b411b363SPhilipp Reisner } 2829b411b363SPhilipp Reisner 2830b411b363SPhilipp Reisner *rule_nr = 60; 2831b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2832b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2833b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2834b411b363SPhilipp Reisner if (self == peer) 2835b411b363SPhilipp Reisner return -2; 2836b411b363SPhilipp Reisner } 2837b411b363SPhilipp Reisner 2838b411b363SPhilipp Reisner *rule_nr = 70; 2839b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2840b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2841b411b363SPhilipp Reisner if (self == peer) 2842b411b363SPhilipp Reisner return 1; 2843b411b363SPhilipp Reisner 2844b411b363SPhilipp Reisner *rule_nr = 71; 2845b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2846b411b363SPhilipp Reisner if (self == peer) { 284731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 28484a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 28494a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 28504a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2851b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2852b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2853b411b363SPhilipp Reisner 285431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 28554a23f264SPhilipp Reisner return -1091; 2856b411b363SPhilipp Reisner 2857b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2858b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2859b411b363SPhilipp Reisner 28604a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2861b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2862b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2863b411b363SPhilipp Reisner 2864b411b363SPhilipp Reisner return 1; 2865b411b363SPhilipp Reisner } 2866b411b363SPhilipp Reisner } 2867b411b363SPhilipp Reisner 2868b411b363SPhilipp Reisner 2869b411b363SPhilipp Reisner *rule_nr = 80; 2870d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2871b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2872b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2873b411b363SPhilipp Reisner if (self == peer) 2874b411b363SPhilipp Reisner return 2; 2875b411b363SPhilipp Reisner } 2876b411b363SPhilipp Reisner 2877b411b363SPhilipp Reisner *rule_nr = 90; 2878b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2879b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2880b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2881b411b363SPhilipp Reisner return 100; 2882b411b363SPhilipp Reisner 2883b411b363SPhilipp Reisner *rule_nr = 100; 2884b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2885b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2886b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2887b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2888b411b363SPhilipp Reisner if (self == peer) 2889b411b363SPhilipp Reisner return -100; 2890b411b363SPhilipp Reisner } 2891b411b363SPhilipp Reisner } 2892b411b363SPhilipp Reisner 2893b411b363SPhilipp Reisner return -1000; 2894b411b363SPhilipp Reisner } 2895b411b363SPhilipp Reisner 2896b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2897b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2898b411b363SPhilipp Reisner */ 2899b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2900b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2901b411b363SPhilipp Reisner { 2902b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2903b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 290444ed167dSPhilipp Reisner struct net_conf *nc; 29056dff2902SAndreas Gruenbacher int hg, rule_nr, rr_conflict, tentative; 2906b411b363SPhilipp Reisner 2907b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2908b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2909b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2910b411b363SPhilipp Reisner 2911b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2912b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2913b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2914b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2915b411b363SPhilipp Reisner 2916b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2917b411b363SPhilipp Reisner 2918b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2919b411b363SPhilipp Reisner 2920b411b363SPhilipp Reisner if (hg == -1000) { 2921b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2922b411b363SPhilipp Reisner return C_MASK; 2923b411b363SPhilipp Reisner } 29244a23f264SPhilipp Reisner if (hg < -1000) { 29254a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2926b411b363SPhilipp Reisner return C_MASK; 2927b411b363SPhilipp Reisner } 2928b411b363SPhilipp Reisner 2929b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2930b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2931b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2932b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2933b411b363SPhilipp Reisner if (f) 2934b411b363SPhilipp Reisner hg = hg*2; 2935b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2936b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2937b411b363SPhilipp Reisner } 2938b411b363SPhilipp Reisner 29393a11a487SAdam Gandelman if (abs(hg) == 100) 29403a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 29413a11a487SAdam Gandelman 294244ed167dSPhilipp Reisner rcu_read_lock(); 294344ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 294444ed167dSPhilipp Reisner 294544ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2946b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2947b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2948b411b363SPhilipp Reisner int forced = (hg == -100); 2949b411b363SPhilipp Reisner 2950b411b363SPhilipp Reisner switch (pcount) { 2951b411b363SPhilipp Reisner case 0: 2952b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2953b411b363SPhilipp Reisner break; 2954b411b363SPhilipp Reisner case 1: 2955b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2956b411b363SPhilipp Reisner break; 2957b411b363SPhilipp Reisner case 2: 2958b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2959b411b363SPhilipp Reisner break; 2960b411b363SPhilipp Reisner } 2961b411b363SPhilipp Reisner if (abs(hg) < 100) { 2962b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2963b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2964b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2965b411b363SPhilipp Reisner if (forced) { 2966b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2967b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2968b411b363SPhilipp Reisner hg = hg*2; 2969b411b363SPhilipp Reisner } 2970b411b363SPhilipp Reisner } 2971b411b363SPhilipp Reisner } 2972b411b363SPhilipp Reisner 2973b411b363SPhilipp Reisner if (hg == -100) { 297408b165baSPhilipp Reisner if (test_bit(DISCARD_MY_DATA, &mdev->flags) && !(mdev->p_uuid[UI_FLAGS]&1)) 2975b411b363SPhilipp Reisner hg = -1; 297608b165baSPhilipp Reisner if (!test_bit(DISCARD_MY_DATA, &mdev->flags) && (mdev->p_uuid[UI_FLAGS]&1)) 2977b411b363SPhilipp Reisner hg = 1; 2978b411b363SPhilipp Reisner 2979b411b363SPhilipp Reisner if (abs(hg) < 100) 2980b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2981b411b363SPhilipp Reisner "Sync from %s node\n", 2982b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2983b411b363SPhilipp Reisner } 298444ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 29856dff2902SAndreas Gruenbacher tentative = nc->tentative; 298644ed167dSPhilipp Reisner rcu_read_unlock(); 2987b411b363SPhilipp Reisner 2988b411b363SPhilipp Reisner if (hg == -100) { 2989580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2990580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2991580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2992580b9767SLars Ellenberg * to that disk, in a way... */ 29933a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2994b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2995b411b363SPhilipp Reisner return C_MASK; 2996b411b363SPhilipp Reisner } 2997b411b363SPhilipp Reisner 2998b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2999b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 3000b411b363SPhilipp Reisner return C_MASK; 3001b411b363SPhilipp Reisner } 3002b411b363SPhilipp Reisner 3003b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 3004b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 300544ed167dSPhilipp Reisner switch (rr_conflict) { 3006b411b363SPhilipp Reisner case ASB_CALL_HELPER: 3007b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 3008b411b363SPhilipp Reisner /* fall through */ 3009b411b363SPhilipp Reisner case ASB_DISCONNECT: 3010b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 3011b411b363SPhilipp Reisner return C_MASK; 3012b411b363SPhilipp Reisner case ASB_VIOLENTLY: 3013b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 3014b411b363SPhilipp Reisner "assumption\n"); 3015b411b363SPhilipp Reisner } 3016b411b363SPhilipp Reisner } 3017b411b363SPhilipp Reisner 30186dff2902SAndreas Gruenbacher if (tentative || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 3019cf14c2e9SPhilipp Reisner if (hg == 0) 3020cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 3021cf14c2e9SPhilipp Reisner else 3022cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 3023cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 3024cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 3025cf14c2e9SPhilipp Reisner return C_MASK; 3026cf14c2e9SPhilipp Reisner } 3027cf14c2e9SPhilipp Reisner 3028b411b363SPhilipp Reisner if (abs(hg) >= 2) { 3029b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 303020ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 303120ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 3032b411b363SPhilipp Reisner return C_MASK; 3033b411b363SPhilipp Reisner } 3034b411b363SPhilipp Reisner 3035b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 3036b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 3037b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 3038b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 3039b411b363SPhilipp Reisner } else { 3040b411b363SPhilipp Reisner rv = C_CONNECTED; 3041b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 3042b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 3043b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 3044b411b363SPhilipp Reisner } 3045b411b363SPhilipp Reisner } 3046b411b363SPhilipp Reisner 3047b411b363SPhilipp Reisner return rv; 3048b411b363SPhilipp Reisner } 3049b411b363SPhilipp Reisner 3050f179d76dSPhilipp Reisner static enum drbd_after_sb_p convert_after_sb(enum drbd_after_sb_p peer) 3051b411b363SPhilipp Reisner { 3052b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 3053f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_REMOTE) 3054f179d76dSPhilipp Reisner return ASB_DISCARD_LOCAL; 3055b411b363SPhilipp Reisner 3056b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 3057f179d76dSPhilipp Reisner if (peer == ASB_DISCARD_LOCAL) 3058f179d76dSPhilipp Reisner return ASB_DISCARD_REMOTE; 3059b411b363SPhilipp Reisner 3060b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 3061f179d76dSPhilipp Reisner return peer; 3062b411b363SPhilipp Reisner } 3063b411b363SPhilipp Reisner 3064e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3065b411b363SPhilipp Reisner { 3066e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3067036b17eaSPhilipp Reisner enum drbd_after_sb_p p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3068036b17eaSPhilipp Reisner int p_proto, p_discard_my_data, p_two_primaries, cf; 3069036b17eaSPhilipp Reisner struct net_conf *nc, *old_net_conf, *new_net_conf = NULL; 3070036b17eaSPhilipp Reisner char integrity_alg[SHARED_SECRET_MAX] = ""; 3071accdbcc5SAndreas Gruenbacher struct crypto_hash *peer_integrity_tfm = NULL; 30727aca6c75SPhilipp Reisner void *int_dig_in = NULL, *int_dig_vv = NULL; 3073b411b363SPhilipp Reisner 3074b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3075b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3076b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3077b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3078b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3079cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 30806139f60dSAndreas Gruenbacher p_discard_my_data = cf & CF_DISCARD_MY_DATA; 3081cf14c2e9SPhilipp Reisner 308286db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 308386db0618SAndreas Gruenbacher int err; 308486db0618SAndreas Gruenbacher 308588104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 308686db0618SAndreas Gruenbacher return -EIO; 308788104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 308886db0618SAndreas Gruenbacher if (err) 308986db0618SAndreas Gruenbacher return err; 309088104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX - 1] = 0; 3091036b17eaSPhilipp Reisner } 309286db0618SAndreas Gruenbacher 30937d4c782cSAndreas Gruenbacher if (pi->cmd != P_PROTOCOL_UPDATE) { 30947204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3095cf14c2e9SPhilipp Reisner 3096cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 30977204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3098b411b363SPhilipp Reisner 309944ed167dSPhilipp Reisner rcu_read_lock(); 310044ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 310144ed167dSPhilipp Reisner 3102036b17eaSPhilipp Reisner if (p_proto != nc->wire_protocol) { 3103d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "protocol"); 310444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3105b411b363SPhilipp Reisner } 3106b411b363SPhilipp Reisner 3107f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_0p) != nc->after_sb_0p) { 3108d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-0pri"); 310944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3110b411b363SPhilipp Reisner } 3111b411b363SPhilipp Reisner 3112f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_1p) != nc->after_sb_1p) { 3113d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-1pri"); 311444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3115b411b363SPhilipp Reisner } 3116b411b363SPhilipp Reisner 3117f179d76dSPhilipp Reisner if (convert_after_sb(p_after_sb_2p) != nc->after_sb_2p) { 3118d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "after-sb-2pri"); 311944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3120b411b363SPhilipp Reisner } 3121b411b363SPhilipp Reisner 31226139f60dSAndreas Gruenbacher if (p_discard_my_data && nc->discard_my_data) { 3123d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "discard-my-data"); 312444ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3125b411b363SPhilipp Reisner } 3126b411b363SPhilipp Reisner 312744ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 3128d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "allow-two-primaries"); 312944ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3130b411b363SPhilipp Reisner } 3131b411b363SPhilipp Reisner 3132036b17eaSPhilipp Reisner if (strcmp(integrity_alg, nc->integrity_alg)) { 3133d505d9beSAndreas Gruenbacher conn_err(tconn, "incompatible %s settings\n", "data-integrity-alg"); 3134036b17eaSPhilipp Reisner goto disconnect_rcu_unlock; 3135036b17eaSPhilipp Reisner } 3136036b17eaSPhilipp Reisner 313786db0618SAndreas Gruenbacher rcu_read_unlock(); 3138fbc12f45SAndreas Gruenbacher } 31397d4c782cSAndreas Gruenbacher 31407d4c782cSAndreas Gruenbacher if (integrity_alg[0]) { 31417d4c782cSAndreas Gruenbacher int hash_size; 31427d4c782cSAndreas Gruenbacher 31437d4c782cSAndreas Gruenbacher /* 31447d4c782cSAndreas Gruenbacher * We can only change the peer data integrity algorithm 31457d4c782cSAndreas Gruenbacher * here. Changing our own data integrity algorithm 31467d4c782cSAndreas Gruenbacher * requires that we send a P_PROTOCOL_UPDATE packet at 31477d4c782cSAndreas Gruenbacher * the same time; otherwise, the peer has no way to 31487d4c782cSAndreas Gruenbacher * tell between which packets the algorithm should 31497d4c782cSAndreas Gruenbacher * change. 31507d4c782cSAndreas Gruenbacher */ 31517d4c782cSAndreas Gruenbacher 31527d4c782cSAndreas Gruenbacher peer_integrity_tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 31537d4c782cSAndreas Gruenbacher if (!peer_integrity_tfm) { 31547d4c782cSAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 31557d4c782cSAndreas Gruenbacher integrity_alg); 31567d4c782cSAndreas Gruenbacher goto disconnect; 31577d4c782cSAndreas Gruenbacher } 31587d4c782cSAndreas Gruenbacher 31597d4c782cSAndreas Gruenbacher hash_size = crypto_hash_digestsize(peer_integrity_tfm); 31607d4c782cSAndreas Gruenbacher int_dig_in = kmalloc(hash_size, GFP_KERNEL); 31617d4c782cSAndreas Gruenbacher int_dig_vv = kmalloc(hash_size, GFP_KERNEL); 31627d4c782cSAndreas Gruenbacher if (!(int_dig_in && int_dig_vv)) { 31637d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of buffers for data integrity checking failed\n"); 31647d4c782cSAndreas Gruenbacher goto disconnect; 31657d4c782cSAndreas Gruenbacher } 31667d4c782cSAndreas Gruenbacher } 31677d4c782cSAndreas Gruenbacher 31687d4c782cSAndreas Gruenbacher new_net_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL); 31697d4c782cSAndreas Gruenbacher if (!new_net_conf) { 31707d4c782cSAndreas Gruenbacher conn_err(tconn, "Allocation of new net_conf failed\n"); 31717d4c782cSAndreas Gruenbacher goto disconnect; 31727d4c782cSAndreas Gruenbacher } 31737d4c782cSAndreas Gruenbacher 31747d4c782cSAndreas Gruenbacher mutex_lock(&tconn->data.mutex); 31757d4c782cSAndreas Gruenbacher mutex_lock(&tconn->conf_update); 31767d4c782cSAndreas Gruenbacher old_net_conf = tconn->net_conf; 31777d4c782cSAndreas Gruenbacher *new_net_conf = *old_net_conf; 31787d4c782cSAndreas Gruenbacher 31797d4c782cSAndreas Gruenbacher new_net_conf->wire_protocol = p_proto; 31807d4c782cSAndreas Gruenbacher new_net_conf->after_sb_0p = convert_after_sb(p_after_sb_0p); 31817d4c782cSAndreas Gruenbacher new_net_conf->after_sb_1p = convert_after_sb(p_after_sb_1p); 31827d4c782cSAndreas Gruenbacher new_net_conf->after_sb_2p = convert_after_sb(p_after_sb_2p); 31837d4c782cSAndreas Gruenbacher new_net_conf->two_primaries = p_two_primaries; 31847d4c782cSAndreas Gruenbacher 31857d4c782cSAndreas Gruenbacher rcu_assign_pointer(tconn->net_conf, new_net_conf); 31867d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->conf_update); 31877d4c782cSAndreas Gruenbacher mutex_unlock(&tconn->data.mutex); 31887d4c782cSAndreas Gruenbacher 31897d4c782cSAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 31907d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_in); 31917d4c782cSAndreas Gruenbacher kfree(tconn->int_dig_vv); 31927d4c782cSAndreas Gruenbacher tconn->peer_integrity_tfm = peer_integrity_tfm; 31937d4c782cSAndreas Gruenbacher tconn->int_dig_in = int_dig_in; 31947d4c782cSAndreas Gruenbacher tconn->int_dig_vv = int_dig_vv; 31957d4c782cSAndreas Gruenbacher 31967d4c782cSAndreas Gruenbacher if (strcmp(old_net_conf->integrity_alg, integrity_alg)) 31977d4c782cSAndreas Gruenbacher conn_info(tconn, "peer data-integrity-alg: %s\n", 31987d4c782cSAndreas Gruenbacher integrity_alg[0] ? integrity_alg : "(none)"); 31997d4c782cSAndreas Gruenbacher 32007d4c782cSAndreas Gruenbacher synchronize_rcu(); 32017d4c782cSAndreas Gruenbacher kfree(old_net_conf); 320282bc0194SAndreas Gruenbacher return 0; 3203b411b363SPhilipp Reisner 320444ed167dSPhilipp Reisner disconnect_rcu_unlock: 320544ed167dSPhilipp Reisner rcu_read_unlock(); 3206b411b363SPhilipp Reisner disconnect: 3207b792c35cSAndreas Gruenbacher crypto_free_hash(peer_integrity_tfm); 3208036b17eaSPhilipp Reisner kfree(int_dig_in); 3209036b17eaSPhilipp Reisner kfree(int_dig_vv); 32107204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 321182bc0194SAndreas Gruenbacher return -EIO; 3212b411b363SPhilipp Reisner } 3213b411b363SPhilipp Reisner 3214b411b363SPhilipp Reisner /* helper function 3215b411b363SPhilipp Reisner * input: alg name, feature name 3216b411b363SPhilipp Reisner * return: NULL (alg name was "") 3217b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3218b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3219b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3220b411b363SPhilipp Reisner const char *alg, const char *name) 3221b411b363SPhilipp Reisner { 3222b411b363SPhilipp Reisner struct crypto_hash *tfm; 3223b411b363SPhilipp Reisner 3224b411b363SPhilipp Reisner if (!alg[0]) 3225b411b363SPhilipp Reisner return NULL; 3226b411b363SPhilipp Reisner 3227b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3228b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3229b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3230b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3231b411b363SPhilipp Reisner return tfm; 3232b411b363SPhilipp Reisner } 3233b411b363SPhilipp Reisner return tfm; 3234b411b363SPhilipp Reisner } 3235b411b363SPhilipp Reisner 32364a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3237b411b363SPhilipp Reisner { 32384a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 32394a76b161SAndreas Gruenbacher int size = pi->size; 32404a76b161SAndreas Gruenbacher 32414a76b161SAndreas Gruenbacher while (size) { 32424a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 32434a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 32444a76b161SAndreas Gruenbacher if (s <= 0) { 32454a76b161SAndreas Gruenbacher if (s < 0) 32464a76b161SAndreas Gruenbacher return s; 32474a76b161SAndreas Gruenbacher break; 32484a76b161SAndreas Gruenbacher } 32494a76b161SAndreas Gruenbacher size -= s; 32504a76b161SAndreas Gruenbacher } 32514a76b161SAndreas Gruenbacher if (size) 32524a76b161SAndreas Gruenbacher return -EIO; 32534a76b161SAndreas Gruenbacher return 0; 32544a76b161SAndreas Gruenbacher } 32554a76b161SAndreas Gruenbacher 32564a76b161SAndreas Gruenbacher /* 32574a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 32584a76b161SAndreas Gruenbacher * 32594a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 32604a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 32614a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 32624a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 32634a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 32644a76b161SAndreas Gruenbacher * 32654a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 32664a76b161SAndreas Gruenbacher */ 32674a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 32684a76b161SAndreas Gruenbacher { 32692fcb8f30SAndreas Gruenbacher conn_warn(tconn, "%s packet received for volume %u, which is not configured locally\n", 32702fcb8f30SAndreas Gruenbacher cmdname(pi->cmd), pi->vnr); 32714a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 32724a76b161SAndreas Gruenbacher } 32734a76b161SAndreas Gruenbacher 32744a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 32754a76b161SAndreas Gruenbacher { 32764a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3277e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3278b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3279b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3280b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 32812ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3282813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 32834a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3284813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3285778f271dSPhilipp Reisner int fifo_size = 0; 328682bc0194SAndreas Gruenbacher int err; 3287b411b363SPhilipp Reisner 32884a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 32894a76b161SAndreas Gruenbacher if (!mdev) 32904a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 32914a76b161SAndreas Gruenbacher 3292b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3293b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3294b411b363SPhilipp Reisner + SHARED_SECRET_MAX 32958e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 32968e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3297b411b363SPhilipp Reisner 3298e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3299b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3300e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 330182bc0194SAndreas Gruenbacher return -EIO; 3302b411b363SPhilipp Reisner } 3303b411b363SPhilipp Reisner 3304b411b363SPhilipp Reisner if (apv <= 88) { 3305e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3306e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 33078e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3308e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3309e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3310b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 33118e26f9ccSPhilipp Reisner } else { 3312e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3313e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3314b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3315b411b363SPhilipp Reisner } 3316b411b363SPhilipp Reisner 3317b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3318e658983aSAndreas Gruenbacher p = pi->data; 3319b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3320b411b363SPhilipp Reisner 3321e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 332282bc0194SAndreas Gruenbacher if (err) 332382bc0194SAndreas Gruenbacher return err; 3324b411b363SPhilipp Reisner 3325813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3326813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3327813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3328daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3329daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3330813472ceSPhilipp Reisner put_ldev(mdev); 3331813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3332daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3333daeda1ccSPhilipp Reisner return -ENOMEM; 3334f399002eSLars Ellenberg } 3335b411b363SPhilipp Reisner 3336daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3337daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3338daeda1ccSPhilipp Reisner 33396394b935SAndreas Gruenbacher new_disk_conf->resync_rate = be32_to_cpu(p->resync_rate); 3340813472ceSPhilipp Reisner } 3341daeda1ccSPhilipp Reisner 3342b411b363SPhilipp Reisner if (apv >= 88) { 3343b411b363SPhilipp Reisner if (apv == 88) { 3344e4bad1bcSPhilipp Reisner if (data_size > SHARED_SECRET_MAX || data_size == 0) { 3345e4bad1bcSPhilipp Reisner dev_err(DEV, "verify-alg of wrong size, " 3346e4bad1bcSPhilipp Reisner "peer wants %u, accepting only up to %u byte\n", 3347b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3348813472ceSPhilipp Reisner err = -EIO; 3349813472ceSPhilipp Reisner goto reconnect; 3350b411b363SPhilipp Reisner } 3351b411b363SPhilipp Reisner 335282bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3353813472ceSPhilipp Reisner if (err) 3354813472ceSPhilipp Reisner goto reconnect; 3355b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3356b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3357b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3358b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3359b411b363SPhilipp Reisner 3360b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3361b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3362b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3363b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3364b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3365b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3366b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3367b411b363SPhilipp Reisner } 3368b411b363SPhilipp Reisner 33692ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3370b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3371b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 33722ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3373b411b363SPhilipp Reisner goto disconnect; 3374b411b363SPhilipp Reisner } 3375b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3376b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3377b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3378b411b363SPhilipp Reisner verify_tfm = NULL; 3379b411b363SPhilipp Reisner goto disconnect; 3380b411b363SPhilipp Reisner } 3381b411b363SPhilipp Reisner } 3382b411b363SPhilipp Reisner 33832ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3384b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3385b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 33862ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3387b411b363SPhilipp Reisner goto disconnect; 3388b411b363SPhilipp Reisner } 3389b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3390b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3391b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3392b411b363SPhilipp Reisner csums_tfm = NULL; 3393b411b363SPhilipp Reisner goto disconnect; 3394b411b363SPhilipp Reisner } 3395b411b363SPhilipp Reisner } 3396b411b363SPhilipp Reisner 3397813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3398daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3399daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3400daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3401daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3402778f271dSPhilipp Reisner 3403daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 34049958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3405813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3406813472ceSPhilipp Reisner if (!new_plan) { 3407778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3408f399002eSLars Ellenberg put_ldev(mdev); 3409778f271dSPhilipp Reisner goto disconnect; 3410778f271dSPhilipp Reisner } 3411778f271dSPhilipp Reisner } 34128e26f9ccSPhilipp Reisner } 3413b411b363SPhilipp Reisner 341491fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 34152ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 34162ec91e0eSPhilipp Reisner if (!new_net_conf) { 341791fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 341891fd4dadSPhilipp Reisner goto disconnect; 341991fd4dadSPhilipp Reisner } 342091fd4dadSPhilipp Reisner 34212ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 342291fd4dadSPhilipp Reisner 3423b411b363SPhilipp Reisner if (verify_tfm) { 34242ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 34252ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3426f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3427f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3428b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3429b411b363SPhilipp Reisner } 3430b411b363SPhilipp Reisner if (csums_tfm) { 34312ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 34322ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3433f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3434f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3435b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3436b411b363SPhilipp Reisner } 34372ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 343891fd4dadSPhilipp Reisner } 343991fd4dadSPhilipp Reisner } 344091fd4dadSPhilipp Reisner 3441813472ceSPhilipp Reisner if (new_disk_conf) { 3442daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3443813472ceSPhilipp Reisner put_ldev(mdev); 3444778f271dSPhilipp Reisner } 3445813472ceSPhilipp Reisner 3446813472ceSPhilipp Reisner if (new_plan) { 3447813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3448813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3449813472ceSPhilipp Reisner } 3450daeda1ccSPhilipp Reisner 3451daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3452daeda1ccSPhilipp Reisner synchronize_rcu(); 3453daeda1ccSPhilipp Reisner if (new_net_conf) 3454daeda1ccSPhilipp Reisner kfree(old_net_conf); 3455daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3456813472ceSPhilipp Reisner kfree(old_plan); 3457daeda1ccSPhilipp Reisner 345882bc0194SAndreas Gruenbacher return 0; 3459b411b363SPhilipp Reisner 3460813472ceSPhilipp Reisner reconnect: 3461813472ceSPhilipp Reisner if (new_disk_conf) { 3462813472ceSPhilipp Reisner put_ldev(mdev); 3463813472ceSPhilipp Reisner kfree(new_disk_conf); 3464813472ceSPhilipp Reisner } 3465813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3466813472ceSPhilipp Reisner return -EIO; 3467813472ceSPhilipp Reisner 3468b411b363SPhilipp Reisner disconnect: 3469813472ceSPhilipp Reisner kfree(new_plan); 3470813472ceSPhilipp Reisner if (new_disk_conf) { 3471813472ceSPhilipp Reisner put_ldev(mdev); 3472813472ceSPhilipp Reisner kfree(new_disk_conf); 3473813472ceSPhilipp Reisner } 3474a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3475b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3476b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3477b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3478b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3479b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 348038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 348182bc0194SAndreas Gruenbacher return -EIO; 3482b411b363SPhilipp Reisner } 3483b411b363SPhilipp Reisner 3484b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3485b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3486b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3487b411b363SPhilipp Reisner { 3488b411b363SPhilipp Reisner sector_t d; 3489b411b363SPhilipp Reisner if (a == 0 || b == 0) 3490b411b363SPhilipp Reisner return; 3491b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3492b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3493b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3494b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3495b411b363SPhilipp Reisner } 3496b411b363SPhilipp Reisner 34974a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3498b411b363SPhilipp Reisner { 34994a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3500e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3501b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3502b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3503b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3504e89b591cSPhilipp Reisner enum dds_flags ddsf; 3505b411b363SPhilipp Reisner 35064a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35074a76b161SAndreas Gruenbacher if (!mdev) 35084a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35094a76b161SAndreas Gruenbacher 3510b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3511b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3512b411b363SPhilipp Reisner 3513b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3514b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3515b411b363SPhilipp Reisner mdev->p_size = p_size; 3516b411b363SPhilipp Reisner 3517b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3518daeda1ccSPhilipp Reisner rcu_read_lock(); 3519daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3520daeda1ccSPhilipp Reisner rcu_read_unlock(); 3521daeda1ccSPhilipp Reisner 3522b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3523b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3524b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3525daeda1ccSPhilipp Reisner p_usize, my_usize); 3526b411b363SPhilipp Reisner 3527b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3528b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3529b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3530daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3531b411b363SPhilipp Reisner 3532b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3533b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3534ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3535b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3536b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3537b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3538b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 353938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3540b411b363SPhilipp Reisner put_ldev(mdev); 354182bc0194SAndreas Gruenbacher return -EIO; 3542b411b363SPhilipp Reisner } 3543daeda1ccSPhilipp Reisner 3544daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3545daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3546daeda1ccSPhilipp Reisner 3547daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3548daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3549daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3550daeda1ccSPhilipp Reisner put_ldev(mdev); 3551daeda1ccSPhilipp Reisner return -ENOMEM; 3552daeda1ccSPhilipp Reisner } 3553daeda1ccSPhilipp Reisner 3554daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3555daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3556daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3557daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3558daeda1ccSPhilipp Reisner 3559daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3560daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3561daeda1ccSPhilipp Reisner synchronize_rcu(); 3562daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3563daeda1ccSPhilipp Reisner 3564daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3565daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3566daeda1ccSPhilipp Reisner } 3567daeda1ccSPhilipp Reisner 3568b411b363SPhilipp Reisner put_ldev(mdev); 3569b411b363SPhilipp Reisner } 3570b411b363SPhilipp Reisner 3571e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3572b411b363SPhilipp Reisner if (get_ldev(mdev)) { 357324c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3574b411b363SPhilipp Reisner put_ldev(mdev); 3575b411b363SPhilipp Reisner if (dd == dev_size_error) 357682bc0194SAndreas Gruenbacher return -EIO; 3577b411b363SPhilipp Reisner drbd_md_sync(mdev); 3578b411b363SPhilipp Reisner } else { 3579b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3580b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3581b411b363SPhilipp Reisner } 3582b411b363SPhilipp Reisner 358399432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 358499432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 358599432fccSPhilipp Reisner 3586b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3587b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3588b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3589b411b363SPhilipp Reisner ldsc = 1; 3590b411b363SPhilipp Reisner } 3591b411b363SPhilipp Reisner 3592b411b363SPhilipp Reisner put_ldev(mdev); 3593b411b363SPhilipp Reisner } 3594b411b363SPhilipp Reisner 3595b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3596b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3597b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3598b411b363SPhilipp Reisner /* we have different sizes, probably peer 3599b411b363SPhilipp Reisner * needs to know my new size... */ 3600e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3601b411b363SPhilipp Reisner } 3602b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3603b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3604b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3605e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3606e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3607e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3608b411b363SPhilipp Reisner else 3609e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3610e89b591cSPhilipp Reisner } else 3611b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3612b411b363SPhilipp Reisner } 3613b411b363SPhilipp Reisner } 3614b411b363SPhilipp Reisner 361582bc0194SAndreas Gruenbacher return 0; 3616b411b363SPhilipp Reisner } 3617b411b363SPhilipp Reisner 36184a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3619b411b363SPhilipp Reisner { 36204a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3621e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3622b411b363SPhilipp Reisner u64 *p_uuid; 362362b0da3aSLars Ellenberg int i, updated_uuids = 0; 3624b411b363SPhilipp Reisner 36254a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36264a76b161SAndreas Gruenbacher if (!mdev) 36274a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 36284a76b161SAndreas Gruenbacher 3629b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3630b411b363SPhilipp Reisner 3631b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3632b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3633b411b363SPhilipp Reisner 3634b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3635b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3636b411b363SPhilipp Reisner 3637b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3638b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3639b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3640b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3641b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3642b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 364338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 364482bc0194SAndreas Gruenbacher return -EIO; 3645b411b363SPhilipp Reisner } 3646b411b363SPhilipp Reisner 3647b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3648b411b363SPhilipp Reisner int skip_initial_sync = 3649b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 365031890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3651b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3652b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3653b411b363SPhilipp Reisner if (skip_initial_sync) { 3654b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3655b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 365620ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 365720ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3658b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3659b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3660b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3661b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3662b411b363SPhilipp Reisner drbd_md_sync(mdev); 366362b0da3aSLars Ellenberg updated_uuids = 1; 3664b411b363SPhilipp Reisner } 3665b411b363SPhilipp Reisner put_ldev(mdev); 366618a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 366718a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 366818a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 366918a50fa2SPhilipp Reisner for me. */ 367062b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3671b411b363SPhilipp Reisner } 3672b411b363SPhilipp Reisner 3673b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3674b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3675b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3676b411b363SPhilipp Reisner new disk state... */ 36778410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 36788410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3679b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 368062b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 368162b0da3aSLars Ellenberg 368262b0da3aSLars Ellenberg if (updated_uuids) 368362b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3684b411b363SPhilipp Reisner 368582bc0194SAndreas Gruenbacher return 0; 3686b411b363SPhilipp Reisner } 3687b411b363SPhilipp Reisner 3688b411b363SPhilipp Reisner /** 3689b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3690b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3691b411b363SPhilipp Reisner */ 3692b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3693b411b363SPhilipp Reisner { 3694b411b363SPhilipp Reisner union drbd_state ms; 3695b411b363SPhilipp Reisner 3696b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3697369bea63SPhilipp Reisner [C_WF_REPORT_PARAMS] = C_WF_REPORT_PARAMS, 3698b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3699b411b363SPhilipp Reisner 3700b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3701b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3702b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3703b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3704b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3705b411b363SPhilipp Reisner }; 3706b411b363SPhilipp Reisner 3707b411b363SPhilipp Reisner ms.i = ps.i; 3708b411b363SPhilipp Reisner 3709b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3710b411b363SPhilipp Reisner ms.peer = ps.role; 3711b411b363SPhilipp Reisner ms.role = ps.peer; 3712b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3713b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3714b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3715b411b363SPhilipp Reisner 3716b411b363SPhilipp Reisner return ms; 3717b411b363SPhilipp Reisner } 3718b411b363SPhilipp Reisner 37194a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3720b411b363SPhilipp Reisner { 37214a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3722e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3723b411b363SPhilipp Reisner union drbd_state mask, val; 3724bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3725b411b363SPhilipp Reisner 37264a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37274a76b161SAndreas Gruenbacher if (!mdev) 37284a76b161SAndreas Gruenbacher return -EIO; 37294a76b161SAndreas Gruenbacher 3730b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3731b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3732b411b363SPhilipp Reisner 373325703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 37348410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3735b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 373682bc0194SAndreas Gruenbacher return 0; 3737b411b363SPhilipp Reisner } 3738b411b363SPhilipp Reisner 3739b411b363SPhilipp Reisner mask = convert_state(mask); 3740b411b363SPhilipp Reisner val = convert_state(val); 3741b411b363SPhilipp Reisner 3742b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3743b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3744047cd4a6SPhilipp Reisner 3745b411b363SPhilipp Reisner drbd_md_sync(mdev); 3746b411b363SPhilipp Reisner 374782bc0194SAndreas Gruenbacher return 0; 3748b411b363SPhilipp Reisner } 3749b411b363SPhilipp Reisner 3750e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3751dfafcc8aSPhilipp Reisner { 3752e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3753dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3754dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3755dfafcc8aSPhilipp Reisner 3756dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3757dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3758dfafcc8aSPhilipp Reisner 3759dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3760dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3761dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 376282bc0194SAndreas Gruenbacher return 0; 3763dfafcc8aSPhilipp Reisner } 3764dfafcc8aSPhilipp Reisner 3765dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3766dfafcc8aSPhilipp Reisner val = convert_state(val); 3767dfafcc8aSPhilipp Reisner 3768778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3769dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3770dfafcc8aSPhilipp Reisner 377182bc0194SAndreas Gruenbacher return 0; 3772dfafcc8aSPhilipp Reisner } 3773dfafcc8aSPhilipp Reisner 37744a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3775b411b363SPhilipp Reisner { 37764a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3777e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 37784ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3779b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 378065d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3781b411b363SPhilipp Reisner int rv; 3782b411b363SPhilipp Reisner 37834a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 37844a76b161SAndreas Gruenbacher if (!mdev) 37854a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 37864a76b161SAndreas Gruenbacher 3787b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3788b411b363SPhilipp Reisner 3789b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3790b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3791b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3792b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3793b411b363SPhilipp Reisner } 3794b411b363SPhilipp Reisner 379587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3796b411b363SPhilipp Reisner retry: 379778bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 379887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3799b411b363SPhilipp Reisner 3800b8853dbdSPhilipp Reisner /* If some other part of the code (asender thread, timeout) 3801b8853dbdSPhilipp Reisner * already decided to close the connection again, 3802b8853dbdSPhilipp Reisner * we must not "re-establish" it here. */ 3803b8853dbdSPhilipp Reisner if (os.conn <= C_TEAR_DOWN) 3804b8853dbdSPhilipp Reisner return false; 3805b8853dbdSPhilipp Reisner 38069bcd2521SPhilipp Reisner /* If this is the "end of sync" confirmation, usually the peer disk 38079bcd2521SPhilipp Reisner * transitions from D_INCONSISTENT to D_UP_TO_DATE. For empty (0 bits 38089bcd2521SPhilipp Reisner * set) resync started in PausedSyncT, or if the timing of pause-/ 38099bcd2521SPhilipp Reisner * unpause-sync events has been "just right", the peer disk may 38109bcd2521SPhilipp Reisner * transition from D_CONSISTENT to D_UP_TO_DATE as well. 38119bcd2521SPhilipp Reisner */ 38129bcd2521SPhilipp Reisner if ((os.pdsk == D_INCONSISTENT || os.pdsk == D_CONSISTENT) && 38139bcd2521SPhilipp Reisner real_peer_disk == D_UP_TO_DATE && 3814e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3815e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3816e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3817e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3818e9ef7bb6SLars Ellenberg * syncing states. 3819e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3820e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3821e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3822e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3823e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3824e9ef7bb6SLars Ellenberg 3825e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3826e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3827e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3828e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3829e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3830e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3831e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 383282bc0194SAndreas Gruenbacher return 0; 3833e9ef7bb6SLars Ellenberg } 3834e9ef7bb6SLars Ellenberg } 3835e9ef7bb6SLars Ellenberg 3836e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3837e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3838e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3839e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3840e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3841e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3842e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3843e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3844e9ef7bb6SLars Ellenberg 38454ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 38464ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3847b411b363SPhilipp Reisner 384867531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 384967531718SPhilipp Reisner ns.conn = C_BEHIND; 385067531718SPhilipp Reisner 3851b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3852b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3853b411b363SPhilipp Reisner int cr; /* consider resync */ 3854b411b363SPhilipp Reisner 3855b411b363SPhilipp Reisner /* if we established a new connection */ 38564ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3857b411b363SPhilipp Reisner /* if we had an established connection 3858b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 38594ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3860b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 38614ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3862b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3863b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3864b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3865b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3866b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 38674ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3868b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3869b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3870b411b363SPhilipp Reisner 3871b411b363SPhilipp Reisner if (cr) 38724ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3873b411b363SPhilipp Reisner 3874b411b363SPhilipp Reisner put_ldev(mdev); 38754ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 38764ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3877b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 387882f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3879b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3880b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3881b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3882580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3883b411b363SPhilipp Reisner } else { 38848169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 388582bc0194SAndreas Gruenbacher return -EIO; 38864ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 388738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 388882bc0194SAndreas Gruenbacher return -EIO; 3889b411b363SPhilipp Reisner } 3890b411b363SPhilipp Reisner } 3891b411b363SPhilipp Reisner } 3892b411b363SPhilipp Reisner 389387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 389478bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3895b411b363SPhilipp Reisner goto retry; 3896b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3897b411b363SPhilipp Reisner ns.peer = peer_state.role; 3898b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3899b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 39004ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3901b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 39024ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 39032aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3904481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 39058554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3906481c6f50SPhilipp Reisner for temporal network outages! */ 390787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3908481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 39092f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3910481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3911481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 391238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 391382bc0194SAndreas Gruenbacher return -EIO; 3914481c6f50SPhilipp Reisner } 391565d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 391678bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 391787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3918b411b363SPhilipp Reisner 3919b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 392038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 392182bc0194SAndreas Gruenbacher return -EIO; 3922b411b363SPhilipp Reisner } 3923b411b363SPhilipp Reisner 39244ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 39254ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3926b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3927b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3928b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3929b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3930b411b363SPhilipp Reisner drbd_send_uuids(mdev); 393143de7c85SPhilipp Reisner drbd_send_current_state(mdev); 3932b411b363SPhilipp Reisner } 3933b411b363SPhilipp Reisner } 3934b411b363SPhilipp Reisner 393508b165baSPhilipp Reisner clear_bit(DISCARD_MY_DATA, &mdev->flags); 3936b411b363SPhilipp Reisner 3937b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3938b411b363SPhilipp Reisner 393982bc0194SAndreas Gruenbacher return 0; 3940b411b363SPhilipp Reisner } 3941b411b363SPhilipp Reisner 39424a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3943b411b363SPhilipp Reisner { 39444a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3945e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 39464a76b161SAndreas Gruenbacher 39474a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 39484a76b161SAndreas Gruenbacher if (!mdev) 39494a76b161SAndreas Gruenbacher return -EIO; 3950b411b363SPhilipp Reisner 3951b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3952b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3953c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3954b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3955b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3956b411b363SPhilipp Reisner 3957b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3958b411b363SPhilipp Reisner 3959b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3960b411b363SPhilipp Reisner _not_ be rotated into the history */ 3961b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3962b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3963b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3964b411b363SPhilipp Reisner 396562b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3966b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3967b411b363SPhilipp Reisner 3968b411b363SPhilipp Reisner put_ldev(mdev); 3969b411b363SPhilipp Reisner } else 3970b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3971b411b363SPhilipp Reisner 397282bc0194SAndreas Gruenbacher return 0; 3973b411b363SPhilipp Reisner } 3974b411b363SPhilipp Reisner 39752c46407dSAndreas Gruenbacher /** 39762c46407dSAndreas Gruenbacher * receive_bitmap_plain 39772c46407dSAndreas Gruenbacher * 39782c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 39792c46407dSAndreas Gruenbacher * code upon failure. 39802c46407dSAndreas Gruenbacher */ 39812c46407dSAndreas Gruenbacher static int 398250d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 3983e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 3984b411b363SPhilipp Reisner { 398550d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 398650d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 3987e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 398850d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 3989e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 39902c46407dSAndreas Gruenbacher int err; 3991b411b363SPhilipp Reisner 399250d0b1adSAndreas Gruenbacher if (want != size) { 399350d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 39942c46407dSAndreas Gruenbacher return -EIO; 3995b411b363SPhilipp Reisner } 3996b411b363SPhilipp Reisner if (want == 0) 39972c46407dSAndreas Gruenbacher return 0; 3998e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 399982bc0194SAndreas Gruenbacher if (err) 40002c46407dSAndreas Gruenbacher return err; 4001b411b363SPhilipp Reisner 4002e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 4003b411b363SPhilipp Reisner 4004b411b363SPhilipp Reisner c->word_offset += num_words; 4005b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 4006b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 4007b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 4008b411b363SPhilipp Reisner 40092c46407dSAndreas Gruenbacher return 1; 4010b411b363SPhilipp Reisner } 4011b411b363SPhilipp Reisner 4012a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 4013a02d1240SAndreas Gruenbacher { 4014a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 4015a02d1240SAndreas Gruenbacher } 4016a02d1240SAndreas Gruenbacher 4017a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 4018a02d1240SAndreas Gruenbacher { 4019a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 4020a02d1240SAndreas Gruenbacher } 4021a02d1240SAndreas Gruenbacher 4022a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 4023a02d1240SAndreas Gruenbacher { 4024a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 4025a02d1240SAndreas Gruenbacher } 4026a02d1240SAndreas Gruenbacher 40272c46407dSAndreas Gruenbacher /** 40282c46407dSAndreas Gruenbacher * recv_bm_rle_bits 40292c46407dSAndreas Gruenbacher * 40302c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40312c46407dSAndreas Gruenbacher * code upon failure. 40322c46407dSAndreas Gruenbacher */ 40332c46407dSAndreas Gruenbacher static int 4034b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 4035b411b363SPhilipp Reisner struct p_compressed_bm *p, 4036c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4037c6d25cfeSPhilipp Reisner unsigned int len) 4038b411b363SPhilipp Reisner { 4039b411b363SPhilipp Reisner struct bitstream bs; 4040b411b363SPhilipp Reisner u64 look_ahead; 4041b411b363SPhilipp Reisner u64 rl; 4042b411b363SPhilipp Reisner u64 tmp; 4043b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 4044b411b363SPhilipp Reisner unsigned long e; 4045a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 4046b411b363SPhilipp Reisner int have; 4047b411b363SPhilipp Reisner int bits; 4048b411b363SPhilipp Reisner 4049a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 4050b411b363SPhilipp Reisner 4051b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 4052b411b363SPhilipp Reisner if (bits < 0) 40532c46407dSAndreas Gruenbacher return -EIO; 4054b411b363SPhilipp Reisner 4055b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 4056b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 4057b411b363SPhilipp Reisner if (bits <= 0) 40582c46407dSAndreas Gruenbacher return -EIO; 4059b411b363SPhilipp Reisner 4060b411b363SPhilipp Reisner if (toggle) { 4061b411b363SPhilipp Reisner e = s + rl -1; 4062b411b363SPhilipp Reisner if (e >= c->bm_bits) { 4063b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 40642c46407dSAndreas Gruenbacher return -EIO; 4065b411b363SPhilipp Reisner } 4066b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 4067b411b363SPhilipp Reisner } 4068b411b363SPhilipp Reisner 4069b411b363SPhilipp Reisner if (have < bits) { 4070b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 4071b411b363SPhilipp Reisner have, bits, look_ahead, 4072b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 4073b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 40742c46407dSAndreas Gruenbacher return -EIO; 4075b411b363SPhilipp Reisner } 4076b411b363SPhilipp Reisner look_ahead >>= bits; 4077b411b363SPhilipp Reisner have -= bits; 4078b411b363SPhilipp Reisner 4079b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 4080b411b363SPhilipp Reisner if (bits < 0) 40812c46407dSAndreas Gruenbacher return -EIO; 4082b411b363SPhilipp Reisner look_ahead |= tmp << have; 4083b411b363SPhilipp Reisner have += bits; 4084b411b363SPhilipp Reisner } 4085b411b363SPhilipp Reisner 4086b411b363SPhilipp Reisner c->bit_offset = s; 4087b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 4088b411b363SPhilipp Reisner 40892c46407dSAndreas Gruenbacher return (s != c->bm_bits); 4090b411b363SPhilipp Reisner } 4091b411b363SPhilipp Reisner 40922c46407dSAndreas Gruenbacher /** 40932c46407dSAndreas Gruenbacher * decode_bitmap_c 40942c46407dSAndreas Gruenbacher * 40952c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 40962c46407dSAndreas Gruenbacher * code upon failure. 40972c46407dSAndreas Gruenbacher */ 40982c46407dSAndreas Gruenbacher static int 4099b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 4100b411b363SPhilipp Reisner struct p_compressed_bm *p, 4101c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 4102c6d25cfeSPhilipp Reisner unsigned int len) 4103b411b363SPhilipp Reisner { 4104a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 4105e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 4106b411b363SPhilipp Reisner 4107b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 4108b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 4109b411b363SPhilipp Reisner * during all our tests. */ 4110b411b363SPhilipp Reisner 4111b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 411238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 41132c46407dSAndreas Gruenbacher return -EIO; 4114b411b363SPhilipp Reisner } 4115b411b363SPhilipp Reisner 4116b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 4117b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 4118b411b363SPhilipp Reisner { 4119b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 412050d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 412150d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 412250d0b1adSAndreas Gruenbacher unsigned int plain = 412350d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 412450d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 412550d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 412650d0b1adSAndreas Gruenbacher unsigned int r; 4127b411b363SPhilipp Reisner 4128b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 4129b411b363SPhilipp Reisner if (total == 0) 4130b411b363SPhilipp Reisner return; 4131b411b363SPhilipp Reisner 4132b411b363SPhilipp Reisner /* don't report if not compressed */ 4133b411b363SPhilipp Reisner if (total >= plain) 4134b411b363SPhilipp Reisner return; 4135b411b363SPhilipp Reisner 4136b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4137b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4138b411b363SPhilipp Reisner : (1000 * total / plain); 4139b411b363SPhilipp Reisner 4140b411b363SPhilipp Reisner if (r > 1000) 4141b411b363SPhilipp Reisner r = 1000; 4142b411b363SPhilipp Reisner 4143b411b363SPhilipp Reisner r = 1000 - r; 4144b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4145b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4146b411b363SPhilipp Reisner direction, 4147b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4148b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4149b411b363SPhilipp Reisner total, r/10, r % 10); 4150b411b363SPhilipp Reisner } 4151b411b363SPhilipp Reisner 4152b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4153b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4154b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4155b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4156b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4157b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4158b411b363SPhilipp Reisner 4159b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 41604a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4161b411b363SPhilipp Reisner { 41624a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4163b411b363SPhilipp Reisner struct bm_xfer_ctx c; 41642c46407dSAndreas Gruenbacher int err; 41654a76b161SAndreas Gruenbacher 41664a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 41674a76b161SAndreas Gruenbacher if (!mdev) 41684a76b161SAndreas Gruenbacher return -EIO; 4169b411b363SPhilipp Reisner 417020ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 417120ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 417220ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4173b411b363SPhilipp Reisner 4174b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4175b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4176b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4177b411b363SPhilipp Reisner }; 4178b411b363SPhilipp Reisner 41792c46407dSAndreas Gruenbacher for(;;) { 4180e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4181e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4182e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4183b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4184b411b363SPhilipp Reisner * and the feature is enabled! */ 4185e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4186b411b363SPhilipp Reisner 418750d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4188b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 418982bc0194SAndreas Gruenbacher err = -EIO; 4190b411b363SPhilipp Reisner goto out; 4191b411b363SPhilipp Reisner } 4192e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4193e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 419482bc0194SAndreas Gruenbacher err = -EIO; 419578fcbdaeSAndreas Gruenbacher goto out; 4196b411b363SPhilipp Reisner } 4197e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4198e658983aSAndreas Gruenbacher if (err) 4199e658983aSAndreas Gruenbacher goto out; 4200e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4201b411b363SPhilipp Reisner } else { 4202e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 420382bc0194SAndreas Gruenbacher err = -EIO; 4204b411b363SPhilipp Reisner goto out; 4205b411b363SPhilipp Reisner } 4206b411b363SPhilipp Reisner 4207e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 420850d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4209b411b363SPhilipp Reisner 42102c46407dSAndreas Gruenbacher if (err <= 0) { 42112c46407dSAndreas Gruenbacher if (err < 0) 42122c46407dSAndreas Gruenbacher goto out; 4213b411b363SPhilipp Reisner break; 42142c46407dSAndreas Gruenbacher } 4215e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 421682bc0194SAndreas Gruenbacher if (err) 4217b411b363SPhilipp Reisner goto out; 42182c46407dSAndreas Gruenbacher } 4219b411b363SPhilipp Reisner 4220b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4221b411b363SPhilipp Reisner 4222b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4223de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4224de1f8e4aSAndreas Gruenbacher 422582bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 422682bc0194SAndreas Gruenbacher if (err) 4227b411b363SPhilipp Reisner goto out; 4228b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4229de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4230de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4231b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4232b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4233b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4234b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4235b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4236b411b363SPhilipp Reisner } 423782bc0194SAndreas Gruenbacher err = 0; 4238b411b363SPhilipp Reisner 4239b411b363SPhilipp Reisner out: 424020ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 424182bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4242b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 424382bc0194SAndreas Gruenbacher return err; 4244b411b363SPhilipp Reisner } 4245b411b363SPhilipp Reisner 42464a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4247b411b363SPhilipp Reisner { 42484a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4249e2857216SAndreas Gruenbacher pi->cmd, pi->size); 42502de876efSPhilipp Reisner 42514a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 42522de876efSPhilipp Reisner } 42532de876efSPhilipp Reisner 42544a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4255b411b363SPhilipp Reisner { 4256b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4257b411b363SPhilipp Reisner * with the data requests being unplugged */ 42584a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4259b411b363SPhilipp Reisner 426082bc0194SAndreas Gruenbacher return 0; 4261b411b363SPhilipp Reisner } 4262b411b363SPhilipp Reisner 42634a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 426473a01a18SPhilipp Reisner { 42654a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4266e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 42674a76b161SAndreas Gruenbacher 42684a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 42694a76b161SAndreas Gruenbacher if (!mdev) 42704a76b161SAndreas Gruenbacher return -EIO; 427173a01a18SPhilipp Reisner 4272f735e363SLars Ellenberg switch (mdev->state.conn) { 4273f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4274f735e363SLars Ellenberg case C_WF_BITMAP_T: 4275f735e363SLars Ellenberg case C_BEHIND: 4276f735e363SLars Ellenberg break; 4277f735e363SLars Ellenberg default: 4278f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4279f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4280f735e363SLars Ellenberg } 4281f735e363SLars Ellenberg 428273a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 428373a01a18SPhilipp Reisner 428482bc0194SAndreas Gruenbacher return 0; 428573a01a18SPhilipp Reisner } 428673a01a18SPhilipp Reisner 428702918be2SPhilipp Reisner struct data_cmd { 428802918be2SPhilipp Reisner int expect_payload; 428902918be2SPhilipp Reisner size_t pkt_size; 42904a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4291b411b363SPhilipp Reisner }; 4292b411b363SPhilipp Reisner 429302918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 42944a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 42954a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 42964a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 42974a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4298e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4299e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4300e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 43014a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 43024a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4303e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4304e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 43054a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 43064a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 43074a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 43084a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 43094a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 43104a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 43114a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 43124a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 43134a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 43144a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 43154a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 43164a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 4317036b17eaSPhilipp Reisner [P_PROTOCOL_UPDATE] = { 1, sizeof(struct p_protocol), receive_protocol }, 431802918be2SPhilipp Reisner }; 431902918be2SPhilipp Reisner 4320eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4321b411b363SPhilipp Reisner { 432277351055SPhilipp Reisner struct packet_info pi; 432302918be2SPhilipp Reisner size_t shs; /* sub header size */ 432482bc0194SAndreas Gruenbacher int err; 4325b411b363SPhilipp Reisner 4326eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4327deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4328deebe195SAndreas Gruenbacher 4329eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 433069bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 433102918be2SPhilipp Reisner goto err_out; 433202918be2SPhilipp Reisner 4333deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 43344a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 43352fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected data packet %s (0x%04x)", 43362fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 433702918be2SPhilipp Reisner goto err_out; 43380b33a916SLars Ellenberg } 4339b411b363SPhilipp Reisner 4340e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4341e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 43422fcb8f30SAndreas Gruenbacher conn_err(tconn, "No payload expected %s l:%d\n", 43432fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.size); 4344c13f7e1aSLars Ellenberg goto err_out; 4345c13f7e1aSLars Ellenberg } 4346c13f7e1aSLars Ellenberg 4347c13f7e1aSLars Ellenberg if (shs) { 4348e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4349a5c31904SAndreas Gruenbacher if (err) 435002918be2SPhilipp Reisner goto err_out; 4351e2857216SAndreas Gruenbacher pi.size -= shs; 4352b411b363SPhilipp Reisner } 435302918be2SPhilipp Reisner 43544a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 43554a76b161SAndreas Gruenbacher if (err) { 43569f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 43579f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 435802918be2SPhilipp Reisner goto err_out; 4359b411b363SPhilipp Reisner } 4360b411b363SPhilipp Reisner } 436182bc0194SAndreas Gruenbacher return; 436202918be2SPhilipp Reisner 436302918be2SPhilipp Reisner err_out: 4364bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4365b411b363SPhilipp Reisner } 4366b411b363SPhilipp Reisner 43670e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4368b411b363SPhilipp Reisner { 4369b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4370b411b363SPhilipp Reisner 4371b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 43720e29d163SPhilipp Reisner barr.w.tconn = tconn; 4373b411b363SPhilipp Reisner init_completion(&barr.done); 43740e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4375b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4376b411b363SPhilipp Reisner } 4377b411b363SPhilipp Reisner 437881fa2e67SPhilipp Reisner static void conn_disconnect(struct drbd_tconn *tconn) 4379b411b363SPhilipp Reisner { 4380c141ebdaSPhilipp Reisner struct drbd_conf *mdev; 4381bbeb641cSPhilipp Reisner enum drbd_conns oc; 4382376694a0SPhilipp Reisner int vnr; 4383b411b363SPhilipp Reisner 4384bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4385b411b363SPhilipp Reisner return; 4386b411b363SPhilipp Reisner 4387b8853dbdSPhilipp Reisner /* We are about to start the cleanup after connection loss. 4388b8853dbdSPhilipp Reisner * Make sure drbd_make_request knows about that. 4389b8853dbdSPhilipp Reisner * Usually we should be in some network failure state already, 4390b8853dbdSPhilipp Reisner * but just in case we are not, we fix it up here. 4391b8853dbdSPhilipp Reisner */ 4392b8853dbdSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4393b8853dbdSPhilipp Reisner 4394b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4395360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4396360cc740SPhilipp Reisner drbd_free_sock(tconn); 4397360cc740SPhilipp Reisner 4398c141ebdaSPhilipp Reisner rcu_read_lock(); 4399c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 4400c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 4401c141ebdaSPhilipp Reisner rcu_read_unlock(); 4402c141ebdaSPhilipp Reisner drbd_disconnected(mdev); 4403c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 4404c141ebdaSPhilipp Reisner rcu_read_lock(); 4405c141ebdaSPhilipp Reisner } 4406c141ebdaSPhilipp Reisner rcu_read_unlock(); 4407c141ebdaSPhilipp Reisner 440812038a3aSPhilipp Reisner if (!list_empty(&tconn->current_epoch->list)) 440912038a3aSPhilipp Reisner conn_err(tconn, "ASSERTION FAILED: tconn->current_epoch->list not empty\n"); 441012038a3aSPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 441112038a3aSPhilipp Reisner atomic_set(&tconn->current_epoch->epoch_size, 0); 441212038a3aSPhilipp Reisner 4413360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4414360cc740SPhilipp Reisner 4415cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4416cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4417cb703454SPhilipp Reisner 4418360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4419bbeb641cSPhilipp Reisner oc = tconn->cstate; 4420bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4421376694a0SPhilipp Reisner _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4422bbeb641cSPhilipp Reisner 4423360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4424360cc740SPhilipp Reisner 4425f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4426d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4427360cc740SPhilipp Reisner } 4428360cc740SPhilipp Reisner 4429c141ebdaSPhilipp Reisner static int drbd_disconnected(struct drbd_conf *mdev) 4430360cc740SPhilipp Reisner { 4431360cc740SPhilipp Reisner unsigned int i; 4432b411b363SPhilipp Reisner 443385719573SPhilipp Reisner /* wait for current activity to cease. */ 443487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4435b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4436b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4437b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 443887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4439b411b363SPhilipp Reisner 4440b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4441b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4442b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4443b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4444b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4445b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4446b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4447b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4448b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4449b411b363SPhilipp Reisner * on the fly. */ 4450b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4451b411b363SPhilipp Reisner mdev->rs_total = 0; 4452b411b363SPhilipp Reisner mdev->rs_failed = 0; 4453b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4454b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4455b411b363SPhilipp Reisner 4456b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4457b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4458b411b363SPhilipp Reisner 4459b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4460b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4461b411b363SPhilipp Reisner * to be "canceled" */ 4462a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4463b411b363SPhilipp Reisner 4464a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4465b411b363SPhilipp Reisner 4466d10b4ea3SPhilipp Reisner /* This second workqueue flush is necessary, since drbd_finish_peer_reqs() 4467d10b4ea3SPhilipp Reisner might have issued a work again. The one before drbd_finish_peer_reqs() is 4468d10b4ea3SPhilipp Reisner necessary to reclain net_ee in drbd_finish_peer_reqs(). */ 4469d10b4ea3SPhilipp Reisner drbd_flush_workqueue(mdev); 4470d10b4ea3SPhilipp Reisner 4471b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4472b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4473b411b363SPhilipp Reisner 44742aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 44752f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4476b411b363SPhilipp Reisner 4477b411b363SPhilipp Reisner drbd_md_sync(mdev); 4478b411b363SPhilipp Reisner 447920ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 448020ceb2b2SLars Ellenberg * if any. */ 448120ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 448220ceb2b2SLars Ellenberg 4483b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4484b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4485b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4486b411b363SPhilipp Reisner * 4487b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4488b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4489b411b363SPhilipp Reisner */ 44907721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4491b411b363SPhilipp Reisner if (i) 4492b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4493435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4494435f0740SLars Ellenberg if (i) 4495435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4496b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4497b411b363SPhilipp Reisner if (i) 449845bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4499b411b363SPhilipp Reisner 4500b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4501b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4502b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4503b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4504b411b363SPhilipp Reisner 4505360cc740SPhilipp Reisner return 0; 4506b411b363SPhilipp Reisner } 4507b411b363SPhilipp Reisner 4508b411b363SPhilipp Reisner /* 4509b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4510b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4511b411b363SPhilipp Reisner * 4512b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4513b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4514b411b363SPhilipp Reisner * 4515b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4516b411b363SPhilipp Reisner */ 45176038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4518b411b363SPhilipp Reisner { 45199f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 45209f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4521b411b363SPhilipp Reisner 45229f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45239f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 45249f5bdc33SAndreas Gruenbacher if (!p) 4525e8d17b01SAndreas Gruenbacher return -EIO; 4526b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4527b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4528b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 45299f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4530b411b363SPhilipp Reisner } 4531b411b363SPhilipp Reisner 4532b411b363SPhilipp Reisner /* 4533b411b363SPhilipp Reisner * return values: 4534b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4535b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4536b411b363SPhilipp Reisner * -1 peer talks different language, 4537b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4538b411b363SPhilipp Reisner */ 45396038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4540b411b363SPhilipp Reisner { 454165d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4542e658983aSAndreas Gruenbacher struct p_connection_features *p; 4543e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 454477351055SPhilipp Reisner struct packet_info pi; 4545a5c31904SAndreas Gruenbacher int err; 4546b411b363SPhilipp Reisner 45476038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4548e8d17b01SAndreas Gruenbacher if (err) 4549b411b363SPhilipp Reisner return 0; 4550b411b363SPhilipp Reisner 455169bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 455269bc7bc3SAndreas Gruenbacher if (err) 4553b411b363SPhilipp Reisner return 0; 4554b411b363SPhilipp Reisner 45556038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 45566038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 455777351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4558b411b363SPhilipp Reisner return -1; 4559b411b363SPhilipp Reisner } 4560b411b363SPhilipp Reisner 456177351055SPhilipp Reisner if (pi.size != expect) { 45626038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 456377351055SPhilipp Reisner expect, pi.size); 4564b411b363SPhilipp Reisner return -1; 4565b411b363SPhilipp Reisner } 4566b411b363SPhilipp Reisner 4567e658983aSAndreas Gruenbacher p = pi.data; 4568e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4569a5c31904SAndreas Gruenbacher if (err) 4570b411b363SPhilipp Reisner return 0; 4571b411b363SPhilipp Reisner 4572b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4573b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4574b411b363SPhilipp Reisner if (p->protocol_max == 0) 4575b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4576b411b363SPhilipp Reisner 4577b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4578b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4579b411b363SPhilipp Reisner goto incompat; 4580b411b363SPhilipp Reisner 458165d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4582b411b363SPhilipp Reisner 458365d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 458465d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4585b411b363SPhilipp Reisner 4586b411b363SPhilipp Reisner return 1; 4587b411b363SPhilipp Reisner 4588b411b363SPhilipp Reisner incompat: 458965d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4590b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4591b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4592b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4593b411b363SPhilipp Reisner return -1; 4594b411b363SPhilipp Reisner } 4595b411b363SPhilipp Reisner 4596b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 459713e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4598b411b363SPhilipp Reisner { 4599b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4600b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4601b10d96cbSJohannes Thoma return -1; 4602b411b363SPhilipp Reisner } 4603b411b363SPhilipp Reisner #else 4604b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4605b10d96cbSJohannes Thoma 4606b10d96cbSJohannes Thoma /* Return value: 4607b10d96cbSJohannes Thoma 1 - auth succeeded, 4608b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4609b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4610b10d96cbSJohannes Thoma */ 4611b10d96cbSJohannes Thoma 461213e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4613b411b363SPhilipp Reisner { 46149f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4615b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4616b411b363SPhilipp Reisner struct scatterlist sg; 4617b411b363SPhilipp Reisner char *response = NULL; 4618b411b363SPhilipp Reisner char *right_response = NULL; 4619b411b363SPhilipp Reisner char *peers_ch = NULL; 462044ed167dSPhilipp Reisner unsigned int key_len; 462144ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4622b411b363SPhilipp Reisner unsigned int resp_size; 4623b411b363SPhilipp Reisner struct hash_desc desc; 462477351055SPhilipp Reisner struct packet_info pi; 462544ed167dSPhilipp Reisner struct net_conf *nc; 462669bc7bc3SAndreas Gruenbacher int err, rv; 4627b411b363SPhilipp Reisner 46289f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 46299f5bdc33SAndreas Gruenbacher 463044ed167dSPhilipp Reisner rcu_read_lock(); 463144ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 463244ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 463344ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 463444ed167dSPhilipp Reisner rcu_read_unlock(); 463544ed167dSPhilipp Reisner 463613e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4637b411b363SPhilipp Reisner desc.flags = 0; 4638b411b363SPhilipp Reisner 463944ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4640b411b363SPhilipp Reisner if (rv) { 464113e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4642b10d96cbSJohannes Thoma rv = -1; 4643b411b363SPhilipp Reisner goto fail; 4644b411b363SPhilipp Reisner } 4645b411b363SPhilipp Reisner 4646b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4647b411b363SPhilipp Reisner 46489f5bdc33SAndreas Gruenbacher sock = &tconn->data; 46499f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 46509f5bdc33SAndreas Gruenbacher rv = 0; 46519f5bdc33SAndreas Gruenbacher goto fail; 46529f5bdc33SAndreas Gruenbacher } 4653e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 46549f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4655b411b363SPhilipp Reisner if (!rv) 4656b411b363SPhilipp Reisner goto fail; 4657b411b363SPhilipp Reisner 465869bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 465969bc7bc3SAndreas Gruenbacher if (err) { 466069bc7bc3SAndreas Gruenbacher rv = 0; 4661b411b363SPhilipp Reisner goto fail; 466269bc7bc3SAndreas Gruenbacher } 4663b411b363SPhilipp Reisner 466477351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 466513e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 466677351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4667b411b363SPhilipp Reisner rv = 0; 4668b411b363SPhilipp Reisner goto fail; 4669b411b363SPhilipp Reisner } 4670b411b363SPhilipp Reisner 467177351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 467213e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4673b10d96cbSJohannes Thoma rv = -1; 4674b411b363SPhilipp Reisner goto fail; 4675b411b363SPhilipp Reisner } 4676b411b363SPhilipp Reisner 467777351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4678b411b363SPhilipp Reisner if (peers_ch == NULL) { 467913e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4680b10d96cbSJohannes Thoma rv = -1; 4681b411b363SPhilipp Reisner goto fail; 4682b411b363SPhilipp Reisner } 4683b411b363SPhilipp Reisner 4684a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4685a5c31904SAndreas Gruenbacher if (err) { 4686b411b363SPhilipp Reisner rv = 0; 4687b411b363SPhilipp Reisner goto fail; 4688b411b363SPhilipp Reisner } 4689b411b363SPhilipp Reisner 469013e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4691b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4692b411b363SPhilipp Reisner if (response == NULL) { 469313e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4694b10d96cbSJohannes Thoma rv = -1; 4695b411b363SPhilipp Reisner goto fail; 4696b411b363SPhilipp Reisner } 4697b411b363SPhilipp Reisner 4698b411b363SPhilipp Reisner sg_init_table(&sg, 1); 469977351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4700b411b363SPhilipp Reisner 4701b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4702b411b363SPhilipp Reisner if (rv) { 470313e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4704b10d96cbSJohannes Thoma rv = -1; 4705b411b363SPhilipp Reisner goto fail; 4706b411b363SPhilipp Reisner } 4707b411b363SPhilipp Reisner 47089f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 47099f5bdc33SAndreas Gruenbacher rv = 0; 47109f5bdc33SAndreas Gruenbacher goto fail; 47119f5bdc33SAndreas Gruenbacher } 4712e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 47139f5bdc33SAndreas Gruenbacher response, resp_size); 4714b411b363SPhilipp Reisner if (!rv) 4715b411b363SPhilipp Reisner goto fail; 4716b411b363SPhilipp Reisner 471769bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 471869bc7bc3SAndreas Gruenbacher if (err) { 471969bc7bc3SAndreas Gruenbacher rv = 0; 4720b411b363SPhilipp Reisner goto fail; 472169bc7bc3SAndreas Gruenbacher } 4722b411b363SPhilipp Reisner 472377351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 472413e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 472577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4726b411b363SPhilipp Reisner rv = 0; 4727b411b363SPhilipp Reisner goto fail; 4728b411b363SPhilipp Reisner } 4729b411b363SPhilipp Reisner 473077351055SPhilipp Reisner if (pi.size != resp_size) { 473113e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4732b411b363SPhilipp Reisner rv = 0; 4733b411b363SPhilipp Reisner goto fail; 4734b411b363SPhilipp Reisner } 4735b411b363SPhilipp Reisner 4736a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4737a5c31904SAndreas Gruenbacher if (err) { 4738b411b363SPhilipp Reisner rv = 0; 4739b411b363SPhilipp Reisner goto fail; 4740b411b363SPhilipp Reisner } 4741b411b363SPhilipp Reisner 4742b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 47432d1ee87dSJulia Lawall if (right_response == NULL) { 474413e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4745b10d96cbSJohannes Thoma rv = -1; 4746b411b363SPhilipp Reisner goto fail; 4747b411b363SPhilipp Reisner } 4748b411b363SPhilipp Reisner 4749b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4750b411b363SPhilipp Reisner 4751b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4752b411b363SPhilipp Reisner if (rv) { 475313e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4754b10d96cbSJohannes Thoma rv = -1; 4755b411b363SPhilipp Reisner goto fail; 4756b411b363SPhilipp Reisner } 4757b411b363SPhilipp Reisner 4758b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4759b411b363SPhilipp Reisner 4760b411b363SPhilipp Reisner if (rv) 476144ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 476244ed167dSPhilipp Reisner resp_size); 4763b10d96cbSJohannes Thoma else 4764b10d96cbSJohannes Thoma rv = -1; 4765b411b363SPhilipp Reisner 4766b411b363SPhilipp Reisner fail: 4767b411b363SPhilipp Reisner kfree(peers_ch); 4768b411b363SPhilipp Reisner kfree(response); 4769b411b363SPhilipp Reisner kfree(right_response); 4770b411b363SPhilipp Reisner 4771b411b363SPhilipp Reisner return rv; 4772b411b363SPhilipp Reisner } 4773b411b363SPhilipp Reisner #endif 4774b411b363SPhilipp Reisner 4775b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4776b411b363SPhilipp Reisner { 4777392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4778b411b363SPhilipp Reisner int h; 4779b411b363SPhilipp Reisner 47804d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4781b411b363SPhilipp Reisner 4782b411b363SPhilipp Reisner do { 478381fa2e67SPhilipp Reisner h = conn_connect(tconn); 4784b411b363SPhilipp Reisner if (h == 0) { 478581fa2e67SPhilipp Reisner conn_disconnect(tconn); 478620ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4787b411b363SPhilipp Reisner } 4788b411b363SPhilipp Reisner if (h == -1) { 47894d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4790bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4791b411b363SPhilipp Reisner } 4792b411b363SPhilipp Reisner } while (h == 0); 4793b411b363SPhilipp Reisner 479491fd4dadSPhilipp Reisner if (h > 0) 47954d641dd7SPhilipp Reisner drbdd(tconn); 4796b411b363SPhilipp Reisner 479781fa2e67SPhilipp Reisner conn_disconnect(tconn); 4798b411b363SPhilipp Reisner 47994d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4800b411b363SPhilipp Reisner return 0; 4801b411b363SPhilipp Reisner } 4802b411b363SPhilipp Reisner 4803b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4804b411b363SPhilipp Reisner 4805e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4806b411b363SPhilipp Reisner { 4807e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4808b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4809b411b363SPhilipp Reisner 4810fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4811fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4812fc3b10a4SPhilipp Reisner } else { 4813fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4814fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4815fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4816fc3b10a4SPhilipp Reisner } 4817fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4818e4f78edeSPhilipp Reisner 48192735a594SAndreas Gruenbacher return 0; 4820fc3b10a4SPhilipp Reisner } 4821e4f78edeSPhilipp Reisner 48221952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4823e4f78edeSPhilipp Reisner { 48241952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4825e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4826e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4827e4f78edeSPhilipp Reisner 48281952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48291952e916SAndreas Gruenbacher if (!mdev) 48302735a594SAndreas Gruenbacher return -EIO; 48311952e916SAndreas Gruenbacher 48324d0fc3fdSPhilipp Reisner if (test_bit(CONN_WD_ST_CHG_REQ, &tconn->flags)) { 48334d0fc3fdSPhilipp Reisner D_ASSERT(tconn->agreed_pro_version < 100); 48344d0fc3fdSPhilipp Reisner return got_conn_RqSReply(tconn, pi); 48354d0fc3fdSPhilipp Reisner } 48364d0fc3fdSPhilipp Reisner 4837e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4838e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4839e4f78edeSPhilipp Reisner } else { 4840e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4841e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4842e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4843e4f78edeSPhilipp Reisner } 4844e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4845e4f78edeSPhilipp Reisner 48462735a594SAndreas Gruenbacher return 0; 4847b411b363SPhilipp Reisner } 4848b411b363SPhilipp Reisner 4849e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4850b411b363SPhilipp Reisner { 48512735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4852b411b363SPhilipp Reisner 4853b411b363SPhilipp Reisner } 4854b411b363SPhilipp Reisner 4855e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4856b411b363SPhilipp Reisner { 4857b411b363SPhilipp Reisner /* restore idle timeout */ 48582a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 48592a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 48602a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4861b411b363SPhilipp Reisner 48622735a594SAndreas Gruenbacher return 0; 4863b411b363SPhilipp Reisner } 4864b411b363SPhilipp Reisner 48651952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4866b411b363SPhilipp Reisner { 48671952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4868e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4869b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4870b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4871b411b363SPhilipp Reisner 48721952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48731952e916SAndreas Gruenbacher if (!mdev) 48742735a594SAndreas Gruenbacher return -EIO; 48751952e916SAndreas Gruenbacher 487631890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4877b411b363SPhilipp Reisner 4878b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4879b411b363SPhilipp Reisner 48801d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4881b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4882b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4883b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4884b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 48851d53f09eSLars Ellenberg put_ldev(mdev); 48861d53f09eSLars Ellenberg } 4887b411b363SPhilipp Reisner dec_rs_pending(mdev); 4888778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4889b411b363SPhilipp Reisner 48902735a594SAndreas Gruenbacher return 0; 4891b411b363SPhilipp Reisner } 4892b411b363SPhilipp Reisner 4893bc9c5c41SAndreas Gruenbacher static int 4894bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4895bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4896bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4897b411b363SPhilipp Reisner { 4898b411b363SPhilipp Reisner struct drbd_request *req; 4899b411b363SPhilipp Reisner struct bio_and_error m; 4900b411b363SPhilipp Reisner 490187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4902bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4903b411b363SPhilipp Reisner if (unlikely(!req)) { 490487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 490585997675SAndreas Gruenbacher return -EIO; 4906b411b363SPhilipp Reisner } 4907b411b363SPhilipp Reisner __req_mod(req, what, &m); 490887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4909b411b363SPhilipp Reisner 4910b411b363SPhilipp Reisner if (m.bio) 4911b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 491285997675SAndreas Gruenbacher return 0; 4913b411b363SPhilipp Reisner } 4914b411b363SPhilipp Reisner 49151952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4916b411b363SPhilipp Reisner { 49171952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4918e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4919b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4920b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4921b411b363SPhilipp Reisner enum drbd_req_event what; 4922b411b363SPhilipp Reisner 49231952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49241952e916SAndreas Gruenbacher if (!mdev) 49252735a594SAndreas Gruenbacher return -EIO; 49261952e916SAndreas Gruenbacher 4927b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4928b411b363SPhilipp Reisner 4929579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4930b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4931b411b363SPhilipp Reisner dec_rs_pending(mdev); 49322735a594SAndreas Gruenbacher return 0; 4933b411b363SPhilipp Reisner } 4934e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4935b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 49368554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4937b411b363SPhilipp Reisner break; 4938b411b363SPhilipp Reisner case P_WRITE_ACK: 49398554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4940b411b363SPhilipp Reisner break; 4941b411b363SPhilipp Reisner case P_RECV_ACK: 49428554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4943b411b363SPhilipp Reisner break; 49447be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 49457be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 49467be8da07SAndreas Gruenbacher break; 49477be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 49487be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4949b411b363SPhilipp Reisner break; 4950b411b363SPhilipp Reisner default: 49512735a594SAndreas Gruenbacher BUG(); 4952b411b363SPhilipp Reisner } 4953b411b363SPhilipp Reisner 49542735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4955bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4956bc9c5c41SAndreas Gruenbacher what, false); 4957b411b363SPhilipp Reisner } 4958b411b363SPhilipp Reisner 49591952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 4960b411b363SPhilipp Reisner { 49611952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4962e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4963b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 49642deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 496585997675SAndreas Gruenbacher int err; 4966b411b363SPhilipp Reisner 49671952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49681952e916SAndreas Gruenbacher if (!mdev) 49692735a594SAndreas Gruenbacher return -EIO; 49701952e916SAndreas Gruenbacher 4971b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4972b411b363SPhilipp Reisner 4973579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4974b411b363SPhilipp Reisner dec_rs_pending(mdev); 4975b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 49762735a594SAndreas Gruenbacher return 0; 4977b411b363SPhilipp Reisner } 49782deb8336SPhilipp Reisner 497985997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 4980bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4981303d1448SPhilipp Reisner NEG_ACKED, true); 498285997675SAndreas Gruenbacher if (err) { 49832deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 49842deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4985c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 49862deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 49872deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4988c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 49892deb8336SPhilipp Reisner } 49902735a594SAndreas Gruenbacher return 0; 4991b411b363SPhilipp Reisner } 4992b411b363SPhilipp Reisner 49931952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4994b411b363SPhilipp Reisner { 49951952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4996e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4997b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4998b411b363SPhilipp Reisner 49991952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50001952e916SAndreas Gruenbacher if (!mdev) 50012735a594SAndreas Gruenbacher return -EIO; 50021952e916SAndreas Gruenbacher 5003b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 50047be8da07SAndreas Gruenbacher 5005380207d0SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u.\n", 5006b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 5007b411b363SPhilipp Reisner 50082735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 5009bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 50108554df1cSAndreas Gruenbacher NEG_ACKED, false); 5011b411b363SPhilipp Reisner } 5012b411b363SPhilipp Reisner 50131952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 5014b411b363SPhilipp Reisner { 50151952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5016b411b363SPhilipp Reisner sector_t sector; 5017b411b363SPhilipp Reisner int size; 5018e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 50191952e916SAndreas Gruenbacher 50201952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50211952e916SAndreas Gruenbacher if (!mdev) 50222735a594SAndreas Gruenbacher return -EIO; 5023b411b363SPhilipp Reisner 5024b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5025b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5026b411b363SPhilipp Reisner 5027b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5028b411b363SPhilipp Reisner 5029b411b363SPhilipp Reisner dec_rs_pending(mdev); 5030b411b363SPhilipp Reisner 5031b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 5032b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5033e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 5034d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 5035b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 5036d612d309SPhilipp Reisner case P_RS_CANCEL: 5037d612d309SPhilipp Reisner break; 5038d612d309SPhilipp Reisner default: 50392735a594SAndreas Gruenbacher BUG(); 5040d612d309SPhilipp Reisner } 5041b411b363SPhilipp Reisner put_ldev(mdev); 5042b411b363SPhilipp Reisner } 5043b411b363SPhilipp Reisner 50442735a594SAndreas Gruenbacher return 0; 5045b411b363SPhilipp Reisner } 5046b411b363SPhilipp Reisner 50471952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 5048b411b363SPhilipp Reisner { 5049e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 50509ed57dcbSLars Ellenberg struct drbd_conf *mdev; 50519ed57dcbSLars Ellenberg int vnr; 50521952e916SAndreas Gruenbacher 50539ed57dcbSLars Ellenberg tl_release(tconn, p->barrier, be32_to_cpu(p->set_size)); 5054b411b363SPhilipp Reisner 50559ed57dcbSLars Ellenberg rcu_read_lock(); 50569ed57dcbSLars Ellenberg idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5057c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 5058c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 505936baf611SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->flags)) { 5060370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 5061370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 5062c4752ef1SPhilipp Reisner } 50639ed57dcbSLars Ellenberg } 50649ed57dcbSLars Ellenberg rcu_read_unlock(); 5065c4752ef1SPhilipp Reisner 50662735a594SAndreas Gruenbacher return 0; 5067b411b363SPhilipp Reisner } 5068b411b363SPhilipp Reisner 50691952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 5070b411b363SPhilipp Reisner { 50711952e916SAndreas Gruenbacher struct drbd_conf *mdev; 5072e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 5073b411b363SPhilipp Reisner struct drbd_work *w; 5074b411b363SPhilipp Reisner sector_t sector; 5075b411b363SPhilipp Reisner int size; 5076b411b363SPhilipp Reisner 50771952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 50781952e916SAndreas Gruenbacher if (!mdev) 50792735a594SAndreas Gruenbacher return -EIO; 50801952e916SAndreas Gruenbacher 5081b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 5082b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 5083b411b363SPhilipp Reisner 5084b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 5085b411b363SPhilipp Reisner 5086b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 50878f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 5088b411b363SPhilipp Reisner else 50898f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5090b411b363SPhilipp Reisner 50911d53f09eSLars Ellenberg if (!get_ldev(mdev)) 50922735a594SAndreas Gruenbacher return 0; 50931d53f09eSLars Ellenberg 5094b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 5095b411b363SPhilipp Reisner dec_rs_pending(mdev); 5096b411b363SPhilipp Reisner 5097ea5442afSLars Ellenberg --mdev->ov_left; 5098ea5442afSLars Ellenberg 5099ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 5100ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 5101ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 5102ea5442afSLars Ellenberg 5103ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 5104b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 5105b411b363SPhilipp Reisner if (w) { 5106b411b363SPhilipp Reisner w->cb = w_ov_finished; 5107a21e9298SPhilipp Reisner w->mdev = mdev; 5108e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 5109b411b363SPhilipp Reisner } else { 5110b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 51118f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 5112b411b363SPhilipp Reisner drbd_resync_finished(mdev); 5113b411b363SPhilipp Reisner } 5114b411b363SPhilipp Reisner } 51151d53f09eSLars Ellenberg put_ldev(mdev); 51162735a594SAndreas Gruenbacher return 0; 5117b411b363SPhilipp Reisner } 5118b411b363SPhilipp Reisner 51191952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 51200ced55a3SPhilipp Reisner { 51212735a594SAndreas Gruenbacher return 0; 51220ced55a3SPhilipp Reisner } 51230ced55a3SPhilipp Reisner 5124a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 512532862ec7SPhilipp Reisner { 5126082a3439SPhilipp Reisner struct drbd_conf *mdev; 5127c141ebdaSPhilipp Reisner int vnr, not_empty = 0; 512832862ec7SPhilipp Reisner 512932862ec7SPhilipp Reisner do { 513032862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 513132862ec7SPhilipp Reisner flush_signals(current); 5132c141ebdaSPhilipp Reisner 5133c141ebdaSPhilipp Reisner rcu_read_lock(); 5134c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5135c141ebdaSPhilipp Reisner kref_get(&mdev->kref); 5136c141ebdaSPhilipp Reisner rcu_read_unlock(); 5137d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 5138c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5139c141ebdaSPhilipp Reisner return 1; 5140082a3439SPhilipp Reisner } 5141c141ebdaSPhilipp Reisner kref_put(&mdev->kref, &drbd_minor_destroy); 5142c141ebdaSPhilipp Reisner rcu_read_lock(); 5143d3fcb490SPhilipp Reisner } 514432862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 5145082a3439SPhilipp Reisner 5146082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 5147c141ebdaSPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, vnr) { 5148082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 5149082a3439SPhilipp Reisner if (not_empty) 5150082a3439SPhilipp Reisner break; 5151082a3439SPhilipp Reisner } 5152082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 5153c141ebdaSPhilipp Reisner rcu_read_unlock(); 515432862ec7SPhilipp Reisner } while (not_empty); 515532862ec7SPhilipp Reisner 515632862ec7SPhilipp Reisner return 0; 515732862ec7SPhilipp Reisner } 515832862ec7SPhilipp Reisner 51597201b972SAndreas Gruenbacher struct asender_cmd { 51607201b972SAndreas Gruenbacher size_t pkt_size; 51611952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 51627201b972SAndreas Gruenbacher }; 51637201b972SAndreas Gruenbacher 51647201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 5165e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5166e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 51671952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 51681952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 51691952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 51701952e916SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 51711952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 51721952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 51731952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 51741952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 51751952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 51761952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 51771952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 51781952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 51791952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 51801952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 51811952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 51827201b972SAndreas Gruenbacher }; 51837201b972SAndreas Gruenbacher 5184b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5185b411b363SPhilipp Reisner { 5186392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5187b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 518877351055SPhilipp Reisner struct packet_info pi; 5189257d0af6SPhilipp Reisner int rv; 5190e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5191b411b363SPhilipp Reisner int received = 0; 519252b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 519352b061a4SAndreas Gruenbacher int expect = header_size; 519444ed167dSPhilipp Reisner bool ping_timeout_active = false; 519544ed167dSPhilipp Reisner struct net_conf *nc; 5196bb77d34eSAndreas Gruenbacher int ping_timeo, tcp_cork, ping_int; 5197b411b363SPhilipp Reisner 5198b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 5199b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 5200b411b363SPhilipp Reisner 5201e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 520280822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 520344ed167dSPhilipp Reisner 520444ed167dSPhilipp Reisner rcu_read_lock(); 520544ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 520644ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 5207bb77d34eSAndreas Gruenbacher tcp_cork = nc->tcp_cork; 520844ed167dSPhilipp Reisner ping_int = nc->ping_int; 520944ed167dSPhilipp Reisner rcu_read_unlock(); 521044ed167dSPhilipp Reisner 521132862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5212a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 521332862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5214841ce241SAndreas Gruenbacher goto reconnect; 5215841ce241SAndreas Gruenbacher } 521644ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 521744ed167dSPhilipp Reisner ping_timeout_active = true; 5218b411b363SPhilipp Reisner } 5219b411b363SPhilipp Reisner 522032862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 522132862ec7SPhilipp Reisner much to send */ 5222bb77d34eSAndreas Gruenbacher if (tcp_cork) 522332862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5224a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5225a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5226b411b363SPhilipp Reisner goto reconnect; 5227082a3439SPhilipp Reisner } 5228b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 5229bb77d34eSAndreas Gruenbacher if (tcp_cork) 523032862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5231b411b363SPhilipp Reisner 5232b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5233b411b363SPhilipp Reisner if (signal_pending(current)) 5234b411b363SPhilipp Reisner continue; 5235b411b363SPhilipp Reisner 523632862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 523732862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5238b411b363SPhilipp Reisner 5239b411b363SPhilipp Reisner flush_signals(current); 5240b411b363SPhilipp Reisner 5241b411b363SPhilipp Reisner /* Note: 5242b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5243b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5244b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5245b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5246b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5247b411b363SPhilipp Reisner * rv == expected: full header or command 5248b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5249b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5250b411b363SPhilipp Reisner */ 5251b411b363SPhilipp Reisner if (likely(rv > 0)) { 5252b411b363SPhilipp Reisner received += rv; 5253b411b363SPhilipp Reisner buf += rv; 5254b411b363SPhilipp Reisner } else if (rv == 0) { 525532862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5256b411b363SPhilipp Reisner goto reconnect; 5257b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5258cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5259cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 526032862ec7SPhilipp Reisner if (time_after(tconn->last_received, 526132862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5262cb6518cbSLars Ellenberg continue; 5263f36af18cSLars Ellenberg if (ping_timeout_active) { 526432862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5265b411b363SPhilipp Reisner goto reconnect; 5266b411b363SPhilipp Reisner } 526732862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5268b411b363SPhilipp Reisner continue; 5269b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5270b411b363SPhilipp Reisner continue; 5271b411b363SPhilipp Reisner } else { 527232862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5273b411b363SPhilipp Reisner goto reconnect; 5274b411b363SPhilipp Reisner } 5275b411b363SPhilipp Reisner 5276b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5277e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5278b411b363SPhilipp Reisner goto reconnect; 52797201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 52801952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 52812fcb8f30SAndreas Gruenbacher conn_err(tconn, "Unexpected meta packet %s (0x%04x)\n", 52822fcb8f30SAndreas Gruenbacher cmdname(pi.cmd), pi.cmd); 5283b411b363SPhilipp Reisner goto disconnect; 5284b411b363SPhilipp Reisner } 5285e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 528652b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 528732862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 528877351055SPhilipp Reisner pi.cmd, pi.size); 5289b411b363SPhilipp Reisner goto reconnect; 5290b411b363SPhilipp Reisner } 5291257d0af6SPhilipp Reisner } 5292b411b363SPhilipp Reisner if (received == expect) { 52932735a594SAndreas Gruenbacher bool err; 5294a4fbda8eSPhilipp Reisner 52952735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 52962735a594SAndreas Gruenbacher if (err) { 52971952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5298b411b363SPhilipp Reisner goto reconnect; 52991952e916SAndreas Gruenbacher } 5300b411b363SPhilipp Reisner 5301a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5302a4fbda8eSPhilipp Reisner 530344ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 530444ed167dSPhilipp Reisner /* restore idle timeout */ 530544ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 530644ed167dSPhilipp Reisner ping_timeout_active = false; 530744ed167dSPhilipp Reisner } 5308f36af18cSLars Ellenberg 5309e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5310b411b363SPhilipp Reisner received = 0; 531152b061a4SAndreas Gruenbacher expect = header_size; 5312b411b363SPhilipp Reisner cmd = NULL; 5313b411b363SPhilipp Reisner } 5314b411b363SPhilipp Reisner } 5315b411b363SPhilipp Reisner 5316b411b363SPhilipp Reisner if (0) { 5317b411b363SPhilipp Reisner reconnect: 5318bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5319b411b363SPhilipp Reisner } 5320b411b363SPhilipp Reisner if (0) { 5321b411b363SPhilipp Reisner disconnect: 5322bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5323b411b363SPhilipp Reisner } 532432862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5325b411b363SPhilipp Reisner 532632862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5327b411b363SPhilipp Reisner 5328b411b363SPhilipp Reisner return 0; 5329b411b363SPhilipp Reisner } 5330