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); 66360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data); 67b411b363SPhilipp Reisner 68b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 6999920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 73b411b363SPhilipp Reisner 7445bb912bSLars Ellenberg /* 7545bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7645bb912bSLars Ellenberg * page->private being our "next" pointer. 7745bb912bSLars Ellenberg */ 7845bb912bSLars Ellenberg 7945bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8045bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8145bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8245bb912bSLars Ellenberg */ 8345bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8445bb912bSLars Ellenberg { 8545bb912bSLars Ellenberg struct page *page; 8645bb912bSLars Ellenberg struct page *tmp; 8745bb912bSLars Ellenberg 8845bb912bSLars Ellenberg BUG_ON(!n); 8945bb912bSLars Ellenberg BUG_ON(!head); 9045bb912bSLars Ellenberg 9145bb912bSLars Ellenberg page = *head; 9223ce4227SPhilipp Reisner 9323ce4227SPhilipp Reisner if (!page) 9423ce4227SPhilipp Reisner return NULL; 9523ce4227SPhilipp Reisner 9645bb912bSLars Ellenberg while (page) { 9745bb912bSLars Ellenberg tmp = page_chain_next(page); 9845bb912bSLars Ellenberg if (--n == 0) 9945bb912bSLars Ellenberg break; /* found sufficient pages */ 10045bb912bSLars Ellenberg if (tmp == NULL) 10145bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10245bb912bSLars Ellenberg return NULL; 10345bb912bSLars Ellenberg page = tmp; 10445bb912bSLars Ellenberg } 10545bb912bSLars Ellenberg 10645bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10745bb912bSLars Ellenberg set_page_private(page, 0); 10845bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10945bb912bSLars Ellenberg page = *head; 11045bb912bSLars Ellenberg *head = tmp; 11145bb912bSLars Ellenberg return page; 11245bb912bSLars Ellenberg } 11345bb912bSLars Ellenberg 11445bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11545bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11645bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11745bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11845bb912bSLars Ellenberg { 11945bb912bSLars Ellenberg struct page *tmp; 12045bb912bSLars Ellenberg int i = 1; 12145bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12245bb912bSLars Ellenberg ++i, page = tmp; 12345bb912bSLars Ellenberg if (len) 12445bb912bSLars Ellenberg *len = i; 12545bb912bSLars Ellenberg return page; 12645bb912bSLars Ellenberg } 12745bb912bSLars Ellenberg 12845bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12945bb912bSLars Ellenberg { 13045bb912bSLars Ellenberg struct page *tmp; 13145bb912bSLars Ellenberg int i = 0; 13245bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13345bb912bSLars Ellenberg put_page(page); 13445bb912bSLars Ellenberg ++i; 13545bb912bSLars Ellenberg } 13645bb912bSLars Ellenberg return i; 13745bb912bSLars Ellenberg } 13845bb912bSLars Ellenberg 13945bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14045bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14145bb912bSLars Ellenberg { 14245bb912bSLars Ellenberg #if 1 14345bb912bSLars Ellenberg struct page *tmp; 14445bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14545bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14645bb912bSLars Ellenberg #endif 14745bb912bSLars Ellenberg 14845bb912bSLars Ellenberg /* add chain to head */ 14945bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15045bb912bSLars Ellenberg *head = chain_first; 15145bb912bSLars Ellenberg } 15245bb912bSLars Ellenberg 15318c2d522SAndreas Gruenbacher static struct page *__drbd_alloc_pages(struct drbd_conf *mdev, 15418c2d522SAndreas Gruenbacher unsigned int number) 155b411b363SPhilipp Reisner { 156b411b363SPhilipp Reisner struct page *page = NULL; 15745bb912bSLars Ellenberg struct page *tmp = NULL; 15818c2d522SAndreas Gruenbacher unsigned int i = 0; 159b411b363SPhilipp Reisner 160b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 161b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16245bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 163b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16445bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16545bb912bSLars Ellenberg if (page) 16645bb912bSLars Ellenberg drbd_pp_vacant -= number; 167b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16845bb912bSLars Ellenberg if (page) 16945bb912bSLars Ellenberg return page; 170b411b363SPhilipp Reisner } 17145bb912bSLars Ellenberg 172b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 173b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 174b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17545bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17645bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17745bb912bSLars Ellenberg if (!tmp) 17845bb912bSLars Ellenberg break; 17945bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18045bb912bSLars Ellenberg page = tmp; 18145bb912bSLars Ellenberg } 18245bb912bSLars Ellenberg 18345bb912bSLars Ellenberg if (i == number) 184b411b363SPhilipp Reisner return page; 18545bb912bSLars Ellenberg 18645bb912bSLars Ellenberg /* Not enough pages immediately available this time. 187c37c8ecfSAndreas Gruenbacher * No need to jump around here, drbd_alloc_pages will retry this 18845bb912bSLars Ellenberg * function "soon". */ 18945bb912bSLars Ellenberg if (page) { 19045bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19145bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19245bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19345bb912bSLars Ellenberg drbd_pp_vacant += i; 19445bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19545bb912bSLars Ellenberg } 19645bb912bSLars Ellenberg return NULL; 197b411b363SPhilipp Reisner } 198b411b363SPhilipp Reisner 199a990be46SAndreas Gruenbacher static void reclaim_finished_net_peer_reqs(struct drbd_conf *mdev, 200a990be46SAndreas Gruenbacher struct list_head *to_be_freed) 201b411b363SPhilipp Reisner { 202db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 203b411b363SPhilipp Reisner struct list_head *le, *tle; 204b411b363SPhilipp Reisner 205b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 206b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 207b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 208b411b363SPhilipp Reisner stop to examine the list... */ 209b411b363SPhilipp Reisner 210b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 211db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 212045417f7SAndreas Gruenbacher if (drbd_peer_req_has_active_page(peer_req)) 213b411b363SPhilipp Reisner break; 214b411b363SPhilipp Reisner list_move(le, to_be_freed); 215b411b363SPhilipp Reisner } 216b411b363SPhilipp Reisner } 217b411b363SPhilipp Reisner 218b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 219b411b363SPhilipp Reisner { 220b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 221db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 222b411b363SPhilipp Reisner 22387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 224a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 22587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 226b411b363SPhilipp Reisner 227db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 2283967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 229b411b363SPhilipp Reisner } 230b411b363SPhilipp Reisner 231b411b363SPhilipp Reisner /** 232c37c8ecfSAndreas Gruenbacher * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled) 233b411b363SPhilipp Reisner * @mdev: DRBD device. 23445bb912bSLars Ellenberg * @number: number of pages requested 23545bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 236b411b363SPhilipp Reisner * 23745bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23845bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23945bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 24045bb912bSLars Ellenberg * 24145bb912bSLars Ellenberg * Returns a page chain linked via page->private. 242b411b363SPhilipp Reisner */ 243c37c8ecfSAndreas Gruenbacher struct page *drbd_alloc_pages(struct drbd_conf *mdev, unsigned int number, 244c37c8ecfSAndreas Gruenbacher bool retry) 245b411b363SPhilipp Reisner { 246b411b363SPhilipp Reisner struct page *page = NULL; 24744ed167dSPhilipp Reisner struct net_conf *nc; 248b411b363SPhilipp Reisner DEFINE_WAIT(wait); 24944ed167dSPhilipp Reisner int mxb; 250b411b363SPhilipp Reisner 25145bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 25245bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25344ed167dSPhilipp Reisner rcu_read_lock(); 25444ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 25544ed167dSPhilipp Reisner mxb = nc ? nc->max_buffers : 1000000; 25644ed167dSPhilipp Reisner rcu_read_unlock(); 25744ed167dSPhilipp Reisner 25844ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) 25918c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 260b411b363SPhilipp Reisner 26145bb912bSLars Ellenberg while (page == NULL) { 262b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 263b411b363SPhilipp Reisner 264b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 265b411b363SPhilipp Reisner 26644ed167dSPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mxb) { 26718c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 268b411b363SPhilipp Reisner if (page) 269b411b363SPhilipp Reisner break; 270b411b363SPhilipp Reisner } 271b411b363SPhilipp Reisner 272b411b363SPhilipp Reisner if (!retry) 273b411b363SPhilipp Reisner break; 274b411b363SPhilipp Reisner 275b411b363SPhilipp Reisner if (signal_pending(current)) { 276c37c8ecfSAndreas Gruenbacher dev_warn(DEV, "drbd_alloc_pages interrupted!\n"); 277b411b363SPhilipp Reisner break; 278b411b363SPhilipp Reisner } 279b411b363SPhilipp Reisner 280b411b363SPhilipp Reisner schedule(); 281b411b363SPhilipp Reisner } 282b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 283b411b363SPhilipp Reisner 28445bb912bSLars Ellenberg if (page) 28545bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 286b411b363SPhilipp Reisner return page; 287b411b363SPhilipp Reisner } 288b411b363SPhilipp Reisner 289c37c8ecfSAndreas Gruenbacher /* Must not be used from irq, as that may deadlock: see drbd_alloc_pages. 29087eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 29145bb912bSLars Ellenberg * Either links the page chain back to the global pool, 29245bb912bSLars Ellenberg * or returns all pages to the system. */ 2935cc287e0SAndreas Gruenbacher static void drbd_free_pages(struct drbd_conf *mdev, struct page *page, int is_net) 294b411b363SPhilipp Reisner { 295435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 296b411b363SPhilipp Reisner int i; 297435f0740SLars Ellenberg 2981816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 29945bb912bSLars Ellenberg i = page_chain_free(page); 30045bb912bSLars Ellenberg else { 30145bb912bSLars Ellenberg struct page *tmp; 30245bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 303b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 30445bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 30545bb912bSLars Ellenberg drbd_pp_vacant += i; 306b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 307b411b363SPhilipp Reisner } 308435f0740SLars Ellenberg i = atomic_sub_return(i, a); 30945bb912bSLars Ellenberg if (i < 0) 310435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 311435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 312b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 313b411b363SPhilipp Reisner } 314b411b363SPhilipp Reisner 315b411b363SPhilipp Reisner /* 316b411b363SPhilipp Reisner You need to hold the req_lock: 317b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 318b411b363SPhilipp Reisner 319b411b363SPhilipp Reisner You must not have the req_lock: 3203967deb1SAndreas Gruenbacher drbd_free_peer_req() 3210db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3227721f567SAndreas Gruenbacher drbd_free_peer_reqs() 323b411b363SPhilipp Reisner drbd_ee_fix_bhs() 324a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 325b411b363SPhilipp Reisner drbd_clear_done_ee() 326b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 327b411b363SPhilipp Reisner */ 328b411b363SPhilipp Reisner 329f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 3300db55363SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector, 331f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 332b411b363SPhilipp Reisner { 333db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 334b411b363SPhilipp Reisner struct page *page; 33545bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 336b411b363SPhilipp Reisner 3370cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 338b411b363SPhilipp Reisner return NULL; 339b411b363SPhilipp Reisner 340db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 341db830c46SAndreas Gruenbacher if (!peer_req) { 342b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 3430db55363SAndreas Gruenbacher dev_err(DEV, "%s: allocation failed\n", __func__); 344b411b363SPhilipp Reisner return NULL; 345b411b363SPhilipp Reisner } 346b411b363SPhilipp Reisner 347c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 34845bb912bSLars Ellenberg if (!page) 34945bb912bSLars Ellenberg goto fail; 350b411b363SPhilipp Reisner 351db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 352db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 353db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 354db830c46SAndreas Gruenbacher peer_req->i.local = false; 355db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 35653840641SAndreas Gruenbacher 357db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 358a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 359db830c46SAndreas Gruenbacher peer_req->pages = page; 360db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 361db830c46SAndreas Gruenbacher peer_req->flags = 0; 3629a8e7753SAndreas Gruenbacher /* 3639a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3649a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3659a8e7753SAndreas Gruenbacher */ 366db830c46SAndreas Gruenbacher peer_req->block_id = id; 367b411b363SPhilipp Reisner 368db830c46SAndreas Gruenbacher return peer_req; 369b411b363SPhilipp Reisner 37045bb912bSLars Ellenberg fail: 371db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 372b411b363SPhilipp Reisner return NULL; 373b411b363SPhilipp Reisner } 374b411b363SPhilipp Reisner 3753967deb1SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 376f6ffca9fSAndreas Gruenbacher int is_net) 377b411b363SPhilipp Reisner { 378db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 379db830c46SAndreas Gruenbacher kfree(peer_req->digest); 3805cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, peer_req->pages, is_net); 381db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 382db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 383db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 384b411b363SPhilipp Reisner } 385b411b363SPhilipp Reisner 3867721f567SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_conf *mdev, struct list_head *list) 387b411b363SPhilipp Reisner { 388b411b363SPhilipp Reisner LIST_HEAD(work_list); 389db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 390b411b363SPhilipp Reisner int count = 0; 391435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 392b411b363SPhilipp Reisner 39387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 394b411b363SPhilipp Reisner list_splice_init(list, &work_list); 39587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 396b411b363SPhilipp Reisner 397db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 3983967deb1SAndreas Gruenbacher __drbd_free_peer_req(mdev, peer_req, is_net); 399b411b363SPhilipp Reisner count++; 400b411b363SPhilipp Reisner } 401b411b363SPhilipp Reisner return count; 402b411b363SPhilipp Reisner } 403b411b363SPhilipp Reisner 404a990be46SAndreas Gruenbacher /* 405a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 406b411b363SPhilipp Reisner */ 407a990be46SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_conf *mdev) 408b411b363SPhilipp Reisner { 409b411b363SPhilipp Reisner LIST_HEAD(work_list); 410b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 411db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 412e2b3032bSAndreas Gruenbacher int err = 0; 413b411b363SPhilipp Reisner 41487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 415a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 416b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 41787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 418b411b363SPhilipp Reisner 419db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 4203967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 421b411b363SPhilipp Reisner 422b411b363SPhilipp Reisner /* possible callbacks here: 4237be8da07SAndreas Gruenbacher * e_end_block, and e_end_resync_block, e_send_discard_write. 424b411b363SPhilipp Reisner * all ignore the last argument. 425b411b363SPhilipp Reisner */ 426db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 427e2b3032bSAndreas Gruenbacher int err2; 428e2b3032bSAndreas Gruenbacher 429b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 430e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 431e2b3032bSAndreas Gruenbacher if (!err) 432e2b3032bSAndreas Gruenbacher err = err2; 4333967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 434b411b363SPhilipp Reisner } 435b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 436b411b363SPhilipp Reisner 437e2b3032bSAndreas Gruenbacher return err; 438b411b363SPhilipp Reisner } 439b411b363SPhilipp Reisner 440d4da1537SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, 441d4da1537SAndreas Gruenbacher struct list_head *head) 442b411b363SPhilipp Reisner { 443b411b363SPhilipp Reisner DEFINE_WAIT(wait); 444b411b363SPhilipp Reisner 445b411b363SPhilipp Reisner /* avoids spin_lock/unlock 446b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 447b411b363SPhilipp Reisner while (!list_empty(head)) { 448b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 44987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4507eaceaccSJens Axboe io_schedule(); 451b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 45287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 453b411b363SPhilipp Reisner } 454b411b363SPhilipp Reisner } 455b411b363SPhilipp Reisner 456d4da1537SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_conf *mdev, 457d4da1537SAndreas Gruenbacher struct list_head *head) 458b411b363SPhilipp Reisner { 45987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 460b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 46187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 462b411b363SPhilipp Reisner } 463b411b363SPhilipp Reisner 464b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 465b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4667653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 467b411b363SPhilipp Reisner { 468b411b363SPhilipp Reisner struct sock *sk = sock->sk; 469b411b363SPhilipp Reisner int err = 0; 470b411b363SPhilipp Reisner 471b411b363SPhilipp Reisner *what = "listen"; 472b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 473b411b363SPhilipp Reisner if (err < 0) 474b411b363SPhilipp Reisner goto out; 475b411b363SPhilipp Reisner 476b411b363SPhilipp Reisner *what = "sock_create_lite"; 477b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 478b411b363SPhilipp Reisner newsock); 479b411b363SPhilipp Reisner if (err < 0) 480b411b363SPhilipp Reisner goto out; 481b411b363SPhilipp Reisner 482b411b363SPhilipp Reisner *what = "accept"; 483b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 484b411b363SPhilipp Reisner if (err < 0) { 485b411b363SPhilipp Reisner sock_release(*newsock); 486b411b363SPhilipp Reisner *newsock = NULL; 487b411b363SPhilipp Reisner goto out; 488b411b363SPhilipp Reisner } 489b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 490b411b363SPhilipp Reisner 491b411b363SPhilipp Reisner out: 492b411b363SPhilipp Reisner return err; 493b411b363SPhilipp Reisner } 494b411b363SPhilipp Reisner 495dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 496b411b363SPhilipp Reisner { 497b411b363SPhilipp Reisner mm_segment_t oldfs; 498b411b363SPhilipp Reisner struct kvec iov = { 499b411b363SPhilipp Reisner .iov_base = buf, 500b411b363SPhilipp Reisner .iov_len = size, 501b411b363SPhilipp Reisner }; 502b411b363SPhilipp Reisner struct msghdr msg = { 503b411b363SPhilipp Reisner .msg_iovlen = 1, 504b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 505b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 506b411b363SPhilipp Reisner }; 507b411b363SPhilipp Reisner int rv; 508b411b363SPhilipp Reisner 509b411b363SPhilipp Reisner oldfs = get_fs(); 510b411b363SPhilipp Reisner set_fs(KERNEL_DS); 511b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 512b411b363SPhilipp Reisner set_fs(oldfs); 513b411b363SPhilipp Reisner 514b411b363SPhilipp Reisner return rv; 515b411b363SPhilipp Reisner } 516b411b363SPhilipp Reisner 517de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 518b411b363SPhilipp Reisner { 519b411b363SPhilipp Reisner mm_segment_t oldfs; 520b411b363SPhilipp Reisner struct kvec iov = { 521b411b363SPhilipp Reisner .iov_base = buf, 522b411b363SPhilipp Reisner .iov_len = size, 523b411b363SPhilipp Reisner }; 524b411b363SPhilipp Reisner struct msghdr msg = { 525b411b363SPhilipp Reisner .msg_iovlen = 1, 526b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 527b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 528b411b363SPhilipp Reisner }; 529b411b363SPhilipp Reisner int rv; 530b411b363SPhilipp Reisner 531b411b363SPhilipp Reisner oldfs = get_fs(); 532b411b363SPhilipp Reisner set_fs(KERNEL_DS); 533b411b363SPhilipp Reisner 534b411b363SPhilipp Reisner for (;;) { 535de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 536b411b363SPhilipp Reisner if (rv == size) 537b411b363SPhilipp Reisner break; 538b411b363SPhilipp Reisner 539b411b363SPhilipp Reisner /* Note: 540b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 541b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 542b411b363SPhilipp Reisner */ 543b411b363SPhilipp Reisner 544b411b363SPhilipp Reisner if (rv < 0) { 545b411b363SPhilipp Reisner if (rv == -ECONNRESET) 546de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 547b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 548de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 549b411b363SPhilipp Reisner break; 550b411b363SPhilipp Reisner } else if (rv == 0) { 551de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 552b411b363SPhilipp Reisner break; 553b411b363SPhilipp Reisner } else { 554b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 555b411b363SPhilipp Reisner * after we read a partial message 556b411b363SPhilipp Reisner */ 557b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 558b411b363SPhilipp Reisner break; 559b411b363SPhilipp Reisner } 560b411b363SPhilipp Reisner }; 561b411b363SPhilipp Reisner 562b411b363SPhilipp Reisner set_fs(oldfs); 563b411b363SPhilipp Reisner 564b411b363SPhilipp Reisner if (rv != size) 565bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 566b411b363SPhilipp Reisner 567b411b363SPhilipp Reisner return rv; 568b411b363SPhilipp Reisner } 569b411b363SPhilipp Reisner 570c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 571c6967746SAndreas Gruenbacher { 572c6967746SAndreas Gruenbacher int err; 573c6967746SAndreas Gruenbacher 574c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 575c6967746SAndreas Gruenbacher if (err != size) { 576c6967746SAndreas Gruenbacher if (err >= 0) 577c6967746SAndreas Gruenbacher err = -EIO; 578c6967746SAndreas Gruenbacher } else 579c6967746SAndreas Gruenbacher err = 0; 580c6967746SAndreas Gruenbacher return err; 581c6967746SAndreas Gruenbacher } 582c6967746SAndreas Gruenbacher 583a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 584a5c31904SAndreas Gruenbacher { 585a5c31904SAndreas Gruenbacher int err; 586a5c31904SAndreas Gruenbacher 587a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 588a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 589a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 590a5c31904SAndreas Gruenbacher return err; 591a5c31904SAndreas Gruenbacher } 592a5c31904SAndreas Gruenbacher 5935dbf1673SLars Ellenberg /* quoting tcp(7): 5945dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5955dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5965dbf1673SLars Ellenberg * This is our wrapper to do so. 5975dbf1673SLars Ellenberg */ 5985dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5995dbf1673SLars Ellenberg unsigned int rcv) 6005dbf1673SLars Ellenberg { 6015dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 6025dbf1673SLars Ellenberg if (snd) { 6035dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 6045dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 6055dbf1673SLars Ellenberg } 6065dbf1673SLars Ellenberg if (rcv) { 6075dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 6085dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 6095dbf1673SLars Ellenberg } 6105dbf1673SLars Ellenberg } 6115dbf1673SLars Ellenberg 612eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 613b411b363SPhilipp Reisner { 614b411b363SPhilipp Reisner const char *what; 615b411b363SPhilipp Reisner struct socket *sock; 616b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 61744ed167dSPhilipp Reisner struct sockaddr_in6 peer_in6; 61844ed167dSPhilipp Reisner struct net_conf *nc; 61944ed167dSPhilipp Reisner int err, peer_addr_len, my_addr_len; 62044ed167dSPhilipp Reisner int sndbuf_size, rcvbuf_size, try_connect_int; 621b411b363SPhilipp Reisner int disconnect_on_error = 1; 622b411b363SPhilipp Reisner 62344ed167dSPhilipp Reisner rcu_read_lock(); 62444ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 62544ed167dSPhilipp Reisner if (!nc) { 62644ed167dSPhilipp Reisner rcu_read_unlock(); 627b411b363SPhilipp Reisner return NULL; 62844ed167dSPhilipp Reisner } 62944ed167dSPhilipp Reisner 63044ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 63144ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 63244ed167dSPhilipp Reisner try_connect_int = nc->try_connect_int; 63344ed167dSPhilipp Reisner 63444ed167dSPhilipp Reisner my_addr_len = min_t(int, nc->my_addr_len, sizeof(src_in6)); 63544ed167dSPhilipp Reisner memcpy(&src_in6, nc->my_addr, my_addr_len); 63644ed167dSPhilipp Reisner 63744ed167dSPhilipp Reisner if (((struct sockaddr *)nc->my_addr)->sa_family == AF_INET6) 63844ed167dSPhilipp Reisner src_in6.sin6_port = 0; 63944ed167dSPhilipp Reisner else 64044ed167dSPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 64144ed167dSPhilipp Reisner 64244ed167dSPhilipp Reisner peer_addr_len = min_t(int, nc->peer_addr_len, sizeof(src_in6)); 64344ed167dSPhilipp Reisner memcpy(&peer_in6, nc->peer_addr, peer_addr_len); 64444ed167dSPhilipp Reisner 64544ed167dSPhilipp Reisner rcu_read_unlock(); 646b411b363SPhilipp Reisner 647b411b363SPhilipp Reisner what = "sock_create_kern"; 64844ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family, 649b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 650b411b363SPhilipp Reisner if (err < 0) { 651b411b363SPhilipp Reisner sock = NULL; 652b411b363SPhilipp Reisner goto out; 653b411b363SPhilipp Reisner } 654b411b363SPhilipp Reisner 655b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 65644ed167dSPhilipp Reisner sock->sk->sk_sndtimeo = try_connect_int * HZ; 65744ed167dSPhilipp Reisner drbd_setbufsize(sock, sndbuf_size, rcvbuf_size); 658b411b363SPhilipp Reisner 659b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 660b411b363SPhilipp Reisner * for the outgoing connections. 661b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 662b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 663b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 664b411b363SPhilipp Reisner * a free one dynamically. 665b411b363SPhilipp Reisner */ 666b411b363SPhilipp Reisner what = "bind before connect"; 66744ed167dSPhilipp Reisner err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len); 668b411b363SPhilipp Reisner if (err < 0) 669b411b363SPhilipp Reisner goto out; 670b411b363SPhilipp Reisner 671b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 672b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 673b411b363SPhilipp Reisner disconnect_on_error = 0; 674b411b363SPhilipp Reisner what = "connect"; 67544ed167dSPhilipp Reisner err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0); 676b411b363SPhilipp Reisner 677b411b363SPhilipp Reisner out: 678b411b363SPhilipp Reisner if (err < 0) { 679b411b363SPhilipp Reisner if (sock) { 680b411b363SPhilipp Reisner sock_release(sock); 681b411b363SPhilipp Reisner sock = NULL; 682b411b363SPhilipp Reisner } 683b411b363SPhilipp Reisner switch (-err) { 684b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 685b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 686b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 687b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 688b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 689b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 690b411b363SPhilipp Reisner disconnect_on_error = 0; 691b411b363SPhilipp Reisner break; 692b411b363SPhilipp Reisner default: 693eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 694b411b363SPhilipp Reisner } 695b411b363SPhilipp Reisner if (disconnect_on_error) 696bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 697b411b363SPhilipp Reisner } 69844ed167dSPhilipp Reisner 699b411b363SPhilipp Reisner return sock; 700b411b363SPhilipp Reisner } 701b411b363SPhilipp Reisner 7027653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 703b411b363SPhilipp Reisner { 70444ed167dSPhilipp Reisner int timeo, err, my_addr_len; 70544ed167dSPhilipp Reisner int sndbuf_size, rcvbuf_size, try_connect_int; 706b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 70744ed167dSPhilipp Reisner struct sockaddr_in6 my_addr; 70844ed167dSPhilipp Reisner struct net_conf *nc; 709b411b363SPhilipp Reisner const char *what; 710b411b363SPhilipp Reisner 71144ed167dSPhilipp Reisner rcu_read_lock(); 71244ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 71344ed167dSPhilipp Reisner if (!nc) { 71444ed167dSPhilipp Reisner rcu_read_unlock(); 715b411b363SPhilipp Reisner return NULL; 71644ed167dSPhilipp Reisner } 71744ed167dSPhilipp Reisner 71844ed167dSPhilipp Reisner sndbuf_size = nc->sndbuf_size; 71944ed167dSPhilipp Reisner rcvbuf_size = nc->rcvbuf_size; 72044ed167dSPhilipp Reisner try_connect_int = nc->try_connect_int; 72144ed167dSPhilipp Reisner 72244ed167dSPhilipp Reisner my_addr_len = min_t(int, nc->my_addr_len, sizeof(struct sockaddr_in6)); 72344ed167dSPhilipp Reisner memcpy(&my_addr, nc->my_addr, my_addr_len); 72444ed167dSPhilipp Reisner rcu_read_unlock(); 725b411b363SPhilipp Reisner 726b411b363SPhilipp Reisner what = "sock_create_kern"; 72744ed167dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family, 728b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 729b411b363SPhilipp Reisner if (err) { 730b411b363SPhilipp Reisner s_listen = NULL; 731b411b363SPhilipp Reisner goto out; 732b411b363SPhilipp Reisner } 733b411b363SPhilipp Reisner 73444ed167dSPhilipp Reisner timeo = try_connect_int * HZ; 735b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 736b411b363SPhilipp Reisner 737b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 738b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 739b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 74044ed167dSPhilipp Reisner drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size); 741b411b363SPhilipp Reisner 742b411b363SPhilipp Reisner what = "bind before listen"; 74344ed167dSPhilipp Reisner err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len); 744b411b363SPhilipp Reisner if (err < 0) 745b411b363SPhilipp Reisner goto out; 746b411b363SPhilipp Reisner 7477653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 748b411b363SPhilipp Reisner 749b411b363SPhilipp Reisner out: 750b411b363SPhilipp Reisner if (s_listen) 751b411b363SPhilipp Reisner sock_release(s_listen); 752b411b363SPhilipp Reisner if (err < 0) { 753b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7547653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 755bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 756b411b363SPhilipp Reisner } 757b411b363SPhilipp Reisner } 758b411b363SPhilipp Reisner 759b411b363SPhilipp Reisner return s_estab; 760b411b363SPhilipp Reisner } 761b411b363SPhilipp Reisner 762e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 763b411b363SPhilipp Reisner 7649f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7659f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7669f5bdc33SAndreas Gruenbacher { 7679f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7689f5bdc33SAndreas Gruenbacher return -EIO; 769e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 770b411b363SPhilipp Reisner } 771b411b363SPhilipp Reisner 7729f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 773b411b363SPhilipp Reisner { 7749f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7759f5bdc33SAndreas Gruenbacher struct packet_info pi; 7769f5bdc33SAndreas Gruenbacher int err; 777b411b363SPhilipp Reisner 7789f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7799f5bdc33SAndreas Gruenbacher if (err != header_size) { 7809f5bdc33SAndreas Gruenbacher if (err >= 0) 7819f5bdc33SAndreas Gruenbacher err = -EIO; 7829f5bdc33SAndreas Gruenbacher return err; 7839f5bdc33SAndreas Gruenbacher } 7849f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 7859f5bdc33SAndreas Gruenbacher if (err) 7869f5bdc33SAndreas Gruenbacher return err; 7879f5bdc33SAndreas Gruenbacher return pi.cmd; 788b411b363SPhilipp Reisner } 789b411b363SPhilipp Reisner 790b411b363SPhilipp Reisner /** 791b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 792b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 793b411b363SPhilipp Reisner */ 794dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 795b411b363SPhilipp Reisner { 796b411b363SPhilipp Reisner int rr; 797b411b363SPhilipp Reisner char tb[4]; 798b411b363SPhilipp Reisner 799b411b363SPhilipp Reisner if (!*sock) 80081e84650SAndreas Gruenbacher return false; 801b411b363SPhilipp Reisner 802dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 803b411b363SPhilipp Reisner 804b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 80581e84650SAndreas Gruenbacher return true; 806b411b363SPhilipp Reisner } else { 807b411b363SPhilipp Reisner sock_release(*sock); 808b411b363SPhilipp Reisner *sock = NULL; 80981e84650SAndreas Gruenbacher return false; 810b411b363SPhilipp Reisner } 811b411b363SPhilipp Reisner } 8122325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 8132325eb66SPhilipp Reisner in a connection */ 8142325eb66SPhilipp Reisner int drbd_connected(int vnr, void *p, void *data) 815907599e0SPhilipp Reisner { 816907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 8170829f5edSAndreas Gruenbacher int err; 818907599e0SPhilipp Reisner 819907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 820907599e0SPhilipp Reisner mdev->peer_seq = 0; 821907599e0SPhilipp Reisner 8228410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 8238410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 8248410da8fSPhilipp Reisner &mdev->own_state_mutex; 8258410da8fSPhilipp Reisner 8260829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 8270829f5edSAndreas Gruenbacher if (!err) 8280829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 8290829f5edSAndreas Gruenbacher if (!err) 8300829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8310829f5edSAndreas Gruenbacher if (!err) 8320829f5edSAndreas Gruenbacher err = drbd_send_state(mdev); 833907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 834907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8358b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8360829f5edSAndreas Gruenbacher return err; 837907599e0SPhilipp Reisner } 838907599e0SPhilipp Reisner 839b411b363SPhilipp Reisner /* 840b411b363SPhilipp Reisner * return values: 841b411b363SPhilipp Reisner * 1 yes, we have a valid connection 842b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 843b411b363SPhilipp Reisner * -1 peer talks different language, 844b411b363SPhilipp Reisner * no point in trying again, please go standalone. 845b411b363SPhilipp Reisner * -2 We do not have a network config... 846b411b363SPhilipp Reisner */ 847907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 848b411b363SPhilipp Reisner { 8492bf89621SAndreas Gruenbacher struct socket *sock, *msock; 85044ed167dSPhilipp Reisner struct net_conf *nc; 85144ed167dSPhilipp Reisner int timeout, try, h, ok; 852b411b363SPhilipp Reisner 853bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 854b411b363SPhilipp Reisner return -2; 855b411b363SPhilipp Reisner 856907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 8570916e0e3SAndreas Gruenbacher 8580916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8590916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 860b411b363SPhilipp Reisner 861b411b363SPhilipp Reisner do { 8622bf89621SAndreas Gruenbacher struct socket *s; 8632bf89621SAndreas Gruenbacher 864b411b363SPhilipp Reisner for (try = 0;;) { 865b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 866907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 867b411b363SPhilipp Reisner if (s || ++try >= 3) 868b411b363SPhilipp Reisner break; 869b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 87020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 871b411b363SPhilipp Reisner } 872b411b363SPhilipp Reisner 873b411b363SPhilipp Reisner if (s) { 8742bf89621SAndreas Gruenbacher if (!tconn->data.socket) { 8752bf89621SAndreas Gruenbacher tconn->data.socket = s; 8769f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->data, P_INITIAL_DATA); 8772bf89621SAndreas Gruenbacher } else if (!tconn->meta.socket) { 8782bf89621SAndreas Gruenbacher tconn->meta.socket = s; 8799f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->meta, P_INITIAL_META); 880b411b363SPhilipp Reisner } else { 881907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 882b411b363SPhilipp Reisner goto out_release_sockets; 883b411b363SPhilipp Reisner } 884b411b363SPhilipp Reisner } 885b411b363SPhilipp Reisner 8862bf89621SAndreas Gruenbacher if (tconn->data.socket && tconn->meta.socket) { 887907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 8882bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 8892bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 890b411b363SPhilipp Reisner if (ok) 891b411b363SPhilipp Reisner break; 892b411b363SPhilipp Reisner } 893b411b363SPhilipp Reisner 894b411b363SPhilipp Reisner retry: 895907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 896b411b363SPhilipp Reisner if (s) { 8979f5bdc33SAndreas Gruenbacher try = receive_first_packet(tconn, s); 8982bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->data.socket); 8992bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->meta.socket); 900b411b363SPhilipp Reisner switch (try) { 901e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 9022bf89621SAndreas Gruenbacher if (tconn->data.socket) { 903907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 9042bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 905b411b363SPhilipp Reisner } 9062bf89621SAndreas Gruenbacher tconn->data.socket = s; 907b411b363SPhilipp Reisner break; 908e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 9092bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 910907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 9112bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 912b411b363SPhilipp Reisner } 9132bf89621SAndreas Gruenbacher tconn->meta.socket = s; 914907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 915b411b363SPhilipp Reisner break; 916b411b363SPhilipp Reisner default: 917907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 918b411b363SPhilipp Reisner sock_release(s); 919b411b363SPhilipp Reisner if (random32() & 1) 920b411b363SPhilipp Reisner goto retry; 921b411b363SPhilipp Reisner } 922b411b363SPhilipp Reisner } 923b411b363SPhilipp Reisner 924bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 925b411b363SPhilipp Reisner goto out_release_sockets; 926b411b363SPhilipp Reisner if (signal_pending(current)) { 927b411b363SPhilipp Reisner flush_signals(current); 928b411b363SPhilipp Reisner smp_rmb(); 929907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 930b411b363SPhilipp Reisner goto out_release_sockets; 931b411b363SPhilipp Reisner } 932b411b363SPhilipp Reisner 9332bf89621SAndreas Gruenbacher if (tconn->data.socket && &tconn->meta.socket) { 9342bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 9352bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 936b411b363SPhilipp Reisner if (ok) 937b411b363SPhilipp Reisner break; 938b411b363SPhilipp Reisner } 939b411b363SPhilipp Reisner } while (1); 940b411b363SPhilipp Reisner 9412bf89621SAndreas Gruenbacher sock = tconn->data.socket; 9422bf89621SAndreas Gruenbacher msock = tconn->meta.socket; 9432bf89621SAndreas Gruenbacher 944b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 945b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 946b411b363SPhilipp Reisner 947b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 948b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 949b411b363SPhilipp Reisner 950b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 951b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 952b411b363SPhilipp Reisner 953b411b363SPhilipp Reisner /* NOT YET ... 954907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 955b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9566038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 957b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 95844ed167dSPhilipp Reisner rcu_read_lock(); 95944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 960b411b363SPhilipp Reisner 96144ed167dSPhilipp Reisner sock->sk->sk_sndtimeo = 96244ed167dSPhilipp Reisner sock->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10; 96344ed167dSPhilipp Reisner 96444ed167dSPhilipp Reisner msock->sk->sk_rcvtimeo = nc->ping_int*HZ; 96544ed167dSPhilipp Reisner timeout = nc->timeout * HZ / 10; 96644ed167dSPhilipp Reisner rcu_read_unlock(); 96744ed167dSPhilipp Reisner 96844ed167dSPhilipp Reisner msock->sk->sk_sndtimeo = timeout; 969b411b363SPhilipp Reisner 970b411b363SPhilipp Reisner /* we don't want delays. 97125985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 972b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 973b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 974b411b363SPhilipp Reisner 975907599e0SPhilipp Reisner tconn->last_received = jiffies; 976b411b363SPhilipp Reisner 9776038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 978b411b363SPhilipp Reisner if (h <= 0) 979b411b363SPhilipp Reisner return h; 980b411b363SPhilipp Reisner 981907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 982b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 983907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 984b10d96cbSJohannes Thoma case -1: 985907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 986b411b363SPhilipp Reisner return -1; 987b10d96cbSJohannes Thoma case 0: 988907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 989b10d96cbSJohannes Thoma return 0; 990b411b363SPhilipp Reisner } 991b411b363SPhilipp Reisner } 992b411b363SPhilipp Reisner 993bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 994b411b363SPhilipp Reisner return 0; 995b411b363SPhilipp Reisner 99644ed167dSPhilipp Reisner sock->sk->sk_sndtimeo = timeout; 997b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 998b411b363SPhilipp Reisner 999907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 1000b411b363SPhilipp Reisner 1001387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 10027e2455c1SPhilipp Reisner return -1; 1003b411b363SPhilipp Reisner 1004d3fcb490SPhilipp Reisner down_read(&drbd_cfg_rwsem); 1005d3fcb490SPhilipp Reisner h = !idr_for_each(&tconn->volumes, drbd_connected, tconn); 1006d3fcb490SPhilipp Reisner up_read(&drbd_cfg_rwsem); 1007d3fcb490SPhilipp Reisner return h; 1008b411b363SPhilipp Reisner 1009b411b363SPhilipp Reisner out_release_sockets: 10102bf89621SAndreas Gruenbacher if (tconn->data.socket) { 10112bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 10122bf89621SAndreas Gruenbacher tconn->data.socket = NULL; 10132bf89621SAndreas Gruenbacher } 10142bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 10152bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 10162bf89621SAndreas Gruenbacher tconn->meta.socket = NULL; 10172bf89621SAndreas Gruenbacher } 1018b411b363SPhilipp Reisner return -1; 1019b411b363SPhilipp Reisner } 1020b411b363SPhilipp Reisner 1021e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 1022b411b363SPhilipp Reisner { 1023e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 1024e658983aSAndreas Gruenbacher 10250c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 10260c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 10270c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 10280c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 10290c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 10300c8e36d9SAndreas Gruenbacher return -EINVAL; 10310c8e36d9SAndreas Gruenbacher } 10320c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 10330c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 10340c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 10350c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 1036e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 1037e658983aSAndreas Gruenbacher struct p_header95 *h = header; 1038e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1039b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 1040eefc2f7dSPhilipp Reisner pi->vnr = 0; 1041e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1042e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1043e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1044e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1045e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 104677351055SPhilipp Reisner pi->vnr = 0; 104702918be2SPhilipp Reisner } else { 1048e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1049e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1050e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 10518172f3e9SAndreas Gruenbacher return -EINVAL; 1052b411b363SPhilipp Reisner } 1053e658983aSAndreas Gruenbacher pi->data = header + header_size; 10548172f3e9SAndreas Gruenbacher return 0; 1055257d0af6SPhilipp Reisner } 1056257d0af6SPhilipp Reisner 10579ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1058257d0af6SPhilipp Reisner { 1059e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 106069bc7bc3SAndreas Gruenbacher int err; 1061257d0af6SPhilipp Reisner 1062e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1063a5c31904SAndreas Gruenbacher if (err) 106469bc7bc3SAndreas Gruenbacher return err; 1065257d0af6SPhilipp Reisner 1066e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 10679ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1068b411b363SPhilipp Reisner 106969bc7bc3SAndreas Gruenbacher return err; 1070b411b363SPhilipp Reisner } 1071b411b363SPhilipp Reisner 10722451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 1073b411b363SPhilipp Reisner { 1074b411b363SPhilipp Reisner int rv; 1075b411b363SPhilipp Reisner 1076b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 1077fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 1078dd3932edSChristoph Hellwig NULL); 1079b411b363SPhilipp Reisner if (rv) { 1080b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 1081b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1082b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1083b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1084b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 1085b411b363SPhilipp Reisner } 1086b411b363SPhilipp Reisner put_ldev(mdev); 1087b411b363SPhilipp Reisner } 1088b411b363SPhilipp Reisner } 1089b411b363SPhilipp Reisner 1090b411b363SPhilipp Reisner /** 1091b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1092b411b363SPhilipp Reisner * @mdev: DRBD device. 1093b411b363SPhilipp Reisner * @epoch: Epoch object. 1094b411b363SPhilipp Reisner * @ev: Epoch event. 1095b411b363SPhilipp Reisner */ 1096b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1097b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1098b411b363SPhilipp Reisner enum epoch_event ev) 1099b411b363SPhilipp Reisner { 11002451fc3bSPhilipp Reisner int epoch_size; 1101b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1102b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1103b411b363SPhilipp Reisner 1104b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1105b411b363SPhilipp Reisner do { 1106b411b363SPhilipp Reisner next_epoch = NULL; 1107b411b363SPhilipp Reisner 1108b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1109b411b363SPhilipp Reisner 1110b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1111b411b363SPhilipp Reisner case EV_PUT: 1112b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1113b411b363SPhilipp Reisner break; 1114b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1115b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1116b411b363SPhilipp Reisner break; 1117b411b363SPhilipp Reisner case EV_BECAME_LAST: 1118b411b363SPhilipp Reisner /* nothing to do*/ 1119b411b363SPhilipp Reisner break; 1120b411b363SPhilipp Reisner } 1121b411b363SPhilipp Reisner 1122b411b363SPhilipp Reisner if (epoch_size != 0 && 1123b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 11242451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1125b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1126b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1127b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1128b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1129b411b363SPhilipp Reisner } 1130b411b363SPhilipp Reisner dec_unacked(mdev); 1131b411b363SPhilipp Reisner 1132b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1133b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1134b411b363SPhilipp Reisner list_del(&epoch->list); 1135b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1136b411b363SPhilipp Reisner mdev->epochs--; 1137b411b363SPhilipp Reisner kfree(epoch); 1138b411b363SPhilipp Reisner 1139b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1140b411b363SPhilipp Reisner rv = FE_DESTROYED; 1141b411b363SPhilipp Reisner } else { 1142b411b363SPhilipp Reisner epoch->flags = 0; 1143b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1144698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1145b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1146b411b363SPhilipp Reisner rv = FE_RECYCLED; 11472451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1148b411b363SPhilipp Reisner } 1149b411b363SPhilipp Reisner } 1150b411b363SPhilipp Reisner 1151b411b363SPhilipp Reisner if (!next_epoch) 1152b411b363SPhilipp Reisner break; 1153b411b363SPhilipp Reisner 1154b411b363SPhilipp Reisner epoch = next_epoch; 1155b411b363SPhilipp Reisner } while (1); 1156b411b363SPhilipp Reisner 1157b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1158b411b363SPhilipp Reisner 1159b411b363SPhilipp Reisner return rv; 1160b411b363SPhilipp Reisner } 1161b411b363SPhilipp Reisner 1162b411b363SPhilipp Reisner /** 1163b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1164b411b363SPhilipp Reisner * @mdev: DRBD device. 1165b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1166b411b363SPhilipp Reisner */ 1167b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1168b411b363SPhilipp Reisner { 1169daeda1ccSPhilipp Reisner struct disk_conf *dc; 1170b411b363SPhilipp Reisner enum write_ordering_e pwo; 1171b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1172b411b363SPhilipp Reisner [WO_none] = "none", 1173b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1174b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1175b411b363SPhilipp Reisner }; 1176b411b363SPhilipp Reisner 1177b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1178b411b363SPhilipp Reisner wo = min(pwo, wo); 1179daeda1ccSPhilipp Reisner rcu_read_lock(); 1180daeda1ccSPhilipp Reisner dc = rcu_dereference(mdev->ldev->disk_conf); 1181daeda1ccSPhilipp Reisner 1182daeda1ccSPhilipp Reisner if (wo == WO_bdev_flush && dc->no_disk_flush) 1183b411b363SPhilipp Reisner wo = WO_drain_io; 1184daeda1ccSPhilipp Reisner if (wo == WO_drain_io && dc->no_disk_drain) 1185b411b363SPhilipp Reisner wo = WO_none; 1186daeda1ccSPhilipp Reisner rcu_read_unlock(); 1187b411b363SPhilipp Reisner mdev->write_ordering = wo; 11882451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1189b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1190b411b363SPhilipp Reisner } 1191b411b363SPhilipp Reisner 1192b411b363SPhilipp Reisner /** 1193fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 119445bb912bSLars Ellenberg * @mdev: DRBD device. 1195db830c46SAndreas Gruenbacher * @peer_req: peer request 119645bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 119710f6d992SLars Ellenberg * 119810f6d992SLars Ellenberg * May spread the pages to multiple bios, 119910f6d992SLars Ellenberg * depending on bio_add_page restrictions. 120010f6d992SLars Ellenberg * 120110f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 120210f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 120310f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 120410f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 120510f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 120610f6d992SLars Ellenberg * on certain Xen deployments. 120745bb912bSLars Ellenberg */ 120845bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1209fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1210fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 121145bb912bSLars Ellenberg const unsigned rw, const int fault_type) 121245bb912bSLars Ellenberg { 121345bb912bSLars Ellenberg struct bio *bios = NULL; 121445bb912bSLars Ellenberg struct bio *bio; 1215db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1216db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1217db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 121845bb912bSLars Ellenberg unsigned n_bios = 0; 121945bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 122010f6d992SLars Ellenberg int err = -ENOMEM; 122145bb912bSLars Ellenberg 122245bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 122345bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 122445bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1225da4a75d2SLars Ellenberg * request in more than one bio. 1226da4a75d2SLars Ellenberg * 1227da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1228da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1229da4a75d2SLars Ellenberg */ 123045bb912bSLars Ellenberg next_bio: 123145bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 123245bb912bSLars Ellenberg if (!bio) { 123345bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 123445bb912bSLars Ellenberg goto fail; 123545bb912bSLars Ellenberg } 1236db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 123745bb912bSLars Ellenberg bio->bi_sector = sector; 123845bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 123945bb912bSLars Ellenberg bio->bi_rw = rw; 1240db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1241fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 124245bb912bSLars Ellenberg 124345bb912bSLars Ellenberg bio->bi_next = bios; 124445bb912bSLars Ellenberg bios = bio; 124545bb912bSLars Ellenberg ++n_bios; 124645bb912bSLars Ellenberg 124745bb912bSLars Ellenberg page_chain_for_each(page) { 124845bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 124945bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 125010f6d992SLars Ellenberg /* A single page must always be possible! 125110f6d992SLars Ellenberg * But in case it fails anyways, 125210f6d992SLars Ellenberg * we deal with it, and complain (below). */ 125310f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 125410f6d992SLars Ellenberg dev_err(DEV, 125510f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 125610f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 125710f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 125810f6d992SLars Ellenberg err = -ENOSPC; 125910f6d992SLars Ellenberg goto fail; 126010f6d992SLars Ellenberg } 126145bb912bSLars Ellenberg goto next_bio; 126245bb912bSLars Ellenberg } 126345bb912bSLars Ellenberg ds -= len; 126445bb912bSLars Ellenberg sector += len >> 9; 126545bb912bSLars Ellenberg --nr_pages; 126645bb912bSLars Ellenberg } 126745bb912bSLars Ellenberg D_ASSERT(page == NULL); 126845bb912bSLars Ellenberg D_ASSERT(ds == 0); 126945bb912bSLars Ellenberg 1270db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 127145bb912bSLars Ellenberg do { 127245bb912bSLars Ellenberg bio = bios; 127345bb912bSLars Ellenberg bios = bios->bi_next; 127445bb912bSLars Ellenberg bio->bi_next = NULL; 127545bb912bSLars Ellenberg 127645bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 127745bb912bSLars Ellenberg } while (bios); 127845bb912bSLars Ellenberg return 0; 127945bb912bSLars Ellenberg 128045bb912bSLars Ellenberg fail: 128145bb912bSLars Ellenberg while (bios) { 128245bb912bSLars Ellenberg bio = bios; 128345bb912bSLars Ellenberg bios = bios->bi_next; 128445bb912bSLars Ellenberg bio_put(bio); 128545bb912bSLars Ellenberg } 128610f6d992SLars Ellenberg return err; 128745bb912bSLars Ellenberg } 128845bb912bSLars Ellenberg 128953840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1290db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 129153840641SAndreas Gruenbacher { 1292db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 129353840641SAndreas Gruenbacher 129453840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 129553840641SAndreas Gruenbacher drbd_clear_interval(i); 129653840641SAndreas Gruenbacher 12976c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 129853840641SAndreas Gruenbacher if (i->waiting) 129953840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 130053840641SAndreas Gruenbacher } 130153840641SAndreas Gruenbacher 13024a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1303b411b363SPhilipp Reisner { 13044a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 13052451fc3bSPhilipp Reisner int rv; 1306e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1307b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1308b411b363SPhilipp Reisner 13094a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 13104a76b161SAndreas Gruenbacher if (!mdev) 13114a76b161SAndreas Gruenbacher return -EIO; 13124a76b161SAndreas Gruenbacher 1313b411b363SPhilipp Reisner inc_unacked(mdev); 1314b411b363SPhilipp Reisner 1315b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1316b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1317b411b363SPhilipp Reisner 1318b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1319b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1320b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1321b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1322b411b363SPhilipp Reisner * completed. */ 1323b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1324b411b363SPhilipp Reisner case WO_none: 1325b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 132682bc0194SAndreas Gruenbacher return 0; 1327b411b363SPhilipp Reisner 1328b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1329b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1330b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 13312451fc3bSPhilipp Reisner if (epoch) 13322451fc3bSPhilipp Reisner break; 13332451fc3bSPhilipp Reisner else 1334b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 13352451fc3bSPhilipp Reisner /* Fall through */ 13362451fc3bSPhilipp Reisner 13372451fc3bSPhilipp Reisner case WO_bdev_flush: 13382451fc3bSPhilipp Reisner case WO_drain_io: 1339b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 13402451fc3bSPhilipp Reisner drbd_flush(mdev); 13412451fc3bSPhilipp Reisner 13422451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 13432451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 13442451fc3bSPhilipp Reisner if (epoch) 13452451fc3bSPhilipp Reisner break; 1346b411b363SPhilipp Reisner } 1347b411b363SPhilipp Reisner 13482451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 13492451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 13502451fc3bSPhilipp Reisner 13512451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 13522451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1353b411b363SPhilipp Reisner 135482bc0194SAndreas Gruenbacher return 0; 13552451fc3bSPhilipp Reisner default: 13562451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 135782bc0194SAndreas Gruenbacher return -EIO; 1358b411b363SPhilipp Reisner } 1359b411b363SPhilipp Reisner 1360b411b363SPhilipp Reisner epoch->flags = 0; 1361b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1362b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1363b411b363SPhilipp Reisner 1364b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1365b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1366b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1367b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1368b411b363SPhilipp Reisner mdev->epochs++; 1369b411b363SPhilipp Reisner } else { 1370b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1371b411b363SPhilipp Reisner kfree(epoch); 1372b411b363SPhilipp Reisner } 1373b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1374b411b363SPhilipp Reisner 137582bc0194SAndreas Gruenbacher return 0; 1376b411b363SPhilipp Reisner } 1377b411b363SPhilipp Reisner 1378b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1379b411b363SPhilipp Reisner * and from receive_Data */ 1380f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1381f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1382f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1383b411b363SPhilipp Reisner { 13846666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1385db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1386b411b363SPhilipp Reisner struct page *page; 1387a5c31904SAndreas Gruenbacher int dgs, ds, err; 1388a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1389a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 13906b4388acSPhilipp Reisner unsigned long *data; 1391b411b363SPhilipp Reisner 139288104ca4SAndreas Gruenbacher dgs = 0; 139388104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 139488104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 13959f5bdc33SAndreas Gruenbacher /* 13969f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 13979f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 13989f5bdc33SAndreas Gruenbacher */ 1399a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1400a5c31904SAndreas Gruenbacher if (err) 1401b411b363SPhilipp Reisner return NULL; 1402b411b363SPhilipp Reisner data_size -= dgs; 140388104ca4SAndreas Gruenbacher } 1404b411b363SPhilipp Reisner 1405841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1406841ce241SAndreas Gruenbacher return NULL; 1407841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1408841ce241SAndreas Gruenbacher return NULL; 1409841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1410841ce241SAndreas Gruenbacher return NULL; 1411b411b363SPhilipp Reisner 14126666032aSLars Ellenberg /* even though we trust out peer, 14136666032aSLars Ellenberg * we sometimes have to double check. */ 14146666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1415fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1416fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 14176666032aSLars Ellenberg (unsigned long long)capacity, 14186666032aSLars Ellenberg (unsigned long long)sector, data_size); 14196666032aSLars Ellenberg return NULL; 14206666032aSLars Ellenberg } 14216666032aSLars Ellenberg 1422b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1423b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1424b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 14250db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1426db830c46SAndreas Gruenbacher if (!peer_req) 1427b411b363SPhilipp Reisner return NULL; 142845bb912bSLars Ellenberg 1429b411b363SPhilipp Reisner ds = data_size; 1430db830c46SAndreas Gruenbacher page = peer_req->pages; 143145bb912bSLars Ellenberg page_chain_for_each(page) { 143245bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 14336b4388acSPhilipp Reisner data = kmap(page); 1434a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 14350cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 14366b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 14376b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 14386b4388acSPhilipp Reisner } 1439b411b363SPhilipp Reisner kunmap(page); 1440a5c31904SAndreas Gruenbacher if (err) { 14413967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1442b411b363SPhilipp Reisner return NULL; 1443b411b363SPhilipp Reisner } 1444a5c31904SAndreas Gruenbacher ds -= len; 1445b411b363SPhilipp Reisner } 1446b411b363SPhilipp Reisner 1447b411b363SPhilipp Reisner if (dgs) { 14485b614abeSAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->peer_integrity_tfm, peer_req, dig_vv); 1449b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1450470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1451470be44aSLars Ellenberg (unsigned long long)sector, data_size); 14523967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1453b411b363SPhilipp Reisner return NULL; 1454b411b363SPhilipp Reisner } 1455b411b363SPhilipp Reisner } 1456b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1457db830c46SAndreas Gruenbacher return peer_req; 1458b411b363SPhilipp Reisner } 1459b411b363SPhilipp Reisner 1460b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1461b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1462b411b363SPhilipp Reisner */ 1463b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1464b411b363SPhilipp Reisner { 1465b411b363SPhilipp Reisner struct page *page; 1466a5c31904SAndreas Gruenbacher int err = 0; 1467b411b363SPhilipp Reisner void *data; 1468b411b363SPhilipp Reisner 1469c3470cdeSLars Ellenberg if (!data_size) 1470fc5be839SAndreas Gruenbacher return 0; 1471c3470cdeSLars Ellenberg 1472c37c8ecfSAndreas Gruenbacher page = drbd_alloc_pages(mdev, 1, 1); 1473b411b363SPhilipp Reisner 1474b411b363SPhilipp Reisner data = kmap(page); 1475b411b363SPhilipp Reisner while (data_size) { 1476fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1477fc5be839SAndreas Gruenbacher 1478a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1479a5c31904SAndreas Gruenbacher if (err) 1480b411b363SPhilipp Reisner break; 1481a5c31904SAndreas Gruenbacher data_size -= len; 1482b411b363SPhilipp Reisner } 1483b411b363SPhilipp Reisner kunmap(page); 14845cc287e0SAndreas Gruenbacher drbd_free_pages(mdev, page, 0); 1485fc5be839SAndreas Gruenbacher return err; 1486b411b363SPhilipp Reisner } 1487b411b363SPhilipp Reisner 1488b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1489b411b363SPhilipp Reisner sector_t sector, int data_size) 1490b411b363SPhilipp Reisner { 1491b411b363SPhilipp Reisner struct bio_vec *bvec; 1492b411b363SPhilipp Reisner struct bio *bio; 1493a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1494a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1495a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1496b411b363SPhilipp Reisner 149788104ca4SAndreas Gruenbacher dgs = 0; 149888104ca4SAndreas Gruenbacher if (mdev->tconn->peer_integrity_tfm) { 149988104ca4SAndreas Gruenbacher dgs = crypto_hash_digestsize(mdev->tconn->peer_integrity_tfm); 1500a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1501a5c31904SAndreas Gruenbacher if (err) 1502a5c31904SAndreas Gruenbacher return err; 1503b411b363SPhilipp Reisner data_size -= dgs; 150488104ca4SAndreas Gruenbacher } 1505b411b363SPhilipp Reisner 1506b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1507b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1508b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1509b411b363SPhilipp Reisner 1510b411b363SPhilipp Reisner bio = req->master_bio; 1511b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1512b411b363SPhilipp Reisner 1513b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1514a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1515b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1516a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1517b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1518a5c31904SAndreas Gruenbacher if (err) 1519a5c31904SAndreas Gruenbacher return err; 1520a5c31904SAndreas Gruenbacher data_size -= expect; 1521b411b363SPhilipp Reisner } 1522b411b363SPhilipp Reisner 1523b411b363SPhilipp Reisner if (dgs) { 15245b614abeSAndreas Gruenbacher drbd_csum_bio(mdev, mdev->tconn->peer_integrity_tfm, bio, dig_vv); 1525b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1526b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 152728284cefSAndreas Gruenbacher return -EINVAL; 1528b411b363SPhilipp Reisner } 1529b411b363SPhilipp Reisner } 1530b411b363SPhilipp Reisner 1531b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 153228284cefSAndreas Gruenbacher return 0; 1533b411b363SPhilipp Reisner } 1534b411b363SPhilipp Reisner 1535a990be46SAndreas Gruenbacher /* 1536a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1537a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1538a990be46SAndreas Gruenbacher */ 153999920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1540b411b363SPhilipp Reisner { 15418050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 15428050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 154300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1544db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 154599920dc5SAndreas Gruenbacher int err; 1546b411b363SPhilipp Reisner 1547db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1548b411b363SPhilipp Reisner 1549db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1550db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 155199920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1552b411b363SPhilipp Reisner } else { 1553b411b363SPhilipp Reisner /* Record failure to sync */ 1554db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1555b411b363SPhilipp Reisner 155699920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1557b411b363SPhilipp Reisner } 1558b411b363SPhilipp Reisner dec_unacked(mdev); 1559b411b363SPhilipp Reisner 156099920dc5SAndreas Gruenbacher return err; 1561b411b363SPhilipp Reisner } 1562b411b363SPhilipp Reisner 1563b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1564b411b363SPhilipp Reisner { 1565db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1566b411b363SPhilipp Reisner 1567db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1568db830c46SAndreas Gruenbacher if (!peer_req) 156945bb912bSLars Ellenberg goto fail; 1570b411b363SPhilipp Reisner 1571b411b363SPhilipp Reisner dec_rs_pending(mdev); 1572b411b363SPhilipp Reisner 1573b411b363SPhilipp Reisner inc_unacked(mdev); 1574b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1575b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1576b411b363SPhilipp Reisner 1577db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 157845bb912bSLars Ellenberg 157987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1580db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 158187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1582b411b363SPhilipp Reisner 15830f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1584fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1585e1c1b0fcSAndreas Gruenbacher return 0; 158645bb912bSLars Ellenberg 158710f6d992SLars Ellenberg /* don't care for the reason here */ 158810f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 158987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1590db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 159187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 159222cc37a9SLars Ellenberg 15933967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 159445bb912bSLars Ellenberg fail: 159545bb912bSLars Ellenberg put_ldev(mdev); 1596e1c1b0fcSAndreas Gruenbacher return -EIO; 1597b411b363SPhilipp Reisner } 1598b411b363SPhilipp Reisner 1599668eebc6SAndreas Gruenbacher static struct drbd_request * 1600bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1601bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1602668eebc6SAndreas Gruenbacher { 1603668eebc6SAndreas Gruenbacher struct drbd_request *req; 1604668eebc6SAndreas Gruenbacher 1605bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1606bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 16075e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1608668eebc6SAndreas Gruenbacher return req; 1609c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1610c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1611c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1612c3afd8f5SAndreas Gruenbacher } 1613668eebc6SAndreas Gruenbacher return NULL; 1614668eebc6SAndreas Gruenbacher } 1615668eebc6SAndreas Gruenbacher 16164a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1617b411b363SPhilipp Reisner { 16184a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1619b411b363SPhilipp Reisner struct drbd_request *req; 1620b411b363SPhilipp Reisner sector_t sector; 162182bc0194SAndreas Gruenbacher int err; 1622e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16234a76b161SAndreas Gruenbacher 16244a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16254a76b161SAndreas Gruenbacher if (!mdev) 16264a76b161SAndreas Gruenbacher return -EIO; 1627b411b363SPhilipp Reisner 1628b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1629b411b363SPhilipp Reisner 163087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1631bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 163287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1633c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 163482bc0194SAndreas Gruenbacher return -EIO; 1635b411b363SPhilipp Reisner 163624c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1637b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1638b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1639e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 164082bc0194SAndreas Gruenbacher if (!err) 16418554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1642b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1643b411b363SPhilipp Reisner * I don't think we may complete this just yet 1644b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1645b411b363SPhilipp Reisner 164682bc0194SAndreas Gruenbacher return err; 1647b411b363SPhilipp Reisner } 1648b411b363SPhilipp Reisner 16494a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1650b411b363SPhilipp Reisner { 16514a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1652b411b363SPhilipp Reisner sector_t sector; 165382bc0194SAndreas Gruenbacher int err; 1654e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16554a76b161SAndreas Gruenbacher 16564a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16574a76b161SAndreas Gruenbacher if (!mdev) 16584a76b161SAndreas Gruenbacher return -EIO; 1659b411b363SPhilipp Reisner 1660b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1661b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1662b411b363SPhilipp Reisner 1663b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1664b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1665b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1666fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1667e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1668b411b363SPhilipp Reisner } else { 1669b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1670b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1671b411b363SPhilipp Reisner 1672e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1673b411b363SPhilipp Reisner 1674e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1675b411b363SPhilipp Reisner } 1676b411b363SPhilipp Reisner 1677e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1678778f271dSPhilipp Reisner 167982bc0194SAndreas Gruenbacher return err; 1680b411b363SPhilipp Reisner } 1681b411b363SPhilipp Reisner 168299920dc5SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 16837be8da07SAndreas Gruenbacher { 16847be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 16857be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16867be8da07SAndreas Gruenbacher struct bio *bio; 16877be8da07SAndreas Gruenbacher unsigned long start_time; 16887be8da07SAndreas Gruenbacher unsigned long flags; 16897be8da07SAndreas Gruenbacher 16907be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16917be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16927be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 169399920dc5SAndreas Gruenbacher return -EIO; 16947be8da07SAndreas Gruenbacher } 16957be8da07SAndreas Gruenbacher bio = req->master_bio; 16967be8da07SAndreas Gruenbacher start_time = req->start_time; 16977be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 16987be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 16997be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 17007be8da07SAndreas Gruenbacher 17017be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 17027be8da07SAndreas Gruenbacher /* retry */ ; 170399920dc5SAndreas Gruenbacher return 0; 17047be8da07SAndreas Gruenbacher } 17057be8da07SAndreas Gruenbacher 17067be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 17077be8da07SAndreas Gruenbacher sector_t sector, int size) 17087be8da07SAndreas Gruenbacher { 17097be8da07SAndreas Gruenbacher struct drbd_interval *i; 17107be8da07SAndreas Gruenbacher struct drbd_request *req; 17117be8da07SAndreas Gruenbacher 17127be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 17137be8da07SAndreas Gruenbacher if (!i->local) 17147be8da07SAndreas Gruenbacher continue; 17157be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 17167be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 17177be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 17187be8da07SAndreas Gruenbacher continue; 17197be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 17207be8da07SAndreas Gruenbacher req->w.mdev = mdev; 17217be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 17227be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 17237be8da07SAndreas Gruenbacher } 17247be8da07SAndreas Gruenbacher } 17257be8da07SAndreas Gruenbacher } 17267be8da07SAndreas Gruenbacher 1727a990be46SAndreas Gruenbacher /* 1728a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1729b411b363SPhilipp Reisner */ 173099920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1731b411b363SPhilipp Reisner { 17328050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17338050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 173400d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1735db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 173699920dc5SAndreas Gruenbacher int err = 0, pcmd; 1737b411b363SPhilipp Reisner 1738303d1448SPhilipp Reisner if (peer_req->flags & EE_SEND_WRITE_ACK) { 1739db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1740b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1741b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1742db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1743b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 174499920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1745b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1746db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1747b411b363SPhilipp Reisner } else { 174899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1749b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1750b411b363SPhilipp Reisner * maybe assert this? */ 1751b411b363SPhilipp Reisner } 1752b411b363SPhilipp Reisner dec_unacked(mdev); 1753b411b363SPhilipp Reisner } 1754b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1755b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 1756302bdeaeSPhilipp Reisner if (peer_req->flags & EE_IN_INTERVAL_TREE) { 175787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1758db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1759db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 17607be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 17617be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 176287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1763bb3bfe96SAndreas Gruenbacher } else 1764db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1765b411b363SPhilipp Reisner 1766db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1767b411b363SPhilipp Reisner 176899920dc5SAndreas Gruenbacher return err; 1769b411b363SPhilipp Reisner } 1770b411b363SPhilipp Reisner 17717be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1772b411b363SPhilipp Reisner { 17737be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 17748050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17758050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 177699920dc5SAndreas Gruenbacher int err; 1777b411b363SPhilipp Reisner 177899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1779b411b363SPhilipp Reisner dec_unacked(mdev); 1780b411b363SPhilipp Reisner 178199920dc5SAndreas Gruenbacher return err; 1782b411b363SPhilipp Reisner } 1783b411b363SPhilipp Reisner 178499920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 17857be8da07SAndreas Gruenbacher { 17867be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17877be8da07SAndreas Gruenbacher } 17887be8da07SAndreas Gruenbacher 178999920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17907be8da07SAndreas Gruenbacher { 17917be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17927be8da07SAndreas Gruenbacher 17937be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 17947be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 17957be8da07SAndreas Gruenbacher } 17967be8da07SAndreas Gruenbacher 17973e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 17983e394da1SAndreas Gruenbacher { 17993e394da1SAndreas Gruenbacher /* 18003e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 18013e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 18023e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 18033e394da1SAndreas Gruenbacher */ 18043e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 18053e394da1SAndreas Gruenbacher } 18063e394da1SAndreas Gruenbacher 18073e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 18083e394da1SAndreas Gruenbacher { 18093e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 18103e394da1SAndreas Gruenbacher } 18113e394da1SAndreas Gruenbacher 18127be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 18137be8da07SAndreas Gruenbacher { 18147be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 1815302bdeaeSPhilipp Reisner int tp; 18167be8da07SAndreas Gruenbacher 18177be8da07SAndreas Gruenbacher /* 18187be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 18197be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 18207be8da07SAndreas Gruenbacher * handle_write_conflicts(). 18217be8da07SAndreas Gruenbacher */ 1822302bdeaeSPhilipp Reisner 1823302bdeaeSPhilipp Reisner rcu_read_lock(); 1824302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 1825302bdeaeSPhilipp Reisner rcu_read_unlock(); 1826302bdeaeSPhilipp Reisner 1827302bdeaeSPhilipp Reisner return tp && test_bit(DISCARD_CONCURRENT, &tconn->flags); 18287be8da07SAndreas Gruenbacher } 18297be8da07SAndreas Gruenbacher 183043ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 18313e394da1SAndreas Gruenbacher { 18323c13b680SLars Ellenberg unsigned int newest_peer_seq; 18333e394da1SAndreas Gruenbacher 18347be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 18353e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 18363c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 18373c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 18383e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 18393c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 18403c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 18413e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 18423e394da1SAndreas Gruenbacher } 18437be8da07SAndreas Gruenbacher } 18443e394da1SAndreas Gruenbacher 1845b411b363SPhilipp Reisner /* Called from receive_Data. 1846b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1847b411b363SPhilipp Reisner * 1848b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1849b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1850b411b363SPhilipp Reisner * been sent. 1851b411b363SPhilipp Reisner * 1852b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1853b411b363SPhilipp Reisner * 1854b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1855b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1856b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1857b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1858b411b363SPhilipp Reisner * 1859b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1860b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1861b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1862b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1863b411b363SPhilipp Reisner * 1864b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1865b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 18667be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1867b411b363SPhilipp Reisner { 1868b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1869b411b363SPhilipp Reisner long timeout; 18707be8da07SAndreas Gruenbacher int ret; 18717be8da07SAndreas Gruenbacher 18727be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 18737be8da07SAndreas Gruenbacher return 0; 18747be8da07SAndreas Gruenbacher 1875b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1876b411b363SPhilipp Reisner for (;;) { 18777be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 18787be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 18797be8da07SAndreas Gruenbacher ret = 0; 1880b411b363SPhilipp Reisner break; 18817be8da07SAndreas Gruenbacher } 1882b411b363SPhilipp Reisner if (signal_pending(current)) { 1883b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1884b411b363SPhilipp Reisner break; 1885b411b363SPhilipp Reisner } 18867be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1887b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 188844ed167dSPhilipp Reisner rcu_read_lock(); 188944ed167dSPhilipp Reisner timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10; 189044ed167dSPhilipp Reisner rcu_read_unlock(); 189171b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1892b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 18937be8da07SAndreas Gruenbacher if (!timeout) { 1894b411b363SPhilipp Reisner ret = -ETIMEDOUT; 189571b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1896b411b363SPhilipp Reisner break; 1897b411b363SPhilipp Reisner } 1898b411b363SPhilipp Reisner } 1899b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 19007be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1901b411b363SPhilipp Reisner return ret; 1902b411b363SPhilipp Reisner } 1903b411b363SPhilipp Reisner 1904688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1905688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1906688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1907688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 190876d2e7ecSPhilipp Reisner { 190976d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 191076d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1911688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 191276d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 191376d2e7ecSPhilipp Reisner } 191476d2e7ecSPhilipp Reisner 19157be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 19167be8da07SAndreas Gruenbacher unsigned int size) 19177be8da07SAndreas Gruenbacher { 19187be8da07SAndreas Gruenbacher struct drbd_interval *i; 19197be8da07SAndreas Gruenbacher 19207be8da07SAndreas Gruenbacher repeat: 19217be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19227be8da07SAndreas Gruenbacher struct drbd_request *req; 19237be8da07SAndreas Gruenbacher struct bio_and_error m; 19247be8da07SAndreas Gruenbacher 19257be8da07SAndreas Gruenbacher if (!i->local) 19267be8da07SAndreas Gruenbacher continue; 19277be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 19287be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 19297be8da07SAndreas Gruenbacher continue; 19307be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 19317be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 19327be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 19337be8da07SAndreas Gruenbacher if (m.bio) 19347be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 19357be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 19367be8da07SAndreas Gruenbacher goto repeat; 19377be8da07SAndreas Gruenbacher } 19387be8da07SAndreas Gruenbacher } 19397be8da07SAndreas Gruenbacher 19407be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 19417be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 19427be8da07SAndreas Gruenbacher { 19437be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 19447be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 19457be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 19467be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 19477be8da07SAndreas Gruenbacher struct drbd_interval *i; 19487be8da07SAndreas Gruenbacher bool equal; 19497be8da07SAndreas Gruenbacher int err; 19507be8da07SAndreas Gruenbacher 19517be8da07SAndreas Gruenbacher /* 19527be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 19537be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 19547be8da07SAndreas Gruenbacher */ 19557be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 19567be8da07SAndreas Gruenbacher 19577be8da07SAndreas Gruenbacher repeat: 19587be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19597be8da07SAndreas Gruenbacher if (i == &peer_req->i) 19607be8da07SAndreas Gruenbacher continue; 19617be8da07SAndreas Gruenbacher 19627be8da07SAndreas Gruenbacher if (!i->local) { 19637be8da07SAndreas Gruenbacher /* 19647be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 19657be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 19667be8da07SAndreas Gruenbacher * earlier peer request to complete. 19677be8da07SAndreas Gruenbacher */ 19687be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 19697be8da07SAndreas Gruenbacher if (err) 19707be8da07SAndreas Gruenbacher goto out; 19717be8da07SAndreas Gruenbacher goto repeat; 19727be8da07SAndreas Gruenbacher } 19737be8da07SAndreas Gruenbacher 19747be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 19757be8da07SAndreas Gruenbacher if (resolve_conflicts) { 19767be8da07SAndreas Gruenbacher /* 19777be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 19787be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 19797be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 19807be8da07SAndreas Gruenbacher * have completed. 19817be8da07SAndreas Gruenbacher */ 19827be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 19837be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 19847be8da07SAndreas Gruenbacher 19857be8da07SAndreas Gruenbacher if (!equal) 19867be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19877be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 19887be8da07SAndreas Gruenbacher "assuming %s came first\n", 19897be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19907be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 19917be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 19927be8da07SAndreas Gruenbacher 19937be8da07SAndreas Gruenbacher inc_unacked(mdev); 19947be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 19957be8da07SAndreas Gruenbacher e_send_retry_write; 19967be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 19977be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 19987be8da07SAndreas Gruenbacher 19997be8da07SAndreas Gruenbacher err = -ENOENT; 20007be8da07SAndreas Gruenbacher goto out; 20017be8da07SAndreas Gruenbacher } else { 20027be8da07SAndreas Gruenbacher struct drbd_request *req = 20037be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 20047be8da07SAndreas Gruenbacher 20057be8da07SAndreas Gruenbacher if (!equal) 20067be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 20077be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 20087be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 20097be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 20107be8da07SAndreas Gruenbacher 20117be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 20127be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 20137be8da07SAndreas Gruenbacher /* 20147be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 20157be8da07SAndreas Gruenbacher * decide if this request will be discarded or 20167be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 20177be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 20187be8da07SAndreas Gruenbacher * 20197be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 20207be8da07SAndreas Gruenbacher * request to finish locally before submitting 20217be8da07SAndreas Gruenbacher * the conflicting peer request. 20227be8da07SAndreas Gruenbacher */ 20237be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 20247be8da07SAndreas Gruenbacher if (err) { 20257be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 20267be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 20277be8da07SAndreas Gruenbacher CS_HARD); 20287be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 20297be8da07SAndreas Gruenbacher goto out; 20307be8da07SAndreas Gruenbacher } 20317be8da07SAndreas Gruenbacher goto repeat; 20327be8da07SAndreas Gruenbacher } 20337be8da07SAndreas Gruenbacher /* 20347be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 20357be8da07SAndreas Gruenbacher * the new peer request has completed. 20367be8da07SAndreas Gruenbacher */ 20377be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 20387be8da07SAndreas Gruenbacher } 20397be8da07SAndreas Gruenbacher } 20407be8da07SAndreas Gruenbacher err = 0; 20417be8da07SAndreas Gruenbacher 20427be8da07SAndreas Gruenbacher out: 20437be8da07SAndreas Gruenbacher if (err) 20447be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 20457be8da07SAndreas Gruenbacher return err; 20467be8da07SAndreas Gruenbacher } 20477be8da07SAndreas Gruenbacher 2048b411b363SPhilipp Reisner /* mirrored write */ 20494a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2050b411b363SPhilipp Reisner { 20514a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2052b411b363SPhilipp Reisner sector_t sector; 2053db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2054e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20557be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2056b411b363SPhilipp Reisner int rw = WRITE; 2057b411b363SPhilipp Reisner u32 dp_flags; 2058302bdeaeSPhilipp Reisner int err, tp; 20597be8da07SAndreas Gruenbacher 20604a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 20614a76b161SAndreas Gruenbacher if (!mdev) 20624a76b161SAndreas Gruenbacher return -EIO; 20634a76b161SAndreas Gruenbacher 2064b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 206582bc0194SAndreas Gruenbacher int err2; 206682bc0194SAndreas Gruenbacher 20677be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2068e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 2069b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 2070e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 207182bc0194SAndreas Gruenbacher if (!err) 207282bc0194SAndreas Gruenbacher err = err2; 207382bc0194SAndreas Gruenbacher return err; 2074b411b363SPhilipp Reisner } 2075b411b363SPhilipp Reisner 2076fcefa62eSAndreas Gruenbacher /* 2077fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2078fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2079fcefa62eSAndreas Gruenbacher * end of this function. 2080fcefa62eSAndreas Gruenbacher */ 2081b411b363SPhilipp Reisner 2082b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2083e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2084db830c46SAndreas Gruenbacher if (!peer_req) { 2085b411b363SPhilipp Reisner put_ldev(mdev); 208682bc0194SAndreas Gruenbacher return -EIO; 2087b411b363SPhilipp Reisner } 2088b411b363SPhilipp Reisner 2089db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2090b411b363SPhilipp Reisner 2091688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2092688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2093688593c5SLars Ellenberg 2094688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2095db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2096688593c5SLars Ellenberg 2097b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2098db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2099db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2100db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2101b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2102b411b363SPhilipp Reisner 2103302bdeaeSPhilipp Reisner rcu_read_lock(); 2104302bdeaeSPhilipp Reisner tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries; 2105302bdeaeSPhilipp Reisner rcu_read_unlock(); 2106302bdeaeSPhilipp Reisner if (tp) { 2107302bdeaeSPhilipp Reisner peer_req->flags |= EE_IN_INTERVAL_TREE; 21087be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 21097be8da07SAndreas Gruenbacher if (err) 2110b411b363SPhilipp Reisner goto out_interrupted; 211187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 21127be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 21137be8da07SAndreas Gruenbacher if (err) { 211487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 21157be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2116b411b363SPhilipp Reisner put_ldev(mdev); 211782bc0194SAndreas Gruenbacher return 0; 2118b411b363SPhilipp Reisner } 2119b411b363SPhilipp Reisner goto out_interrupted; 2120b411b363SPhilipp Reisner } 21217be8da07SAndreas Gruenbacher } else 212287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2123db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 212487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2125b411b363SPhilipp Reisner 2126303d1448SPhilipp Reisner if (mdev->tconn->agreed_pro_version < 100) { 212744ed167dSPhilipp Reisner rcu_read_lock(); 212844ed167dSPhilipp Reisner switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) { 2129b411b363SPhilipp Reisner case DRBD_PROT_C: 2130303d1448SPhilipp Reisner dp_flags |= DP_SEND_WRITE_ACK; 2131303d1448SPhilipp Reisner break; 2132303d1448SPhilipp Reisner case DRBD_PROT_B: 2133303d1448SPhilipp Reisner dp_flags |= DP_SEND_RECEIVE_ACK; 2134303d1448SPhilipp Reisner break; 2135303d1448SPhilipp Reisner } 213644ed167dSPhilipp Reisner rcu_read_unlock(); 2137303d1448SPhilipp Reisner } 2138303d1448SPhilipp Reisner 2139303d1448SPhilipp Reisner if (dp_flags & DP_SEND_WRITE_ACK) { 2140303d1448SPhilipp Reisner peer_req->flags |= EE_SEND_WRITE_ACK; 2141b411b363SPhilipp Reisner inc_unacked(mdev); 2142b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2143b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2144303d1448SPhilipp Reisner } 2145303d1448SPhilipp Reisner 2146303d1448SPhilipp Reisner if (dp_flags & DP_SEND_RECEIVE_ACK) { 2147b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2148b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2149db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2150b411b363SPhilipp Reisner } 2151b411b363SPhilipp Reisner 21526719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2153b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2154db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2155db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2156db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2157181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2158b411b363SPhilipp Reisner } 2159b411b363SPhilipp Reisner 216082bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 216182bc0194SAndreas Gruenbacher if (!err) 216282bc0194SAndreas Gruenbacher return 0; 2163b411b363SPhilipp Reisner 216410f6d992SLars Ellenberg /* don't care for the reason here */ 216510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 216687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2167db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2168db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 216987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2170db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2171181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 217222cc37a9SLars Ellenberg 2173b411b363SPhilipp Reisner out_interrupted: 2174db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2175b411b363SPhilipp Reisner put_ldev(mdev); 21763967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 217782bc0194SAndreas Gruenbacher return err; 2178b411b363SPhilipp Reisner } 2179b411b363SPhilipp Reisner 21800f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 21810f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 21820f0601f4SLars Ellenberg * 21830f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 21840f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 21850f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 21860f0601f4SLars Ellenberg * activity, it obviously is "busy". 21870f0601f4SLars Ellenberg * 21880f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 21890f0601f4SLars Ellenberg * to have a short time average so we can react faster. 21900f0601f4SLars Ellenberg */ 2191e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 21920f0601f4SLars Ellenberg { 21930f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 21940f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2195e3555d85SPhilipp Reisner struct lc_element *tmp; 21960f0601f4SLars Ellenberg int curr_events; 21970f0601f4SLars Ellenberg int throttle = 0; 2198daeda1ccSPhilipp Reisner unsigned int c_min_rate; 2199daeda1ccSPhilipp Reisner 2200daeda1ccSPhilipp Reisner rcu_read_lock(); 2201daeda1ccSPhilipp Reisner c_min_rate = rcu_dereference(mdev->ldev->disk_conf)->c_min_rate; 2202daeda1ccSPhilipp Reisner rcu_read_unlock(); 22030f0601f4SLars Ellenberg 22040f0601f4SLars Ellenberg /* feature disabled? */ 2205daeda1ccSPhilipp Reisner if (c_min_rate == 0) 22060f0601f4SLars Ellenberg return 0; 22070f0601f4SLars Ellenberg 2208e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2209e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2210e3555d85SPhilipp Reisner if (tmp) { 2211e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2212e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2213e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2214e3555d85SPhilipp Reisner return 0; 2215e3555d85SPhilipp Reisner } 2216e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2217e3555d85SPhilipp Reisner } 2218e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2219e3555d85SPhilipp Reisner 22200f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 22210f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 22220f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2223e3555d85SPhilipp Reisner 22240f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 22250f0601f4SLars Ellenberg unsigned long rs_left; 22260f0601f4SLars Ellenberg int i; 22270f0601f4SLars Ellenberg 22280f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 22290f0601f4SLars Ellenberg 22300f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 22310f0601f4SLars Ellenberg * approx. */ 22322649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 22332649f080SLars Ellenberg 22342649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 22352649f080SLars Ellenberg rs_left = mdev->ov_left; 22362649f080SLars Ellenberg else 22370f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 22380f0601f4SLars Ellenberg 22390f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 22400f0601f4SLars Ellenberg if (!dt) 22410f0601f4SLars Ellenberg dt++; 22420f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 22430f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 22440f0601f4SLars Ellenberg 2245daeda1ccSPhilipp Reisner if (dbdt > c_min_rate) 22460f0601f4SLars Ellenberg throttle = 1; 22470f0601f4SLars Ellenberg } 22480f0601f4SLars Ellenberg return throttle; 22490f0601f4SLars Ellenberg } 22500f0601f4SLars Ellenberg 22510f0601f4SLars Ellenberg 22524a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2253b411b363SPhilipp Reisner { 22544a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2255b411b363SPhilipp Reisner sector_t sector; 22564a76b161SAndreas Gruenbacher sector_t capacity; 2257db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2258b411b363SPhilipp Reisner struct digest_info *di = NULL; 2259b18b37beSPhilipp Reisner int size, verb; 2260b411b363SPhilipp Reisner unsigned int fault_type; 2261e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 22624a76b161SAndreas Gruenbacher 22634a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 22644a76b161SAndreas Gruenbacher if (!mdev) 22654a76b161SAndreas Gruenbacher return -EIO; 22664a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2267b411b363SPhilipp Reisner 2268b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2269b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2270b411b363SPhilipp Reisner 2271c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2272b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2273b411b363SPhilipp Reisner (unsigned long long)sector, size); 227482bc0194SAndreas Gruenbacher return -EINVAL; 2275b411b363SPhilipp Reisner } 2276b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2277b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2278b411b363SPhilipp Reisner (unsigned long long)sector, size); 227982bc0194SAndreas Gruenbacher return -EINVAL; 2280b411b363SPhilipp Reisner } 2281b411b363SPhilipp Reisner 2282b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2283b18b37beSPhilipp Reisner verb = 1; 2284e2857216SAndreas Gruenbacher switch (pi->cmd) { 2285b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2286b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2287b18b37beSPhilipp Reisner break; 2288b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2289b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2290b18b37beSPhilipp Reisner case P_OV_REQUEST: 2291b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2292b18b37beSPhilipp Reisner break; 2293b18b37beSPhilipp Reisner case P_OV_REPLY: 2294b18b37beSPhilipp Reisner verb = 0; 2295b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2296b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2297b18b37beSPhilipp Reisner break; 2298b18b37beSPhilipp Reisner default: 229949ba9b1bSAndreas Gruenbacher BUG(); 2300b18b37beSPhilipp Reisner } 2301b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2302b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2303b411b363SPhilipp Reisner "no local data.\n"); 2304b18b37beSPhilipp Reisner 2305a821cc4aSLars Ellenberg /* drain possibly payload */ 2306e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2307b411b363SPhilipp Reisner } 2308b411b363SPhilipp Reisner 2309b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2310b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2311b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 23120db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2313db830c46SAndreas Gruenbacher if (!peer_req) { 2314b411b363SPhilipp Reisner put_ldev(mdev); 231582bc0194SAndreas Gruenbacher return -ENOMEM; 2316b411b363SPhilipp Reisner } 2317b411b363SPhilipp Reisner 2318e2857216SAndreas Gruenbacher switch (pi->cmd) { 2319b411b363SPhilipp Reisner case P_DATA_REQUEST: 2320db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2321b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 232280a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 232380a40e43SLars Ellenberg goto submit; 232480a40e43SLars Ellenberg 2325b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2326db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2327b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 23285f9915bbSLars Ellenberg /* used in the sector offset progress display */ 23295f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2330b411b363SPhilipp Reisner break; 2331b411b363SPhilipp Reisner 2332b411b363SPhilipp Reisner case P_OV_REPLY: 2333b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2334b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2335e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2336b411b363SPhilipp Reisner if (!di) 2337b411b363SPhilipp Reisner goto out_free_e; 2338b411b363SPhilipp Reisner 2339e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2340b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2341b411b363SPhilipp Reisner 2342db830c46SAndreas Gruenbacher peer_req->digest = di; 2343db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2344c36c3cedSLars Ellenberg 2345e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2346b411b363SPhilipp Reisner goto out_free_e; 2347b411b363SPhilipp Reisner 2348e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 234931890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2350db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 23515f9915bbSLars Ellenberg /* used in the sector offset progress display */ 23525f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2353e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 23542649f080SLars Ellenberg /* track progress, we may need to throttle */ 23552649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2356db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2357b411b363SPhilipp Reisner dec_rs_pending(mdev); 23580f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 23590f0601f4SLars Ellenberg * but accounting still needs to be done. */ 23600f0601f4SLars Ellenberg goto submit_for_resync; 2361b411b363SPhilipp Reisner } 2362b411b363SPhilipp Reisner break; 2363b411b363SPhilipp Reisner 2364b411b363SPhilipp Reisner case P_OV_REQUEST: 2365b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 236631890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2367de228bbaSLars Ellenberg unsigned long now = jiffies; 2368de228bbaSLars Ellenberg int i; 2369b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2370b411b363SPhilipp Reisner mdev->ov_position = sector; 237130b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 237230b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2373de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2374de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2375de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2376de228bbaSLars Ellenberg } 2377b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2378b411b363SPhilipp Reisner (unsigned long long)sector); 2379b411b363SPhilipp Reisner } 2380db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2381b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2382b411b363SPhilipp Reisner break; 2383b411b363SPhilipp Reisner 2384b411b363SPhilipp Reisner default: 238549ba9b1bSAndreas Gruenbacher BUG(); 2386b411b363SPhilipp Reisner } 2387b411b363SPhilipp Reisner 23880f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 23890f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 23900f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 23910f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 23920f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 23930f0601f4SLars Ellenberg * 23940f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 23950f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 23960f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 23970f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 23980f0601f4SLars Ellenberg * a while, anyways. 23990f0601f4SLars Ellenberg */ 2400b411b363SPhilipp Reisner 24010f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 24020f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 24030f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 24040f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 24050f0601f4SLars Ellenberg * 24060f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 24070f0601f4SLars Ellenberg * we would also throttle its application reads. 24080f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 24090f0601f4SLars Ellenberg */ 2410e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2411e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2412e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 241380a40e43SLars Ellenberg goto out_free_e; 2414b411b363SPhilipp Reisner 24150f0601f4SLars Ellenberg submit_for_resync: 24160f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 24170f0601f4SLars Ellenberg 241880a40e43SLars Ellenberg submit: 2419b411b363SPhilipp Reisner inc_unacked(mdev); 242087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2421db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 242287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2423b411b363SPhilipp Reisner 2424fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 242582bc0194SAndreas Gruenbacher return 0; 2426b411b363SPhilipp Reisner 242710f6d992SLars Ellenberg /* don't care for the reason here */ 242810f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 242987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2430db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 243187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 243222cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 243322cc37a9SLars Ellenberg 2434b411b363SPhilipp Reisner out_free_e: 2435b411b363SPhilipp Reisner put_ldev(mdev); 24363967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 243782bc0194SAndreas Gruenbacher return -EIO; 2438b411b363SPhilipp Reisner } 2439b411b363SPhilipp Reisner 2440b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2441b411b363SPhilipp Reisner { 2442b411b363SPhilipp Reisner int self, peer, rv = -100; 2443b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 244444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_0p; 2445b411b363SPhilipp Reisner 2446b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2447b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2448b411b363SPhilipp Reisner 2449b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2450b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2451b411b363SPhilipp Reisner 245244ed167dSPhilipp Reisner rcu_read_lock(); 245344ed167dSPhilipp Reisner after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p; 245444ed167dSPhilipp Reisner rcu_read_unlock(); 245544ed167dSPhilipp Reisner switch (after_sb_0p) { 2456b411b363SPhilipp Reisner case ASB_CONSENSUS: 2457b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2458b411b363SPhilipp Reisner case ASB_CALL_HELPER: 245944ed167dSPhilipp Reisner case ASB_VIOLENTLY: 2460b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2461b411b363SPhilipp Reisner break; 2462b411b363SPhilipp Reisner case ASB_DISCONNECT: 2463b411b363SPhilipp Reisner break; 2464b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2465b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2466b411b363SPhilipp Reisner rv = -1; 2467b411b363SPhilipp Reisner break; 2468b411b363SPhilipp Reisner } 2469b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2470b411b363SPhilipp Reisner rv = 1; 2471b411b363SPhilipp Reisner break; 2472b411b363SPhilipp Reisner } 2473b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2474b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2475b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2476b411b363SPhilipp Reisner rv = 1; 2477b411b363SPhilipp Reisner break; 2478b411b363SPhilipp Reisner } 2479b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2480b411b363SPhilipp Reisner rv = -1; 2481b411b363SPhilipp Reisner break; 2482b411b363SPhilipp Reisner } 2483b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2484ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2485b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2486b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2487b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 248825703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2489b411b363SPhilipp Reisner ? -1 : 1; 2490b411b363SPhilipp Reisner break; 2491b411b363SPhilipp Reisner } else { 2492b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2493b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2494b411b363SPhilipp Reisner } 249544ed167dSPhilipp Reisner if (after_sb_0p == ASB_DISCARD_ZERO_CHG) 2496b411b363SPhilipp Reisner break; 2497b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2498b411b363SPhilipp Reisner if (ch_self < ch_peer) 2499b411b363SPhilipp Reisner rv = -1; 2500b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2501b411b363SPhilipp Reisner rv = 1; 2502b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2503b411b363SPhilipp Reisner /* Well, then use something else. */ 250425703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2505b411b363SPhilipp Reisner ? -1 : 1; 2506b411b363SPhilipp Reisner break; 2507b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2508b411b363SPhilipp Reisner rv = -1; 2509b411b363SPhilipp Reisner break; 2510b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2511b411b363SPhilipp Reisner rv = 1; 2512b411b363SPhilipp Reisner } 2513b411b363SPhilipp Reisner 2514b411b363SPhilipp Reisner return rv; 2515b411b363SPhilipp Reisner } 2516b411b363SPhilipp Reisner 2517b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2518b411b363SPhilipp Reisner { 25196184ea21SAndreas Gruenbacher int hg, rv = -100; 252044ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_1p; 2521b411b363SPhilipp Reisner 252244ed167dSPhilipp Reisner rcu_read_lock(); 252344ed167dSPhilipp Reisner after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p; 252444ed167dSPhilipp Reisner rcu_read_unlock(); 252544ed167dSPhilipp Reisner switch (after_sb_1p) { 2526b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2527b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2528b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2529b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2530b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 253144ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2532b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2533b411b363SPhilipp Reisner break; 2534b411b363SPhilipp Reisner case ASB_DISCONNECT: 2535b411b363SPhilipp Reisner break; 2536b411b363SPhilipp Reisner case ASB_CONSENSUS: 2537b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2538b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2539b411b363SPhilipp Reisner rv = hg; 2540b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2541b411b363SPhilipp Reisner rv = hg; 2542b411b363SPhilipp Reisner break; 2543b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2544b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2545b411b363SPhilipp Reisner break; 2546b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2547b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2548b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2549b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2550b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2551bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2552bb437946SAndreas Gruenbacher 2553bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2554b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2555b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2556b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2557bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2558bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2559b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2560b411b363SPhilipp Reisner } else { 2561b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2562b411b363SPhilipp Reisner rv = hg; 2563b411b363SPhilipp Reisner } 2564b411b363SPhilipp Reisner } else 2565b411b363SPhilipp Reisner rv = hg; 2566b411b363SPhilipp Reisner } 2567b411b363SPhilipp Reisner 2568b411b363SPhilipp Reisner return rv; 2569b411b363SPhilipp Reisner } 2570b411b363SPhilipp Reisner 2571b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2572b411b363SPhilipp Reisner { 25736184ea21SAndreas Gruenbacher int hg, rv = -100; 257444ed167dSPhilipp Reisner enum drbd_after_sb_p after_sb_2p; 2575b411b363SPhilipp Reisner 257644ed167dSPhilipp Reisner rcu_read_lock(); 257744ed167dSPhilipp Reisner after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p; 257844ed167dSPhilipp Reisner rcu_read_unlock(); 257944ed167dSPhilipp Reisner switch (after_sb_2p) { 2580b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2581b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2582b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2583b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2584b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2585b411b363SPhilipp Reisner case ASB_CONSENSUS: 2586b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 258744ed167dSPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2588b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2589b411b363SPhilipp Reisner break; 2590b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2591b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2592b411b363SPhilipp Reisner break; 2593b411b363SPhilipp Reisner case ASB_DISCONNECT: 2594b411b363SPhilipp Reisner break; 2595b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2596b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2597b411b363SPhilipp Reisner if (hg == -1) { 2598bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2599bb437946SAndreas Gruenbacher 2600b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2601b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2602b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2603bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2604bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2605b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2606b411b363SPhilipp Reisner } else { 2607b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2608b411b363SPhilipp Reisner rv = hg; 2609b411b363SPhilipp Reisner } 2610b411b363SPhilipp Reisner } else 2611b411b363SPhilipp Reisner rv = hg; 2612b411b363SPhilipp Reisner } 2613b411b363SPhilipp Reisner 2614b411b363SPhilipp Reisner return rv; 2615b411b363SPhilipp Reisner } 2616b411b363SPhilipp Reisner 2617b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2618b411b363SPhilipp Reisner u64 bits, u64 flags) 2619b411b363SPhilipp Reisner { 2620b411b363SPhilipp Reisner if (!uuid) { 2621b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2622b411b363SPhilipp Reisner return; 2623b411b363SPhilipp Reisner } 2624b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2625b411b363SPhilipp Reisner text, 2626b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2627b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2628b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2629b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2630b411b363SPhilipp Reisner (unsigned long long)bits, 2631b411b363SPhilipp Reisner (unsigned long long)flags); 2632b411b363SPhilipp Reisner } 2633b411b363SPhilipp Reisner 2634b411b363SPhilipp Reisner /* 2635b411b363SPhilipp Reisner 100 after split brain try auto recover 2636b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2637b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2638b411b363SPhilipp Reisner 0 no Sync 2639b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2640b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2641b411b363SPhilipp Reisner -100 after split brain, disconnect 2642b411b363SPhilipp Reisner -1000 unrelated data 26434a23f264SPhilipp Reisner -1091 requires proto 91 26444a23f264SPhilipp Reisner -1096 requires proto 96 2645b411b363SPhilipp Reisner */ 2646b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2647b411b363SPhilipp Reisner { 2648b411b363SPhilipp Reisner u64 self, peer; 2649b411b363SPhilipp Reisner int i, j; 2650b411b363SPhilipp Reisner 2651b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2652b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2653b411b363SPhilipp Reisner 2654b411b363SPhilipp Reisner *rule_nr = 10; 2655b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2656b411b363SPhilipp Reisner return 0; 2657b411b363SPhilipp Reisner 2658b411b363SPhilipp Reisner *rule_nr = 20; 2659b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2660b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2661b411b363SPhilipp Reisner return -2; 2662b411b363SPhilipp Reisner 2663b411b363SPhilipp Reisner *rule_nr = 30; 2664b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2665b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2666b411b363SPhilipp Reisner return 2; 2667b411b363SPhilipp Reisner 2668b411b363SPhilipp Reisner if (self == peer) { 2669b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2670b411b363SPhilipp Reisner 2671b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2672b411b363SPhilipp Reisner 267331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26744a23f264SPhilipp Reisner return -1091; 2675b411b363SPhilipp Reisner 2676b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2677b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2678b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2679b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2680b411b363SPhilipp Reisner 2681b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2682b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2683b411b363SPhilipp Reisner *rule_nr = 34; 2684b411b363SPhilipp Reisner } else { 2685b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2686b411b363SPhilipp Reisner *rule_nr = 36; 2687b411b363SPhilipp Reisner } 2688b411b363SPhilipp Reisner 2689b411b363SPhilipp Reisner return 1; 2690b411b363SPhilipp Reisner } 2691b411b363SPhilipp Reisner 2692b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2693b411b363SPhilipp Reisner 269431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26954a23f264SPhilipp Reisner return -1091; 2696b411b363SPhilipp Reisner 2697b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2698b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2699b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2700b411b363SPhilipp Reisner 2701b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2702b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2703b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2704b411b363SPhilipp Reisner 2705b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2706b411b363SPhilipp Reisner *rule_nr = 35; 2707b411b363SPhilipp Reisner } else { 2708b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2709b411b363SPhilipp Reisner *rule_nr = 37; 2710b411b363SPhilipp Reisner } 2711b411b363SPhilipp Reisner 2712b411b363SPhilipp Reisner return -1; 2713b411b363SPhilipp Reisner } 2714b411b363SPhilipp Reisner 2715b411b363SPhilipp Reisner /* Common power [off|failure] */ 2716b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2717b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2718b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2719b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2720b411b363SPhilipp Reisner *rule_nr = 40; 2721b411b363SPhilipp Reisner 2722b411b363SPhilipp Reisner switch (rct) { 2723b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2724b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2725b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2726b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 272725703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2728b411b363SPhilipp Reisner return dc ? -1 : 1; 2729b411b363SPhilipp Reisner } 2730b411b363SPhilipp Reisner } 2731b411b363SPhilipp Reisner 2732b411b363SPhilipp Reisner *rule_nr = 50; 2733b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2734b411b363SPhilipp Reisner if (self == peer) 2735b411b363SPhilipp Reisner return -1; 2736b411b363SPhilipp Reisner 2737b411b363SPhilipp Reisner *rule_nr = 51; 2738b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2739b411b363SPhilipp Reisner if (self == peer) { 274031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 27414a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 27424a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 27434a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2744b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2745b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2746b411b363SPhilipp Reisner 274731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27484a23f264SPhilipp Reisner return -1091; 2749b411b363SPhilipp Reisner 2750b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2751b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 27524a23f264SPhilipp Reisner 27534a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 27544a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 27554a23f264SPhilipp Reisner 2756b411b363SPhilipp Reisner return -1; 2757b411b363SPhilipp Reisner } 2758b411b363SPhilipp Reisner } 2759b411b363SPhilipp Reisner 2760b411b363SPhilipp Reisner *rule_nr = 60; 2761b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2762b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2763b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2764b411b363SPhilipp Reisner if (self == peer) 2765b411b363SPhilipp Reisner return -2; 2766b411b363SPhilipp Reisner } 2767b411b363SPhilipp Reisner 2768b411b363SPhilipp Reisner *rule_nr = 70; 2769b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2770b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2771b411b363SPhilipp Reisner if (self == peer) 2772b411b363SPhilipp Reisner return 1; 2773b411b363SPhilipp Reisner 2774b411b363SPhilipp Reisner *rule_nr = 71; 2775b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2776b411b363SPhilipp Reisner if (self == peer) { 277731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 27784a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 27794a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 27804a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2781b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2782b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2783b411b363SPhilipp Reisner 278431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27854a23f264SPhilipp Reisner return -1091; 2786b411b363SPhilipp Reisner 2787b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2788b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2789b411b363SPhilipp Reisner 27904a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2791b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2792b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2793b411b363SPhilipp Reisner 2794b411b363SPhilipp Reisner return 1; 2795b411b363SPhilipp Reisner } 2796b411b363SPhilipp Reisner } 2797b411b363SPhilipp Reisner 2798b411b363SPhilipp Reisner 2799b411b363SPhilipp Reisner *rule_nr = 80; 2800d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2801b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2802b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2803b411b363SPhilipp Reisner if (self == peer) 2804b411b363SPhilipp Reisner return 2; 2805b411b363SPhilipp Reisner } 2806b411b363SPhilipp Reisner 2807b411b363SPhilipp Reisner *rule_nr = 90; 2808b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2809b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2810b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2811b411b363SPhilipp Reisner return 100; 2812b411b363SPhilipp Reisner 2813b411b363SPhilipp Reisner *rule_nr = 100; 2814b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2815b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2816b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2817b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2818b411b363SPhilipp Reisner if (self == peer) 2819b411b363SPhilipp Reisner return -100; 2820b411b363SPhilipp Reisner } 2821b411b363SPhilipp Reisner } 2822b411b363SPhilipp Reisner 2823b411b363SPhilipp Reisner return -1000; 2824b411b363SPhilipp Reisner } 2825b411b363SPhilipp Reisner 2826b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2827b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2828b411b363SPhilipp Reisner */ 2829b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2830b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2831b411b363SPhilipp Reisner { 2832b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2833b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 283444ed167dSPhilipp Reisner struct net_conf *nc; 283544ed167dSPhilipp Reisner int hg, rule_nr, rr_conflict, dry_run; 2836b411b363SPhilipp Reisner 2837b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2838b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2839b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2840b411b363SPhilipp Reisner 2841b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2842b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2843b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2844b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2845b411b363SPhilipp Reisner 2846b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2847b411b363SPhilipp Reisner 2848b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2849b411b363SPhilipp Reisner 2850b411b363SPhilipp Reisner if (hg == -1000) { 2851b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2852b411b363SPhilipp Reisner return C_MASK; 2853b411b363SPhilipp Reisner } 28544a23f264SPhilipp Reisner if (hg < -1000) { 28554a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2856b411b363SPhilipp Reisner return C_MASK; 2857b411b363SPhilipp Reisner } 2858b411b363SPhilipp Reisner 2859b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2860b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2861b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2862b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2863b411b363SPhilipp Reisner if (f) 2864b411b363SPhilipp Reisner hg = hg*2; 2865b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2866b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2867b411b363SPhilipp Reisner } 2868b411b363SPhilipp Reisner 28693a11a487SAdam Gandelman if (abs(hg) == 100) 28703a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 28713a11a487SAdam Gandelman 287244ed167dSPhilipp Reisner rcu_read_lock(); 287344ed167dSPhilipp Reisner nc = rcu_dereference(mdev->tconn->net_conf); 287444ed167dSPhilipp Reisner 287544ed167dSPhilipp Reisner if (hg == 100 || (hg == -100 && nc->always_asbp)) { 2876b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2877b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2878b411b363SPhilipp Reisner int forced = (hg == -100); 2879b411b363SPhilipp Reisner 2880b411b363SPhilipp Reisner switch (pcount) { 2881b411b363SPhilipp Reisner case 0: 2882b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2883b411b363SPhilipp Reisner break; 2884b411b363SPhilipp Reisner case 1: 2885b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2886b411b363SPhilipp Reisner break; 2887b411b363SPhilipp Reisner case 2: 2888b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2889b411b363SPhilipp Reisner break; 2890b411b363SPhilipp Reisner } 2891b411b363SPhilipp Reisner if (abs(hg) < 100) { 2892b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2893b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2894b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2895b411b363SPhilipp Reisner if (forced) { 2896b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2897b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2898b411b363SPhilipp Reisner hg = hg*2; 2899b411b363SPhilipp Reisner } 2900b411b363SPhilipp Reisner } 2901b411b363SPhilipp Reisner } 2902b411b363SPhilipp Reisner 2903b411b363SPhilipp Reisner if (hg == -100) { 290444ed167dSPhilipp Reisner if (nc->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2905b411b363SPhilipp Reisner hg = -1; 290644ed167dSPhilipp Reisner if (!nc->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2907b411b363SPhilipp Reisner hg = 1; 2908b411b363SPhilipp Reisner 2909b411b363SPhilipp Reisner if (abs(hg) < 100) 2910b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2911b411b363SPhilipp Reisner "Sync from %s node\n", 2912b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2913b411b363SPhilipp Reisner } 291444ed167dSPhilipp Reisner rr_conflict = nc->rr_conflict; 291544ed167dSPhilipp Reisner dry_run = nc->dry_run; 291644ed167dSPhilipp Reisner rcu_read_unlock(); 2917b411b363SPhilipp Reisner 2918b411b363SPhilipp Reisner if (hg == -100) { 2919580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2920580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2921580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2922580b9767SLars Ellenberg * to that disk, in a way... */ 29233a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2924b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2925b411b363SPhilipp Reisner return C_MASK; 2926b411b363SPhilipp Reisner } 2927b411b363SPhilipp Reisner 2928b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2929b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2930b411b363SPhilipp Reisner return C_MASK; 2931b411b363SPhilipp Reisner } 2932b411b363SPhilipp Reisner 2933b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2934b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 293544ed167dSPhilipp Reisner switch (rr_conflict) { 2936b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2937b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2938b411b363SPhilipp Reisner /* fall through */ 2939b411b363SPhilipp Reisner case ASB_DISCONNECT: 2940b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2941b411b363SPhilipp Reisner return C_MASK; 2942b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2943b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2944b411b363SPhilipp Reisner "assumption\n"); 2945b411b363SPhilipp Reisner } 2946b411b363SPhilipp Reisner } 2947b411b363SPhilipp Reisner 294844ed167dSPhilipp Reisner if (dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2949cf14c2e9SPhilipp Reisner if (hg == 0) 2950cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2951cf14c2e9SPhilipp Reisner else 2952cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2953cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2954cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2955cf14c2e9SPhilipp Reisner return C_MASK; 2956cf14c2e9SPhilipp Reisner } 2957cf14c2e9SPhilipp Reisner 2958b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2959b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 296020ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 296120ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2962b411b363SPhilipp Reisner return C_MASK; 2963b411b363SPhilipp Reisner } 2964b411b363SPhilipp Reisner 2965b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2966b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2967b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2968b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2969b411b363SPhilipp Reisner } else { 2970b411b363SPhilipp Reisner rv = C_CONNECTED; 2971b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2972b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2973b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2974b411b363SPhilipp Reisner } 2975b411b363SPhilipp Reisner } 2976b411b363SPhilipp Reisner 2977b411b363SPhilipp Reisner return rv; 2978b411b363SPhilipp Reisner } 2979b411b363SPhilipp Reisner 2980b411b363SPhilipp Reisner /* returns 1 if invalid */ 2981b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2982b411b363SPhilipp Reisner { 2983b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2984b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2985b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2986b411b363SPhilipp Reisner return 0; 2987b411b363SPhilipp Reisner 2988b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2989b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2990b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2991b411b363SPhilipp Reisner return 1; 2992b411b363SPhilipp Reisner 2993b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2994b411b363SPhilipp Reisner if (peer == self) 2995b411b363SPhilipp Reisner return 0; 2996b411b363SPhilipp Reisner 2997b411b363SPhilipp Reisner /* everything es is invalid. */ 2998b411b363SPhilipp Reisner return 1; 2999b411b363SPhilipp Reisner } 3000b411b363SPhilipp Reisner 3001e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 3002b411b363SPhilipp Reisner { 3003e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 3004b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 3005cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 300644ed167dSPhilipp Reisner struct net_conf *nc; 3007b411b363SPhilipp Reisner 3008b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 3009b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 3010b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 3011b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 3012b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 3013cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 3014cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 3015cf14c2e9SPhilipp Reisner 301686db0618SAndreas Gruenbacher if (tconn->agreed_pro_version >= 87) { 301788104ca4SAndreas Gruenbacher char integrity_alg[SHARED_SECRET_MAX]; 301888104ca4SAndreas Gruenbacher struct crypto_hash *tfm = NULL; 301986db0618SAndreas Gruenbacher int err; 302086db0618SAndreas Gruenbacher 302188104ca4SAndreas Gruenbacher if (pi->size > sizeof(integrity_alg)) 302286db0618SAndreas Gruenbacher return -EIO; 302388104ca4SAndreas Gruenbacher err = drbd_recv_all(tconn, integrity_alg, pi->size); 302486db0618SAndreas Gruenbacher if (err) 302586db0618SAndreas Gruenbacher return err; 302688104ca4SAndreas Gruenbacher integrity_alg[SHARED_SECRET_MAX-1] = 0; 302786db0618SAndreas Gruenbacher 302888104ca4SAndreas Gruenbacher if (integrity_alg[0]) { 302988104ca4SAndreas Gruenbacher tfm = crypto_alloc_hash(integrity_alg, 0, CRYPTO_ALG_ASYNC); 303088104ca4SAndreas Gruenbacher if (!tfm) { 303188104ca4SAndreas Gruenbacher conn_err(tconn, "peer data-integrity-alg %s not supported\n", 303288104ca4SAndreas Gruenbacher integrity_alg); 303388104ca4SAndreas Gruenbacher goto disconnect; 303488104ca4SAndreas Gruenbacher } 303588104ca4SAndreas Gruenbacher conn_info(tconn, "peer data-integrity-alg: %s\n", integrity_alg); 303688104ca4SAndreas Gruenbacher } 303788104ca4SAndreas Gruenbacher 303888104ca4SAndreas Gruenbacher if (tconn->peer_integrity_tfm) 303988104ca4SAndreas Gruenbacher crypto_free_hash(tconn->peer_integrity_tfm); 304088104ca4SAndreas Gruenbacher tconn->peer_integrity_tfm = tfm; 304186db0618SAndreas Gruenbacher } 304286db0618SAndreas Gruenbacher 30437204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 3044cf14c2e9SPhilipp Reisner 3045cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 30467204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 3047b411b363SPhilipp Reisner 304844ed167dSPhilipp Reisner rcu_read_lock(); 304944ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 305044ed167dSPhilipp Reisner 305144ed167dSPhilipp Reisner if (p_proto != nc->wire_protocol && tconn->agreed_pro_version < 100) { 30527204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 305344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3054b411b363SPhilipp Reisner } 3055b411b363SPhilipp Reisner 305644ed167dSPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, nc->after_sb_0p)) { 30577204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 305844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3059b411b363SPhilipp Reisner } 3060b411b363SPhilipp Reisner 306144ed167dSPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, nc->after_sb_1p)) { 30627204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 306344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3064b411b363SPhilipp Reisner } 3065b411b363SPhilipp Reisner 306644ed167dSPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, nc->after_sb_2p)) { 30677204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 306844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3069b411b363SPhilipp Reisner } 3070b411b363SPhilipp Reisner 307144ed167dSPhilipp Reisner if (p_want_lose && nc->want_lose) { 30727204624cSPhilipp Reisner conn_err(tconn, "both sides have the 'want_lose' flag set\n"); 307344ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3074b411b363SPhilipp Reisner } 3075b411b363SPhilipp Reisner 307644ed167dSPhilipp Reisner if (p_two_primaries != nc->two_primaries) { 30777204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 307844ed167dSPhilipp Reisner goto disconnect_rcu_unlock; 3079b411b363SPhilipp Reisner } 3080b411b363SPhilipp Reisner 308186db0618SAndreas Gruenbacher rcu_read_unlock(); 308286db0618SAndreas Gruenbacher 308382bc0194SAndreas Gruenbacher return 0; 3084b411b363SPhilipp Reisner 308544ed167dSPhilipp Reisner disconnect_rcu_unlock: 308644ed167dSPhilipp Reisner rcu_read_unlock(); 3087b411b363SPhilipp Reisner disconnect: 30887204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 308982bc0194SAndreas Gruenbacher return -EIO; 3090b411b363SPhilipp Reisner } 3091b411b363SPhilipp Reisner 3092b411b363SPhilipp Reisner /* helper function 3093b411b363SPhilipp Reisner * input: alg name, feature name 3094b411b363SPhilipp Reisner * return: NULL (alg name was "") 3095b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 3096b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 3097b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 3098b411b363SPhilipp Reisner const char *alg, const char *name) 3099b411b363SPhilipp Reisner { 3100b411b363SPhilipp Reisner struct crypto_hash *tfm; 3101b411b363SPhilipp Reisner 3102b411b363SPhilipp Reisner if (!alg[0]) 3103b411b363SPhilipp Reisner return NULL; 3104b411b363SPhilipp Reisner 3105b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 3106b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3107b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3108b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3109b411b363SPhilipp Reisner return tfm; 3110b411b363SPhilipp Reisner } 3111b411b363SPhilipp Reisner return tfm; 3112b411b363SPhilipp Reisner } 3113b411b363SPhilipp Reisner 31144a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3115b411b363SPhilipp Reisner { 31164a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 31174a76b161SAndreas Gruenbacher int size = pi->size; 31184a76b161SAndreas Gruenbacher 31194a76b161SAndreas Gruenbacher while (size) { 31204a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 31214a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 31224a76b161SAndreas Gruenbacher if (s <= 0) { 31234a76b161SAndreas Gruenbacher if (s < 0) 31244a76b161SAndreas Gruenbacher return s; 31254a76b161SAndreas Gruenbacher break; 31264a76b161SAndreas Gruenbacher } 31274a76b161SAndreas Gruenbacher size -= s; 31284a76b161SAndreas Gruenbacher } 31294a76b161SAndreas Gruenbacher if (size) 31304a76b161SAndreas Gruenbacher return -EIO; 31314a76b161SAndreas Gruenbacher return 0; 31324a76b161SAndreas Gruenbacher } 31334a76b161SAndreas Gruenbacher 31344a76b161SAndreas Gruenbacher /* 31354a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 31364a76b161SAndreas Gruenbacher * 31374a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 31384a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 31394a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 31404a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 31414a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 31424a76b161SAndreas Gruenbacher * 31434a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 31444a76b161SAndreas Gruenbacher */ 31454a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 31464a76b161SAndreas Gruenbacher { 31474a76b161SAndreas Gruenbacher conn_warn(tconn, "Volume %u unknown; ignoring %s packet\n", 31484a76b161SAndreas Gruenbacher pi->vnr, cmdname(pi->cmd)); 31494a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 31504a76b161SAndreas Gruenbacher } 31514a76b161SAndreas Gruenbacher 31524a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 31534a76b161SAndreas Gruenbacher { 31544a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3155e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3156b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3157b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3158b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 31592ec91e0eSPhilipp Reisner struct net_conf *old_net_conf, *new_net_conf = NULL; 3160813472ceSPhilipp Reisner struct disk_conf *old_disk_conf = NULL, *new_disk_conf = NULL; 31614a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3162813472ceSPhilipp Reisner struct fifo_buffer *old_plan = NULL, *new_plan = NULL; 3163778f271dSPhilipp Reisner int fifo_size = 0; 316482bc0194SAndreas Gruenbacher int err; 3165b411b363SPhilipp Reisner 31664a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 31674a76b161SAndreas Gruenbacher if (!mdev) 31684a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 31694a76b161SAndreas Gruenbacher 3170b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3171b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3172b411b363SPhilipp Reisner + SHARED_SECRET_MAX 31738e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 31748e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3175b411b363SPhilipp Reisner 3176e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3177b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3178e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 317982bc0194SAndreas Gruenbacher return -EIO; 3180b411b363SPhilipp Reisner } 3181b411b363SPhilipp Reisner 3182b411b363SPhilipp Reisner if (apv <= 88) { 3183e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3184e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 31858e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3186e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3187e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3188b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 31898e26f9ccSPhilipp Reisner } else { 3190e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3191e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3192b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3193b411b363SPhilipp Reisner } 3194b411b363SPhilipp Reisner 3195b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3196e658983aSAndreas Gruenbacher p = pi->data; 3197b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3198b411b363SPhilipp Reisner 3199e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 320082bc0194SAndreas Gruenbacher if (err) 320182bc0194SAndreas Gruenbacher return err; 3202b411b363SPhilipp Reisner 3203813472ceSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3204813472ceSPhilipp Reisner old_net_conf = mdev->tconn->net_conf; 3205813472ceSPhilipp Reisner if (get_ldev(mdev)) { 3206daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3207daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3208813472ceSPhilipp Reisner put_ldev(mdev); 3209813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3210daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3211daeda1ccSPhilipp Reisner return -ENOMEM; 3212f399002eSLars Ellenberg } 3213b411b363SPhilipp Reisner 3214daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3215daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3216daeda1ccSPhilipp Reisner 3217daeda1ccSPhilipp Reisner new_disk_conf->resync_rate = be32_to_cpu(p->rate); 3218813472ceSPhilipp Reisner } 3219daeda1ccSPhilipp Reisner 3220b411b363SPhilipp Reisner if (apv >= 88) { 3221b411b363SPhilipp Reisner if (apv == 88) { 3222b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3223b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3224b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3225b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 3226813472ceSPhilipp Reisner err = -EIO; 3227813472ceSPhilipp Reisner goto reconnect; 3228b411b363SPhilipp Reisner } 3229b411b363SPhilipp Reisner 323082bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 3231813472ceSPhilipp Reisner if (err) 3232813472ceSPhilipp Reisner goto reconnect; 3233b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3234b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3235b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3236b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3237b411b363SPhilipp Reisner 3238b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3239b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3240b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3241b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3242b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3243b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3244b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3245b411b363SPhilipp Reisner } 3246b411b363SPhilipp Reisner 32472ec91e0eSPhilipp Reisner if (strcmp(old_net_conf->verify_alg, p->verify_alg)) { 3248b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3249b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 32502ec91e0eSPhilipp Reisner old_net_conf->verify_alg, p->verify_alg); 3251b411b363SPhilipp Reisner goto disconnect; 3252b411b363SPhilipp Reisner } 3253b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3254b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3255b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3256b411b363SPhilipp Reisner verify_tfm = NULL; 3257b411b363SPhilipp Reisner goto disconnect; 3258b411b363SPhilipp Reisner } 3259b411b363SPhilipp Reisner } 3260b411b363SPhilipp Reisner 32612ec91e0eSPhilipp Reisner if (apv >= 89 && strcmp(old_net_conf->csums_alg, p->csums_alg)) { 3262b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3263b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 32642ec91e0eSPhilipp Reisner old_net_conf->csums_alg, p->csums_alg); 3265b411b363SPhilipp Reisner goto disconnect; 3266b411b363SPhilipp Reisner } 3267b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3268b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3269b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3270b411b363SPhilipp Reisner csums_tfm = NULL; 3271b411b363SPhilipp Reisner goto disconnect; 3272b411b363SPhilipp Reisner } 3273b411b363SPhilipp Reisner } 3274b411b363SPhilipp Reisner 3275813472ceSPhilipp Reisner if (apv > 94 && new_disk_conf) { 3276daeda1ccSPhilipp Reisner new_disk_conf->c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3277daeda1ccSPhilipp Reisner new_disk_conf->c_delay_target = be32_to_cpu(p->c_delay_target); 3278daeda1ccSPhilipp Reisner new_disk_conf->c_fill_target = be32_to_cpu(p->c_fill_target); 3279daeda1ccSPhilipp Reisner new_disk_conf->c_max_rate = be32_to_cpu(p->c_max_rate); 3280778f271dSPhilipp Reisner 3281daeda1ccSPhilipp Reisner fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ; 32829958c857SPhilipp Reisner if (fifo_size != mdev->rs_plan_s->size) { 3283813472ceSPhilipp Reisner new_plan = fifo_alloc(fifo_size); 3284813472ceSPhilipp Reisner if (!new_plan) { 3285778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3286f399002eSLars Ellenberg put_ldev(mdev); 3287778f271dSPhilipp Reisner goto disconnect; 3288778f271dSPhilipp Reisner } 3289778f271dSPhilipp Reisner } 32908e26f9ccSPhilipp Reisner } 3291b411b363SPhilipp Reisner 329291fd4dadSPhilipp Reisner if (verify_tfm || csums_tfm) { 32932ec91e0eSPhilipp Reisner new_net_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL); 32942ec91e0eSPhilipp Reisner if (!new_net_conf) { 329591fd4dadSPhilipp Reisner dev_err(DEV, "Allocation of new net_conf failed\n"); 329691fd4dadSPhilipp Reisner goto disconnect; 329791fd4dadSPhilipp Reisner } 329891fd4dadSPhilipp Reisner 32992ec91e0eSPhilipp Reisner *new_net_conf = *old_net_conf; 330091fd4dadSPhilipp Reisner 3301b411b363SPhilipp Reisner if (verify_tfm) { 33022ec91e0eSPhilipp Reisner strcpy(new_net_conf->verify_alg, p->verify_alg); 33032ec91e0eSPhilipp Reisner new_net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3304f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3305f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3306b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3307b411b363SPhilipp Reisner } 3308b411b363SPhilipp Reisner if (csums_tfm) { 33092ec91e0eSPhilipp Reisner strcpy(new_net_conf->csums_alg, p->csums_alg); 33102ec91e0eSPhilipp Reisner new_net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3311f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3312f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3313b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3314b411b363SPhilipp Reisner } 33152ec91e0eSPhilipp Reisner rcu_assign_pointer(tconn->net_conf, new_net_conf); 331691fd4dadSPhilipp Reisner } 331791fd4dadSPhilipp Reisner } 331891fd4dadSPhilipp Reisner 3319813472ceSPhilipp Reisner if (new_disk_conf) { 3320daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3321813472ceSPhilipp Reisner put_ldev(mdev); 3322778f271dSPhilipp Reisner } 3323813472ceSPhilipp Reisner 3324813472ceSPhilipp Reisner if (new_plan) { 3325813472ceSPhilipp Reisner old_plan = mdev->rs_plan_s; 3326813472ceSPhilipp Reisner rcu_assign_pointer(mdev->rs_plan_s, new_plan); 3327813472ceSPhilipp Reisner } 3328daeda1ccSPhilipp Reisner 3329daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3330daeda1ccSPhilipp Reisner synchronize_rcu(); 3331daeda1ccSPhilipp Reisner if (new_net_conf) 3332daeda1ccSPhilipp Reisner kfree(old_net_conf); 3333daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3334813472ceSPhilipp Reisner kfree(old_plan); 3335daeda1ccSPhilipp Reisner 333682bc0194SAndreas Gruenbacher return 0; 3337b411b363SPhilipp Reisner 3338813472ceSPhilipp Reisner reconnect: 3339813472ceSPhilipp Reisner if (new_disk_conf) { 3340813472ceSPhilipp Reisner put_ldev(mdev); 3341813472ceSPhilipp Reisner kfree(new_disk_conf); 3342813472ceSPhilipp Reisner } 3343813472ceSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3344813472ceSPhilipp Reisner return -EIO; 3345813472ceSPhilipp Reisner 3346b411b363SPhilipp Reisner disconnect: 3347813472ceSPhilipp Reisner kfree(new_plan); 3348813472ceSPhilipp Reisner if (new_disk_conf) { 3349813472ceSPhilipp Reisner put_ldev(mdev); 3350813472ceSPhilipp Reisner kfree(new_disk_conf); 3351813472ceSPhilipp Reisner } 3352a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3353b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3354b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3355b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3356b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3357b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 335838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 335982bc0194SAndreas Gruenbacher return -EIO; 3360b411b363SPhilipp Reisner } 3361b411b363SPhilipp Reisner 3362b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3363b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3364b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3365b411b363SPhilipp Reisner { 3366b411b363SPhilipp Reisner sector_t d; 3367b411b363SPhilipp Reisner if (a == 0 || b == 0) 3368b411b363SPhilipp Reisner return; 3369b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3370b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3371b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3372b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3373b411b363SPhilipp Reisner } 3374b411b363SPhilipp Reisner 33754a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3376b411b363SPhilipp Reisner { 33774a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3378e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3379b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3380b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3381b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3382e89b591cSPhilipp Reisner enum dds_flags ddsf; 3383b411b363SPhilipp Reisner 33844a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 33854a76b161SAndreas Gruenbacher if (!mdev) 33864a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 33874a76b161SAndreas Gruenbacher 3388b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3389b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3390b411b363SPhilipp Reisner 3391b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3392b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3393b411b363SPhilipp Reisner mdev->p_size = p_size; 3394b411b363SPhilipp Reisner 3395b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3396daeda1ccSPhilipp Reisner rcu_read_lock(); 3397daeda1ccSPhilipp Reisner my_usize = rcu_dereference(mdev->ldev->disk_conf)->disk_size; 3398daeda1ccSPhilipp Reisner rcu_read_unlock(); 3399daeda1ccSPhilipp Reisner 3400b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3401b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3402b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3403daeda1ccSPhilipp Reisner p_usize, my_usize); 3404b411b363SPhilipp Reisner 3405b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3406b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3407b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3408daeda1ccSPhilipp Reisner p_usize = min_not_zero(my_usize, p_usize); 3409b411b363SPhilipp Reisner 3410b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3411b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3412ef5e44a6SPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, p_usize, 0) < 3413b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3414b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3415b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3416b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 341738fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3418b411b363SPhilipp Reisner put_ldev(mdev); 341982bc0194SAndreas Gruenbacher return -EIO; 3420b411b363SPhilipp Reisner } 3421daeda1ccSPhilipp Reisner 3422daeda1ccSPhilipp Reisner if (my_usize != p_usize) { 3423daeda1ccSPhilipp Reisner struct disk_conf *old_disk_conf, *new_disk_conf = NULL; 3424daeda1ccSPhilipp Reisner 3425daeda1ccSPhilipp Reisner new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL); 3426daeda1ccSPhilipp Reisner if (!new_disk_conf) { 3427daeda1ccSPhilipp Reisner dev_err(DEV, "Allocation of new disk_conf failed\n"); 3428daeda1ccSPhilipp Reisner put_ldev(mdev); 3429daeda1ccSPhilipp Reisner return -ENOMEM; 3430daeda1ccSPhilipp Reisner } 3431daeda1ccSPhilipp Reisner 3432daeda1ccSPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 3433daeda1ccSPhilipp Reisner old_disk_conf = mdev->ldev->disk_conf; 3434daeda1ccSPhilipp Reisner *new_disk_conf = *old_disk_conf; 3435daeda1ccSPhilipp Reisner new_disk_conf->disk_size = p_usize; 3436daeda1ccSPhilipp Reisner 3437daeda1ccSPhilipp Reisner rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf); 3438daeda1ccSPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3439daeda1ccSPhilipp Reisner synchronize_rcu(); 3440daeda1ccSPhilipp Reisner kfree(old_disk_conf); 3441daeda1ccSPhilipp Reisner 3442daeda1ccSPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3443daeda1ccSPhilipp Reisner (unsigned long)my_usize); 3444daeda1ccSPhilipp Reisner } 3445daeda1ccSPhilipp Reisner 3446b411b363SPhilipp Reisner put_ldev(mdev); 3447b411b363SPhilipp Reisner } 3448b411b363SPhilipp Reisner 3449e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3450b411b363SPhilipp Reisner if (get_ldev(mdev)) { 345124c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3452b411b363SPhilipp Reisner put_ldev(mdev); 3453b411b363SPhilipp Reisner if (dd == dev_size_error) 345482bc0194SAndreas Gruenbacher return -EIO; 3455b411b363SPhilipp Reisner drbd_md_sync(mdev); 3456b411b363SPhilipp Reisner } else { 3457b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3458b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3459b411b363SPhilipp Reisner } 3460b411b363SPhilipp Reisner 346199432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 346299432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 346399432fccSPhilipp Reisner 3464b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3465b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3466b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3467b411b363SPhilipp Reisner ldsc = 1; 3468b411b363SPhilipp Reisner } 3469b411b363SPhilipp Reisner 3470b411b363SPhilipp Reisner put_ldev(mdev); 3471b411b363SPhilipp Reisner } 3472b411b363SPhilipp Reisner 3473b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3474b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3475b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3476b411b363SPhilipp Reisner /* we have different sizes, probably peer 3477b411b363SPhilipp Reisner * needs to know my new size... */ 3478e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3479b411b363SPhilipp Reisner } 3480b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3481b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3482b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3483e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3484e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3485e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3486b411b363SPhilipp Reisner else 3487e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3488e89b591cSPhilipp Reisner } else 3489b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3490b411b363SPhilipp Reisner } 3491b411b363SPhilipp Reisner } 3492b411b363SPhilipp Reisner 349382bc0194SAndreas Gruenbacher return 0; 3494b411b363SPhilipp Reisner } 3495b411b363SPhilipp Reisner 34964a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3497b411b363SPhilipp Reisner { 34984a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3499e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3500b411b363SPhilipp Reisner u64 *p_uuid; 350162b0da3aSLars Ellenberg int i, updated_uuids = 0; 3502b411b363SPhilipp Reisner 35034a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 35044a76b161SAndreas Gruenbacher if (!mdev) 35054a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 35064a76b161SAndreas Gruenbacher 3507b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3508b411b363SPhilipp Reisner 3509b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3510b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3511b411b363SPhilipp Reisner 3512b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3513b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3514b411b363SPhilipp Reisner 3515b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3516b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3517b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3518b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3519b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3520b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 352138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 352282bc0194SAndreas Gruenbacher return -EIO; 3523b411b363SPhilipp Reisner } 3524b411b363SPhilipp Reisner 3525b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3526b411b363SPhilipp Reisner int skip_initial_sync = 3527b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 352831890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3529b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3530b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3531b411b363SPhilipp Reisner if (skip_initial_sync) { 3532b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3533b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 353420ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 353520ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3536b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3537b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3538b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3539b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3540b411b363SPhilipp Reisner drbd_md_sync(mdev); 354162b0da3aSLars Ellenberg updated_uuids = 1; 3542b411b363SPhilipp Reisner } 3543b411b363SPhilipp Reisner put_ldev(mdev); 354418a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 354518a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 354618a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 354718a50fa2SPhilipp Reisner for me. */ 354862b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3549b411b363SPhilipp Reisner } 3550b411b363SPhilipp Reisner 3551b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3552b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3553b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3554b411b363SPhilipp Reisner new disk state... */ 35558410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 35568410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3557b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 355862b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 355962b0da3aSLars Ellenberg 356062b0da3aSLars Ellenberg if (updated_uuids) 356162b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3562b411b363SPhilipp Reisner 356382bc0194SAndreas Gruenbacher return 0; 3564b411b363SPhilipp Reisner } 3565b411b363SPhilipp Reisner 3566b411b363SPhilipp Reisner /** 3567b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3568b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3569b411b363SPhilipp Reisner */ 3570b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3571b411b363SPhilipp Reisner { 3572b411b363SPhilipp Reisner union drbd_state ms; 3573b411b363SPhilipp Reisner 3574b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3575b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3576b411b363SPhilipp Reisner 3577b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3578b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3579b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3580b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3581b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3582b411b363SPhilipp Reisner }; 3583b411b363SPhilipp Reisner 3584b411b363SPhilipp Reisner ms.i = ps.i; 3585b411b363SPhilipp Reisner 3586b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3587b411b363SPhilipp Reisner ms.peer = ps.role; 3588b411b363SPhilipp Reisner ms.role = ps.peer; 3589b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3590b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3591b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3592b411b363SPhilipp Reisner 3593b411b363SPhilipp Reisner return ms; 3594b411b363SPhilipp Reisner } 3595b411b363SPhilipp Reisner 35964a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3597b411b363SPhilipp Reisner { 35984a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3599e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3600b411b363SPhilipp Reisner union drbd_state mask, val; 3601bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3602b411b363SPhilipp Reisner 36034a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36044a76b161SAndreas Gruenbacher if (!mdev) 36054a76b161SAndreas Gruenbacher return -EIO; 36064a76b161SAndreas Gruenbacher 3607b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3608b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3609b411b363SPhilipp Reisner 361025703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 36118410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3612b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 361382bc0194SAndreas Gruenbacher return 0; 3614b411b363SPhilipp Reisner } 3615b411b363SPhilipp Reisner 3616b411b363SPhilipp Reisner mask = convert_state(mask); 3617b411b363SPhilipp Reisner val = convert_state(val); 3618b411b363SPhilipp Reisner 3619b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3620b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3621047cd4a6SPhilipp Reisner 3622b411b363SPhilipp Reisner drbd_md_sync(mdev); 3623b411b363SPhilipp Reisner 362482bc0194SAndreas Gruenbacher return 0; 3625b411b363SPhilipp Reisner } 3626b411b363SPhilipp Reisner 3627e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3628dfafcc8aSPhilipp Reisner { 3629e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3630dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3631dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3632dfafcc8aSPhilipp Reisner 3633dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3634dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3635dfafcc8aSPhilipp Reisner 3636dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3637dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3638dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 363982bc0194SAndreas Gruenbacher return 0; 3640dfafcc8aSPhilipp Reisner } 3641dfafcc8aSPhilipp Reisner 3642dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3643dfafcc8aSPhilipp Reisner val = convert_state(val); 3644dfafcc8aSPhilipp Reisner 3645778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3646dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3647dfafcc8aSPhilipp Reisner 364882bc0194SAndreas Gruenbacher return 0; 3649dfafcc8aSPhilipp Reisner } 3650dfafcc8aSPhilipp Reisner 36514a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3652b411b363SPhilipp Reisner { 36534a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3654e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 36554ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3656b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 365765d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3658b411b363SPhilipp Reisner int rv; 3659b411b363SPhilipp Reisner 36604a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36614a76b161SAndreas Gruenbacher if (!mdev) 36624a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 36634a76b161SAndreas Gruenbacher 3664b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3665b411b363SPhilipp Reisner 3666b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3667b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3668b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3669b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3670b411b363SPhilipp Reisner } 3671b411b363SPhilipp Reisner 367287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3673b411b363SPhilipp Reisner retry: 367478bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 367587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3676b411b363SPhilipp Reisner 3677e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3678e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3679e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3680e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3681e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3682e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3683e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3684e9ef7bb6SLars Ellenberg * syncing states. 3685e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3686e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3687e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3688e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3689e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3690e9ef7bb6SLars Ellenberg 3691e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3692e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3693e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3694e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3695e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3696e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3697e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 369882bc0194SAndreas Gruenbacher return 0; 3699e9ef7bb6SLars Ellenberg } 3700e9ef7bb6SLars Ellenberg } 3701e9ef7bb6SLars Ellenberg 3702e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3703e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3704e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3705e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3706e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3707e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3708e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3709e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3710e9ef7bb6SLars Ellenberg 37114ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 37124ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3713b411b363SPhilipp Reisner 371467531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 371567531718SPhilipp Reisner ns.conn = C_BEHIND; 371667531718SPhilipp Reisner 3717b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3718b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3719b411b363SPhilipp Reisner int cr; /* consider resync */ 3720b411b363SPhilipp Reisner 3721b411b363SPhilipp Reisner /* if we established a new connection */ 37224ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3723b411b363SPhilipp Reisner /* if we had an established connection 3724b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 37254ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3726b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 37274ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3728b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3729b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3730b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3731b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3732b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 37334ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3734b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3735b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3736b411b363SPhilipp Reisner 3737b411b363SPhilipp Reisner if (cr) 37384ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3739b411b363SPhilipp Reisner 3740b411b363SPhilipp Reisner put_ldev(mdev); 37414ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 37424ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3743b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 374482f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3745b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3746b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3747b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3748580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3749b411b363SPhilipp Reisner } else { 37508169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 375182bc0194SAndreas Gruenbacher return -EIO; 37524ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 375338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 375482bc0194SAndreas Gruenbacher return -EIO; 3755b411b363SPhilipp Reisner } 3756b411b363SPhilipp Reisner } 3757b411b363SPhilipp Reisner } 3758b411b363SPhilipp Reisner 375987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 376078bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3761b411b363SPhilipp Reisner goto retry; 3762b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3763b411b363SPhilipp Reisner ns.peer = peer_state.role; 3764b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3765b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 37664ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3767b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 37684ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 37692aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3770481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 37718554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3772481c6f50SPhilipp Reisner for temporal network outages! */ 377387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3774481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 37752f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3776481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3777481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 377838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 377982bc0194SAndreas Gruenbacher return -EIO; 3780481c6f50SPhilipp Reisner } 378165d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 378278bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 378387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3784b411b363SPhilipp Reisner 3785b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 378638fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 378782bc0194SAndreas Gruenbacher return -EIO; 3788b411b363SPhilipp Reisner } 3789b411b363SPhilipp Reisner 37904ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 37914ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3792b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3793b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3794b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3795b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3796b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3797b411b363SPhilipp Reisner drbd_send_state(mdev); 3798b411b363SPhilipp Reisner } 3799b411b363SPhilipp Reisner } 3800b411b363SPhilipp Reisner 3801a0095508SPhilipp Reisner mutex_lock(&mdev->tconn->conf_update); 380291fd4dadSPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; /* without copy; single bit op is atomic */ 3803a0095508SPhilipp Reisner mutex_unlock(&mdev->tconn->conf_update); 3804b411b363SPhilipp Reisner 3805b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3806b411b363SPhilipp Reisner 380782bc0194SAndreas Gruenbacher return 0; 3808b411b363SPhilipp Reisner } 3809b411b363SPhilipp Reisner 38104a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3811b411b363SPhilipp Reisner { 38124a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3813e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 38144a76b161SAndreas Gruenbacher 38154a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38164a76b161SAndreas Gruenbacher if (!mdev) 38174a76b161SAndreas Gruenbacher return -EIO; 3818b411b363SPhilipp Reisner 3819b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3820b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3821c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3822b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3823b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3824b411b363SPhilipp Reisner 3825b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3826b411b363SPhilipp Reisner 3827b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3828b411b363SPhilipp Reisner _not_ be rotated into the history */ 3829b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3830b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3831b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3832b411b363SPhilipp Reisner 383362b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3834b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3835b411b363SPhilipp Reisner 3836b411b363SPhilipp Reisner put_ldev(mdev); 3837b411b363SPhilipp Reisner } else 3838b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3839b411b363SPhilipp Reisner 384082bc0194SAndreas Gruenbacher return 0; 3841b411b363SPhilipp Reisner } 3842b411b363SPhilipp Reisner 38432c46407dSAndreas Gruenbacher /** 38442c46407dSAndreas Gruenbacher * receive_bitmap_plain 38452c46407dSAndreas Gruenbacher * 38462c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 38472c46407dSAndreas Gruenbacher * code upon failure. 38482c46407dSAndreas Gruenbacher */ 38492c46407dSAndreas Gruenbacher static int 385050d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 3851e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 3852b411b363SPhilipp Reisner { 385350d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 385450d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 3855e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 385650d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 3857e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 38582c46407dSAndreas Gruenbacher int err; 3859b411b363SPhilipp Reisner 386050d0b1adSAndreas Gruenbacher if (want != size) { 386150d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 38622c46407dSAndreas Gruenbacher return -EIO; 3863b411b363SPhilipp Reisner } 3864b411b363SPhilipp Reisner if (want == 0) 38652c46407dSAndreas Gruenbacher return 0; 3866e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 386782bc0194SAndreas Gruenbacher if (err) 38682c46407dSAndreas Gruenbacher return err; 3869b411b363SPhilipp Reisner 3870e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 3871b411b363SPhilipp Reisner 3872b411b363SPhilipp Reisner c->word_offset += num_words; 3873b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3874b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3875b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3876b411b363SPhilipp Reisner 38772c46407dSAndreas Gruenbacher return 1; 3878b411b363SPhilipp Reisner } 3879b411b363SPhilipp Reisner 3880a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 3881a02d1240SAndreas Gruenbacher { 3882a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 3883a02d1240SAndreas Gruenbacher } 3884a02d1240SAndreas Gruenbacher 3885a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 3886a02d1240SAndreas Gruenbacher { 3887a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 3888a02d1240SAndreas Gruenbacher } 3889a02d1240SAndreas Gruenbacher 3890a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 3891a02d1240SAndreas Gruenbacher { 3892a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 3893a02d1240SAndreas Gruenbacher } 3894a02d1240SAndreas Gruenbacher 38952c46407dSAndreas Gruenbacher /** 38962c46407dSAndreas Gruenbacher * recv_bm_rle_bits 38972c46407dSAndreas Gruenbacher * 38982c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 38992c46407dSAndreas Gruenbacher * code upon failure. 39002c46407dSAndreas Gruenbacher */ 39012c46407dSAndreas Gruenbacher static int 3902b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3903b411b363SPhilipp Reisner struct p_compressed_bm *p, 3904c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3905c6d25cfeSPhilipp Reisner unsigned int len) 3906b411b363SPhilipp Reisner { 3907b411b363SPhilipp Reisner struct bitstream bs; 3908b411b363SPhilipp Reisner u64 look_ahead; 3909b411b363SPhilipp Reisner u64 rl; 3910b411b363SPhilipp Reisner u64 tmp; 3911b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3912b411b363SPhilipp Reisner unsigned long e; 3913a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 3914b411b363SPhilipp Reisner int have; 3915b411b363SPhilipp Reisner int bits; 3916b411b363SPhilipp Reisner 3917a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 3918b411b363SPhilipp Reisner 3919b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3920b411b363SPhilipp Reisner if (bits < 0) 39212c46407dSAndreas Gruenbacher return -EIO; 3922b411b363SPhilipp Reisner 3923b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3924b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3925b411b363SPhilipp Reisner if (bits <= 0) 39262c46407dSAndreas Gruenbacher return -EIO; 3927b411b363SPhilipp Reisner 3928b411b363SPhilipp Reisner if (toggle) { 3929b411b363SPhilipp Reisner e = s + rl -1; 3930b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3931b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 39322c46407dSAndreas Gruenbacher return -EIO; 3933b411b363SPhilipp Reisner } 3934b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3935b411b363SPhilipp Reisner } 3936b411b363SPhilipp Reisner 3937b411b363SPhilipp Reisner if (have < bits) { 3938b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3939b411b363SPhilipp Reisner have, bits, look_ahead, 3940b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3941b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 39422c46407dSAndreas Gruenbacher return -EIO; 3943b411b363SPhilipp Reisner } 3944b411b363SPhilipp Reisner look_ahead >>= bits; 3945b411b363SPhilipp Reisner have -= bits; 3946b411b363SPhilipp Reisner 3947b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3948b411b363SPhilipp Reisner if (bits < 0) 39492c46407dSAndreas Gruenbacher return -EIO; 3950b411b363SPhilipp Reisner look_ahead |= tmp << have; 3951b411b363SPhilipp Reisner have += bits; 3952b411b363SPhilipp Reisner } 3953b411b363SPhilipp Reisner 3954b411b363SPhilipp Reisner c->bit_offset = s; 3955b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3956b411b363SPhilipp Reisner 39572c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3958b411b363SPhilipp Reisner } 3959b411b363SPhilipp Reisner 39602c46407dSAndreas Gruenbacher /** 39612c46407dSAndreas Gruenbacher * decode_bitmap_c 39622c46407dSAndreas Gruenbacher * 39632c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 39642c46407dSAndreas Gruenbacher * code upon failure. 39652c46407dSAndreas Gruenbacher */ 39662c46407dSAndreas Gruenbacher static int 3967b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3968b411b363SPhilipp Reisner struct p_compressed_bm *p, 3969c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3970c6d25cfeSPhilipp Reisner unsigned int len) 3971b411b363SPhilipp Reisner { 3972a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 3973e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 3974b411b363SPhilipp Reisner 3975b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3976b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3977b411b363SPhilipp Reisner * during all our tests. */ 3978b411b363SPhilipp Reisner 3979b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 398038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 39812c46407dSAndreas Gruenbacher return -EIO; 3982b411b363SPhilipp Reisner } 3983b411b363SPhilipp Reisner 3984b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3985b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3986b411b363SPhilipp Reisner { 3987b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 398850d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 398950d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 399050d0b1adSAndreas Gruenbacher unsigned int plain = 399150d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 399250d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 399350d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 399450d0b1adSAndreas Gruenbacher unsigned int r; 3995b411b363SPhilipp Reisner 3996b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3997b411b363SPhilipp Reisner if (total == 0) 3998b411b363SPhilipp Reisner return; 3999b411b363SPhilipp Reisner 4000b411b363SPhilipp Reisner /* don't report if not compressed */ 4001b411b363SPhilipp Reisner if (total >= plain) 4002b411b363SPhilipp Reisner return; 4003b411b363SPhilipp Reisner 4004b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 4005b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 4006b411b363SPhilipp Reisner : (1000 * total / plain); 4007b411b363SPhilipp Reisner 4008b411b363SPhilipp Reisner if (r > 1000) 4009b411b363SPhilipp Reisner r = 1000; 4010b411b363SPhilipp Reisner 4011b411b363SPhilipp Reisner r = 1000 - r; 4012b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 4013b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 4014b411b363SPhilipp Reisner direction, 4015b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 4016b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 4017b411b363SPhilipp Reisner total, r/10, r % 10); 4018b411b363SPhilipp Reisner } 4019b411b363SPhilipp Reisner 4020b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 4021b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 4022b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 4023b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 4024b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 4025b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 4026b411b363SPhilipp Reisner 4027b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 40284a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 4029b411b363SPhilipp Reisner { 40304a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4031b411b363SPhilipp Reisner struct bm_xfer_ctx c; 40322c46407dSAndreas Gruenbacher int err; 40334a76b161SAndreas Gruenbacher 40344a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 40354a76b161SAndreas Gruenbacher if (!mdev) 40364a76b161SAndreas Gruenbacher return -EIO; 4037b411b363SPhilipp Reisner 403820ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 403920ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 404020ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 4041b411b363SPhilipp Reisner 4042b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 4043b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 4044b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 4045b411b363SPhilipp Reisner }; 4046b411b363SPhilipp Reisner 40472c46407dSAndreas Gruenbacher for(;;) { 4048e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 4049e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 4050e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 4051b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 4052b411b363SPhilipp Reisner * and the feature is enabled! */ 4053e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 4054b411b363SPhilipp Reisner 405550d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 4056b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 405782bc0194SAndreas Gruenbacher err = -EIO; 4058b411b363SPhilipp Reisner goto out; 4059b411b363SPhilipp Reisner } 4060e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 4061e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 406282bc0194SAndreas Gruenbacher err = -EIO; 406378fcbdaeSAndreas Gruenbacher goto out; 4064b411b363SPhilipp Reisner } 4065e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 4066e658983aSAndreas Gruenbacher if (err) 4067e658983aSAndreas Gruenbacher goto out; 4068e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 4069b411b363SPhilipp Reisner } else { 4070e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 407182bc0194SAndreas Gruenbacher err = -EIO; 4072b411b363SPhilipp Reisner goto out; 4073b411b363SPhilipp Reisner } 4074b411b363SPhilipp Reisner 4075e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 407650d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 4077b411b363SPhilipp Reisner 40782c46407dSAndreas Gruenbacher if (err <= 0) { 40792c46407dSAndreas Gruenbacher if (err < 0) 40802c46407dSAndreas Gruenbacher goto out; 4081b411b363SPhilipp Reisner break; 40822c46407dSAndreas Gruenbacher } 4083e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 408482bc0194SAndreas Gruenbacher if (err) 4085b411b363SPhilipp Reisner goto out; 40862c46407dSAndreas Gruenbacher } 4087b411b363SPhilipp Reisner 4088b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 4089b411b363SPhilipp Reisner 4090b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 4091de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 4092de1f8e4aSAndreas Gruenbacher 409382bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 409482bc0194SAndreas Gruenbacher if (err) 4095b411b363SPhilipp Reisner goto out; 4096b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 4097de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 4098de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 4099b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 4100b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 4101b411b363SPhilipp Reisner * other threads may have noticed network errors */ 4102b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 4103b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 4104b411b363SPhilipp Reisner } 410582bc0194SAndreas Gruenbacher err = 0; 4106b411b363SPhilipp Reisner 4107b411b363SPhilipp Reisner out: 410820ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 410982bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 4110b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 411182bc0194SAndreas Gruenbacher return err; 4112b411b363SPhilipp Reisner } 4113b411b363SPhilipp Reisner 41144a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 4115b411b363SPhilipp Reisner { 41164a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 4117e2857216SAndreas Gruenbacher pi->cmd, pi->size); 41182de876efSPhilipp Reisner 41194a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 41202de876efSPhilipp Reisner } 41212de876efSPhilipp Reisner 41224a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 4123b411b363SPhilipp Reisner { 4124b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 4125b411b363SPhilipp Reisner * with the data requests being unplugged */ 41264a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 4127b411b363SPhilipp Reisner 412882bc0194SAndreas Gruenbacher return 0; 4129b411b363SPhilipp Reisner } 4130b411b363SPhilipp Reisner 41314a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 413273a01a18SPhilipp Reisner { 41334a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 4134e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 41354a76b161SAndreas Gruenbacher 41364a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 41374a76b161SAndreas Gruenbacher if (!mdev) 41384a76b161SAndreas Gruenbacher return -EIO; 413973a01a18SPhilipp Reisner 4140f735e363SLars Ellenberg switch (mdev->state.conn) { 4141f735e363SLars Ellenberg case C_WF_SYNC_UUID: 4142f735e363SLars Ellenberg case C_WF_BITMAP_T: 4143f735e363SLars Ellenberg case C_BEHIND: 4144f735e363SLars Ellenberg break; 4145f735e363SLars Ellenberg default: 4146f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 4147f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 4148f735e363SLars Ellenberg } 4149f735e363SLars Ellenberg 415073a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 415173a01a18SPhilipp Reisner 415282bc0194SAndreas Gruenbacher return 0; 415373a01a18SPhilipp Reisner } 415473a01a18SPhilipp Reisner 415502918be2SPhilipp Reisner struct data_cmd { 415602918be2SPhilipp Reisner int expect_payload; 415702918be2SPhilipp Reisner size_t pkt_size; 41584a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 4159b411b363SPhilipp Reisner }; 4160b411b363SPhilipp Reisner 416102918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 41624a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 41634a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 41644a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 41654a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 4166e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 4167e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 4168e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 41694a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 41704a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4171e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4172e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 41734a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 41744a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 41754a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 41764a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 41774a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 41784a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 41794a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 41804a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 41814a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 41824a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 41834a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 41844a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 418502918be2SPhilipp Reisner }; 418602918be2SPhilipp Reisner 4187eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4188b411b363SPhilipp Reisner { 418977351055SPhilipp Reisner struct packet_info pi; 419002918be2SPhilipp Reisner size_t shs; /* sub header size */ 419182bc0194SAndreas Gruenbacher int err; 4192b411b363SPhilipp Reisner 4193eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4194deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4195deebe195SAndreas Gruenbacher 4196eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 419769bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 419802918be2SPhilipp Reisner goto err_out; 419902918be2SPhilipp Reisner 4200deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 42014a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 4202eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 420302918be2SPhilipp Reisner goto err_out; 42040b33a916SLars Ellenberg } 4205b411b363SPhilipp Reisner 4206e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4207e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 4208eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 4209c13f7e1aSLars Ellenberg goto err_out; 4210c13f7e1aSLars Ellenberg } 4211c13f7e1aSLars Ellenberg 4212c13f7e1aSLars Ellenberg if (shs) { 4213e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4214a5c31904SAndreas Gruenbacher if (err) 421502918be2SPhilipp Reisner goto err_out; 4216e2857216SAndreas Gruenbacher pi.size -= shs; 4217b411b363SPhilipp Reisner } 421802918be2SPhilipp Reisner 42194a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 42204a76b161SAndreas Gruenbacher if (err) { 42219f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 42229f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 422302918be2SPhilipp Reisner goto err_out; 4224b411b363SPhilipp Reisner } 4225b411b363SPhilipp Reisner } 422682bc0194SAndreas Gruenbacher return; 422702918be2SPhilipp Reisner 422802918be2SPhilipp Reisner err_out: 4229bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4230b411b363SPhilipp Reisner } 4231b411b363SPhilipp Reisner 42320e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4233b411b363SPhilipp Reisner { 4234b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4235b411b363SPhilipp Reisner 4236b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 42370e29d163SPhilipp Reisner barr.w.tconn = tconn; 4238b411b363SPhilipp Reisner init_completion(&barr.done); 42390e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4240b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4241b411b363SPhilipp Reisner } 4242b411b363SPhilipp Reisner 4243360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 4244b411b363SPhilipp Reisner { 4245bbeb641cSPhilipp Reisner enum drbd_conns oc; 4246b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 4247b411b363SPhilipp Reisner 4248bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4249b411b363SPhilipp Reisner return; 4250b411b363SPhilipp Reisner 4251b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4252360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4253360cc740SPhilipp Reisner drbd_free_sock(tconn); 4254360cc740SPhilipp Reisner 4255d3fcb490SPhilipp Reisner down_read(&drbd_cfg_rwsem); 4256360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 4257d3fcb490SPhilipp Reisner up_read(&drbd_cfg_rwsem); 4258360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4259360cc740SPhilipp Reisner 4260cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4261cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4262cb703454SPhilipp Reisner 4263360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4264bbeb641cSPhilipp Reisner oc = tconn->cstate; 4265bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4266bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4267bbeb641cSPhilipp Reisner 4268360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4269360cc740SPhilipp Reisner 4270f3dfa40aSLars Ellenberg if (oc == C_DISCONNECTING) 4271d9cc6e23SLars Ellenberg conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD); 4272360cc740SPhilipp Reisner } 4273360cc740SPhilipp Reisner 4274360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 4275360cc740SPhilipp Reisner { 4276360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 4277360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4278360cc740SPhilipp Reisner unsigned int i; 4279b411b363SPhilipp Reisner 428085719573SPhilipp Reisner /* wait for current activity to cease. */ 428187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4282b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4283b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4284b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 428587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4286b411b363SPhilipp Reisner 4287b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4288b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4289b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4290b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4291b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4292b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4293b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4294b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4295b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4296b411b363SPhilipp Reisner * on the fly. */ 4297b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4298b411b363SPhilipp Reisner mdev->rs_total = 0; 4299b411b363SPhilipp Reisner mdev->rs_failed = 0; 4300b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4301b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4302b411b363SPhilipp Reisner 43037fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 43047fde2be9SPhilipp Reisner 4305b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4306b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4307b411b363SPhilipp Reisner 4308b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4309b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4310b411b363SPhilipp Reisner * to be "canceled" */ 4311a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4312b411b363SPhilipp Reisner 4313a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4314b411b363SPhilipp Reisner 4315b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4316b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4317b411b363SPhilipp Reisner 43182aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 43192f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4320b411b363SPhilipp Reisner 4321b411b363SPhilipp Reisner drbd_md_sync(mdev); 4322b411b363SPhilipp Reisner 4323b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4324b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4325daeda1ccSPhilipp Reisner rcu_read_lock(); 4326daeda1ccSPhilipp Reisner fp = rcu_dereference(mdev->ldev->disk_conf)->fencing; 4327daeda1ccSPhilipp Reisner rcu_read_unlock(); 4328b411b363SPhilipp Reisner put_ldev(mdev); 4329b411b363SPhilipp Reisner } 4330b411b363SPhilipp Reisner 433120ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 433220ceb2b2SLars Ellenberg * if any. */ 433320ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 433420ceb2b2SLars Ellenberg 4335b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4336b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4337b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4338b411b363SPhilipp Reisner * 4339b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4340b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4341b411b363SPhilipp Reisner */ 43427721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4343b411b363SPhilipp Reisner if (i) 4344b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4345435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4346435f0740SLars Ellenberg if (i) 4347435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4348b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4349b411b363SPhilipp Reisner if (i) 435045bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4351b411b363SPhilipp Reisner 4352b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4353b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4354b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4355b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4356b411b363SPhilipp Reisner 4357b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4358b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4359b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4360360cc740SPhilipp Reisner 4361360cc740SPhilipp Reisner return 0; 4362b411b363SPhilipp Reisner } 4363b411b363SPhilipp Reisner 4364b411b363SPhilipp Reisner /* 4365b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4366b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4367b411b363SPhilipp Reisner * 4368b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4369b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4370b411b363SPhilipp Reisner * 4371b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4372b411b363SPhilipp Reisner */ 43736038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4374b411b363SPhilipp Reisner { 43759f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 43769f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4377b411b363SPhilipp Reisner 43789f5bdc33SAndreas Gruenbacher sock = &tconn->data; 43799f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 43809f5bdc33SAndreas Gruenbacher if (!p) 4381e8d17b01SAndreas Gruenbacher return -EIO; 4382b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4383b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4384b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 43859f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4386b411b363SPhilipp Reisner } 4387b411b363SPhilipp Reisner 4388b411b363SPhilipp Reisner /* 4389b411b363SPhilipp Reisner * return values: 4390b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4391b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4392b411b363SPhilipp Reisner * -1 peer talks different language, 4393b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4394b411b363SPhilipp Reisner */ 43956038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4396b411b363SPhilipp Reisner { 439765d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4398e658983aSAndreas Gruenbacher struct p_connection_features *p; 4399e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 440077351055SPhilipp Reisner struct packet_info pi; 4401a5c31904SAndreas Gruenbacher int err; 4402b411b363SPhilipp Reisner 44036038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4404e8d17b01SAndreas Gruenbacher if (err) 4405b411b363SPhilipp Reisner return 0; 4406b411b363SPhilipp Reisner 440769bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 440869bc7bc3SAndreas Gruenbacher if (err) 4409b411b363SPhilipp Reisner return 0; 4410b411b363SPhilipp Reisner 44116038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 44126038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 441377351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4414b411b363SPhilipp Reisner return -1; 4415b411b363SPhilipp Reisner } 4416b411b363SPhilipp Reisner 441777351055SPhilipp Reisner if (pi.size != expect) { 44186038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 441977351055SPhilipp Reisner expect, pi.size); 4420b411b363SPhilipp Reisner return -1; 4421b411b363SPhilipp Reisner } 4422b411b363SPhilipp Reisner 4423e658983aSAndreas Gruenbacher p = pi.data; 4424e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4425a5c31904SAndreas Gruenbacher if (err) 4426b411b363SPhilipp Reisner return 0; 4427b411b363SPhilipp Reisner 4428b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4429b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4430b411b363SPhilipp Reisner if (p->protocol_max == 0) 4431b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4432b411b363SPhilipp Reisner 4433b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4434b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4435b411b363SPhilipp Reisner goto incompat; 4436b411b363SPhilipp Reisner 443765d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4438b411b363SPhilipp Reisner 443965d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 444065d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4441b411b363SPhilipp Reisner 4442b411b363SPhilipp Reisner return 1; 4443b411b363SPhilipp Reisner 4444b411b363SPhilipp Reisner incompat: 444565d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4446b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4447b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4448b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4449b411b363SPhilipp Reisner return -1; 4450b411b363SPhilipp Reisner } 4451b411b363SPhilipp Reisner 4452b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 445313e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4454b411b363SPhilipp Reisner { 4455b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4456b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4457b10d96cbSJohannes Thoma return -1; 4458b411b363SPhilipp Reisner } 4459b411b363SPhilipp Reisner #else 4460b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4461b10d96cbSJohannes Thoma 4462b10d96cbSJohannes Thoma /* Return value: 4463b10d96cbSJohannes Thoma 1 - auth succeeded, 4464b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4465b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4466b10d96cbSJohannes Thoma */ 4467b10d96cbSJohannes Thoma 446813e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4469b411b363SPhilipp Reisner { 44709f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4471b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4472b411b363SPhilipp Reisner struct scatterlist sg; 4473b411b363SPhilipp Reisner char *response = NULL; 4474b411b363SPhilipp Reisner char *right_response = NULL; 4475b411b363SPhilipp Reisner char *peers_ch = NULL; 447644ed167dSPhilipp Reisner unsigned int key_len; 447744ed167dSPhilipp Reisner char secret[SHARED_SECRET_MAX]; /* 64 byte */ 4478b411b363SPhilipp Reisner unsigned int resp_size; 4479b411b363SPhilipp Reisner struct hash_desc desc; 448077351055SPhilipp Reisner struct packet_info pi; 448144ed167dSPhilipp Reisner struct net_conf *nc; 448269bc7bc3SAndreas Gruenbacher int err, rv; 4483b411b363SPhilipp Reisner 44849f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 44859f5bdc33SAndreas Gruenbacher 448644ed167dSPhilipp Reisner rcu_read_lock(); 448744ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 448844ed167dSPhilipp Reisner key_len = strlen(nc->shared_secret); 448944ed167dSPhilipp Reisner memcpy(secret, nc->shared_secret, key_len); 449044ed167dSPhilipp Reisner rcu_read_unlock(); 449144ed167dSPhilipp Reisner 449213e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4493b411b363SPhilipp Reisner desc.flags = 0; 4494b411b363SPhilipp Reisner 449544ed167dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len); 4496b411b363SPhilipp Reisner if (rv) { 449713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4498b10d96cbSJohannes Thoma rv = -1; 4499b411b363SPhilipp Reisner goto fail; 4500b411b363SPhilipp Reisner } 4501b411b363SPhilipp Reisner 4502b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4503b411b363SPhilipp Reisner 45049f5bdc33SAndreas Gruenbacher sock = &tconn->data; 45059f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 45069f5bdc33SAndreas Gruenbacher rv = 0; 45079f5bdc33SAndreas Gruenbacher goto fail; 45089f5bdc33SAndreas Gruenbacher } 4509e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 45109f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4511b411b363SPhilipp Reisner if (!rv) 4512b411b363SPhilipp Reisner goto fail; 4513b411b363SPhilipp Reisner 451469bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 451569bc7bc3SAndreas Gruenbacher if (err) { 451669bc7bc3SAndreas Gruenbacher rv = 0; 4517b411b363SPhilipp Reisner goto fail; 451869bc7bc3SAndreas Gruenbacher } 4519b411b363SPhilipp Reisner 452077351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 452113e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 452277351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4523b411b363SPhilipp Reisner rv = 0; 4524b411b363SPhilipp Reisner goto fail; 4525b411b363SPhilipp Reisner } 4526b411b363SPhilipp Reisner 452777351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 452813e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4529b10d96cbSJohannes Thoma rv = -1; 4530b411b363SPhilipp Reisner goto fail; 4531b411b363SPhilipp Reisner } 4532b411b363SPhilipp Reisner 453377351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4534b411b363SPhilipp Reisner if (peers_ch == NULL) { 453513e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4536b10d96cbSJohannes Thoma rv = -1; 4537b411b363SPhilipp Reisner goto fail; 4538b411b363SPhilipp Reisner } 4539b411b363SPhilipp Reisner 4540a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4541a5c31904SAndreas Gruenbacher if (err) { 4542b411b363SPhilipp Reisner rv = 0; 4543b411b363SPhilipp Reisner goto fail; 4544b411b363SPhilipp Reisner } 4545b411b363SPhilipp Reisner 454613e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4547b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4548b411b363SPhilipp Reisner if (response == NULL) { 454913e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4550b10d96cbSJohannes Thoma rv = -1; 4551b411b363SPhilipp Reisner goto fail; 4552b411b363SPhilipp Reisner } 4553b411b363SPhilipp Reisner 4554b411b363SPhilipp Reisner sg_init_table(&sg, 1); 455577351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4556b411b363SPhilipp Reisner 4557b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4558b411b363SPhilipp Reisner if (rv) { 455913e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4560b10d96cbSJohannes Thoma rv = -1; 4561b411b363SPhilipp Reisner goto fail; 4562b411b363SPhilipp Reisner } 4563b411b363SPhilipp Reisner 45649f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 45659f5bdc33SAndreas Gruenbacher rv = 0; 45669f5bdc33SAndreas Gruenbacher goto fail; 45679f5bdc33SAndreas Gruenbacher } 4568e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 45699f5bdc33SAndreas Gruenbacher response, resp_size); 4570b411b363SPhilipp Reisner if (!rv) 4571b411b363SPhilipp Reisner goto fail; 4572b411b363SPhilipp Reisner 457369bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 457469bc7bc3SAndreas Gruenbacher if (err) { 457569bc7bc3SAndreas Gruenbacher rv = 0; 4576b411b363SPhilipp Reisner goto fail; 457769bc7bc3SAndreas Gruenbacher } 4578b411b363SPhilipp Reisner 457977351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 458013e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 458177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4582b411b363SPhilipp Reisner rv = 0; 4583b411b363SPhilipp Reisner goto fail; 4584b411b363SPhilipp Reisner } 4585b411b363SPhilipp Reisner 458677351055SPhilipp Reisner if (pi.size != resp_size) { 458713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4588b411b363SPhilipp Reisner rv = 0; 4589b411b363SPhilipp Reisner goto fail; 4590b411b363SPhilipp Reisner } 4591b411b363SPhilipp Reisner 4592a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4593a5c31904SAndreas Gruenbacher if (err) { 4594b411b363SPhilipp Reisner rv = 0; 4595b411b363SPhilipp Reisner goto fail; 4596b411b363SPhilipp Reisner } 4597b411b363SPhilipp Reisner 4598b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 45992d1ee87dSJulia Lawall if (right_response == NULL) { 460013e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4601b10d96cbSJohannes Thoma rv = -1; 4602b411b363SPhilipp Reisner goto fail; 4603b411b363SPhilipp Reisner } 4604b411b363SPhilipp Reisner 4605b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4606b411b363SPhilipp Reisner 4607b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4608b411b363SPhilipp Reisner if (rv) { 460913e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4610b10d96cbSJohannes Thoma rv = -1; 4611b411b363SPhilipp Reisner goto fail; 4612b411b363SPhilipp Reisner } 4613b411b363SPhilipp Reisner 4614b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4615b411b363SPhilipp Reisner 4616b411b363SPhilipp Reisner if (rv) 461744ed167dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes HMAC\n", 461844ed167dSPhilipp Reisner resp_size); 4619b10d96cbSJohannes Thoma else 4620b10d96cbSJohannes Thoma rv = -1; 4621b411b363SPhilipp Reisner 4622b411b363SPhilipp Reisner fail: 4623b411b363SPhilipp Reisner kfree(peers_ch); 4624b411b363SPhilipp Reisner kfree(response); 4625b411b363SPhilipp Reisner kfree(right_response); 4626b411b363SPhilipp Reisner 4627b411b363SPhilipp Reisner return rv; 4628b411b363SPhilipp Reisner } 4629b411b363SPhilipp Reisner #endif 4630b411b363SPhilipp Reisner 4631b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4632b411b363SPhilipp Reisner { 4633392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4634b411b363SPhilipp Reisner int h; 4635b411b363SPhilipp Reisner 46364d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4637b411b363SPhilipp Reisner 4638b411b363SPhilipp Reisner do { 46394d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4640b411b363SPhilipp Reisner if (h == 0) { 46414d641dd7SPhilipp Reisner drbd_disconnect(tconn); 464220ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4643b411b363SPhilipp Reisner } 4644b411b363SPhilipp Reisner if (h == -1) { 46454d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4646bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4647b411b363SPhilipp Reisner } 4648b411b363SPhilipp Reisner } while (h == 0); 4649b411b363SPhilipp Reisner 465091fd4dadSPhilipp Reisner if (h > 0) 46514d641dd7SPhilipp Reisner drbdd(tconn); 4652b411b363SPhilipp Reisner 46534d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4654b411b363SPhilipp Reisner 46554d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4656b411b363SPhilipp Reisner return 0; 4657b411b363SPhilipp Reisner } 4658b411b363SPhilipp Reisner 4659b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4660b411b363SPhilipp Reisner 4661e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4662b411b363SPhilipp Reisner { 4663e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4664b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4665b411b363SPhilipp Reisner 4666fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4667fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4668fc3b10a4SPhilipp Reisner } else { 4669fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4670fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4671fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4672fc3b10a4SPhilipp Reisner } 4673fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4674e4f78edeSPhilipp Reisner 46752735a594SAndreas Gruenbacher return 0; 4676fc3b10a4SPhilipp Reisner } 4677e4f78edeSPhilipp Reisner 46781952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4679e4f78edeSPhilipp Reisner { 46801952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4681e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4682e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4683e4f78edeSPhilipp Reisner 46841952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 46851952e916SAndreas Gruenbacher if (!mdev) 46862735a594SAndreas Gruenbacher return -EIO; 46871952e916SAndreas Gruenbacher 4688e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4689e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4690e4f78edeSPhilipp Reisner } else { 4691e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4692e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4693e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4694e4f78edeSPhilipp Reisner } 4695e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4696e4f78edeSPhilipp Reisner 46972735a594SAndreas Gruenbacher return 0; 4698b411b363SPhilipp Reisner } 4699b411b363SPhilipp Reisner 4700e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4701b411b363SPhilipp Reisner { 47022735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4703b411b363SPhilipp Reisner 4704b411b363SPhilipp Reisner } 4705b411b363SPhilipp Reisner 4706e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4707b411b363SPhilipp Reisner { 4708b411b363SPhilipp Reisner /* restore idle timeout */ 47092a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 47102a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 47112a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4712b411b363SPhilipp Reisner 47132735a594SAndreas Gruenbacher return 0; 4714b411b363SPhilipp Reisner } 4715b411b363SPhilipp Reisner 47161952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4717b411b363SPhilipp Reisner { 47181952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4719e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4720b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4721b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4722b411b363SPhilipp Reisner 47231952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47241952e916SAndreas Gruenbacher if (!mdev) 47252735a594SAndreas Gruenbacher return -EIO; 47261952e916SAndreas Gruenbacher 472731890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4728b411b363SPhilipp Reisner 4729b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4730b411b363SPhilipp Reisner 47311d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4732b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4733b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4734b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4735b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 47361d53f09eSLars Ellenberg put_ldev(mdev); 47371d53f09eSLars Ellenberg } 4738b411b363SPhilipp Reisner dec_rs_pending(mdev); 4739778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4740b411b363SPhilipp Reisner 47412735a594SAndreas Gruenbacher return 0; 4742b411b363SPhilipp Reisner } 4743b411b363SPhilipp Reisner 4744bc9c5c41SAndreas Gruenbacher static int 4745bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4746bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4747bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4748b411b363SPhilipp Reisner { 4749b411b363SPhilipp Reisner struct drbd_request *req; 4750b411b363SPhilipp Reisner struct bio_and_error m; 4751b411b363SPhilipp Reisner 475287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4753bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4754b411b363SPhilipp Reisner if (unlikely(!req)) { 475587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 475685997675SAndreas Gruenbacher return -EIO; 4757b411b363SPhilipp Reisner } 4758b411b363SPhilipp Reisner __req_mod(req, what, &m); 475987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4760b411b363SPhilipp Reisner 4761b411b363SPhilipp Reisner if (m.bio) 4762b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 476385997675SAndreas Gruenbacher return 0; 4764b411b363SPhilipp Reisner } 4765b411b363SPhilipp Reisner 47661952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4767b411b363SPhilipp Reisner { 47681952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4769e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4770b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4771b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4772b411b363SPhilipp Reisner enum drbd_req_event what; 4773b411b363SPhilipp Reisner 47741952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47751952e916SAndreas Gruenbacher if (!mdev) 47762735a594SAndreas Gruenbacher return -EIO; 47771952e916SAndreas Gruenbacher 4778b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4779b411b363SPhilipp Reisner 4780579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4781b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4782b411b363SPhilipp Reisner dec_rs_pending(mdev); 47832735a594SAndreas Gruenbacher return 0; 4784b411b363SPhilipp Reisner } 4785e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4786b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 47878554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4788b411b363SPhilipp Reisner break; 4789b411b363SPhilipp Reisner case P_WRITE_ACK: 47908554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4791b411b363SPhilipp Reisner break; 4792b411b363SPhilipp Reisner case P_RECV_ACK: 47938554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4794b411b363SPhilipp Reisner break; 47957be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 47967be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 47977be8da07SAndreas Gruenbacher break; 47987be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 47997be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4800b411b363SPhilipp Reisner break; 4801b411b363SPhilipp Reisner default: 48022735a594SAndreas Gruenbacher BUG(); 4803b411b363SPhilipp Reisner } 4804b411b363SPhilipp Reisner 48052735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4806bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4807bc9c5c41SAndreas Gruenbacher what, false); 4808b411b363SPhilipp Reisner } 4809b411b363SPhilipp Reisner 48101952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 4811b411b363SPhilipp Reisner { 48121952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4813e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4814b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 48152deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 481685997675SAndreas Gruenbacher int err; 4817b411b363SPhilipp Reisner 48181952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48191952e916SAndreas Gruenbacher if (!mdev) 48202735a594SAndreas Gruenbacher return -EIO; 48211952e916SAndreas Gruenbacher 4822b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4823b411b363SPhilipp Reisner 4824579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4825b411b363SPhilipp Reisner dec_rs_pending(mdev); 4826b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 48272735a594SAndreas Gruenbacher return 0; 4828b411b363SPhilipp Reisner } 48292deb8336SPhilipp Reisner 483085997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 4831bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4832303d1448SPhilipp Reisner NEG_ACKED, true); 483385997675SAndreas Gruenbacher if (err) { 48342deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 48352deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4836c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 48372deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 48382deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4839c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 48402deb8336SPhilipp Reisner } 48412735a594SAndreas Gruenbacher return 0; 4842b411b363SPhilipp Reisner } 4843b411b363SPhilipp Reisner 48441952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4845b411b363SPhilipp Reisner { 48461952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4847e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4848b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4849b411b363SPhilipp Reisner 48501952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48511952e916SAndreas Gruenbacher if (!mdev) 48522735a594SAndreas Gruenbacher return -EIO; 48531952e916SAndreas Gruenbacher 4854b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 48557be8da07SAndreas Gruenbacher 4856b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4857b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4858b411b363SPhilipp Reisner 48592735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4860bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 48618554df1cSAndreas Gruenbacher NEG_ACKED, false); 4862b411b363SPhilipp Reisner } 4863b411b363SPhilipp Reisner 48641952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4865b411b363SPhilipp Reisner { 48661952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4867b411b363SPhilipp Reisner sector_t sector; 4868b411b363SPhilipp Reisner int size; 4869e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 48701952e916SAndreas Gruenbacher 48711952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 48721952e916SAndreas Gruenbacher if (!mdev) 48732735a594SAndreas Gruenbacher return -EIO; 4874b411b363SPhilipp Reisner 4875b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4876b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4877b411b363SPhilipp Reisner 4878b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4879b411b363SPhilipp Reisner 4880b411b363SPhilipp Reisner dec_rs_pending(mdev); 4881b411b363SPhilipp Reisner 4882b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4883b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4884e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4885d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4886b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4887d612d309SPhilipp Reisner case P_RS_CANCEL: 4888d612d309SPhilipp Reisner break; 4889d612d309SPhilipp Reisner default: 48902735a594SAndreas Gruenbacher BUG(); 4891d612d309SPhilipp Reisner } 4892b411b363SPhilipp Reisner put_ldev(mdev); 4893b411b363SPhilipp Reisner } 4894b411b363SPhilipp Reisner 48952735a594SAndreas Gruenbacher return 0; 4896b411b363SPhilipp Reisner } 4897b411b363SPhilipp Reisner 48981952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 4899b411b363SPhilipp Reisner { 49001952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4901e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 49021952e916SAndreas Gruenbacher 49031952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49041952e916SAndreas Gruenbacher if (!mdev) 49052735a594SAndreas Gruenbacher return -EIO; 4906b411b363SPhilipp Reisner 49072f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4908b411b363SPhilipp Reisner 4909c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4910c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4911370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4912370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4913370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4914c4752ef1SPhilipp Reisner } 4915c4752ef1SPhilipp Reisner 49162735a594SAndreas Gruenbacher return 0; 4917b411b363SPhilipp Reisner } 4918b411b363SPhilipp Reisner 49191952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 4920b411b363SPhilipp Reisner { 49211952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4922e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4923b411b363SPhilipp Reisner struct drbd_work *w; 4924b411b363SPhilipp Reisner sector_t sector; 4925b411b363SPhilipp Reisner int size; 4926b411b363SPhilipp Reisner 49271952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 49281952e916SAndreas Gruenbacher if (!mdev) 49292735a594SAndreas Gruenbacher return -EIO; 49301952e916SAndreas Gruenbacher 4931b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4932b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4933b411b363SPhilipp Reisner 4934b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4935b411b363SPhilipp Reisner 4936b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 49378f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 4938b411b363SPhilipp Reisner else 49398f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4940b411b363SPhilipp Reisner 49411d53f09eSLars Ellenberg if (!get_ldev(mdev)) 49422735a594SAndreas Gruenbacher return 0; 49431d53f09eSLars Ellenberg 4944b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4945b411b363SPhilipp Reisner dec_rs_pending(mdev); 4946b411b363SPhilipp Reisner 4947ea5442afSLars Ellenberg --mdev->ov_left; 4948ea5442afSLars Ellenberg 4949ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4950ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4951ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4952ea5442afSLars Ellenberg 4953ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4954b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4955b411b363SPhilipp Reisner if (w) { 4956b411b363SPhilipp Reisner w->cb = w_ov_finished; 4957a21e9298SPhilipp Reisner w->mdev = mdev; 4958e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4959b411b363SPhilipp Reisner } else { 4960b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 49618f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4962b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4963b411b363SPhilipp Reisner } 4964b411b363SPhilipp Reisner } 49651d53f09eSLars Ellenberg put_ldev(mdev); 49662735a594SAndreas Gruenbacher return 0; 4967b411b363SPhilipp Reisner } 4968b411b363SPhilipp Reisner 49691952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 49700ced55a3SPhilipp Reisner { 49712735a594SAndreas Gruenbacher return 0; 49720ced55a3SPhilipp Reisner } 49730ced55a3SPhilipp Reisner 4974a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 497532862ec7SPhilipp Reisner { 4976082a3439SPhilipp Reisner struct drbd_conf *mdev; 4977082a3439SPhilipp Reisner int i, not_empty = 0; 497832862ec7SPhilipp Reisner 497932862ec7SPhilipp Reisner do { 498032862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 498132862ec7SPhilipp Reisner flush_signals(current); 4982d3fcb490SPhilipp Reisner down_read(&drbd_cfg_rwsem); 4983082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4984d3fcb490SPhilipp Reisner if (drbd_finish_peer_reqs(mdev)) { 4985d3fcb490SPhilipp Reisner up_read(&drbd_cfg_rwsem); 4986082a3439SPhilipp Reisner return 1; /* error */ 4987082a3439SPhilipp Reisner } 4988d3fcb490SPhilipp Reisner } 4989d3fcb490SPhilipp Reisner up_read(&drbd_cfg_rwsem); 499032862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 4991082a3439SPhilipp Reisner 4992082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4993695d08faSPhilipp Reisner rcu_read_lock(); 4994082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4995082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 4996082a3439SPhilipp Reisner if (not_empty) 4997082a3439SPhilipp Reisner break; 4998082a3439SPhilipp Reisner } 4999695d08faSPhilipp Reisner rcu_read_unlock(); 5000082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 500132862ec7SPhilipp Reisner } while (not_empty); 500232862ec7SPhilipp Reisner 500332862ec7SPhilipp Reisner return 0; 500432862ec7SPhilipp Reisner } 500532862ec7SPhilipp Reisner 50067201b972SAndreas Gruenbacher struct asender_cmd { 50077201b972SAndreas Gruenbacher size_t pkt_size; 50081952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 50097201b972SAndreas Gruenbacher }; 50107201b972SAndreas Gruenbacher 50117201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 5012e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 5013e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 50141952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 50151952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 50161952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 50171952e916SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 50181952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 50191952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 50201952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 50211952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 50221952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 50231952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 50241952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 50251952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 50261952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 50271952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 50281952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 50297201b972SAndreas Gruenbacher }; 50307201b972SAndreas Gruenbacher 5031b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 5032b411b363SPhilipp Reisner { 5033392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 5034b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 503577351055SPhilipp Reisner struct packet_info pi; 5036257d0af6SPhilipp Reisner int rv; 5037e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 5038b411b363SPhilipp Reisner int received = 0; 503952b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 504052b061a4SAndreas Gruenbacher int expect = header_size; 504144ed167dSPhilipp Reisner bool ping_timeout_active = false; 504244ed167dSPhilipp Reisner struct net_conf *nc; 504344ed167dSPhilipp Reisner int ping_timeo, no_cork, ping_int; 5044b411b363SPhilipp Reisner 5045b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 5046b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 5047b411b363SPhilipp Reisner 5048e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 504980822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 505044ed167dSPhilipp Reisner 505144ed167dSPhilipp Reisner rcu_read_lock(); 505244ed167dSPhilipp Reisner nc = rcu_dereference(tconn->net_conf); 505344ed167dSPhilipp Reisner ping_timeo = nc->ping_timeo; 505444ed167dSPhilipp Reisner no_cork = nc->no_cork; 505544ed167dSPhilipp Reisner ping_int = nc->ping_int; 505644ed167dSPhilipp Reisner rcu_read_unlock(); 505744ed167dSPhilipp Reisner 505832862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 5059a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 506032862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 5061841ce241SAndreas Gruenbacher goto reconnect; 5062841ce241SAndreas Gruenbacher } 506344ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10; 506444ed167dSPhilipp Reisner ping_timeout_active = true; 5065b411b363SPhilipp Reisner } 5066b411b363SPhilipp Reisner 506732862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 506832862ec7SPhilipp Reisner much to send */ 506944ed167dSPhilipp Reisner if (!no_cork) 507032862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 5071a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 5072a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 5073b411b363SPhilipp Reisner goto reconnect; 5074082a3439SPhilipp Reisner } 5075b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 507644ed167dSPhilipp Reisner if (!no_cork) 507732862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 5078b411b363SPhilipp Reisner 5079b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 5080b411b363SPhilipp Reisner if (signal_pending(current)) 5081b411b363SPhilipp Reisner continue; 5082b411b363SPhilipp Reisner 508332862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 508432862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5085b411b363SPhilipp Reisner 5086b411b363SPhilipp Reisner flush_signals(current); 5087b411b363SPhilipp Reisner 5088b411b363SPhilipp Reisner /* Note: 5089b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 5090b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 5091b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 5092b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 5093b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 5094b411b363SPhilipp Reisner * rv == expected: full header or command 5095b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 5096b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 5097b411b363SPhilipp Reisner */ 5098b411b363SPhilipp Reisner if (likely(rv > 0)) { 5099b411b363SPhilipp Reisner received += rv; 5100b411b363SPhilipp Reisner buf += rv; 5101b411b363SPhilipp Reisner } else if (rv == 0) { 510232862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 5103b411b363SPhilipp Reisner goto reconnect; 5104b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 5105cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 5106cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 510732862ec7SPhilipp Reisner if (time_after(tconn->last_received, 510832862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 5109cb6518cbSLars Ellenberg continue; 5110f36af18cSLars Ellenberg if (ping_timeout_active) { 511132862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 5112b411b363SPhilipp Reisner goto reconnect; 5113b411b363SPhilipp Reisner } 511432862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 5115b411b363SPhilipp Reisner continue; 5116b411b363SPhilipp Reisner } else if (rv == -EINTR) { 5117b411b363SPhilipp Reisner continue; 5118b411b363SPhilipp Reisner } else { 511932862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 5120b411b363SPhilipp Reisner goto reconnect; 5121b411b363SPhilipp Reisner } 5122b411b363SPhilipp Reisner 5123b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 5124e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 5125b411b363SPhilipp Reisner goto reconnect; 51267201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 51271952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 512832862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 512977351055SPhilipp Reisner pi.cmd, pi.size); 5130b411b363SPhilipp Reisner goto disconnect; 5131b411b363SPhilipp Reisner } 5132e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 513352b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 513432862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 513577351055SPhilipp Reisner pi.cmd, pi.size); 5136b411b363SPhilipp Reisner goto reconnect; 5137b411b363SPhilipp Reisner } 5138257d0af6SPhilipp Reisner } 5139b411b363SPhilipp Reisner if (received == expect) { 51402735a594SAndreas Gruenbacher bool err; 5141a4fbda8eSPhilipp Reisner 51422735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 51432735a594SAndreas Gruenbacher if (err) { 51441952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 5145b411b363SPhilipp Reisner goto reconnect; 51461952e916SAndreas Gruenbacher } 5147b411b363SPhilipp Reisner 5148a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 5149a4fbda8eSPhilipp Reisner 515044ed167dSPhilipp Reisner if (cmd == &asender_tbl[P_PING_ACK]) { 515144ed167dSPhilipp Reisner /* restore idle timeout */ 515244ed167dSPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ; 515344ed167dSPhilipp Reisner ping_timeout_active = false; 515444ed167dSPhilipp Reisner } 5155f36af18cSLars Ellenberg 5156e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 5157b411b363SPhilipp Reisner received = 0; 515852b061a4SAndreas Gruenbacher expect = header_size; 5159b411b363SPhilipp Reisner cmd = NULL; 5160b411b363SPhilipp Reisner } 5161b411b363SPhilipp Reisner } 5162b411b363SPhilipp Reisner 5163b411b363SPhilipp Reisner if (0) { 5164b411b363SPhilipp Reisner reconnect: 5165bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 5166b411b363SPhilipp Reisner } 5167b411b363SPhilipp Reisner if (0) { 5168b411b363SPhilipp Reisner disconnect: 5169bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 5170b411b363SPhilipp Reisner } 517132862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 5172b411b363SPhilipp Reisner 517332862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 5174b411b363SPhilipp Reisner 5175b411b363SPhilipp Reisner return 0; 5176b411b363SPhilipp Reisner } 5177