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. 18745bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc 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 /** 23245bb912bSLars Ellenberg * drbd_pp_alloc() - 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 */ 24345bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 244b411b363SPhilipp Reisner { 245b411b363SPhilipp Reisner struct page *page = NULL; 246b411b363SPhilipp Reisner DEFINE_WAIT(wait); 247b411b363SPhilipp Reisner 24845bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 24945bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25089e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) 25118c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 252b411b363SPhilipp Reisner 25345bb912bSLars Ellenberg while (page == NULL) { 254b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 255b411b363SPhilipp Reisner 256b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 257b411b363SPhilipp Reisner 25889e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) { 25918c2d522SAndreas Gruenbacher page = __drbd_alloc_pages(mdev, number); 260b411b363SPhilipp Reisner if (page) 261b411b363SPhilipp Reisner break; 262b411b363SPhilipp Reisner } 263b411b363SPhilipp Reisner 264b411b363SPhilipp Reisner if (!retry) 265b411b363SPhilipp Reisner break; 266b411b363SPhilipp Reisner 267b411b363SPhilipp Reisner if (signal_pending(current)) { 268b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 269b411b363SPhilipp Reisner break; 270b411b363SPhilipp Reisner } 271b411b363SPhilipp Reisner 272b411b363SPhilipp Reisner schedule(); 273b411b363SPhilipp Reisner } 274b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 275b411b363SPhilipp Reisner 27645bb912bSLars Ellenberg if (page) 27745bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 278b411b363SPhilipp Reisner return page; 279b411b363SPhilipp Reisner } 280b411b363SPhilipp Reisner 281b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 28287eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 28345bb912bSLars Ellenberg * Either links the page chain back to the global pool, 28445bb912bSLars Ellenberg * or returns all pages to the system. */ 285435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 286b411b363SPhilipp Reisner { 287435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 288b411b363SPhilipp Reisner int i; 289435f0740SLars Ellenberg 2901816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 29145bb912bSLars Ellenberg i = page_chain_free(page); 29245bb912bSLars Ellenberg else { 29345bb912bSLars Ellenberg struct page *tmp; 29445bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 295b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 29645bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 29745bb912bSLars Ellenberg drbd_pp_vacant += i; 298b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 299b411b363SPhilipp Reisner } 300435f0740SLars Ellenberg i = atomic_sub_return(i, a); 30145bb912bSLars Ellenberg if (i < 0) 302435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 303435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 304b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 305b411b363SPhilipp Reisner } 306b411b363SPhilipp Reisner 307b411b363SPhilipp Reisner /* 308b411b363SPhilipp Reisner You need to hold the req_lock: 309b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 310b411b363SPhilipp Reisner 311b411b363SPhilipp Reisner You must not have the req_lock: 3123967deb1SAndreas Gruenbacher drbd_free_peer_req() 3130db55363SAndreas Gruenbacher drbd_alloc_peer_req() 3147721f567SAndreas Gruenbacher drbd_free_peer_reqs() 315b411b363SPhilipp Reisner drbd_ee_fix_bhs() 316a990be46SAndreas Gruenbacher drbd_finish_peer_reqs() 317b411b363SPhilipp Reisner drbd_clear_done_ee() 318b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 319b411b363SPhilipp Reisner */ 320b411b363SPhilipp Reisner 321f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 3220db55363SAndreas Gruenbacher drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector, 323f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 324b411b363SPhilipp Reisner { 325db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 326b411b363SPhilipp Reisner struct page *page; 32745bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 328b411b363SPhilipp Reisner 3290cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 330b411b363SPhilipp Reisner return NULL; 331b411b363SPhilipp Reisner 332db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 333db830c46SAndreas Gruenbacher if (!peer_req) { 334b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 3350db55363SAndreas Gruenbacher dev_err(DEV, "%s: allocation failed\n", __func__); 336b411b363SPhilipp Reisner return NULL; 337b411b363SPhilipp Reisner } 338b411b363SPhilipp Reisner 33945bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 34045bb912bSLars Ellenberg if (!page) 34145bb912bSLars Ellenberg goto fail; 342b411b363SPhilipp Reisner 343db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 344db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 345db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 346db830c46SAndreas Gruenbacher peer_req->i.local = false; 347db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 34853840641SAndreas Gruenbacher 349db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 350a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 351db830c46SAndreas Gruenbacher peer_req->pages = page; 352db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 353db830c46SAndreas Gruenbacher peer_req->flags = 0; 3549a8e7753SAndreas Gruenbacher /* 3559a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3569a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3579a8e7753SAndreas Gruenbacher */ 358db830c46SAndreas Gruenbacher peer_req->block_id = id; 359b411b363SPhilipp Reisner 360db830c46SAndreas Gruenbacher return peer_req; 361b411b363SPhilipp Reisner 36245bb912bSLars Ellenberg fail: 363db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 364b411b363SPhilipp Reisner return NULL; 365b411b363SPhilipp Reisner } 366b411b363SPhilipp Reisner 3673967deb1SAndreas Gruenbacher void __drbd_free_peer_req(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 368f6ffca9fSAndreas Gruenbacher int is_net) 369b411b363SPhilipp Reisner { 370db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 371db830c46SAndreas Gruenbacher kfree(peer_req->digest); 372db830c46SAndreas Gruenbacher drbd_pp_free(mdev, peer_req->pages, is_net); 373db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 374db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 375db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 376b411b363SPhilipp Reisner } 377b411b363SPhilipp Reisner 3787721f567SAndreas Gruenbacher int drbd_free_peer_reqs(struct drbd_conf *mdev, struct list_head *list) 379b411b363SPhilipp Reisner { 380b411b363SPhilipp Reisner LIST_HEAD(work_list); 381db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 382b411b363SPhilipp Reisner int count = 0; 383435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 384b411b363SPhilipp Reisner 38587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 386b411b363SPhilipp Reisner list_splice_init(list, &work_list); 38787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 388b411b363SPhilipp Reisner 389db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 3903967deb1SAndreas Gruenbacher __drbd_free_peer_req(mdev, peer_req, is_net); 391b411b363SPhilipp Reisner count++; 392b411b363SPhilipp Reisner } 393b411b363SPhilipp Reisner return count; 394b411b363SPhilipp Reisner } 395b411b363SPhilipp Reisner 396a990be46SAndreas Gruenbacher /* 397a990be46SAndreas Gruenbacher * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier. 398b411b363SPhilipp Reisner */ 399a990be46SAndreas Gruenbacher static int drbd_finish_peer_reqs(struct drbd_conf *mdev) 400b411b363SPhilipp Reisner { 401b411b363SPhilipp Reisner LIST_HEAD(work_list); 402b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 403db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 404e2b3032bSAndreas Gruenbacher int err = 0; 405b411b363SPhilipp Reisner 40687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 407a990be46SAndreas Gruenbacher reclaim_finished_net_peer_reqs(mdev, &reclaimed); 408b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 40987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 410b411b363SPhilipp Reisner 411db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 4123967deb1SAndreas Gruenbacher drbd_free_net_peer_req(mdev, peer_req); 413b411b363SPhilipp Reisner 414b411b363SPhilipp Reisner /* possible callbacks here: 4157be8da07SAndreas Gruenbacher * e_end_block, and e_end_resync_block, e_send_discard_write. 416b411b363SPhilipp Reisner * all ignore the last argument. 417b411b363SPhilipp Reisner */ 418db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 419e2b3032bSAndreas Gruenbacher int err2; 420e2b3032bSAndreas Gruenbacher 421b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 422e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 423e2b3032bSAndreas Gruenbacher if (!err) 424e2b3032bSAndreas Gruenbacher err = err2; 4253967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 426b411b363SPhilipp Reisner } 427b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 428b411b363SPhilipp Reisner 429e2b3032bSAndreas Gruenbacher return err; 430b411b363SPhilipp Reisner } 431b411b363SPhilipp Reisner 432d4da1537SAndreas Gruenbacher static void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, 433d4da1537SAndreas Gruenbacher struct list_head *head) 434b411b363SPhilipp Reisner { 435b411b363SPhilipp Reisner DEFINE_WAIT(wait); 436b411b363SPhilipp Reisner 437b411b363SPhilipp Reisner /* avoids spin_lock/unlock 438b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 439b411b363SPhilipp Reisner while (!list_empty(head)) { 440b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 44187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4427eaceaccSJens Axboe io_schedule(); 443b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 44487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 445b411b363SPhilipp Reisner } 446b411b363SPhilipp Reisner } 447b411b363SPhilipp Reisner 448d4da1537SAndreas Gruenbacher static void drbd_wait_ee_list_empty(struct drbd_conf *mdev, 449d4da1537SAndreas Gruenbacher struct list_head *head) 450b411b363SPhilipp Reisner { 45187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 452b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 45387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 454b411b363SPhilipp Reisner } 455b411b363SPhilipp Reisner 456b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 457b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4587653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 459b411b363SPhilipp Reisner { 460b411b363SPhilipp Reisner struct sock *sk = sock->sk; 461b411b363SPhilipp Reisner int err = 0; 462b411b363SPhilipp Reisner 463b411b363SPhilipp Reisner *what = "listen"; 464b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 465b411b363SPhilipp Reisner if (err < 0) 466b411b363SPhilipp Reisner goto out; 467b411b363SPhilipp Reisner 468b411b363SPhilipp Reisner *what = "sock_create_lite"; 469b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 470b411b363SPhilipp Reisner newsock); 471b411b363SPhilipp Reisner if (err < 0) 472b411b363SPhilipp Reisner goto out; 473b411b363SPhilipp Reisner 474b411b363SPhilipp Reisner *what = "accept"; 475b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 476b411b363SPhilipp Reisner if (err < 0) { 477b411b363SPhilipp Reisner sock_release(*newsock); 478b411b363SPhilipp Reisner *newsock = NULL; 479b411b363SPhilipp Reisner goto out; 480b411b363SPhilipp Reisner } 481b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 482b411b363SPhilipp Reisner 483b411b363SPhilipp Reisner out: 484b411b363SPhilipp Reisner return err; 485b411b363SPhilipp Reisner } 486b411b363SPhilipp Reisner 487dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 488b411b363SPhilipp Reisner { 489b411b363SPhilipp Reisner mm_segment_t oldfs; 490b411b363SPhilipp Reisner struct kvec iov = { 491b411b363SPhilipp Reisner .iov_base = buf, 492b411b363SPhilipp Reisner .iov_len = size, 493b411b363SPhilipp Reisner }; 494b411b363SPhilipp Reisner struct msghdr msg = { 495b411b363SPhilipp Reisner .msg_iovlen = 1, 496b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 497b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 498b411b363SPhilipp Reisner }; 499b411b363SPhilipp Reisner int rv; 500b411b363SPhilipp Reisner 501b411b363SPhilipp Reisner oldfs = get_fs(); 502b411b363SPhilipp Reisner set_fs(KERNEL_DS); 503b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 504b411b363SPhilipp Reisner set_fs(oldfs); 505b411b363SPhilipp Reisner 506b411b363SPhilipp Reisner return rv; 507b411b363SPhilipp Reisner } 508b411b363SPhilipp Reisner 509de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 510b411b363SPhilipp Reisner { 511b411b363SPhilipp Reisner mm_segment_t oldfs; 512b411b363SPhilipp Reisner struct kvec iov = { 513b411b363SPhilipp Reisner .iov_base = buf, 514b411b363SPhilipp Reisner .iov_len = size, 515b411b363SPhilipp Reisner }; 516b411b363SPhilipp Reisner struct msghdr msg = { 517b411b363SPhilipp Reisner .msg_iovlen = 1, 518b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 519b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 520b411b363SPhilipp Reisner }; 521b411b363SPhilipp Reisner int rv; 522b411b363SPhilipp Reisner 523b411b363SPhilipp Reisner oldfs = get_fs(); 524b411b363SPhilipp Reisner set_fs(KERNEL_DS); 525b411b363SPhilipp Reisner 526b411b363SPhilipp Reisner for (;;) { 527de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 528b411b363SPhilipp Reisner if (rv == size) 529b411b363SPhilipp Reisner break; 530b411b363SPhilipp Reisner 531b411b363SPhilipp Reisner /* Note: 532b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 533b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 534b411b363SPhilipp Reisner */ 535b411b363SPhilipp Reisner 536b411b363SPhilipp Reisner if (rv < 0) { 537b411b363SPhilipp Reisner if (rv == -ECONNRESET) 538de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 539b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 540de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 541b411b363SPhilipp Reisner break; 542b411b363SPhilipp Reisner } else if (rv == 0) { 543de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 544b411b363SPhilipp Reisner break; 545b411b363SPhilipp Reisner } else { 546b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 547b411b363SPhilipp Reisner * after we read a partial message 548b411b363SPhilipp Reisner */ 549b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 550b411b363SPhilipp Reisner break; 551b411b363SPhilipp Reisner } 552b411b363SPhilipp Reisner }; 553b411b363SPhilipp Reisner 554b411b363SPhilipp Reisner set_fs(oldfs); 555b411b363SPhilipp Reisner 556b411b363SPhilipp Reisner if (rv != size) 557bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 558b411b363SPhilipp Reisner 559b411b363SPhilipp Reisner return rv; 560b411b363SPhilipp Reisner } 561b411b363SPhilipp Reisner 562c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 563c6967746SAndreas Gruenbacher { 564c6967746SAndreas Gruenbacher int err; 565c6967746SAndreas Gruenbacher 566c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 567c6967746SAndreas Gruenbacher if (err != size) { 568c6967746SAndreas Gruenbacher if (err >= 0) 569c6967746SAndreas Gruenbacher err = -EIO; 570c6967746SAndreas Gruenbacher } else 571c6967746SAndreas Gruenbacher err = 0; 572c6967746SAndreas Gruenbacher return err; 573c6967746SAndreas Gruenbacher } 574c6967746SAndreas Gruenbacher 575a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 576a5c31904SAndreas Gruenbacher { 577a5c31904SAndreas Gruenbacher int err; 578a5c31904SAndreas Gruenbacher 579a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 580a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 581a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 582a5c31904SAndreas Gruenbacher return err; 583a5c31904SAndreas Gruenbacher } 584a5c31904SAndreas Gruenbacher 5855dbf1673SLars Ellenberg /* quoting tcp(7): 5865dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5875dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5885dbf1673SLars Ellenberg * This is our wrapper to do so. 5895dbf1673SLars Ellenberg */ 5905dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5915dbf1673SLars Ellenberg unsigned int rcv) 5925dbf1673SLars Ellenberg { 5935dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5945dbf1673SLars Ellenberg if (snd) { 5955dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5965dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5975dbf1673SLars Ellenberg } 5985dbf1673SLars Ellenberg if (rcv) { 5995dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 6005dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 6015dbf1673SLars Ellenberg } 6025dbf1673SLars Ellenberg } 6035dbf1673SLars Ellenberg 604eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 605b411b363SPhilipp Reisner { 606b411b363SPhilipp Reisner const char *what; 607b411b363SPhilipp Reisner struct socket *sock; 608b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 609b411b363SPhilipp Reisner int err; 610b411b363SPhilipp Reisner int disconnect_on_error = 1; 611b411b363SPhilipp Reisner 612eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 613b411b363SPhilipp Reisner return NULL; 614b411b363SPhilipp Reisner 615b411b363SPhilipp Reisner what = "sock_create_kern"; 616eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 617b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 618b411b363SPhilipp Reisner if (err < 0) { 619b411b363SPhilipp Reisner sock = NULL; 620b411b363SPhilipp Reisner goto out; 621b411b363SPhilipp Reisner } 622b411b363SPhilipp Reisner 623b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 624eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 625eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 626eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 627b411b363SPhilipp Reisner 628b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 629b411b363SPhilipp Reisner * for the outgoing connections. 630b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 631b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 632b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 633b411b363SPhilipp Reisner * a free one dynamically. 634b411b363SPhilipp Reisner */ 635eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 636eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 637eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 638b411b363SPhilipp Reisner src_in6.sin6_port = 0; 639b411b363SPhilipp Reisner else 640b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 641b411b363SPhilipp Reisner 642b411b363SPhilipp Reisner what = "bind before connect"; 643b411b363SPhilipp Reisner err = sock->ops->bind(sock, 644b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 645eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 646b411b363SPhilipp Reisner if (err < 0) 647b411b363SPhilipp Reisner goto out; 648b411b363SPhilipp Reisner 649b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 650b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 651b411b363SPhilipp Reisner disconnect_on_error = 0; 652b411b363SPhilipp Reisner what = "connect"; 653b411b363SPhilipp Reisner err = sock->ops->connect(sock, 654eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 655eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 656b411b363SPhilipp Reisner 657b411b363SPhilipp Reisner out: 658b411b363SPhilipp Reisner if (err < 0) { 659b411b363SPhilipp Reisner if (sock) { 660b411b363SPhilipp Reisner sock_release(sock); 661b411b363SPhilipp Reisner sock = NULL; 662b411b363SPhilipp Reisner } 663b411b363SPhilipp Reisner switch (-err) { 664b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 665b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 666b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 667b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 668b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 669b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 670b411b363SPhilipp Reisner disconnect_on_error = 0; 671b411b363SPhilipp Reisner break; 672b411b363SPhilipp Reisner default: 673eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 674b411b363SPhilipp Reisner } 675b411b363SPhilipp Reisner if (disconnect_on_error) 676bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 677b411b363SPhilipp Reisner } 678eac3e990SPhilipp Reisner put_net_conf(tconn); 679b411b363SPhilipp Reisner return sock; 680b411b363SPhilipp Reisner } 681b411b363SPhilipp Reisner 6827653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 683b411b363SPhilipp Reisner { 684b411b363SPhilipp Reisner int timeo, err; 685b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 686b411b363SPhilipp Reisner const char *what; 687b411b363SPhilipp Reisner 6887653620dSPhilipp Reisner if (!get_net_conf(tconn)) 689b411b363SPhilipp Reisner return NULL; 690b411b363SPhilipp Reisner 691b411b363SPhilipp Reisner what = "sock_create_kern"; 6927653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 693b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 694b411b363SPhilipp Reisner if (err) { 695b411b363SPhilipp Reisner s_listen = NULL; 696b411b363SPhilipp Reisner goto out; 697b411b363SPhilipp Reisner } 698b411b363SPhilipp Reisner 6997653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 700b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 701b411b363SPhilipp Reisner 702b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 703b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 704b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 7057653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 7067653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 707b411b363SPhilipp Reisner 708b411b363SPhilipp Reisner what = "bind before listen"; 709b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 7107653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 7117653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 712b411b363SPhilipp Reisner if (err < 0) 713b411b363SPhilipp Reisner goto out; 714b411b363SPhilipp Reisner 7157653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 716b411b363SPhilipp Reisner 717b411b363SPhilipp Reisner out: 718b411b363SPhilipp Reisner if (s_listen) 719b411b363SPhilipp Reisner sock_release(s_listen); 720b411b363SPhilipp Reisner if (err < 0) { 721b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7227653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 723bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 724b411b363SPhilipp Reisner } 725b411b363SPhilipp Reisner } 7267653620dSPhilipp Reisner put_net_conf(tconn); 727b411b363SPhilipp Reisner 728b411b363SPhilipp Reisner return s_estab; 729b411b363SPhilipp Reisner } 730b411b363SPhilipp Reisner 731e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *, void *, struct packet_info *); 732b411b363SPhilipp Reisner 7339f5bdc33SAndreas Gruenbacher static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock, 7349f5bdc33SAndreas Gruenbacher enum drbd_packet cmd) 7359f5bdc33SAndreas Gruenbacher { 7369f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) 7379f5bdc33SAndreas Gruenbacher return -EIO; 738e658983aSAndreas Gruenbacher return conn_send_command(tconn, sock, cmd, 0, NULL, 0); 739b411b363SPhilipp Reisner } 740b411b363SPhilipp Reisner 7419f5bdc33SAndreas Gruenbacher static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock) 742b411b363SPhilipp Reisner { 7439f5bdc33SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 7449f5bdc33SAndreas Gruenbacher struct packet_info pi; 7459f5bdc33SAndreas Gruenbacher int err; 746b411b363SPhilipp Reisner 7479f5bdc33SAndreas Gruenbacher err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0); 7489f5bdc33SAndreas Gruenbacher if (err != header_size) { 7499f5bdc33SAndreas Gruenbacher if (err >= 0) 7509f5bdc33SAndreas Gruenbacher err = -EIO; 7519f5bdc33SAndreas Gruenbacher return err; 7529f5bdc33SAndreas Gruenbacher } 7539f5bdc33SAndreas Gruenbacher err = decode_header(tconn, tconn->data.rbuf, &pi); 7549f5bdc33SAndreas Gruenbacher if (err) 7559f5bdc33SAndreas Gruenbacher return err; 7569f5bdc33SAndreas Gruenbacher return pi.cmd; 757b411b363SPhilipp Reisner } 758b411b363SPhilipp Reisner 759b411b363SPhilipp Reisner /** 760b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 761b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 762b411b363SPhilipp Reisner */ 763dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 764b411b363SPhilipp Reisner { 765b411b363SPhilipp Reisner int rr; 766b411b363SPhilipp Reisner char tb[4]; 767b411b363SPhilipp Reisner 768b411b363SPhilipp Reisner if (!*sock) 76981e84650SAndreas Gruenbacher return false; 770b411b363SPhilipp Reisner 771dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 772b411b363SPhilipp Reisner 773b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 77481e84650SAndreas Gruenbacher return true; 775b411b363SPhilipp Reisner } else { 776b411b363SPhilipp Reisner sock_release(*sock); 777b411b363SPhilipp Reisner *sock = NULL; 77881e84650SAndreas Gruenbacher return false; 779b411b363SPhilipp Reisner } 780b411b363SPhilipp Reisner } 7812325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 7822325eb66SPhilipp Reisner in a connection */ 7832325eb66SPhilipp Reisner int drbd_connected(int vnr, void *p, void *data) 784907599e0SPhilipp Reisner { 785907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 7860829f5edSAndreas Gruenbacher int err; 787907599e0SPhilipp Reisner 788907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 789907599e0SPhilipp Reisner mdev->peer_seq = 0; 790907599e0SPhilipp Reisner 7918410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 7928410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 7938410da8fSPhilipp Reisner &mdev->own_state_mutex; 7948410da8fSPhilipp Reisner 7950829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 7960829f5edSAndreas Gruenbacher if (!err) 7970829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 7980829f5edSAndreas Gruenbacher if (!err) 7990829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 8000829f5edSAndreas Gruenbacher if (!err) 8010829f5edSAndreas Gruenbacher err = drbd_send_state(mdev); 802907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 803907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8048b924f1dSPhilipp Reisner mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */ 8050829f5edSAndreas Gruenbacher return err; 806907599e0SPhilipp Reisner } 807907599e0SPhilipp Reisner 808b411b363SPhilipp Reisner /* 809b411b363SPhilipp Reisner * return values: 810b411b363SPhilipp Reisner * 1 yes, we have a valid connection 811b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 812b411b363SPhilipp Reisner * -1 peer talks different language, 813b411b363SPhilipp Reisner * no point in trying again, please go standalone. 814b411b363SPhilipp Reisner * -2 We do not have a network config... 815b411b363SPhilipp Reisner */ 816907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 817b411b363SPhilipp Reisner { 8182bf89621SAndreas Gruenbacher struct socket *sock, *msock; 819b411b363SPhilipp Reisner int try, h, ok; 820b411b363SPhilipp Reisner 821bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 822b411b363SPhilipp Reisner return -2; 823b411b363SPhilipp Reisner 824907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 8250916e0e3SAndreas Gruenbacher 8260916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8270916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 828b411b363SPhilipp Reisner 829b411b363SPhilipp Reisner do { 8302bf89621SAndreas Gruenbacher struct socket *s; 8312bf89621SAndreas Gruenbacher 832b411b363SPhilipp Reisner for (try = 0;;) { 833b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 834907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 835b411b363SPhilipp Reisner if (s || ++try >= 3) 836b411b363SPhilipp Reisner break; 837b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 83820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 839b411b363SPhilipp Reisner } 840b411b363SPhilipp Reisner 841b411b363SPhilipp Reisner if (s) { 8422bf89621SAndreas Gruenbacher if (!tconn->data.socket) { 8432bf89621SAndreas Gruenbacher tconn->data.socket = s; 8449f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->data, P_INITIAL_DATA); 8452bf89621SAndreas Gruenbacher } else if (!tconn->meta.socket) { 8462bf89621SAndreas Gruenbacher tconn->meta.socket = s; 8479f5bdc33SAndreas Gruenbacher send_first_packet(tconn, &tconn->meta, P_INITIAL_META); 848b411b363SPhilipp Reisner } else { 849907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 850b411b363SPhilipp Reisner goto out_release_sockets; 851b411b363SPhilipp Reisner } 852b411b363SPhilipp Reisner } 853b411b363SPhilipp Reisner 8542bf89621SAndreas Gruenbacher if (tconn->data.socket && tconn->meta.socket) { 855907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 8562bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 8572bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 858b411b363SPhilipp Reisner if (ok) 859b411b363SPhilipp Reisner break; 860b411b363SPhilipp Reisner } 861b411b363SPhilipp Reisner 862b411b363SPhilipp Reisner retry: 863907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 864b411b363SPhilipp Reisner if (s) { 8659f5bdc33SAndreas Gruenbacher try = receive_first_packet(tconn, s); 8662bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->data.socket); 8672bf89621SAndreas Gruenbacher drbd_socket_okay(&tconn->meta.socket); 868b411b363SPhilipp Reisner switch (try) { 869e5d6f33aSAndreas Gruenbacher case P_INITIAL_DATA: 8702bf89621SAndreas Gruenbacher if (tconn->data.socket) { 871907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 8722bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 873b411b363SPhilipp Reisner } 8742bf89621SAndreas Gruenbacher tconn->data.socket = s; 875b411b363SPhilipp Reisner break; 876e5d6f33aSAndreas Gruenbacher case P_INITIAL_META: 8772bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 878907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 8792bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 880b411b363SPhilipp Reisner } 8812bf89621SAndreas Gruenbacher tconn->meta.socket = s; 882907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 883b411b363SPhilipp Reisner break; 884b411b363SPhilipp Reisner default: 885907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 886b411b363SPhilipp Reisner sock_release(s); 887b411b363SPhilipp Reisner if (random32() & 1) 888b411b363SPhilipp Reisner goto retry; 889b411b363SPhilipp Reisner } 890b411b363SPhilipp Reisner } 891b411b363SPhilipp Reisner 892bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 893b411b363SPhilipp Reisner goto out_release_sockets; 894b411b363SPhilipp Reisner if (signal_pending(current)) { 895b411b363SPhilipp Reisner flush_signals(current); 896b411b363SPhilipp Reisner smp_rmb(); 897907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 898b411b363SPhilipp Reisner goto out_release_sockets; 899b411b363SPhilipp Reisner } 900b411b363SPhilipp Reisner 9012bf89621SAndreas Gruenbacher if (tconn->data.socket && &tconn->meta.socket) { 9022bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->data.socket); 9032bf89621SAndreas Gruenbacher ok = drbd_socket_okay(&tconn->meta.socket) && ok; 904b411b363SPhilipp Reisner if (ok) 905b411b363SPhilipp Reisner break; 906b411b363SPhilipp Reisner } 907b411b363SPhilipp Reisner } while (1); 908b411b363SPhilipp Reisner 9092bf89621SAndreas Gruenbacher sock = tconn->data.socket; 9102bf89621SAndreas Gruenbacher msock = tconn->meta.socket; 9112bf89621SAndreas Gruenbacher 912b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 913b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 914b411b363SPhilipp Reisner 915b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 916b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 917b411b363SPhilipp Reisner 918b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 919b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 920b411b363SPhilipp Reisner 921b411b363SPhilipp Reisner /* NOT YET ... 922907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 923b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 9246038178eSAndreas Gruenbacher * first set it to the P_CONNECTION_FEATURES timeout, 925b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 926b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 927907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 928b411b363SPhilipp Reisner 929907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 930907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 931b411b363SPhilipp Reisner 932b411b363SPhilipp Reisner /* we don't want delays. 93325985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 934b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 935b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 936b411b363SPhilipp Reisner 937907599e0SPhilipp Reisner tconn->last_received = jiffies; 938b411b363SPhilipp Reisner 9396038178eSAndreas Gruenbacher h = drbd_do_features(tconn); 940b411b363SPhilipp Reisner if (h <= 0) 941b411b363SPhilipp Reisner return h; 942b411b363SPhilipp Reisner 943907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 944b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 945907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 946b10d96cbSJohannes Thoma case -1: 947907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 948b411b363SPhilipp Reisner return -1; 949b10d96cbSJohannes Thoma case 0: 950907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 951b10d96cbSJohannes Thoma return 0; 952b411b363SPhilipp Reisner } 953b411b363SPhilipp Reisner } 954b411b363SPhilipp Reisner 955bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 956b411b363SPhilipp Reisner return 0; 957b411b363SPhilipp Reisner 958907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 959b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 960b411b363SPhilipp Reisner 961907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 962b411b363SPhilipp Reisner 963387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 9647e2455c1SPhilipp Reisner return -1; 965b411b363SPhilipp Reisner 966907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 967b411b363SPhilipp Reisner 968b411b363SPhilipp Reisner out_release_sockets: 9692bf89621SAndreas Gruenbacher if (tconn->data.socket) { 9702bf89621SAndreas Gruenbacher sock_release(tconn->data.socket); 9712bf89621SAndreas Gruenbacher tconn->data.socket = NULL; 9722bf89621SAndreas Gruenbacher } 9732bf89621SAndreas Gruenbacher if (tconn->meta.socket) { 9742bf89621SAndreas Gruenbacher sock_release(tconn->meta.socket); 9752bf89621SAndreas Gruenbacher tconn->meta.socket = NULL; 9762bf89621SAndreas Gruenbacher } 977b411b363SPhilipp Reisner return -1; 978b411b363SPhilipp Reisner } 979b411b363SPhilipp Reisner 980e658983aSAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi) 981b411b363SPhilipp Reisner { 982e658983aSAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 983e658983aSAndreas Gruenbacher 9840c8e36d9SAndreas Gruenbacher if (header_size == sizeof(struct p_header100) && 9850c8e36d9SAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) { 9860c8e36d9SAndreas Gruenbacher struct p_header100 *h = header; 9870c8e36d9SAndreas Gruenbacher if (h->pad != 0) { 9880c8e36d9SAndreas Gruenbacher conn_err(tconn, "Header padding is not zero\n"); 9890c8e36d9SAndreas Gruenbacher return -EINVAL; 9900c8e36d9SAndreas Gruenbacher } 9910c8e36d9SAndreas Gruenbacher pi->vnr = be16_to_cpu(h->volume); 9920c8e36d9SAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 9930c8e36d9SAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 9940c8e36d9SAndreas Gruenbacher } else if (header_size == sizeof(struct p_header95) && 995e658983aSAndreas Gruenbacher *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) { 996e658983aSAndreas Gruenbacher struct p_header95 *h = header; 997e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 998b55d84baSAndreas Gruenbacher pi->size = be32_to_cpu(h->length); 999eefc2f7dSPhilipp Reisner pi->vnr = 0; 1000e658983aSAndreas Gruenbacher } else if (header_size == sizeof(struct p_header80) && 1001e658983aSAndreas Gruenbacher *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) { 1002e658983aSAndreas Gruenbacher struct p_header80 *h = header; 1003e658983aSAndreas Gruenbacher pi->cmd = be16_to_cpu(h->command); 1004e658983aSAndreas Gruenbacher pi->size = be16_to_cpu(h->length); 100577351055SPhilipp Reisner pi->vnr = 0; 100602918be2SPhilipp Reisner } else { 1007e658983aSAndreas Gruenbacher conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n", 1008e658983aSAndreas Gruenbacher be32_to_cpu(*(__be32 *)header), 1009e658983aSAndreas Gruenbacher tconn->agreed_pro_version); 10108172f3e9SAndreas Gruenbacher return -EINVAL; 1011b411b363SPhilipp Reisner } 1012e658983aSAndreas Gruenbacher pi->data = header + header_size; 10138172f3e9SAndreas Gruenbacher return 0; 1014257d0af6SPhilipp Reisner } 1015257d0af6SPhilipp Reisner 10169ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 1017257d0af6SPhilipp Reisner { 1018e658983aSAndreas Gruenbacher void *buffer = tconn->data.rbuf; 101969bc7bc3SAndreas Gruenbacher int err; 1020257d0af6SPhilipp Reisner 1021e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn)); 1022a5c31904SAndreas Gruenbacher if (err) 102369bc7bc3SAndreas Gruenbacher return err; 1024257d0af6SPhilipp Reisner 1025e658983aSAndreas Gruenbacher err = decode_header(tconn, buffer, pi); 10269ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1027b411b363SPhilipp Reisner 102869bc7bc3SAndreas Gruenbacher return err; 1029b411b363SPhilipp Reisner } 1030b411b363SPhilipp Reisner 10312451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 1032b411b363SPhilipp Reisner { 1033b411b363SPhilipp Reisner int rv; 1034b411b363SPhilipp Reisner 1035b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 1036fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 1037dd3932edSChristoph Hellwig NULL); 1038b411b363SPhilipp Reisner if (rv) { 1039b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 1040b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1041b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1042b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1043b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 1044b411b363SPhilipp Reisner } 1045b411b363SPhilipp Reisner put_ldev(mdev); 1046b411b363SPhilipp Reisner } 1047b411b363SPhilipp Reisner } 1048b411b363SPhilipp Reisner 1049b411b363SPhilipp Reisner /** 1050b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1051b411b363SPhilipp Reisner * @mdev: DRBD device. 1052b411b363SPhilipp Reisner * @epoch: Epoch object. 1053b411b363SPhilipp Reisner * @ev: Epoch event. 1054b411b363SPhilipp Reisner */ 1055b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1056b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1057b411b363SPhilipp Reisner enum epoch_event ev) 1058b411b363SPhilipp Reisner { 10592451fc3bSPhilipp Reisner int epoch_size; 1060b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1061b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1062b411b363SPhilipp Reisner 1063b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1064b411b363SPhilipp Reisner do { 1065b411b363SPhilipp Reisner next_epoch = NULL; 1066b411b363SPhilipp Reisner 1067b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1068b411b363SPhilipp Reisner 1069b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1070b411b363SPhilipp Reisner case EV_PUT: 1071b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1072b411b363SPhilipp Reisner break; 1073b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1074b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1075b411b363SPhilipp Reisner break; 1076b411b363SPhilipp Reisner case EV_BECAME_LAST: 1077b411b363SPhilipp Reisner /* nothing to do*/ 1078b411b363SPhilipp Reisner break; 1079b411b363SPhilipp Reisner } 1080b411b363SPhilipp Reisner 1081b411b363SPhilipp Reisner if (epoch_size != 0 && 1082b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10832451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1084b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1085b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1086b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1087b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1088b411b363SPhilipp Reisner } 1089b411b363SPhilipp Reisner dec_unacked(mdev); 1090b411b363SPhilipp Reisner 1091b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1092b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1093b411b363SPhilipp Reisner list_del(&epoch->list); 1094b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1095b411b363SPhilipp Reisner mdev->epochs--; 1096b411b363SPhilipp Reisner kfree(epoch); 1097b411b363SPhilipp Reisner 1098b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1099b411b363SPhilipp Reisner rv = FE_DESTROYED; 1100b411b363SPhilipp Reisner } else { 1101b411b363SPhilipp Reisner epoch->flags = 0; 1102b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1103698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1104b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1105b411b363SPhilipp Reisner rv = FE_RECYCLED; 11062451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1107b411b363SPhilipp Reisner } 1108b411b363SPhilipp Reisner } 1109b411b363SPhilipp Reisner 1110b411b363SPhilipp Reisner if (!next_epoch) 1111b411b363SPhilipp Reisner break; 1112b411b363SPhilipp Reisner 1113b411b363SPhilipp Reisner epoch = next_epoch; 1114b411b363SPhilipp Reisner } while (1); 1115b411b363SPhilipp Reisner 1116b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1117b411b363SPhilipp Reisner 1118b411b363SPhilipp Reisner return rv; 1119b411b363SPhilipp Reisner } 1120b411b363SPhilipp Reisner 1121b411b363SPhilipp Reisner /** 1122b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1123b411b363SPhilipp Reisner * @mdev: DRBD device. 1124b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1125b411b363SPhilipp Reisner */ 1126b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1127b411b363SPhilipp Reisner { 1128b411b363SPhilipp Reisner enum write_ordering_e pwo; 1129b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1130b411b363SPhilipp Reisner [WO_none] = "none", 1131b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1132b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1133b411b363SPhilipp Reisner }; 1134b411b363SPhilipp Reisner 1135b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1136b411b363SPhilipp Reisner wo = min(pwo, wo); 1137b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1138b411b363SPhilipp Reisner wo = WO_drain_io; 1139b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1140b411b363SPhilipp Reisner wo = WO_none; 1141b411b363SPhilipp Reisner mdev->write_ordering = wo; 11422451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1143b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1144b411b363SPhilipp Reisner } 1145b411b363SPhilipp Reisner 1146b411b363SPhilipp Reisner /** 1147fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 114845bb912bSLars Ellenberg * @mdev: DRBD device. 1149db830c46SAndreas Gruenbacher * @peer_req: peer request 115045bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 115110f6d992SLars Ellenberg * 115210f6d992SLars Ellenberg * May spread the pages to multiple bios, 115310f6d992SLars Ellenberg * depending on bio_add_page restrictions. 115410f6d992SLars Ellenberg * 115510f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 115610f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 115710f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 115810f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 115910f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 116010f6d992SLars Ellenberg * on certain Xen deployments. 116145bb912bSLars Ellenberg */ 116245bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1163fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1164fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 116545bb912bSLars Ellenberg const unsigned rw, const int fault_type) 116645bb912bSLars Ellenberg { 116745bb912bSLars Ellenberg struct bio *bios = NULL; 116845bb912bSLars Ellenberg struct bio *bio; 1169db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1170db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1171db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 117245bb912bSLars Ellenberg unsigned n_bios = 0; 117345bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 117410f6d992SLars Ellenberg int err = -ENOMEM; 117545bb912bSLars Ellenberg 117645bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 117745bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 117845bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1179da4a75d2SLars Ellenberg * request in more than one bio. 1180da4a75d2SLars Ellenberg * 1181da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1182da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1183da4a75d2SLars Ellenberg */ 118445bb912bSLars Ellenberg next_bio: 118545bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 118645bb912bSLars Ellenberg if (!bio) { 118745bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 118845bb912bSLars Ellenberg goto fail; 118945bb912bSLars Ellenberg } 1190db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 119145bb912bSLars Ellenberg bio->bi_sector = sector; 119245bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 119345bb912bSLars Ellenberg bio->bi_rw = rw; 1194db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1195fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 119645bb912bSLars Ellenberg 119745bb912bSLars Ellenberg bio->bi_next = bios; 119845bb912bSLars Ellenberg bios = bio; 119945bb912bSLars Ellenberg ++n_bios; 120045bb912bSLars Ellenberg 120145bb912bSLars Ellenberg page_chain_for_each(page) { 120245bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 120345bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 120410f6d992SLars Ellenberg /* A single page must always be possible! 120510f6d992SLars Ellenberg * But in case it fails anyways, 120610f6d992SLars Ellenberg * we deal with it, and complain (below). */ 120710f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 120810f6d992SLars Ellenberg dev_err(DEV, 120910f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 121010f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 121110f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 121210f6d992SLars Ellenberg err = -ENOSPC; 121310f6d992SLars Ellenberg goto fail; 121410f6d992SLars Ellenberg } 121545bb912bSLars Ellenberg goto next_bio; 121645bb912bSLars Ellenberg } 121745bb912bSLars Ellenberg ds -= len; 121845bb912bSLars Ellenberg sector += len >> 9; 121945bb912bSLars Ellenberg --nr_pages; 122045bb912bSLars Ellenberg } 122145bb912bSLars Ellenberg D_ASSERT(page == NULL); 122245bb912bSLars Ellenberg D_ASSERT(ds == 0); 122345bb912bSLars Ellenberg 1224db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 122545bb912bSLars Ellenberg do { 122645bb912bSLars Ellenberg bio = bios; 122745bb912bSLars Ellenberg bios = bios->bi_next; 122845bb912bSLars Ellenberg bio->bi_next = NULL; 122945bb912bSLars Ellenberg 123045bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 123145bb912bSLars Ellenberg } while (bios); 123245bb912bSLars Ellenberg return 0; 123345bb912bSLars Ellenberg 123445bb912bSLars Ellenberg fail: 123545bb912bSLars Ellenberg while (bios) { 123645bb912bSLars Ellenberg bio = bios; 123745bb912bSLars Ellenberg bios = bios->bi_next; 123845bb912bSLars Ellenberg bio_put(bio); 123945bb912bSLars Ellenberg } 124010f6d992SLars Ellenberg return err; 124145bb912bSLars Ellenberg } 124245bb912bSLars Ellenberg 124353840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1244db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 124553840641SAndreas Gruenbacher { 1246db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 124753840641SAndreas Gruenbacher 124853840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 124953840641SAndreas Gruenbacher drbd_clear_interval(i); 125053840641SAndreas Gruenbacher 12516c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 125253840641SAndreas Gruenbacher if (i->waiting) 125353840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 125453840641SAndreas Gruenbacher } 125553840641SAndreas Gruenbacher 12564a76b161SAndreas Gruenbacher static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi) 1257b411b363SPhilipp Reisner { 12584a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 12592451fc3bSPhilipp Reisner int rv; 1260e658983aSAndreas Gruenbacher struct p_barrier *p = pi->data; 1261b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1262b411b363SPhilipp Reisner 12634a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 12644a76b161SAndreas Gruenbacher if (!mdev) 12654a76b161SAndreas Gruenbacher return -EIO; 12664a76b161SAndreas Gruenbacher 1267b411b363SPhilipp Reisner inc_unacked(mdev); 1268b411b363SPhilipp Reisner 1269b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1270b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1271b411b363SPhilipp Reisner 1272b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1273b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1274b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1275b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1276b411b363SPhilipp Reisner * completed. */ 1277b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1278b411b363SPhilipp Reisner case WO_none: 1279b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 128082bc0194SAndreas Gruenbacher return 0; 1281b411b363SPhilipp Reisner 1282b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1283b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1284b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12852451fc3bSPhilipp Reisner if (epoch) 12862451fc3bSPhilipp Reisner break; 12872451fc3bSPhilipp Reisner else 1288b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12892451fc3bSPhilipp Reisner /* Fall through */ 12902451fc3bSPhilipp Reisner 12912451fc3bSPhilipp Reisner case WO_bdev_flush: 12922451fc3bSPhilipp Reisner case WO_drain_io: 1293b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12942451fc3bSPhilipp Reisner drbd_flush(mdev); 12952451fc3bSPhilipp Reisner 12962451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12972451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12982451fc3bSPhilipp Reisner if (epoch) 12992451fc3bSPhilipp Reisner break; 1300b411b363SPhilipp Reisner } 1301b411b363SPhilipp Reisner 13022451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 13032451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 13042451fc3bSPhilipp Reisner 13052451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 13062451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1307b411b363SPhilipp Reisner 130882bc0194SAndreas Gruenbacher return 0; 13092451fc3bSPhilipp Reisner default: 13102451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 131182bc0194SAndreas Gruenbacher return -EIO; 1312b411b363SPhilipp Reisner } 1313b411b363SPhilipp Reisner 1314b411b363SPhilipp Reisner epoch->flags = 0; 1315b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1316b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1317b411b363SPhilipp Reisner 1318b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1319b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1320b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1321b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1322b411b363SPhilipp Reisner mdev->epochs++; 1323b411b363SPhilipp Reisner } else { 1324b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1325b411b363SPhilipp Reisner kfree(epoch); 1326b411b363SPhilipp Reisner } 1327b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1328b411b363SPhilipp Reisner 132982bc0194SAndreas Gruenbacher return 0; 1330b411b363SPhilipp Reisner } 1331b411b363SPhilipp Reisner 1332b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1333b411b363SPhilipp Reisner * and from receive_Data */ 1334f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1335f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1336f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1337b411b363SPhilipp Reisner { 13386666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1339db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1340b411b363SPhilipp Reisner struct page *page; 1341a5c31904SAndreas Gruenbacher int dgs, ds, err; 1342a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1343a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 13446b4388acSPhilipp Reisner unsigned long *data; 1345b411b363SPhilipp Reisner 1346a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1347a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1348b411b363SPhilipp Reisner 1349b411b363SPhilipp Reisner if (dgs) { 13509f5bdc33SAndreas Gruenbacher /* 13519f5bdc33SAndreas Gruenbacher * FIXME: Receive the incoming digest into the receive buffer 13529f5bdc33SAndreas Gruenbacher * here, together with its struct p_data? 13539f5bdc33SAndreas Gruenbacher */ 1354a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1355a5c31904SAndreas Gruenbacher if (err) 1356b411b363SPhilipp Reisner return NULL; 1357b411b363SPhilipp Reisner } 1358b411b363SPhilipp Reisner 1359b411b363SPhilipp Reisner data_size -= dgs; 1360b411b363SPhilipp Reisner 1361841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1362841ce241SAndreas Gruenbacher return NULL; 1363841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1364841ce241SAndreas Gruenbacher return NULL; 1365841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1366841ce241SAndreas Gruenbacher return NULL; 1367b411b363SPhilipp Reisner 13686666032aSLars Ellenberg /* even though we trust out peer, 13696666032aSLars Ellenberg * we sometimes have to double check. */ 13706666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1371fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1372fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13736666032aSLars Ellenberg (unsigned long long)capacity, 13746666032aSLars Ellenberg (unsigned long long)sector, data_size); 13756666032aSLars Ellenberg return NULL; 13766666032aSLars Ellenberg } 13776666032aSLars Ellenberg 1378b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1379b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1380b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 13810db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO); 1382db830c46SAndreas Gruenbacher if (!peer_req) 1383b411b363SPhilipp Reisner return NULL; 138445bb912bSLars Ellenberg 1385b411b363SPhilipp Reisner ds = data_size; 1386db830c46SAndreas Gruenbacher page = peer_req->pages; 138745bb912bSLars Ellenberg page_chain_for_each(page) { 138845bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13896b4388acSPhilipp Reisner data = kmap(page); 1390a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 13910cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13926b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13936b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13946b4388acSPhilipp Reisner } 1395b411b363SPhilipp Reisner kunmap(page); 1396a5c31904SAndreas Gruenbacher if (err) { 13973967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1398b411b363SPhilipp Reisner return NULL; 1399b411b363SPhilipp Reisner } 1400a5c31904SAndreas Gruenbacher ds -= len; 1401b411b363SPhilipp Reisner } 1402b411b363SPhilipp Reisner 1403b411b363SPhilipp Reisner if (dgs) { 1404db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1405b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1406470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1407470be44aSLars Ellenberg (unsigned long long)sector, data_size); 14083967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 1409b411b363SPhilipp Reisner return NULL; 1410b411b363SPhilipp Reisner } 1411b411b363SPhilipp Reisner } 1412b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1413db830c46SAndreas Gruenbacher return peer_req; 1414b411b363SPhilipp Reisner } 1415b411b363SPhilipp Reisner 1416b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1417b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1418b411b363SPhilipp Reisner */ 1419b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1420b411b363SPhilipp Reisner { 1421b411b363SPhilipp Reisner struct page *page; 1422a5c31904SAndreas Gruenbacher int err = 0; 1423b411b363SPhilipp Reisner void *data; 1424b411b363SPhilipp Reisner 1425c3470cdeSLars Ellenberg if (!data_size) 1426fc5be839SAndreas Gruenbacher return 0; 1427c3470cdeSLars Ellenberg 142845bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1429b411b363SPhilipp Reisner 1430b411b363SPhilipp Reisner data = kmap(page); 1431b411b363SPhilipp Reisner while (data_size) { 1432fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1433fc5be839SAndreas Gruenbacher 1434a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1435a5c31904SAndreas Gruenbacher if (err) 1436b411b363SPhilipp Reisner break; 1437a5c31904SAndreas Gruenbacher data_size -= len; 1438b411b363SPhilipp Reisner } 1439b411b363SPhilipp Reisner kunmap(page); 1440435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1441fc5be839SAndreas Gruenbacher return err; 1442b411b363SPhilipp Reisner } 1443b411b363SPhilipp Reisner 1444b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1445b411b363SPhilipp Reisner sector_t sector, int data_size) 1446b411b363SPhilipp Reisner { 1447b411b363SPhilipp Reisner struct bio_vec *bvec; 1448b411b363SPhilipp Reisner struct bio *bio; 1449a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1450a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1451a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1452b411b363SPhilipp Reisner 1453a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1454a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1455b411b363SPhilipp Reisner 1456b411b363SPhilipp Reisner if (dgs) { 1457a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1458a5c31904SAndreas Gruenbacher if (err) 1459a5c31904SAndreas Gruenbacher return err; 1460b411b363SPhilipp Reisner } 1461b411b363SPhilipp Reisner 1462b411b363SPhilipp Reisner data_size -= dgs; 1463b411b363SPhilipp Reisner 1464b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1465b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1466b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1467b411b363SPhilipp Reisner 1468b411b363SPhilipp Reisner bio = req->master_bio; 1469b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1470b411b363SPhilipp Reisner 1471b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1472a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1473b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1474a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1475b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1476a5c31904SAndreas Gruenbacher if (err) 1477a5c31904SAndreas Gruenbacher return err; 1478a5c31904SAndreas Gruenbacher data_size -= expect; 1479b411b363SPhilipp Reisner } 1480b411b363SPhilipp Reisner 1481b411b363SPhilipp Reisner if (dgs) { 1482a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1483b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1484b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 148528284cefSAndreas Gruenbacher return -EINVAL; 1486b411b363SPhilipp Reisner } 1487b411b363SPhilipp Reisner } 1488b411b363SPhilipp Reisner 1489b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 149028284cefSAndreas Gruenbacher return 0; 1491b411b363SPhilipp Reisner } 1492b411b363SPhilipp Reisner 1493a990be46SAndreas Gruenbacher /* 1494a990be46SAndreas Gruenbacher * e_end_resync_block() is called in asender context via 1495a990be46SAndreas Gruenbacher * drbd_finish_peer_reqs(). 1496a990be46SAndreas Gruenbacher */ 149799920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1498b411b363SPhilipp Reisner { 14998050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 15008050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 150100d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1502db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 150399920dc5SAndreas Gruenbacher int err; 1504b411b363SPhilipp Reisner 1505db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1506b411b363SPhilipp Reisner 1507db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1508db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 150999920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1510b411b363SPhilipp Reisner } else { 1511b411b363SPhilipp Reisner /* Record failure to sync */ 1512db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1513b411b363SPhilipp Reisner 151499920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1515b411b363SPhilipp Reisner } 1516b411b363SPhilipp Reisner dec_unacked(mdev); 1517b411b363SPhilipp Reisner 151899920dc5SAndreas Gruenbacher return err; 1519b411b363SPhilipp Reisner } 1520b411b363SPhilipp Reisner 1521b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1522b411b363SPhilipp Reisner { 1523db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1524b411b363SPhilipp Reisner 1525db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1526db830c46SAndreas Gruenbacher if (!peer_req) 152745bb912bSLars Ellenberg goto fail; 1528b411b363SPhilipp Reisner 1529b411b363SPhilipp Reisner dec_rs_pending(mdev); 1530b411b363SPhilipp Reisner 1531b411b363SPhilipp Reisner inc_unacked(mdev); 1532b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1533b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1534b411b363SPhilipp Reisner 1535db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 153645bb912bSLars Ellenberg 153787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1538db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 153987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1540b411b363SPhilipp Reisner 15410f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1542fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1543e1c1b0fcSAndreas Gruenbacher return 0; 154445bb912bSLars Ellenberg 154510f6d992SLars Ellenberg /* don't care for the reason here */ 154610f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 154787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1548db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 154987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 155022cc37a9SLars Ellenberg 15513967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 155245bb912bSLars Ellenberg fail: 155345bb912bSLars Ellenberg put_ldev(mdev); 1554e1c1b0fcSAndreas Gruenbacher return -EIO; 1555b411b363SPhilipp Reisner } 1556b411b363SPhilipp Reisner 1557668eebc6SAndreas Gruenbacher static struct drbd_request * 1558bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1559bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1560668eebc6SAndreas Gruenbacher { 1561668eebc6SAndreas Gruenbacher struct drbd_request *req; 1562668eebc6SAndreas Gruenbacher 1563bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1564bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15655e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1566668eebc6SAndreas Gruenbacher return req; 1567c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1568c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1569c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1570c3afd8f5SAndreas Gruenbacher } 1571668eebc6SAndreas Gruenbacher return NULL; 1572668eebc6SAndreas Gruenbacher } 1573668eebc6SAndreas Gruenbacher 15744a76b161SAndreas Gruenbacher static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1575b411b363SPhilipp Reisner { 15764a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1577b411b363SPhilipp Reisner struct drbd_request *req; 1578b411b363SPhilipp Reisner sector_t sector; 157982bc0194SAndreas Gruenbacher int err; 1580e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 15814a76b161SAndreas Gruenbacher 15824a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 15834a76b161SAndreas Gruenbacher if (!mdev) 15844a76b161SAndreas Gruenbacher return -EIO; 1585b411b363SPhilipp Reisner 1586b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1587b411b363SPhilipp Reisner 158887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1589bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 159087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1591c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 159282bc0194SAndreas Gruenbacher return -EIO; 1593b411b363SPhilipp Reisner 159424c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1595b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1596b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1597e2857216SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, pi->size); 159882bc0194SAndreas Gruenbacher if (!err) 15998554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1600b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1601b411b363SPhilipp Reisner * I don't think we may complete this just yet 1602b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1603b411b363SPhilipp Reisner 160482bc0194SAndreas Gruenbacher return err; 1605b411b363SPhilipp Reisner } 1606b411b363SPhilipp Reisner 16074a76b161SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi) 1608b411b363SPhilipp Reisner { 16094a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 1610b411b363SPhilipp Reisner sector_t sector; 161182bc0194SAndreas Gruenbacher int err; 1612e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 16134a76b161SAndreas Gruenbacher 16144a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 16154a76b161SAndreas Gruenbacher if (!mdev) 16164a76b161SAndreas Gruenbacher return -EIO; 1617b411b363SPhilipp Reisner 1618b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1619b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1620b411b363SPhilipp Reisner 1621b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1622b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1623b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1624fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1625e2857216SAndreas Gruenbacher err = recv_resync_read(mdev, sector, pi->size); 1626b411b363SPhilipp Reisner } else { 1627b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1628b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1629b411b363SPhilipp Reisner 1630e2857216SAndreas Gruenbacher err = drbd_drain_block(mdev, pi->size); 1631b411b363SPhilipp Reisner 1632e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 1633b411b363SPhilipp Reisner } 1634b411b363SPhilipp Reisner 1635e2857216SAndreas Gruenbacher atomic_add(pi->size >> 9, &mdev->rs_sect_in); 1636778f271dSPhilipp Reisner 163782bc0194SAndreas Gruenbacher return err; 1638b411b363SPhilipp Reisner } 1639b411b363SPhilipp Reisner 164099920dc5SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 16417be8da07SAndreas Gruenbacher { 16427be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 16437be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16447be8da07SAndreas Gruenbacher struct bio *bio; 16457be8da07SAndreas Gruenbacher unsigned long start_time; 16467be8da07SAndreas Gruenbacher unsigned long flags; 16477be8da07SAndreas Gruenbacher 16487be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16497be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16507be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 165199920dc5SAndreas Gruenbacher return -EIO; 16527be8da07SAndreas Gruenbacher } 16537be8da07SAndreas Gruenbacher bio = req->master_bio; 16547be8da07SAndreas Gruenbacher start_time = req->start_time; 16557be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 16567be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 16577be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16587be8da07SAndreas Gruenbacher 16597be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 16607be8da07SAndreas Gruenbacher /* retry */ ; 166199920dc5SAndreas Gruenbacher return 0; 16627be8da07SAndreas Gruenbacher } 16637be8da07SAndreas Gruenbacher 16647be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 16657be8da07SAndreas Gruenbacher sector_t sector, int size) 16667be8da07SAndreas Gruenbacher { 16677be8da07SAndreas Gruenbacher struct drbd_interval *i; 16687be8da07SAndreas Gruenbacher struct drbd_request *req; 16697be8da07SAndreas Gruenbacher 16707be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 16717be8da07SAndreas Gruenbacher if (!i->local) 16727be8da07SAndreas Gruenbacher continue; 16737be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 16747be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 16757be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 16767be8da07SAndreas Gruenbacher continue; 16777be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 16787be8da07SAndreas Gruenbacher req->w.mdev = mdev; 16797be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 16807be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 16817be8da07SAndreas Gruenbacher } 16827be8da07SAndreas Gruenbacher } 16837be8da07SAndreas Gruenbacher } 16847be8da07SAndreas Gruenbacher 1685a990be46SAndreas Gruenbacher /* 1686a990be46SAndreas Gruenbacher * e_end_block() is called in asender context via drbd_finish_peer_reqs(). 1687b411b363SPhilipp Reisner */ 168899920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1689b411b363SPhilipp Reisner { 16908050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16918050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 169200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1693db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 169499920dc5SAndreas Gruenbacher int err = 0, pcmd; 1695b411b363SPhilipp Reisner 169689e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1697db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1698b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1699b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1700db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1701b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 170299920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1703b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1704db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1705b411b363SPhilipp Reisner } else { 170699920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1707b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1708b411b363SPhilipp Reisner * maybe assert this? */ 1709b411b363SPhilipp Reisner } 1710b411b363SPhilipp Reisner dec_unacked(mdev); 1711b411b363SPhilipp Reisner } 1712b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1713b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 171489e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 171587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1716db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1717db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 17187be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 17197be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 172087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1721bb3bfe96SAndreas Gruenbacher } else 1722db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1723b411b363SPhilipp Reisner 1724db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1725b411b363SPhilipp Reisner 172699920dc5SAndreas Gruenbacher return err; 1727b411b363SPhilipp Reisner } 1728b411b363SPhilipp Reisner 17297be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1730b411b363SPhilipp Reisner { 17317be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 17328050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17338050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 173499920dc5SAndreas Gruenbacher int err; 1735b411b363SPhilipp Reisner 173699920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1737b411b363SPhilipp Reisner dec_unacked(mdev); 1738b411b363SPhilipp Reisner 173999920dc5SAndreas Gruenbacher return err; 1740b411b363SPhilipp Reisner } 1741b411b363SPhilipp Reisner 174299920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 17437be8da07SAndreas Gruenbacher { 17447be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17457be8da07SAndreas Gruenbacher } 17467be8da07SAndreas Gruenbacher 174799920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17487be8da07SAndreas Gruenbacher { 17497be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17507be8da07SAndreas Gruenbacher 17517be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 17527be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 17537be8da07SAndreas Gruenbacher } 17547be8da07SAndreas Gruenbacher 17553e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 17563e394da1SAndreas Gruenbacher { 17573e394da1SAndreas Gruenbacher /* 17583e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 17593e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 17603e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 17613e394da1SAndreas Gruenbacher */ 17623e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 17633e394da1SAndreas Gruenbacher } 17643e394da1SAndreas Gruenbacher 17653e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 17663e394da1SAndreas Gruenbacher { 17673e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 17683e394da1SAndreas Gruenbacher } 17693e394da1SAndreas Gruenbacher 17707be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 17717be8da07SAndreas Gruenbacher { 17727be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 17737be8da07SAndreas Gruenbacher 17747be8da07SAndreas Gruenbacher /* 17757be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 17767be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 17777be8da07SAndreas Gruenbacher * handle_write_conflicts(). 17787be8da07SAndreas Gruenbacher */ 17797be8da07SAndreas Gruenbacher return tconn->net_conf->two_primaries && 17807be8da07SAndreas Gruenbacher test_bit(DISCARD_CONCURRENT, &tconn->flags); 17817be8da07SAndreas Gruenbacher } 17827be8da07SAndreas Gruenbacher 178343ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 17843e394da1SAndreas Gruenbacher { 17853c13b680SLars Ellenberg unsigned int newest_peer_seq; 17863e394da1SAndreas Gruenbacher 17877be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 17883e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 17893c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 17903c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 17913e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 17923c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 17933c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 17943e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 17953e394da1SAndreas Gruenbacher } 17967be8da07SAndreas Gruenbacher } 17973e394da1SAndreas Gruenbacher 1798b411b363SPhilipp Reisner /* Called from receive_Data. 1799b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1800b411b363SPhilipp Reisner * 1801b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1802b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1803b411b363SPhilipp Reisner * been sent. 1804b411b363SPhilipp Reisner * 1805b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1806b411b363SPhilipp Reisner * 1807b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1808b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1809b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1810b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1811b411b363SPhilipp Reisner * 1812b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1813b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1814b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1815b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1816b411b363SPhilipp Reisner * 1817b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1818b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 18197be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1820b411b363SPhilipp Reisner { 1821b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1822b411b363SPhilipp Reisner long timeout; 18237be8da07SAndreas Gruenbacher int ret; 18247be8da07SAndreas Gruenbacher 18257be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 18267be8da07SAndreas Gruenbacher return 0; 18277be8da07SAndreas Gruenbacher 1828b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1829b411b363SPhilipp Reisner for (;;) { 18307be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 18317be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 18327be8da07SAndreas Gruenbacher ret = 0; 1833b411b363SPhilipp Reisner break; 18347be8da07SAndreas Gruenbacher } 1835b411b363SPhilipp Reisner if (signal_pending(current)) { 1836b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1837b411b363SPhilipp Reisner break; 1838b411b363SPhilipp Reisner } 18397be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1840b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 184171b1c1ebSAndreas Gruenbacher timeout = mdev->tconn->net_conf->ping_timeo*HZ/10; 184271b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1843b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 18447be8da07SAndreas Gruenbacher if (!timeout) { 1845b411b363SPhilipp Reisner ret = -ETIMEDOUT; 184671b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1847b411b363SPhilipp Reisner break; 1848b411b363SPhilipp Reisner } 1849b411b363SPhilipp Reisner } 1850b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 18517be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1852b411b363SPhilipp Reisner return ret; 1853b411b363SPhilipp Reisner } 1854b411b363SPhilipp Reisner 1855688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1856688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1857688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1858688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 185976d2e7ecSPhilipp Reisner { 186076d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 186176d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1862688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 186376d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 186476d2e7ecSPhilipp Reisner } 186576d2e7ecSPhilipp Reisner 18667be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 18677be8da07SAndreas Gruenbacher unsigned int size) 18687be8da07SAndreas Gruenbacher { 18697be8da07SAndreas Gruenbacher struct drbd_interval *i; 18707be8da07SAndreas Gruenbacher 18717be8da07SAndreas Gruenbacher repeat: 18727be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18737be8da07SAndreas Gruenbacher struct drbd_request *req; 18747be8da07SAndreas Gruenbacher struct bio_and_error m; 18757be8da07SAndreas Gruenbacher 18767be8da07SAndreas Gruenbacher if (!i->local) 18777be8da07SAndreas Gruenbacher continue; 18787be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18797be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 18807be8da07SAndreas Gruenbacher continue; 18817be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 18827be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 18837be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 18847be8da07SAndreas Gruenbacher if (m.bio) 18857be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 18867be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 18877be8da07SAndreas Gruenbacher goto repeat; 18887be8da07SAndreas Gruenbacher } 18897be8da07SAndreas Gruenbacher } 18907be8da07SAndreas Gruenbacher 18917be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 18927be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 18937be8da07SAndreas Gruenbacher { 18947be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 18957be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 18967be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 18977be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 18987be8da07SAndreas Gruenbacher struct drbd_interval *i; 18997be8da07SAndreas Gruenbacher bool equal; 19007be8da07SAndreas Gruenbacher int err; 19017be8da07SAndreas Gruenbacher 19027be8da07SAndreas Gruenbacher /* 19037be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 19047be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 19057be8da07SAndreas Gruenbacher */ 19067be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 19077be8da07SAndreas Gruenbacher 19087be8da07SAndreas Gruenbacher repeat: 19097be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 19107be8da07SAndreas Gruenbacher if (i == &peer_req->i) 19117be8da07SAndreas Gruenbacher continue; 19127be8da07SAndreas Gruenbacher 19137be8da07SAndreas Gruenbacher if (!i->local) { 19147be8da07SAndreas Gruenbacher /* 19157be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 19167be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 19177be8da07SAndreas Gruenbacher * earlier peer request to complete. 19187be8da07SAndreas Gruenbacher */ 19197be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 19207be8da07SAndreas Gruenbacher if (err) 19217be8da07SAndreas Gruenbacher goto out; 19227be8da07SAndreas Gruenbacher goto repeat; 19237be8da07SAndreas Gruenbacher } 19247be8da07SAndreas Gruenbacher 19257be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 19267be8da07SAndreas Gruenbacher if (resolve_conflicts) { 19277be8da07SAndreas Gruenbacher /* 19287be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 19297be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 19307be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 19317be8da07SAndreas Gruenbacher * have completed. 19327be8da07SAndreas Gruenbacher */ 19337be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 19347be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 19357be8da07SAndreas Gruenbacher 19367be8da07SAndreas Gruenbacher if (!equal) 19377be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19387be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 19397be8da07SAndreas Gruenbacher "assuming %s came first\n", 19407be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19417be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 19427be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 19437be8da07SAndreas Gruenbacher 19447be8da07SAndreas Gruenbacher inc_unacked(mdev); 19457be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 19467be8da07SAndreas Gruenbacher e_send_retry_write; 19477be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 19487be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 19497be8da07SAndreas Gruenbacher 19507be8da07SAndreas Gruenbacher err = -ENOENT; 19517be8da07SAndreas Gruenbacher goto out; 19527be8da07SAndreas Gruenbacher } else { 19537be8da07SAndreas Gruenbacher struct drbd_request *req = 19547be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 19557be8da07SAndreas Gruenbacher 19567be8da07SAndreas Gruenbacher if (!equal) 19577be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19587be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 19597be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19607be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 19617be8da07SAndreas Gruenbacher 19627be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 19637be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 19647be8da07SAndreas Gruenbacher /* 19657be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 19667be8da07SAndreas Gruenbacher * decide if this request will be discarded or 19677be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 19687be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 19697be8da07SAndreas Gruenbacher * 19707be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 19717be8da07SAndreas Gruenbacher * request to finish locally before submitting 19727be8da07SAndreas Gruenbacher * the conflicting peer request. 19737be8da07SAndreas Gruenbacher */ 19747be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 19757be8da07SAndreas Gruenbacher if (err) { 19767be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 19777be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 19787be8da07SAndreas Gruenbacher CS_HARD); 19797be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 19807be8da07SAndreas Gruenbacher goto out; 19817be8da07SAndreas Gruenbacher } 19827be8da07SAndreas Gruenbacher goto repeat; 19837be8da07SAndreas Gruenbacher } 19847be8da07SAndreas Gruenbacher /* 19857be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 19867be8da07SAndreas Gruenbacher * the new peer request has completed. 19877be8da07SAndreas Gruenbacher */ 19887be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 19897be8da07SAndreas Gruenbacher } 19907be8da07SAndreas Gruenbacher } 19917be8da07SAndreas Gruenbacher err = 0; 19927be8da07SAndreas Gruenbacher 19937be8da07SAndreas Gruenbacher out: 19947be8da07SAndreas Gruenbacher if (err) 19957be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 19967be8da07SAndreas Gruenbacher return err; 19977be8da07SAndreas Gruenbacher } 19987be8da07SAndreas Gruenbacher 1999b411b363SPhilipp Reisner /* mirrored write */ 20004a76b161SAndreas Gruenbacher static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi) 2001b411b363SPhilipp Reisner { 20024a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2003b411b363SPhilipp Reisner sector_t sector; 2004db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2005e658983aSAndreas Gruenbacher struct p_data *p = pi->data; 20067be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 2007b411b363SPhilipp Reisner int rw = WRITE; 2008b411b363SPhilipp Reisner u32 dp_flags; 20097be8da07SAndreas Gruenbacher int err; 20107be8da07SAndreas Gruenbacher 20114a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 20124a76b161SAndreas Gruenbacher if (!mdev) 20134a76b161SAndreas Gruenbacher return -EIO; 20144a76b161SAndreas Gruenbacher 2015b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 201682bc0194SAndreas Gruenbacher int err2; 201782bc0194SAndreas Gruenbacher 20187be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 2019e2857216SAndreas Gruenbacher drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size); 2020b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 2021e2857216SAndreas Gruenbacher err2 = drbd_drain_block(mdev, pi->size); 202282bc0194SAndreas Gruenbacher if (!err) 202382bc0194SAndreas Gruenbacher err = err2; 202482bc0194SAndreas Gruenbacher return err; 2025b411b363SPhilipp Reisner } 2026b411b363SPhilipp Reisner 2027fcefa62eSAndreas Gruenbacher /* 2028fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2029fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2030fcefa62eSAndreas Gruenbacher * end of this function. 2031fcefa62eSAndreas Gruenbacher */ 2032b411b363SPhilipp Reisner 2033b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2034e2857216SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, pi->size); 2035db830c46SAndreas Gruenbacher if (!peer_req) { 2036b411b363SPhilipp Reisner put_ldev(mdev); 203782bc0194SAndreas Gruenbacher return -EIO; 2038b411b363SPhilipp Reisner } 2039b411b363SPhilipp Reisner 2040db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2041b411b363SPhilipp Reisner 2042688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2043688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2044688593c5SLars Ellenberg 2045688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2046db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2047688593c5SLars Ellenberg 2048b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2049db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2050db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2051db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2052b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2053b411b363SPhilipp Reisner 20547be8da07SAndreas Gruenbacher if (mdev->tconn->net_conf->two_primaries) { 20557be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 20567be8da07SAndreas Gruenbacher if (err) 2057b411b363SPhilipp Reisner goto out_interrupted; 205887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 20597be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 20607be8da07SAndreas Gruenbacher if (err) { 206187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 20627be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2063b411b363SPhilipp Reisner put_ldev(mdev); 206482bc0194SAndreas Gruenbacher return 0; 2065b411b363SPhilipp Reisner } 2066b411b363SPhilipp Reisner goto out_interrupted; 2067b411b363SPhilipp Reisner } 20687be8da07SAndreas Gruenbacher } else 206987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2070db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 207187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2072b411b363SPhilipp Reisner 207389e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 2074b411b363SPhilipp Reisner case DRBD_PROT_C: 2075b411b363SPhilipp Reisner inc_unacked(mdev); 2076b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2077b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2078b411b363SPhilipp Reisner break; 2079b411b363SPhilipp Reisner case DRBD_PROT_B: 2080b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2081b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2082db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2083b411b363SPhilipp Reisner break; 2084b411b363SPhilipp Reisner case DRBD_PROT_A: 2085b411b363SPhilipp Reisner /* nothing to do */ 2086b411b363SPhilipp Reisner break; 2087b411b363SPhilipp Reisner } 2088b411b363SPhilipp Reisner 20896719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2090b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2091db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2092db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2093db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2094181286adSLars Ellenberg drbd_al_begin_io(mdev, &peer_req->i); 2095b411b363SPhilipp Reisner } 2096b411b363SPhilipp Reisner 209782bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 209882bc0194SAndreas Gruenbacher if (!err) 209982bc0194SAndreas Gruenbacher return 0; 2100b411b363SPhilipp Reisner 210110f6d992SLars Ellenberg /* don't care for the reason here */ 210210f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 210387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2104db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2105db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 210687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2107db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2108181286adSLars Ellenberg drbd_al_complete_io(mdev, &peer_req->i); 210922cc37a9SLars Ellenberg 2110b411b363SPhilipp Reisner out_interrupted: 2111db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2112b411b363SPhilipp Reisner put_ldev(mdev); 21133967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 211482bc0194SAndreas Gruenbacher return err; 2115b411b363SPhilipp Reisner } 2116b411b363SPhilipp Reisner 21170f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 21180f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 21190f0601f4SLars Ellenberg * 21200f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 21210f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 21220f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 21230f0601f4SLars Ellenberg * activity, it obviously is "busy". 21240f0601f4SLars Ellenberg * 21250f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 21260f0601f4SLars Ellenberg * to have a short time average so we can react faster. 21270f0601f4SLars Ellenberg */ 2128e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 21290f0601f4SLars Ellenberg { 21300f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 21310f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2132e3555d85SPhilipp Reisner struct lc_element *tmp; 21330f0601f4SLars Ellenberg int curr_events; 21340f0601f4SLars Ellenberg int throttle = 0; 21350f0601f4SLars Ellenberg 21360f0601f4SLars Ellenberg /* feature disabled? */ 2137f399002eSLars Ellenberg if (mdev->ldev->dc.c_min_rate == 0) 21380f0601f4SLars Ellenberg return 0; 21390f0601f4SLars Ellenberg 2140e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2141e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2142e3555d85SPhilipp Reisner if (tmp) { 2143e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2144e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2145e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2146e3555d85SPhilipp Reisner return 0; 2147e3555d85SPhilipp Reisner } 2148e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2149e3555d85SPhilipp Reisner } 2150e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2151e3555d85SPhilipp Reisner 21520f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 21530f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 21540f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2155e3555d85SPhilipp Reisner 21560f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 21570f0601f4SLars Ellenberg unsigned long rs_left; 21580f0601f4SLars Ellenberg int i; 21590f0601f4SLars Ellenberg 21600f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 21610f0601f4SLars Ellenberg 21620f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 21630f0601f4SLars Ellenberg * approx. */ 21642649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 21652649f080SLars Ellenberg 21662649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 21672649f080SLars Ellenberg rs_left = mdev->ov_left; 21682649f080SLars Ellenberg else 21690f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 21700f0601f4SLars Ellenberg 21710f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 21720f0601f4SLars Ellenberg if (!dt) 21730f0601f4SLars Ellenberg dt++; 21740f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 21750f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 21760f0601f4SLars Ellenberg 2177f399002eSLars Ellenberg if (dbdt > mdev->ldev->dc.c_min_rate) 21780f0601f4SLars Ellenberg throttle = 1; 21790f0601f4SLars Ellenberg } 21800f0601f4SLars Ellenberg return throttle; 21810f0601f4SLars Ellenberg } 21820f0601f4SLars Ellenberg 21830f0601f4SLars Ellenberg 21844a76b161SAndreas Gruenbacher static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi) 2185b411b363SPhilipp Reisner { 21864a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 2187b411b363SPhilipp Reisner sector_t sector; 21884a76b161SAndreas Gruenbacher sector_t capacity; 2189db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2190b411b363SPhilipp Reisner struct digest_info *di = NULL; 2191b18b37beSPhilipp Reisner int size, verb; 2192b411b363SPhilipp Reisner unsigned int fault_type; 2193e658983aSAndreas Gruenbacher struct p_block_req *p = pi->data; 21944a76b161SAndreas Gruenbacher 21954a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 21964a76b161SAndreas Gruenbacher if (!mdev) 21974a76b161SAndreas Gruenbacher return -EIO; 21984a76b161SAndreas Gruenbacher capacity = drbd_get_capacity(mdev->this_bdev); 2199b411b363SPhilipp Reisner 2200b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2201b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2202b411b363SPhilipp Reisner 2203c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2204b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2205b411b363SPhilipp Reisner (unsigned long long)sector, size); 220682bc0194SAndreas Gruenbacher return -EINVAL; 2207b411b363SPhilipp Reisner } 2208b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2209b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2210b411b363SPhilipp Reisner (unsigned long long)sector, size); 221182bc0194SAndreas Gruenbacher return -EINVAL; 2212b411b363SPhilipp Reisner } 2213b411b363SPhilipp Reisner 2214b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2215b18b37beSPhilipp Reisner verb = 1; 2216e2857216SAndreas Gruenbacher switch (pi->cmd) { 2217b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2218b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2219b18b37beSPhilipp Reisner break; 2220b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2221b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2222b18b37beSPhilipp Reisner case P_OV_REQUEST: 2223b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2224b18b37beSPhilipp Reisner break; 2225b18b37beSPhilipp Reisner case P_OV_REPLY: 2226b18b37beSPhilipp Reisner verb = 0; 2227b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2228b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2229b18b37beSPhilipp Reisner break; 2230b18b37beSPhilipp Reisner default: 223149ba9b1bSAndreas Gruenbacher BUG(); 2232b18b37beSPhilipp Reisner } 2233b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2234b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2235b411b363SPhilipp Reisner "no local data.\n"); 2236b18b37beSPhilipp Reisner 2237a821cc4aSLars Ellenberg /* drain possibly payload */ 2238e2857216SAndreas Gruenbacher return drbd_drain_block(mdev, pi->size); 2239b411b363SPhilipp Reisner } 2240b411b363SPhilipp Reisner 2241b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2242b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2243b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 22440db55363SAndreas Gruenbacher peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO); 2245db830c46SAndreas Gruenbacher if (!peer_req) { 2246b411b363SPhilipp Reisner put_ldev(mdev); 224782bc0194SAndreas Gruenbacher return -ENOMEM; 2248b411b363SPhilipp Reisner } 2249b411b363SPhilipp Reisner 2250e2857216SAndreas Gruenbacher switch (pi->cmd) { 2251b411b363SPhilipp Reisner case P_DATA_REQUEST: 2252db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2253b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 225480a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 225580a40e43SLars Ellenberg goto submit; 225680a40e43SLars Ellenberg 2257b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2258db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2259b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 22605f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22615f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2262b411b363SPhilipp Reisner break; 2263b411b363SPhilipp Reisner 2264b411b363SPhilipp Reisner case P_OV_REPLY: 2265b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2266b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2267e2857216SAndreas Gruenbacher di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO); 2268b411b363SPhilipp Reisner if (!di) 2269b411b363SPhilipp Reisner goto out_free_e; 2270b411b363SPhilipp Reisner 2271e2857216SAndreas Gruenbacher di->digest_size = pi->size; 2272b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2273b411b363SPhilipp Reisner 2274db830c46SAndreas Gruenbacher peer_req->digest = di; 2275db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2276c36c3cedSLars Ellenberg 2277e2857216SAndreas Gruenbacher if (drbd_recv_all(mdev->tconn, di->digest, pi->size)) 2278b411b363SPhilipp Reisner goto out_free_e; 2279b411b363SPhilipp Reisner 2280e2857216SAndreas Gruenbacher if (pi->cmd == P_CSUM_RS_REQUEST) { 228131890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2282db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 22835f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22845f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2285e2857216SAndreas Gruenbacher } else if (pi->cmd == P_OV_REPLY) { 22862649f080SLars Ellenberg /* track progress, we may need to throttle */ 22872649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2288db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2289b411b363SPhilipp Reisner dec_rs_pending(mdev); 22900f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 22910f0601f4SLars Ellenberg * but accounting still needs to be done. */ 22920f0601f4SLars Ellenberg goto submit_for_resync; 2293b411b363SPhilipp Reisner } 2294b411b363SPhilipp Reisner break; 2295b411b363SPhilipp Reisner 2296b411b363SPhilipp Reisner case P_OV_REQUEST: 2297b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 229831890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2299de228bbaSLars Ellenberg unsigned long now = jiffies; 2300de228bbaSLars Ellenberg int i; 2301b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2302b411b363SPhilipp Reisner mdev->ov_position = sector; 230330b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 230430b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2305de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2306de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2307de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2308de228bbaSLars Ellenberg } 2309b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2310b411b363SPhilipp Reisner (unsigned long long)sector); 2311b411b363SPhilipp Reisner } 2312db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2313b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2314b411b363SPhilipp Reisner break; 2315b411b363SPhilipp Reisner 2316b411b363SPhilipp Reisner default: 231749ba9b1bSAndreas Gruenbacher BUG(); 2318b411b363SPhilipp Reisner } 2319b411b363SPhilipp Reisner 23200f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 23210f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 23220f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 23230f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 23240f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 23250f0601f4SLars Ellenberg * 23260f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 23270f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 23280f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 23290f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 23300f0601f4SLars Ellenberg * a while, anyways. 23310f0601f4SLars Ellenberg */ 2332b411b363SPhilipp Reisner 23330f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 23340f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 23350f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 23360f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 23370f0601f4SLars Ellenberg * 23380f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 23390f0601f4SLars Ellenberg * we would also throttle its application reads. 23400f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 23410f0601f4SLars Ellenberg */ 2342e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2343e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2344e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 234580a40e43SLars Ellenberg goto out_free_e; 2346b411b363SPhilipp Reisner 23470f0601f4SLars Ellenberg submit_for_resync: 23480f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 23490f0601f4SLars Ellenberg 235080a40e43SLars Ellenberg submit: 2351b411b363SPhilipp Reisner inc_unacked(mdev); 235287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2353db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 235487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2355b411b363SPhilipp Reisner 2356fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 235782bc0194SAndreas Gruenbacher return 0; 2358b411b363SPhilipp Reisner 235910f6d992SLars Ellenberg /* don't care for the reason here */ 236010f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 236187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2362db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 236387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 236422cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 236522cc37a9SLars Ellenberg 2366b411b363SPhilipp Reisner out_free_e: 2367b411b363SPhilipp Reisner put_ldev(mdev); 23683967deb1SAndreas Gruenbacher drbd_free_peer_req(mdev, peer_req); 236982bc0194SAndreas Gruenbacher return -EIO; 2370b411b363SPhilipp Reisner } 2371b411b363SPhilipp Reisner 2372b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2373b411b363SPhilipp Reisner { 2374b411b363SPhilipp Reisner int self, peer, rv = -100; 2375b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2376b411b363SPhilipp Reisner 2377b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2378b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2379b411b363SPhilipp Reisner 2380b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2381b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2382b411b363SPhilipp Reisner 238389e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2384b411b363SPhilipp Reisner case ASB_CONSENSUS: 2385b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2386b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2387b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2388b411b363SPhilipp Reisner break; 2389b411b363SPhilipp Reisner case ASB_DISCONNECT: 2390b411b363SPhilipp Reisner break; 2391b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2392b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2393b411b363SPhilipp Reisner rv = -1; 2394b411b363SPhilipp Reisner break; 2395b411b363SPhilipp Reisner } 2396b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2397b411b363SPhilipp Reisner rv = 1; 2398b411b363SPhilipp Reisner break; 2399b411b363SPhilipp Reisner } 2400b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2401b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2402b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2403b411b363SPhilipp Reisner rv = 1; 2404b411b363SPhilipp Reisner break; 2405b411b363SPhilipp Reisner } 2406b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2407b411b363SPhilipp Reisner rv = -1; 2408b411b363SPhilipp Reisner break; 2409b411b363SPhilipp Reisner } 2410b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2411ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2412b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2413b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2414b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 241525703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2416b411b363SPhilipp Reisner ? -1 : 1; 2417b411b363SPhilipp Reisner break; 2418b411b363SPhilipp Reisner } else { 2419b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2420b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2421b411b363SPhilipp Reisner } 242289e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2423b411b363SPhilipp Reisner break; 2424b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2425b411b363SPhilipp Reisner if (ch_self < ch_peer) 2426b411b363SPhilipp Reisner rv = -1; 2427b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2428b411b363SPhilipp Reisner rv = 1; 2429b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2430b411b363SPhilipp Reisner /* Well, then use something else. */ 243125703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2432b411b363SPhilipp Reisner ? -1 : 1; 2433b411b363SPhilipp Reisner break; 2434b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2435b411b363SPhilipp Reisner rv = -1; 2436b411b363SPhilipp Reisner break; 2437b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2438b411b363SPhilipp Reisner rv = 1; 2439b411b363SPhilipp Reisner } 2440b411b363SPhilipp Reisner 2441b411b363SPhilipp Reisner return rv; 2442b411b363SPhilipp Reisner } 2443b411b363SPhilipp Reisner 2444b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2445b411b363SPhilipp Reisner { 24466184ea21SAndreas Gruenbacher int hg, rv = -100; 2447b411b363SPhilipp Reisner 244889e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2449b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2450b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2451b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2452b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2453b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2454b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2455b411b363SPhilipp Reisner break; 2456b411b363SPhilipp Reisner case ASB_DISCONNECT: 2457b411b363SPhilipp Reisner break; 2458b411b363SPhilipp Reisner case ASB_CONSENSUS: 2459b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2460b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2461b411b363SPhilipp Reisner rv = hg; 2462b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2463b411b363SPhilipp Reisner rv = hg; 2464b411b363SPhilipp Reisner break; 2465b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2466b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2467b411b363SPhilipp Reisner break; 2468b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2469b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2470b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2471b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2472b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2473bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2474bb437946SAndreas Gruenbacher 2475bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2476b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2477b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2478b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2479bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2480bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2481b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2482b411b363SPhilipp Reisner } else { 2483b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2484b411b363SPhilipp Reisner rv = hg; 2485b411b363SPhilipp Reisner } 2486b411b363SPhilipp Reisner } else 2487b411b363SPhilipp Reisner rv = hg; 2488b411b363SPhilipp Reisner } 2489b411b363SPhilipp Reisner 2490b411b363SPhilipp Reisner return rv; 2491b411b363SPhilipp Reisner } 2492b411b363SPhilipp Reisner 2493b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2494b411b363SPhilipp Reisner { 24956184ea21SAndreas Gruenbacher int hg, rv = -100; 2496b411b363SPhilipp Reisner 249789e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2498b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2499b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2500b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2501b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2502b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2503b411b363SPhilipp Reisner case ASB_CONSENSUS: 2504b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2505b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2506b411b363SPhilipp Reisner break; 2507b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2508b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2509b411b363SPhilipp Reisner break; 2510b411b363SPhilipp Reisner case ASB_DISCONNECT: 2511b411b363SPhilipp Reisner break; 2512b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2513b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2514b411b363SPhilipp Reisner if (hg == -1) { 2515bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2516bb437946SAndreas Gruenbacher 2517b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2518b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2519b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2520bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2521bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2522b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2523b411b363SPhilipp Reisner } else { 2524b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2525b411b363SPhilipp Reisner rv = hg; 2526b411b363SPhilipp Reisner } 2527b411b363SPhilipp Reisner } else 2528b411b363SPhilipp Reisner rv = hg; 2529b411b363SPhilipp Reisner } 2530b411b363SPhilipp Reisner 2531b411b363SPhilipp Reisner return rv; 2532b411b363SPhilipp Reisner } 2533b411b363SPhilipp Reisner 2534b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2535b411b363SPhilipp Reisner u64 bits, u64 flags) 2536b411b363SPhilipp Reisner { 2537b411b363SPhilipp Reisner if (!uuid) { 2538b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2539b411b363SPhilipp Reisner return; 2540b411b363SPhilipp Reisner } 2541b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2542b411b363SPhilipp Reisner text, 2543b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2544b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2545b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2546b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2547b411b363SPhilipp Reisner (unsigned long long)bits, 2548b411b363SPhilipp Reisner (unsigned long long)flags); 2549b411b363SPhilipp Reisner } 2550b411b363SPhilipp Reisner 2551b411b363SPhilipp Reisner /* 2552b411b363SPhilipp Reisner 100 after split brain try auto recover 2553b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2554b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2555b411b363SPhilipp Reisner 0 no Sync 2556b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2557b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2558b411b363SPhilipp Reisner -100 after split brain, disconnect 2559b411b363SPhilipp Reisner -1000 unrelated data 25604a23f264SPhilipp Reisner -1091 requires proto 91 25614a23f264SPhilipp Reisner -1096 requires proto 96 2562b411b363SPhilipp Reisner */ 2563b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2564b411b363SPhilipp Reisner { 2565b411b363SPhilipp Reisner u64 self, peer; 2566b411b363SPhilipp Reisner int i, j; 2567b411b363SPhilipp Reisner 2568b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2569b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2570b411b363SPhilipp Reisner 2571b411b363SPhilipp Reisner *rule_nr = 10; 2572b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2573b411b363SPhilipp Reisner return 0; 2574b411b363SPhilipp Reisner 2575b411b363SPhilipp Reisner *rule_nr = 20; 2576b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2577b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2578b411b363SPhilipp Reisner return -2; 2579b411b363SPhilipp Reisner 2580b411b363SPhilipp Reisner *rule_nr = 30; 2581b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2582b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2583b411b363SPhilipp Reisner return 2; 2584b411b363SPhilipp Reisner 2585b411b363SPhilipp Reisner if (self == peer) { 2586b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2587b411b363SPhilipp Reisner 2588b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2589b411b363SPhilipp Reisner 259031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25914a23f264SPhilipp Reisner return -1091; 2592b411b363SPhilipp Reisner 2593b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2594b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2595b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2596b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2597b411b363SPhilipp Reisner 2598b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2599b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2600b411b363SPhilipp Reisner *rule_nr = 34; 2601b411b363SPhilipp Reisner } else { 2602b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2603b411b363SPhilipp Reisner *rule_nr = 36; 2604b411b363SPhilipp Reisner } 2605b411b363SPhilipp Reisner 2606b411b363SPhilipp Reisner return 1; 2607b411b363SPhilipp Reisner } 2608b411b363SPhilipp Reisner 2609b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2610b411b363SPhilipp Reisner 261131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26124a23f264SPhilipp Reisner return -1091; 2613b411b363SPhilipp Reisner 2614b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2615b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2616b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2617b411b363SPhilipp Reisner 2618b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2619b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2620b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2621b411b363SPhilipp Reisner 2622b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2623b411b363SPhilipp Reisner *rule_nr = 35; 2624b411b363SPhilipp Reisner } else { 2625b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2626b411b363SPhilipp Reisner *rule_nr = 37; 2627b411b363SPhilipp Reisner } 2628b411b363SPhilipp Reisner 2629b411b363SPhilipp Reisner return -1; 2630b411b363SPhilipp Reisner } 2631b411b363SPhilipp Reisner 2632b411b363SPhilipp Reisner /* Common power [off|failure] */ 2633b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2634b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2635b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2636b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2637b411b363SPhilipp Reisner *rule_nr = 40; 2638b411b363SPhilipp Reisner 2639b411b363SPhilipp Reisner switch (rct) { 2640b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2641b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2642b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2643b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 264425703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2645b411b363SPhilipp Reisner return dc ? -1 : 1; 2646b411b363SPhilipp Reisner } 2647b411b363SPhilipp Reisner } 2648b411b363SPhilipp Reisner 2649b411b363SPhilipp Reisner *rule_nr = 50; 2650b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2651b411b363SPhilipp Reisner if (self == peer) 2652b411b363SPhilipp Reisner return -1; 2653b411b363SPhilipp Reisner 2654b411b363SPhilipp Reisner *rule_nr = 51; 2655b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2656b411b363SPhilipp Reisner if (self == peer) { 265731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26584a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 26594a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 26604a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2661b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2662b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2663b411b363SPhilipp Reisner 266431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26654a23f264SPhilipp Reisner return -1091; 2666b411b363SPhilipp Reisner 2667b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2668b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 26694a23f264SPhilipp Reisner 26704a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 26714a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 26724a23f264SPhilipp Reisner 2673b411b363SPhilipp Reisner return -1; 2674b411b363SPhilipp Reisner } 2675b411b363SPhilipp Reisner } 2676b411b363SPhilipp Reisner 2677b411b363SPhilipp Reisner *rule_nr = 60; 2678b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2679b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2680b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2681b411b363SPhilipp Reisner if (self == peer) 2682b411b363SPhilipp Reisner return -2; 2683b411b363SPhilipp Reisner } 2684b411b363SPhilipp Reisner 2685b411b363SPhilipp Reisner *rule_nr = 70; 2686b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2687b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2688b411b363SPhilipp Reisner if (self == peer) 2689b411b363SPhilipp Reisner return 1; 2690b411b363SPhilipp Reisner 2691b411b363SPhilipp Reisner *rule_nr = 71; 2692b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2693b411b363SPhilipp Reisner if (self == peer) { 269431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26954a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 26964a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 26974a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2698b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2699b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2700b411b363SPhilipp Reisner 270131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 27024a23f264SPhilipp Reisner return -1091; 2703b411b363SPhilipp Reisner 2704b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2705b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2706b411b363SPhilipp Reisner 27074a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2708b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2709b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2710b411b363SPhilipp Reisner 2711b411b363SPhilipp Reisner return 1; 2712b411b363SPhilipp Reisner } 2713b411b363SPhilipp Reisner } 2714b411b363SPhilipp Reisner 2715b411b363SPhilipp Reisner 2716b411b363SPhilipp Reisner *rule_nr = 80; 2717d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2718b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2719b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2720b411b363SPhilipp Reisner if (self == peer) 2721b411b363SPhilipp Reisner return 2; 2722b411b363SPhilipp Reisner } 2723b411b363SPhilipp Reisner 2724b411b363SPhilipp Reisner *rule_nr = 90; 2725b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2726b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2727b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2728b411b363SPhilipp Reisner return 100; 2729b411b363SPhilipp Reisner 2730b411b363SPhilipp Reisner *rule_nr = 100; 2731b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2732b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2733b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2734b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2735b411b363SPhilipp Reisner if (self == peer) 2736b411b363SPhilipp Reisner return -100; 2737b411b363SPhilipp Reisner } 2738b411b363SPhilipp Reisner } 2739b411b363SPhilipp Reisner 2740b411b363SPhilipp Reisner return -1000; 2741b411b363SPhilipp Reisner } 2742b411b363SPhilipp Reisner 2743b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2744b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2745b411b363SPhilipp Reisner */ 2746b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2747b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2748b411b363SPhilipp Reisner { 2749b411b363SPhilipp Reisner int hg, rule_nr; 2750b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2751b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2752b411b363SPhilipp Reisner 2753b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2754b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2755b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2756b411b363SPhilipp Reisner 2757b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2758b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2759b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2760b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2761b411b363SPhilipp Reisner 2762b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2763b411b363SPhilipp Reisner 2764b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2765b411b363SPhilipp Reisner 2766b411b363SPhilipp Reisner if (hg == -1000) { 2767b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2768b411b363SPhilipp Reisner return C_MASK; 2769b411b363SPhilipp Reisner } 27704a23f264SPhilipp Reisner if (hg < -1000) { 27714a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2772b411b363SPhilipp Reisner return C_MASK; 2773b411b363SPhilipp Reisner } 2774b411b363SPhilipp Reisner 2775b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2776b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2777b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2778b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2779b411b363SPhilipp Reisner if (f) 2780b411b363SPhilipp Reisner hg = hg*2; 2781b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2782b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2783b411b363SPhilipp Reisner } 2784b411b363SPhilipp Reisner 27853a11a487SAdam Gandelman if (abs(hg) == 100) 27863a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 27873a11a487SAdam Gandelman 278889e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2789b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2790b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2791b411b363SPhilipp Reisner int forced = (hg == -100); 2792b411b363SPhilipp Reisner 2793b411b363SPhilipp Reisner switch (pcount) { 2794b411b363SPhilipp Reisner case 0: 2795b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2796b411b363SPhilipp Reisner break; 2797b411b363SPhilipp Reisner case 1: 2798b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2799b411b363SPhilipp Reisner break; 2800b411b363SPhilipp Reisner case 2: 2801b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2802b411b363SPhilipp Reisner break; 2803b411b363SPhilipp Reisner } 2804b411b363SPhilipp Reisner if (abs(hg) < 100) { 2805b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2806b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2807b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2808b411b363SPhilipp Reisner if (forced) { 2809b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2810b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2811b411b363SPhilipp Reisner hg = hg*2; 2812b411b363SPhilipp Reisner } 2813b411b363SPhilipp Reisner } 2814b411b363SPhilipp Reisner } 2815b411b363SPhilipp Reisner 2816b411b363SPhilipp Reisner if (hg == -100) { 281789e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2818b411b363SPhilipp Reisner hg = -1; 281989e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2820b411b363SPhilipp Reisner hg = 1; 2821b411b363SPhilipp Reisner 2822b411b363SPhilipp Reisner if (abs(hg) < 100) 2823b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2824b411b363SPhilipp Reisner "Sync from %s node\n", 2825b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2826b411b363SPhilipp Reisner } 2827b411b363SPhilipp Reisner 2828b411b363SPhilipp Reisner if (hg == -100) { 2829580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2830580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2831580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2832580b9767SLars Ellenberg * to that disk, in a way... */ 28333a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2834b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2835b411b363SPhilipp Reisner return C_MASK; 2836b411b363SPhilipp Reisner } 2837b411b363SPhilipp Reisner 2838b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2839b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2840b411b363SPhilipp Reisner return C_MASK; 2841b411b363SPhilipp Reisner } 2842b411b363SPhilipp Reisner 2843b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2844b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 284589e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2846b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2847b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2848b411b363SPhilipp Reisner /* fall through */ 2849b411b363SPhilipp Reisner case ASB_DISCONNECT: 2850b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2851b411b363SPhilipp Reisner return C_MASK; 2852b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2853b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2854b411b363SPhilipp Reisner "assumption\n"); 2855b411b363SPhilipp Reisner } 2856b411b363SPhilipp Reisner } 2857b411b363SPhilipp Reisner 28588169e41bSPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2859cf14c2e9SPhilipp Reisner if (hg == 0) 2860cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2861cf14c2e9SPhilipp Reisner else 2862cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2863cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2864cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2865cf14c2e9SPhilipp Reisner return C_MASK; 2866cf14c2e9SPhilipp Reisner } 2867cf14c2e9SPhilipp Reisner 2868b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2869b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 287020ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 287120ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2872b411b363SPhilipp Reisner return C_MASK; 2873b411b363SPhilipp Reisner } 2874b411b363SPhilipp Reisner 2875b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2876b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2877b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2878b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2879b411b363SPhilipp Reisner } else { 2880b411b363SPhilipp Reisner rv = C_CONNECTED; 2881b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2882b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2883b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2884b411b363SPhilipp Reisner } 2885b411b363SPhilipp Reisner } 2886b411b363SPhilipp Reisner 2887b411b363SPhilipp Reisner return rv; 2888b411b363SPhilipp Reisner } 2889b411b363SPhilipp Reisner 2890b411b363SPhilipp Reisner /* returns 1 if invalid */ 2891b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2892b411b363SPhilipp Reisner { 2893b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2894b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2895b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2896b411b363SPhilipp Reisner return 0; 2897b411b363SPhilipp Reisner 2898b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2899b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2900b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2901b411b363SPhilipp Reisner return 1; 2902b411b363SPhilipp Reisner 2903b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2904b411b363SPhilipp Reisner if (peer == self) 2905b411b363SPhilipp Reisner return 0; 2906b411b363SPhilipp Reisner 2907b411b363SPhilipp Reisner /* everything es is invalid. */ 2908b411b363SPhilipp Reisner return 1; 2909b411b363SPhilipp Reisner } 2910b411b363SPhilipp Reisner 2911e2857216SAndreas Gruenbacher static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi) 2912b411b363SPhilipp Reisner { 2913e658983aSAndreas Gruenbacher struct p_protocol *p = pi->data; 2914b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2915cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2916b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2917b411b363SPhilipp Reisner 2918b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2919b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2920b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2921b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2922b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2923cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2924cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2925cf14c2e9SPhilipp Reisner 29267204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 2927cf14c2e9SPhilipp Reisner 2928cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 29297204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 2930b411b363SPhilipp Reisner 29317204624cSPhilipp Reisner if (p_proto != tconn->net_conf->wire_protocol) { 29327204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 2933b411b363SPhilipp Reisner goto disconnect; 2934b411b363SPhilipp Reisner } 2935b411b363SPhilipp Reisner 29367204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, tconn->net_conf->after_sb_0p)) { 29377204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 2938b411b363SPhilipp Reisner goto disconnect; 2939b411b363SPhilipp Reisner } 2940b411b363SPhilipp Reisner 29417204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, tconn->net_conf->after_sb_1p)) { 29427204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 2943b411b363SPhilipp Reisner goto disconnect; 2944b411b363SPhilipp Reisner } 2945b411b363SPhilipp Reisner 29467204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, tconn->net_conf->after_sb_2p)) { 29477204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 2948b411b363SPhilipp Reisner goto disconnect; 2949b411b363SPhilipp Reisner } 2950b411b363SPhilipp Reisner 29517204624cSPhilipp Reisner if (p_want_lose && tconn->net_conf->want_lose) { 29527204624cSPhilipp Reisner conn_err(tconn, "both sides have the 'want_lose' flag set\n"); 2953b411b363SPhilipp Reisner goto disconnect; 2954b411b363SPhilipp Reisner } 2955b411b363SPhilipp Reisner 29567204624cSPhilipp Reisner if (p_two_primaries != tconn->net_conf->two_primaries) { 29577204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 2958b411b363SPhilipp Reisner goto disconnect; 2959b411b363SPhilipp Reisner } 2960b411b363SPhilipp Reisner 29617204624cSPhilipp Reisner if (tconn->agreed_pro_version >= 87) { 29627204624cSPhilipp Reisner unsigned char *my_alg = tconn->net_conf->integrity_alg; 296382bc0194SAndreas Gruenbacher int err; 2964b411b363SPhilipp Reisner 2965e2857216SAndreas Gruenbacher err = drbd_recv_all(tconn, p_integrity_alg, pi->size); 296682bc0194SAndreas Gruenbacher if (err) 296782bc0194SAndreas Gruenbacher return err; 2968b411b363SPhilipp Reisner 2969b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2970b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 29717204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the data-integrity-alg\n"); 2972b411b363SPhilipp Reisner goto disconnect; 2973b411b363SPhilipp Reisner } 29747204624cSPhilipp Reisner conn_info(tconn, "data-integrity-alg: %s\n", 2975b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2976b411b363SPhilipp Reisner } 2977b411b363SPhilipp Reisner 297882bc0194SAndreas Gruenbacher return 0; 2979b411b363SPhilipp Reisner 2980b411b363SPhilipp Reisner disconnect: 29817204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 298282bc0194SAndreas Gruenbacher return -EIO; 2983b411b363SPhilipp Reisner } 2984b411b363SPhilipp Reisner 2985b411b363SPhilipp Reisner /* helper function 2986b411b363SPhilipp Reisner * input: alg name, feature name 2987b411b363SPhilipp Reisner * return: NULL (alg name was "") 2988b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2989b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2990b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2991b411b363SPhilipp Reisner const char *alg, const char *name) 2992b411b363SPhilipp Reisner { 2993b411b363SPhilipp Reisner struct crypto_hash *tfm; 2994b411b363SPhilipp Reisner 2995b411b363SPhilipp Reisner if (!alg[0]) 2996b411b363SPhilipp Reisner return NULL; 2997b411b363SPhilipp Reisner 2998b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2999b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 3000b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 3001b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 3002b411b363SPhilipp Reisner return tfm; 3003b411b363SPhilipp Reisner } 3004b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 3005b411b363SPhilipp Reisner crypto_free_hash(tfm); 3006b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 3007b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 3008b411b363SPhilipp Reisner } 3009b411b363SPhilipp Reisner return tfm; 3010b411b363SPhilipp Reisner } 3011b411b363SPhilipp Reisner 30124a76b161SAndreas Gruenbacher static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi) 3013b411b363SPhilipp Reisner { 30144a76b161SAndreas Gruenbacher void *buffer = tconn->data.rbuf; 30154a76b161SAndreas Gruenbacher int size = pi->size; 30164a76b161SAndreas Gruenbacher 30174a76b161SAndreas Gruenbacher while (size) { 30184a76b161SAndreas Gruenbacher int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE); 30194a76b161SAndreas Gruenbacher s = drbd_recv(tconn, buffer, s); 30204a76b161SAndreas Gruenbacher if (s <= 0) { 30214a76b161SAndreas Gruenbacher if (s < 0) 30224a76b161SAndreas Gruenbacher return s; 30234a76b161SAndreas Gruenbacher break; 30244a76b161SAndreas Gruenbacher } 30254a76b161SAndreas Gruenbacher size -= s; 30264a76b161SAndreas Gruenbacher } 30274a76b161SAndreas Gruenbacher if (size) 30284a76b161SAndreas Gruenbacher return -EIO; 30294a76b161SAndreas Gruenbacher return 0; 30304a76b161SAndreas Gruenbacher } 30314a76b161SAndreas Gruenbacher 30324a76b161SAndreas Gruenbacher /* 30334a76b161SAndreas Gruenbacher * config_unknown_volume - device configuration command for unknown volume 30344a76b161SAndreas Gruenbacher * 30354a76b161SAndreas Gruenbacher * When a device is added to an existing connection, the node on which the 30364a76b161SAndreas Gruenbacher * device is added first will send configuration commands to its peer but the 30374a76b161SAndreas Gruenbacher * peer will not know about the device yet. It will warn and ignore these 30384a76b161SAndreas Gruenbacher * commands. Once the device is added on the second node, the second node will 30394a76b161SAndreas Gruenbacher * send the same device configuration commands, but in the other direction. 30404a76b161SAndreas Gruenbacher * 30414a76b161SAndreas Gruenbacher * (We can also end up here if drbd is misconfigured.) 30424a76b161SAndreas Gruenbacher */ 30434a76b161SAndreas Gruenbacher static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi) 30444a76b161SAndreas Gruenbacher { 30454a76b161SAndreas Gruenbacher conn_warn(tconn, "Volume %u unknown; ignoring %s packet\n", 30464a76b161SAndreas Gruenbacher pi->vnr, cmdname(pi->cmd)); 30474a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 30484a76b161SAndreas Gruenbacher } 30494a76b161SAndreas Gruenbacher 30504a76b161SAndreas Gruenbacher static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi) 30514a76b161SAndreas Gruenbacher { 30524a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3053e658983aSAndreas Gruenbacher struct p_rs_param_95 *p; 3054b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 3055b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 3056b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 30574a76b161SAndreas Gruenbacher const int apv = tconn->agreed_pro_version; 3058778f271dSPhilipp Reisner int *rs_plan_s = NULL; 3059778f271dSPhilipp Reisner int fifo_size = 0; 306082bc0194SAndreas Gruenbacher int err; 3061b411b363SPhilipp Reisner 30624a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 30634a76b161SAndreas Gruenbacher if (!mdev) 30644a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 30654a76b161SAndreas Gruenbacher 3066b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 3067b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 3068b411b363SPhilipp Reisner + SHARED_SECRET_MAX 30698e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 30708e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 3071b411b363SPhilipp Reisner 3072e2857216SAndreas Gruenbacher if (pi->size > exp_max_sz) { 3073b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 3074e2857216SAndreas Gruenbacher pi->size, exp_max_sz); 307582bc0194SAndreas Gruenbacher return -EIO; 3076b411b363SPhilipp Reisner } 3077b411b363SPhilipp Reisner 3078b411b363SPhilipp Reisner if (apv <= 88) { 3079e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param); 3080e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 30818e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3082e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_89); 3083e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3084b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 30858e26f9ccSPhilipp Reisner } else { 3086e658983aSAndreas Gruenbacher header_size = sizeof(struct p_rs_param_95); 3087e2857216SAndreas Gruenbacher data_size = pi->size - header_size; 3088b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3089b411b363SPhilipp Reisner } 3090b411b363SPhilipp Reisner 3091b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3092e658983aSAndreas Gruenbacher p = pi->data; 3093b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3094b411b363SPhilipp Reisner 3095e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, header_size); 309682bc0194SAndreas Gruenbacher if (err) 309782bc0194SAndreas Gruenbacher return err; 3098b411b363SPhilipp Reisner 3099f399002eSLars Ellenberg if (get_ldev(mdev)) { 3100f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3101f399002eSLars Ellenberg put_ldev(mdev); 3102f399002eSLars Ellenberg } 3103b411b363SPhilipp Reisner 3104b411b363SPhilipp Reisner if (apv >= 88) { 3105b411b363SPhilipp Reisner if (apv == 88) { 3106b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3107b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3108b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3109b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 311082bc0194SAndreas Gruenbacher return -EIO; 3111b411b363SPhilipp Reisner } 3112b411b363SPhilipp Reisner 311382bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 311482bc0194SAndreas Gruenbacher if (err) 311582bc0194SAndreas Gruenbacher return err; 3116b411b363SPhilipp Reisner 3117b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3118b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3119b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3120b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3121b411b363SPhilipp Reisner 3122b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3123b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3124b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3125b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3126b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3127b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3128b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3129b411b363SPhilipp Reisner } 3130b411b363SPhilipp Reisner 3131f399002eSLars Ellenberg if (strcmp(mdev->tconn->net_conf->verify_alg, p->verify_alg)) { 3132b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3133b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 3134f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg, p->verify_alg); 3135b411b363SPhilipp Reisner goto disconnect; 3136b411b363SPhilipp Reisner } 3137b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3138b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3139b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3140b411b363SPhilipp Reisner verify_tfm = NULL; 3141b411b363SPhilipp Reisner goto disconnect; 3142b411b363SPhilipp Reisner } 3143b411b363SPhilipp Reisner } 3144b411b363SPhilipp Reisner 3145f399002eSLars Ellenberg if (apv >= 89 && strcmp(mdev->tconn->net_conf->csums_alg, p->csums_alg)) { 3146b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3147b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 3148f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg, p->csums_alg); 3149b411b363SPhilipp Reisner goto disconnect; 3150b411b363SPhilipp Reisner } 3151b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3152b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3153b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3154b411b363SPhilipp Reisner csums_tfm = NULL; 3155b411b363SPhilipp Reisner goto disconnect; 3156b411b363SPhilipp Reisner } 3157b411b363SPhilipp Reisner } 3158b411b363SPhilipp Reisner 3159f399002eSLars Ellenberg if (apv > 94 && get_ldev(mdev)) { 3160f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3161f399002eSLars Ellenberg mdev->ldev->dc.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3162f399002eSLars Ellenberg mdev->ldev->dc.c_delay_target = be32_to_cpu(p->c_delay_target); 3163f399002eSLars Ellenberg mdev->ldev->dc.c_fill_target = be32_to_cpu(p->c_fill_target); 3164f399002eSLars Ellenberg mdev->ldev->dc.c_max_rate = be32_to_cpu(p->c_max_rate); 3165778f271dSPhilipp Reisner 3166f399002eSLars Ellenberg fifo_size = (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3167778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 3168778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 3169778f271dSPhilipp Reisner if (!rs_plan_s) { 3170778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3171f399002eSLars Ellenberg put_ldev(mdev); 3172778f271dSPhilipp Reisner goto disconnect; 3173778f271dSPhilipp Reisner } 3174778f271dSPhilipp Reisner } 3175f399002eSLars Ellenberg put_ldev(mdev); 31768e26f9ccSPhilipp Reisner } 3177b411b363SPhilipp Reisner 3178b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 3179b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 3180b411b363SPhilipp Reisner if (verify_tfm) { 3181f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->verify_alg, p->verify_alg); 3182f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3183f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3184f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3185b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3186b411b363SPhilipp Reisner } 3187b411b363SPhilipp Reisner if (csums_tfm) { 3188f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->csums_alg, p->csums_alg); 3189f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3190f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3191f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3192b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3193b411b363SPhilipp Reisner } 3194778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 3195778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 3196778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 3197778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 3198778f271dSPhilipp Reisner mdev->rs_planed = 0; 3199778f271dSPhilipp Reisner } 3200b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 3201b411b363SPhilipp Reisner } 320282bc0194SAndreas Gruenbacher return 0; 3203b411b363SPhilipp Reisner 3204b411b363SPhilipp Reisner disconnect: 3205b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3206b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3207b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3208b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3209b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 321038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 321182bc0194SAndreas Gruenbacher return -EIO; 3212b411b363SPhilipp Reisner } 3213b411b363SPhilipp Reisner 3214b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3215b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3216b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3217b411b363SPhilipp Reisner { 3218b411b363SPhilipp Reisner sector_t d; 3219b411b363SPhilipp Reisner if (a == 0 || b == 0) 3220b411b363SPhilipp Reisner return; 3221b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3222b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3223b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3224b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3225b411b363SPhilipp Reisner } 3226b411b363SPhilipp Reisner 32274a76b161SAndreas Gruenbacher static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi) 3228b411b363SPhilipp Reisner { 32294a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3230e658983aSAndreas Gruenbacher struct p_sizes *p = pi->data; 3231b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3232b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3233b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3234e89b591cSPhilipp Reisner enum dds_flags ddsf; 3235b411b363SPhilipp Reisner 32364a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 32374a76b161SAndreas Gruenbacher if (!mdev) 32384a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 32394a76b161SAndreas Gruenbacher 3240b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3241b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3242b411b363SPhilipp Reisner 3243b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3244b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3245b411b363SPhilipp Reisner mdev->p_size = p_size; 3246b411b363SPhilipp Reisner 3247b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3248b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3249b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3250b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3251b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3252b411b363SPhilipp Reisner 3253b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3254b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3255b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3256b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3257b411b363SPhilipp Reisner p_usize); 3258b411b363SPhilipp Reisner 3259b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3260b411b363SPhilipp Reisner 3261b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3262b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3263b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3264b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3265b411b363SPhilipp Reisner } 3266b411b363SPhilipp Reisner 3267b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3268b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3269a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3270b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3271b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3272b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3273b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 327438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3275b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3276b411b363SPhilipp Reisner put_ldev(mdev); 327782bc0194SAndreas Gruenbacher return -EIO; 3278b411b363SPhilipp Reisner } 3279b411b363SPhilipp Reisner put_ldev(mdev); 3280b411b363SPhilipp Reisner } 3281b411b363SPhilipp Reisner 3282e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3283b411b363SPhilipp Reisner if (get_ldev(mdev)) { 328424c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3285b411b363SPhilipp Reisner put_ldev(mdev); 3286b411b363SPhilipp Reisner if (dd == dev_size_error) 328782bc0194SAndreas Gruenbacher return -EIO; 3288b411b363SPhilipp Reisner drbd_md_sync(mdev); 3289b411b363SPhilipp Reisner } else { 3290b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3291b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3292b411b363SPhilipp Reisner } 3293b411b363SPhilipp Reisner 329499432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 329599432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 329699432fccSPhilipp Reisner 3297b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3298b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3299b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3300b411b363SPhilipp Reisner ldsc = 1; 3301b411b363SPhilipp Reisner } 3302b411b363SPhilipp Reisner 3303b411b363SPhilipp Reisner put_ldev(mdev); 3304b411b363SPhilipp Reisner } 3305b411b363SPhilipp Reisner 3306b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3307b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3308b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3309b411b363SPhilipp Reisner /* we have different sizes, probably peer 3310b411b363SPhilipp Reisner * needs to know my new size... */ 3311e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3312b411b363SPhilipp Reisner } 3313b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3314b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3315b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3316e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3317e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3318e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3319b411b363SPhilipp Reisner else 3320e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3321e89b591cSPhilipp Reisner } else 3322b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3323b411b363SPhilipp Reisner } 3324b411b363SPhilipp Reisner } 3325b411b363SPhilipp Reisner 332682bc0194SAndreas Gruenbacher return 0; 3327b411b363SPhilipp Reisner } 3328b411b363SPhilipp Reisner 33294a76b161SAndreas Gruenbacher static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi) 3330b411b363SPhilipp Reisner { 33314a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3332e658983aSAndreas Gruenbacher struct p_uuids *p = pi->data; 3333b411b363SPhilipp Reisner u64 *p_uuid; 333462b0da3aSLars Ellenberg int i, updated_uuids = 0; 3335b411b363SPhilipp Reisner 33364a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 33374a76b161SAndreas Gruenbacher if (!mdev) 33384a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 33394a76b161SAndreas Gruenbacher 3340b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3341b411b363SPhilipp Reisner 3342b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3343b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3344b411b363SPhilipp Reisner 3345b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3346b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3347b411b363SPhilipp Reisner 3348b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3349b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3350b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3351b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3352b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3353b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 335438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 335582bc0194SAndreas Gruenbacher return -EIO; 3356b411b363SPhilipp Reisner } 3357b411b363SPhilipp Reisner 3358b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3359b411b363SPhilipp Reisner int skip_initial_sync = 3360b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 336131890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3362b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3363b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3364b411b363SPhilipp Reisner if (skip_initial_sync) { 3365b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3366b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 336720ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 336820ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3369b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3370b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3371b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3372b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3373b411b363SPhilipp Reisner drbd_md_sync(mdev); 337462b0da3aSLars Ellenberg updated_uuids = 1; 3375b411b363SPhilipp Reisner } 3376b411b363SPhilipp Reisner put_ldev(mdev); 337718a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 337818a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 337918a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 338018a50fa2SPhilipp Reisner for me. */ 338162b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3382b411b363SPhilipp Reisner } 3383b411b363SPhilipp Reisner 3384b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3385b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3386b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3387b411b363SPhilipp Reisner new disk state... */ 33888410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 33898410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3390b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 339162b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 339262b0da3aSLars Ellenberg 339362b0da3aSLars Ellenberg if (updated_uuids) 339462b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3395b411b363SPhilipp Reisner 339682bc0194SAndreas Gruenbacher return 0; 3397b411b363SPhilipp Reisner } 3398b411b363SPhilipp Reisner 3399b411b363SPhilipp Reisner /** 3400b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3401b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3402b411b363SPhilipp Reisner */ 3403b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3404b411b363SPhilipp Reisner { 3405b411b363SPhilipp Reisner union drbd_state ms; 3406b411b363SPhilipp Reisner 3407b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3408b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3409b411b363SPhilipp Reisner 3410b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3411b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3412b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3413b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3414b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3415b411b363SPhilipp Reisner }; 3416b411b363SPhilipp Reisner 3417b411b363SPhilipp Reisner ms.i = ps.i; 3418b411b363SPhilipp Reisner 3419b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3420b411b363SPhilipp Reisner ms.peer = ps.role; 3421b411b363SPhilipp Reisner ms.role = ps.peer; 3422b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3423b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3424b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3425b411b363SPhilipp Reisner 3426b411b363SPhilipp Reisner return ms; 3427b411b363SPhilipp Reisner } 3428b411b363SPhilipp Reisner 34294a76b161SAndreas Gruenbacher static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi) 3430b411b363SPhilipp Reisner { 34314a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3432e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3433b411b363SPhilipp Reisner union drbd_state mask, val; 3434bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3435b411b363SPhilipp Reisner 34364a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 34374a76b161SAndreas Gruenbacher if (!mdev) 34384a76b161SAndreas Gruenbacher return -EIO; 34394a76b161SAndreas Gruenbacher 3440b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3441b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3442b411b363SPhilipp Reisner 344325703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 34448410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3445b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 344682bc0194SAndreas Gruenbacher return 0; 3447b411b363SPhilipp Reisner } 3448b411b363SPhilipp Reisner 3449b411b363SPhilipp Reisner mask = convert_state(mask); 3450b411b363SPhilipp Reisner val = convert_state(val); 3451b411b363SPhilipp Reisner 3452b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3453b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3454047cd4a6SPhilipp Reisner 3455b411b363SPhilipp Reisner drbd_md_sync(mdev); 3456b411b363SPhilipp Reisner 345782bc0194SAndreas Gruenbacher return 0; 3458b411b363SPhilipp Reisner } 3459b411b363SPhilipp Reisner 3460e2857216SAndreas Gruenbacher static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi) 3461dfafcc8aSPhilipp Reisner { 3462e658983aSAndreas Gruenbacher struct p_req_state *p = pi->data; 3463dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3464dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3465dfafcc8aSPhilipp Reisner 3466dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3467dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3468dfafcc8aSPhilipp Reisner 3469dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3470dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3471dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 347282bc0194SAndreas Gruenbacher return 0; 3473dfafcc8aSPhilipp Reisner } 3474dfafcc8aSPhilipp Reisner 3475dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3476dfafcc8aSPhilipp Reisner val = convert_state(val); 3477dfafcc8aSPhilipp Reisner 3478778bcf2eSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL); 3479dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3480dfafcc8aSPhilipp Reisner 348182bc0194SAndreas Gruenbacher return 0; 3482dfafcc8aSPhilipp Reisner } 3483dfafcc8aSPhilipp Reisner 34844a76b161SAndreas Gruenbacher static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi) 3485b411b363SPhilipp Reisner { 34864a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3487e658983aSAndreas Gruenbacher struct p_state *p = pi->data; 34884ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3489b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 349065d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3491b411b363SPhilipp Reisner int rv; 3492b411b363SPhilipp Reisner 34934a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 34944a76b161SAndreas Gruenbacher if (!mdev) 34954a76b161SAndreas Gruenbacher return config_unknown_volume(tconn, pi); 34964a76b161SAndreas Gruenbacher 3497b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3498b411b363SPhilipp Reisner 3499b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3500b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3501b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3502b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3503b411b363SPhilipp Reisner } 3504b411b363SPhilipp Reisner 350587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3506b411b363SPhilipp Reisner retry: 350778bae59bSPhilipp Reisner os = ns = drbd_read_state(mdev); 350887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3509b411b363SPhilipp Reisner 3510e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3511e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3512e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3513e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3514e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3515e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3516e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3517e9ef7bb6SLars Ellenberg * syncing states. 3518e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3519e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3520e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3521e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3522e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3523e9ef7bb6SLars Ellenberg 3524e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3525e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3526e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3527e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3528e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3529e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3530e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 353182bc0194SAndreas Gruenbacher return 0; 3532e9ef7bb6SLars Ellenberg } 3533e9ef7bb6SLars Ellenberg } 3534e9ef7bb6SLars Ellenberg 3535e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3536e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3537e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3538e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3539e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3540e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3541e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3542e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3543e9ef7bb6SLars Ellenberg 35444ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 35454ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3546b411b363SPhilipp Reisner 354767531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 354867531718SPhilipp Reisner ns.conn = C_BEHIND; 354967531718SPhilipp Reisner 3550b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3551b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3552b411b363SPhilipp Reisner int cr; /* consider resync */ 3553b411b363SPhilipp Reisner 3554b411b363SPhilipp Reisner /* if we established a new connection */ 35554ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3556b411b363SPhilipp Reisner /* if we had an established connection 3557b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 35584ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3559b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 35604ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3561b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3562b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3563b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3564b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3565b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 35664ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3567b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3568b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3569b411b363SPhilipp Reisner 3570b411b363SPhilipp Reisner if (cr) 35714ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3572b411b363SPhilipp Reisner 3573b411b363SPhilipp Reisner put_ldev(mdev); 35744ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 35754ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3576b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 357782f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3578b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3579b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3580b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3581580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3582b411b363SPhilipp Reisner } else { 35838169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 358482bc0194SAndreas Gruenbacher return -EIO; 35854ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 358638fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 358782bc0194SAndreas Gruenbacher return -EIO; 3588b411b363SPhilipp Reisner } 3589b411b363SPhilipp Reisner } 3590b411b363SPhilipp Reisner } 3591b411b363SPhilipp Reisner 359287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 359378bae59bSPhilipp Reisner if (os.i != drbd_read_state(mdev).i) 3594b411b363SPhilipp Reisner goto retry; 3595b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3596b411b363SPhilipp Reisner ns.peer = peer_state.role; 3597b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3598b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 35994ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3600b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 36014ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 36022aebfabbSPhilipp Reisner if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3603481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 36048554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3605481c6f50SPhilipp Reisner for temporal network outages! */ 360687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3607481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 36082f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3609481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3610481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 361138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 361282bc0194SAndreas Gruenbacher return -EIO; 3613481c6f50SPhilipp Reisner } 361465d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 361578bae59bSPhilipp Reisner ns = drbd_read_state(mdev); 361687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3617b411b363SPhilipp Reisner 3618b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 361938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 362082bc0194SAndreas Gruenbacher return -EIO; 3621b411b363SPhilipp Reisner } 3622b411b363SPhilipp Reisner 36234ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 36244ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3625b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3626b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3627b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3628b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3629b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3630b411b363SPhilipp Reisner drbd_send_state(mdev); 3631b411b363SPhilipp Reisner } 3632b411b363SPhilipp Reisner } 3633b411b363SPhilipp Reisner 363489e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3635b411b363SPhilipp Reisner 3636b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3637b411b363SPhilipp Reisner 363882bc0194SAndreas Gruenbacher return 0; 3639b411b363SPhilipp Reisner } 3640b411b363SPhilipp Reisner 36414a76b161SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi) 3642b411b363SPhilipp Reisner { 36434a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3644e658983aSAndreas Gruenbacher struct p_rs_uuid *p = pi->data; 36454a76b161SAndreas Gruenbacher 36464a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 36474a76b161SAndreas Gruenbacher if (!mdev) 36484a76b161SAndreas Gruenbacher return -EIO; 3649b411b363SPhilipp Reisner 3650b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3651b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3652c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3653b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3654b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3655b411b363SPhilipp Reisner 3656b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3657b411b363SPhilipp Reisner 3658b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3659b411b363SPhilipp Reisner _not_ be rotated into the history */ 3660b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3661b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3662b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3663b411b363SPhilipp Reisner 366462b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3665b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3666b411b363SPhilipp Reisner 3667b411b363SPhilipp Reisner put_ldev(mdev); 3668b411b363SPhilipp Reisner } else 3669b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3670b411b363SPhilipp Reisner 367182bc0194SAndreas Gruenbacher return 0; 3672b411b363SPhilipp Reisner } 3673b411b363SPhilipp Reisner 36742c46407dSAndreas Gruenbacher /** 36752c46407dSAndreas Gruenbacher * receive_bitmap_plain 36762c46407dSAndreas Gruenbacher * 36772c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36782c46407dSAndreas Gruenbacher * code upon failure. 36792c46407dSAndreas Gruenbacher */ 36802c46407dSAndreas Gruenbacher static int 368150d0b1adSAndreas Gruenbacher receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size, 3682e658983aSAndreas Gruenbacher unsigned long *p, struct bm_xfer_ctx *c) 3683b411b363SPhilipp Reisner { 368450d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - 368550d0b1adSAndreas Gruenbacher drbd_header_size(mdev->tconn); 3686e658983aSAndreas Gruenbacher unsigned int num_words = min_t(size_t, data_size / sizeof(*p), 368750d0b1adSAndreas Gruenbacher c->bm_words - c->word_offset); 3688e658983aSAndreas Gruenbacher unsigned int want = num_words * sizeof(*p); 36892c46407dSAndreas Gruenbacher int err; 3690b411b363SPhilipp Reisner 369150d0b1adSAndreas Gruenbacher if (want != size) { 369250d0b1adSAndreas Gruenbacher dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size); 36932c46407dSAndreas Gruenbacher return -EIO; 3694b411b363SPhilipp Reisner } 3695b411b363SPhilipp Reisner if (want == 0) 36962c46407dSAndreas Gruenbacher return 0; 3697e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, want); 369882bc0194SAndreas Gruenbacher if (err) 36992c46407dSAndreas Gruenbacher return err; 3700b411b363SPhilipp Reisner 3701e658983aSAndreas Gruenbacher drbd_bm_merge_lel(mdev, c->word_offset, num_words, p); 3702b411b363SPhilipp Reisner 3703b411b363SPhilipp Reisner c->word_offset += num_words; 3704b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3705b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3706b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3707b411b363SPhilipp Reisner 37082c46407dSAndreas Gruenbacher return 1; 3709b411b363SPhilipp Reisner } 3710b411b363SPhilipp Reisner 3711a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 3712a02d1240SAndreas Gruenbacher { 3713a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 3714a02d1240SAndreas Gruenbacher } 3715a02d1240SAndreas Gruenbacher 3716a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 3717a02d1240SAndreas Gruenbacher { 3718a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 3719a02d1240SAndreas Gruenbacher } 3720a02d1240SAndreas Gruenbacher 3721a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 3722a02d1240SAndreas Gruenbacher { 3723a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 3724a02d1240SAndreas Gruenbacher } 3725a02d1240SAndreas Gruenbacher 37262c46407dSAndreas Gruenbacher /** 37272c46407dSAndreas Gruenbacher * recv_bm_rle_bits 37282c46407dSAndreas Gruenbacher * 37292c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 37302c46407dSAndreas Gruenbacher * code upon failure. 37312c46407dSAndreas Gruenbacher */ 37322c46407dSAndreas Gruenbacher static int 3733b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3734b411b363SPhilipp Reisner struct p_compressed_bm *p, 3735c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3736c6d25cfeSPhilipp Reisner unsigned int len) 3737b411b363SPhilipp Reisner { 3738b411b363SPhilipp Reisner struct bitstream bs; 3739b411b363SPhilipp Reisner u64 look_ahead; 3740b411b363SPhilipp Reisner u64 rl; 3741b411b363SPhilipp Reisner u64 tmp; 3742b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3743b411b363SPhilipp Reisner unsigned long e; 3744a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 3745b411b363SPhilipp Reisner int have; 3746b411b363SPhilipp Reisner int bits; 3747b411b363SPhilipp Reisner 3748a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 3749b411b363SPhilipp Reisner 3750b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3751b411b363SPhilipp Reisner if (bits < 0) 37522c46407dSAndreas Gruenbacher return -EIO; 3753b411b363SPhilipp Reisner 3754b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3755b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3756b411b363SPhilipp Reisner if (bits <= 0) 37572c46407dSAndreas Gruenbacher return -EIO; 3758b411b363SPhilipp Reisner 3759b411b363SPhilipp Reisner if (toggle) { 3760b411b363SPhilipp Reisner e = s + rl -1; 3761b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3762b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 37632c46407dSAndreas Gruenbacher return -EIO; 3764b411b363SPhilipp Reisner } 3765b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3766b411b363SPhilipp Reisner } 3767b411b363SPhilipp Reisner 3768b411b363SPhilipp Reisner if (have < bits) { 3769b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3770b411b363SPhilipp Reisner have, bits, look_ahead, 3771b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3772b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 37732c46407dSAndreas Gruenbacher return -EIO; 3774b411b363SPhilipp Reisner } 3775b411b363SPhilipp Reisner look_ahead >>= bits; 3776b411b363SPhilipp Reisner have -= bits; 3777b411b363SPhilipp Reisner 3778b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3779b411b363SPhilipp Reisner if (bits < 0) 37802c46407dSAndreas Gruenbacher return -EIO; 3781b411b363SPhilipp Reisner look_ahead |= tmp << have; 3782b411b363SPhilipp Reisner have += bits; 3783b411b363SPhilipp Reisner } 3784b411b363SPhilipp Reisner 3785b411b363SPhilipp Reisner c->bit_offset = s; 3786b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3787b411b363SPhilipp Reisner 37882c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3789b411b363SPhilipp Reisner } 3790b411b363SPhilipp Reisner 37912c46407dSAndreas Gruenbacher /** 37922c46407dSAndreas Gruenbacher * decode_bitmap_c 37932c46407dSAndreas Gruenbacher * 37942c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 37952c46407dSAndreas Gruenbacher * code upon failure. 37962c46407dSAndreas Gruenbacher */ 37972c46407dSAndreas Gruenbacher static int 3798b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3799b411b363SPhilipp Reisner struct p_compressed_bm *p, 3800c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3801c6d25cfeSPhilipp Reisner unsigned int len) 3802b411b363SPhilipp Reisner { 3803a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 3804e658983aSAndreas Gruenbacher return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p)); 3805b411b363SPhilipp Reisner 3806b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3807b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3808b411b363SPhilipp Reisner * during all our tests. */ 3809b411b363SPhilipp Reisner 3810b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 381138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 38122c46407dSAndreas Gruenbacher return -EIO; 3813b411b363SPhilipp Reisner } 3814b411b363SPhilipp Reisner 3815b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3816b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3817b411b363SPhilipp Reisner { 3818b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 381950d0b1adSAndreas Gruenbacher unsigned int header_size = drbd_header_size(mdev->tconn); 382050d0b1adSAndreas Gruenbacher unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size; 382150d0b1adSAndreas Gruenbacher unsigned int plain = 382250d0b1adSAndreas Gruenbacher header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) + 382350d0b1adSAndreas Gruenbacher c->bm_words * sizeof(unsigned long); 382450d0b1adSAndreas Gruenbacher unsigned int total = c->bytes[0] + c->bytes[1]; 382550d0b1adSAndreas Gruenbacher unsigned int r; 3826b411b363SPhilipp Reisner 3827b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3828b411b363SPhilipp Reisner if (total == 0) 3829b411b363SPhilipp Reisner return; 3830b411b363SPhilipp Reisner 3831b411b363SPhilipp Reisner /* don't report if not compressed */ 3832b411b363SPhilipp Reisner if (total >= plain) 3833b411b363SPhilipp Reisner return; 3834b411b363SPhilipp Reisner 3835b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3836b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3837b411b363SPhilipp Reisner : (1000 * total / plain); 3838b411b363SPhilipp Reisner 3839b411b363SPhilipp Reisner if (r > 1000) 3840b411b363SPhilipp Reisner r = 1000; 3841b411b363SPhilipp Reisner 3842b411b363SPhilipp Reisner r = 1000 - r; 3843b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3844b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3845b411b363SPhilipp Reisner direction, 3846b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3847b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3848b411b363SPhilipp Reisner total, r/10, r % 10); 3849b411b363SPhilipp Reisner } 3850b411b363SPhilipp Reisner 3851b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3852b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3853b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3854b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3855b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3856b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3857b411b363SPhilipp Reisner 3858b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 38594a76b161SAndreas Gruenbacher static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi) 3860b411b363SPhilipp Reisner { 38614a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3862b411b363SPhilipp Reisner struct bm_xfer_ctx c; 38632c46407dSAndreas Gruenbacher int err; 38644a76b161SAndreas Gruenbacher 38654a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 38664a76b161SAndreas Gruenbacher if (!mdev) 38674a76b161SAndreas Gruenbacher return -EIO; 3868b411b363SPhilipp Reisner 386920ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 387020ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 387120ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3872b411b363SPhilipp Reisner 3873b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3874b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3875b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3876b411b363SPhilipp Reisner }; 3877b411b363SPhilipp Reisner 38782c46407dSAndreas Gruenbacher for(;;) { 3879e658983aSAndreas Gruenbacher if (pi->cmd == P_BITMAP) 3880e658983aSAndreas Gruenbacher err = receive_bitmap_plain(mdev, pi->size, pi->data, &c); 3881e658983aSAndreas Gruenbacher else if (pi->cmd == P_COMPRESSED_BITMAP) { 3882b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3883b411b363SPhilipp Reisner * and the feature is enabled! */ 3884e658983aSAndreas Gruenbacher struct p_compressed_bm *p = pi->data; 3885b411b363SPhilipp Reisner 388650d0b1adSAndreas Gruenbacher if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) { 3887b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 388882bc0194SAndreas Gruenbacher err = -EIO; 3889b411b363SPhilipp Reisner goto out; 3890b411b363SPhilipp Reisner } 3891e658983aSAndreas Gruenbacher if (pi->size <= sizeof(*p)) { 3892e2857216SAndreas Gruenbacher dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size); 389382bc0194SAndreas Gruenbacher err = -EIO; 389478fcbdaeSAndreas Gruenbacher goto out; 3895b411b363SPhilipp Reisner } 3896e658983aSAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p, pi->size); 3897e658983aSAndreas Gruenbacher if (err) 3898e658983aSAndreas Gruenbacher goto out; 3899e2857216SAndreas Gruenbacher err = decode_bitmap_c(mdev, p, &c, pi->size); 3900b411b363SPhilipp Reisner } else { 3901e2857216SAndreas Gruenbacher dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd); 390282bc0194SAndreas Gruenbacher err = -EIO; 3903b411b363SPhilipp Reisner goto out; 3904b411b363SPhilipp Reisner } 3905b411b363SPhilipp Reisner 3906e2857216SAndreas Gruenbacher c.packets[pi->cmd == P_BITMAP]++; 390750d0b1adSAndreas Gruenbacher c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size; 3908b411b363SPhilipp Reisner 39092c46407dSAndreas Gruenbacher if (err <= 0) { 39102c46407dSAndreas Gruenbacher if (err < 0) 39112c46407dSAndreas Gruenbacher goto out; 3912b411b363SPhilipp Reisner break; 39132c46407dSAndreas Gruenbacher } 3914e2857216SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, pi); 391582bc0194SAndreas Gruenbacher if (err) 3916b411b363SPhilipp Reisner goto out; 39172c46407dSAndreas Gruenbacher } 3918b411b363SPhilipp Reisner 3919b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3920b411b363SPhilipp Reisner 3921b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3922de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3923de1f8e4aSAndreas Gruenbacher 392482bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 392582bc0194SAndreas Gruenbacher if (err) 3926b411b363SPhilipp Reisner goto out; 3927b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3928de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3929de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3930b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3931b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3932b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3933b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3934b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3935b411b363SPhilipp Reisner } 393682bc0194SAndreas Gruenbacher err = 0; 3937b411b363SPhilipp Reisner 3938b411b363SPhilipp Reisner out: 393920ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 394082bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 3941b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 394282bc0194SAndreas Gruenbacher return err; 3943b411b363SPhilipp Reisner } 3944b411b363SPhilipp Reisner 39454a76b161SAndreas Gruenbacher static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi) 3946b411b363SPhilipp Reisner { 39474a76b161SAndreas Gruenbacher conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n", 3948e2857216SAndreas Gruenbacher pi->cmd, pi->size); 39492de876efSPhilipp Reisner 39504a76b161SAndreas Gruenbacher return ignore_remaining_packet(tconn, pi); 39512de876efSPhilipp Reisner } 39522de876efSPhilipp Reisner 39534a76b161SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi) 3954b411b363SPhilipp Reisner { 3955b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3956b411b363SPhilipp Reisner * with the data requests being unplugged */ 39574a76b161SAndreas Gruenbacher drbd_tcp_quickack(tconn->data.socket); 3958b411b363SPhilipp Reisner 395982bc0194SAndreas Gruenbacher return 0; 3960b411b363SPhilipp Reisner } 3961b411b363SPhilipp Reisner 39624a76b161SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi) 396373a01a18SPhilipp Reisner { 39644a76b161SAndreas Gruenbacher struct drbd_conf *mdev; 3965e658983aSAndreas Gruenbacher struct p_block_desc *p = pi->data; 39664a76b161SAndreas Gruenbacher 39674a76b161SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 39684a76b161SAndreas Gruenbacher if (!mdev) 39694a76b161SAndreas Gruenbacher return -EIO; 397073a01a18SPhilipp Reisner 3971f735e363SLars Ellenberg switch (mdev->state.conn) { 3972f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3973f735e363SLars Ellenberg case C_WF_BITMAP_T: 3974f735e363SLars Ellenberg case C_BEHIND: 3975f735e363SLars Ellenberg break; 3976f735e363SLars Ellenberg default: 3977f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3978f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3979f735e363SLars Ellenberg } 3980f735e363SLars Ellenberg 398173a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 398273a01a18SPhilipp Reisner 398382bc0194SAndreas Gruenbacher return 0; 398473a01a18SPhilipp Reisner } 398573a01a18SPhilipp Reisner 398602918be2SPhilipp Reisner struct data_cmd { 398702918be2SPhilipp Reisner int expect_payload; 398802918be2SPhilipp Reisner size_t pkt_size; 39894a76b161SAndreas Gruenbacher int (*fn)(struct drbd_tconn *, struct packet_info *); 3990b411b363SPhilipp Reisner }; 3991b411b363SPhilipp Reisner 399202918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 39934a76b161SAndreas Gruenbacher [P_DATA] = { 1, sizeof(struct p_data), receive_Data }, 39944a76b161SAndreas Gruenbacher [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply }, 39954a76b161SAndreas Gruenbacher [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } , 39964a76b161SAndreas Gruenbacher [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } , 3997e658983aSAndreas Gruenbacher [P_BITMAP] = { 1, 0, receive_bitmap } , 3998e658983aSAndreas Gruenbacher [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } , 3999e658983aSAndreas Gruenbacher [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote }, 40004a76b161SAndreas Gruenbacher [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 40014a76b161SAndreas Gruenbacher [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 4002e658983aSAndreas Gruenbacher [P_SYNC_PARAM] = { 1, 0, receive_SyncParam }, 4003e658983aSAndreas Gruenbacher [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam }, 40044a76b161SAndreas Gruenbacher [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol }, 40054a76b161SAndreas Gruenbacher [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids }, 40064a76b161SAndreas Gruenbacher [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes }, 40074a76b161SAndreas Gruenbacher [P_STATE] = { 0, sizeof(struct p_state), receive_state }, 40084a76b161SAndreas Gruenbacher [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state }, 40094a76b161SAndreas Gruenbacher [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid }, 40104a76b161SAndreas Gruenbacher [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest }, 40114a76b161SAndreas Gruenbacher [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 40124a76b161SAndreas Gruenbacher [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest }, 40134a76b161SAndreas Gruenbacher [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip }, 40144a76b161SAndreas Gruenbacher [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync }, 40154a76b161SAndreas Gruenbacher [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state }, 401602918be2SPhilipp Reisner }; 401702918be2SPhilipp Reisner 4018eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 4019b411b363SPhilipp Reisner { 402077351055SPhilipp Reisner struct packet_info pi; 402102918be2SPhilipp Reisner size_t shs; /* sub header size */ 402282bc0194SAndreas Gruenbacher int err; 4023b411b363SPhilipp Reisner 4024eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 4025deebe195SAndreas Gruenbacher struct data_cmd *cmd; 4026deebe195SAndreas Gruenbacher 4027eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 402869bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 402902918be2SPhilipp Reisner goto err_out; 403002918be2SPhilipp Reisner 4031deebe195SAndreas Gruenbacher cmd = &drbd_cmd_handler[pi.cmd]; 40324a76b161SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) { 4033eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 403402918be2SPhilipp Reisner goto err_out; 40350b33a916SLars Ellenberg } 4036b411b363SPhilipp Reisner 4037e658983aSAndreas Gruenbacher shs = cmd->pkt_size; 4038e658983aSAndreas Gruenbacher if (pi.size > shs && !cmd->expect_payload) { 4039eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 4040c13f7e1aSLars Ellenberg goto err_out; 4041c13f7e1aSLars Ellenberg } 4042c13f7e1aSLars Ellenberg 4043c13f7e1aSLars Ellenberg if (shs) { 4044e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, pi.data, shs); 4045a5c31904SAndreas Gruenbacher if (err) 404602918be2SPhilipp Reisner goto err_out; 4047e2857216SAndreas Gruenbacher pi.size -= shs; 4048b411b363SPhilipp Reisner } 404902918be2SPhilipp Reisner 40504a76b161SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 40514a76b161SAndreas Gruenbacher if (err) { 40529f5bdc33SAndreas Gruenbacher conn_err(tconn, "error receiving %s, e: %d l: %d!\n", 40539f5bdc33SAndreas Gruenbacher cmdname(pi.cmd), err, pi.size); 405402918be2SPhilipp Reisner goto err_out; 4055b411b363SPhilipp Reisner } 4056b411b363SPhilipp Reisner } 405782bc0194SAndreas Gruenbacher return; 405802918be2SPhilipp Reisner 405902918be2SPhilipp Reisner err_out: 4060bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4061b411b363SPhilipp Reisner } 4062b411b363SPhilipp Reisner 40630e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4064b411b363SPhilipp Reisner { 4065b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4066b411b363SPhilipp Reisner 4067b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 40680e29d163SPhilipp Reisner barr.w.tconn = tconn; 4069b411b363SPhilipp Reisner init_completion(&barr.done); 40700e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4071b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4072b411b363SPhilipp Reisner } 4073b411b363SPhilipp Reisner 4074360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 4075b411b363SPhilipp Reisner { 4076bbeb641cSPhilipp Reisner enum drbd_conns oc; 4077b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 4078b411b363SPhilipp Reisner 4079bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4080b411b363SPhilipp Reisner return; 4081b411b363SPhilipp Reisner 4082b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4083360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4084360cc740SPhilipp Reisner drbd_free_sock(tconn); 4085360cc740SPhilipp Reisner 4086360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 4087360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4088360cc740SPhilipp Reisner 4089cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4090cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4091cb703454SPhilipp Reisner 4092360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4093bbeb641cSPhilipp Reisner oc = tconn->cstate; 4094bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4095bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4096bbeb641cSPhilipp Reisner 4097360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4098360cc740SPhilipp Reisner 4099bbeb641cSPhilipp Reisner if (oc == C_DISCONNECTING) { 4100360cc740SPhilipp Reisner wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0); 4101360cc740SPhilipp Reisner 4102360cc740SPhilipp Reisner crypto_free_hash(tconn->cram_hmac_tfm); 4103360cc740SPhilipp Reisner tconn->cram_hmac_tfm = NULL; 4104360cc740SPhilipp Reisner 4105360cc740SPhilipp Reisner kfree(tconn->net_conf); 4106360cc740SPhilipp Reisner tconn->net_conf = NULL; 4107bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE); 4108360cc740SPhilipp Reisner } 4109360cc740SPhilipp Reisner } 4110360cc740SPhilipp Reisner 4111360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 4112360cc740SPhilipp Reisner { 4113360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 4114360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4115360cc740SPhilipp Reisner unsigned int i; 4116b411b363SPhilipp Reisner 411785719573SPhilipp Reisner /* wait for current activity to cease. */ 411887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4119b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4120b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4121b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 412287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4123b411b363SPhilipp Reisner 4124b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4125b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4126b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4127b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4128b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4129b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4130b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4131b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4132b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4133b411b363SPhilipp Reisner * on the fly. */ 4134b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4135b411b363SPhilipp Reisner mdev->rs_total = 0; 4136b411b363SPhilipp Reisner mdev->rs_failed = 0; 4137b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4138b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4139b411b363SPhilipp Reisner 41407fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 41417fde2be9SPhilipp Reisner 4142b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4143b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4144b411b363SPhilipp Reisner 4145b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4146b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4147b411b363SPhilipp Reisner * to be "canceled" */ 4148a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4149b411b363SPhilipp Reisner 4150a990be46SAndreas Gruenbacher drbd_finish_peer_reqs(mdev); 4151b411b363SPhilipp Reisner 4152b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4153b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4154b411b363SPhilipp Reisner 41552aebfabbSPhilipp Reisner if (!drbd_suspended(mdev)) 41562f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4157b411b363SPhilipp Reisner 4158b411b363SPhilipp Reisner drbd_md_sync(mdev); 4159b411b363SPhilipp Reisner 4160b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4161b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4162b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 4163b411b363SPhilipp Reisner put_ldev(mdev); 4164b411b363SPhilipp Reisner } 4165b411b363SPhilipp Reisner 416620ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 416720ceb2b2SLars Ellenberg * if any. */ 416820ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 416920ceb2b2SLars Ellenberg 4170b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4171b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4172b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4173b411b363SPhilipp Reisner * 4174b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4175b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4176b411b363SPhilipp Reisner */ 41777721f567SAndreas Gruenbacher i = drbd_free_peer_reqs(mdev, &mdev->net_ee); 4178b411b363SPhilipp Reisner if (i) 4179b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4180435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4181435f0740SLars Ellenberg if (i) 4182435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4183b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4184b411b363SPhilipp Reisner if (i) 418545bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4186b411b363SPhilipp Reisner 4187b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4188b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4189b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4190b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4191b411b363SPhilipp Reisner 4192b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4193b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4194b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4195360cc740SPhilipp Reisner 4196360cc740SPhilipp Reisner return 0; 4197b411b363SPhilipp Reisner } 4198b411b363SPhilipp Reisner 4199b411b363SPhilipp Reisner /* 4200b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4201b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4202b411b363SPhilipp Reisner * 4203b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4204b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4205b411b363SPhilipp Reisner * 4206b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4207b411b363SPhilipp Reisner */ 42086038178eSAndreas Gruenbacher static int drbd_send_features(struct drbd_tconn *tconn) 4209b411b363SPhilipp Reisner { 42109f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 42119f5bdc33SAndreas Gruenbacher struct p_connection_features *p; 4212b411b363SPhilipp Reisner 42139f5bdc33SAndreas Gruenbacher sock = &tconn->data; 42149f5bdc33SAndreas Gruenbacher p = conn_prepare_command(tconn, sock); 42159f5bdc33SAndreas Gruenbacher if (!p) 4216e8d17b01SAndreas Gruenbacher return -EIO; 4217b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4218b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4219b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 42209f5bdc33SAndreas Gruenbacher return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0); 4221b411b363SPhilipp Reisner } 4222b411b363SPhilipp Reisner 4223b411b363SPhilipp Reisner /* 4224b411b363SPhilipp Reisner * return values: 4225b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4226b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4227b411b363SPhilipp Reisner * -1 peer talks different language, 4228b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4229b411b363SPhilipp Reisner */ 42306038178eSAndreas Gruenbacher static int drbd_do_features(struct drbd_tconn *tconn) 4231b411b363SPhilipp Reisner { 423265d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4233e658983aSAndreas Gruenbacher struct p_connection_features *p; 4234e658983aSAndreas Gruenbacher const int expect = sizeof(struct p_connection_features); 423577351055SPhilipp Reisner struct packet_info pi; 4236a5c31904SAndreas Gruenbacher int err; 4237b411b363SPhilipp Reisner 42386038178eSAndreas Gruenbacher err = drbd_send_features(tconn); 4239e8d17b01SAndreas Gruenbacher if (err) 4240b411b363SPhilipp Reisner return 0; 4241b411b363SPhilipp Reisner 424269bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 424369bc7bc3SAndreas Gruenbacher if (err) 4244b411b363SPhilipp Reisner return 0; 4245b411b363SPhilipp Reisner 42466038178eSAndreas Gruenbacher if (pi.cmd != P_CONNECTION_FEATURES) { 42476038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n", 424877351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4249b411b363SPhilipp Reisner return -1; 4250b411b363SPhilipp Reisner } 4251b411b363SPhilipp Reisner 425277351055SPhilipp Reisner if (pi.size != expect) { 42536038178eSAndreas Gruenbacher conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n", 425477351055SPhilipp Reisner expect, pi.size); 4255b411b363SPhilipp Reisner return -1; 4256b411b363SPhilipp Reisner } 4257b411b363SPhilipp Reisner 4258e658983aSAndreas Gruenbacher p = pi.data; 4259e658983aSAndreas Gruenbacher err = drbd_recv_all_warn(tconn, p, expect); 4260a5c31904SAndreas Gruenbacher if (err) 4261b411b363SPhilipp Reisner return 0; 4262b411b363SPhilipp Reisner 4263b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4264b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4265b411b363SPhilipp Reisner if (p->protocol_max == 0) 4266b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4267b411b363SPhilipp Reisner 4268b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4269b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4270b411b363SPhilipp Reisner goto incompat; 4271b411b363SPhilipp Reisner 427265d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4273b411b363SPhilipp Reisner 427465d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 427565d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4276b411b363SPhilipp Reisner 4277b411b363SPhilipp Reisner return 1; 4278b411b363SPhilipp Reisner 4279b411b363SPhilipp Reisner incompat: 428065d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4281b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4282b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4283b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4284b411b363SPhilipp Reisner return -1; 4285b411b363SPhilipp Reisner } 4286b411b363SPhilipp Reisner 4287b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 428813e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4289b411b363SPhilipp Reisner { 4290b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4291b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4292b10d96cbSJohannes Thoma return -1; 4293b411b363SPhilipp Reisner } 4294b411b363SPhilipp Reisner #else 4295b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4296b10d96cbSJohannes Thoma 4297b10d96cbSJohannes Thoma /* Return value: 4298b10d96cbSJohannes Thoma 1 - auth succeeded, 4299b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4300b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4301b10d96cbSJohannes Thoma */ 4302b10d96cbSJohannes Thoma 430313e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4304b411b363SPhilipp Reisner { 43059f5bdc33SAndreas Gruenbacher struct drbd_socket *sock; 4306b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4307b411b363SPhilipp Reisner struct scatterlist sg; 4308b411b363SPhilipp Reisner char *response = NULL; 4309b411b363SPhilipp Reisner char *right_response = NULL; 4310b411b363SPhilipp Reisner char *peers_ch = NULL; 431113e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4312b411b363SPhilipp Reisner unsigned int resp_size; 4313b411b363SPhilipp Reisner struct hash_desc desc; 431477351055SPhilipp Reisner struct packet_info pi; 431569bc7bc3SAndreas Gruenbacher int err, rv; 4316b411b363SPhilipp Reisner 43179f5bdc33SAndreas Gruenbacher /* FIXME: Put the challenge/response into the preallocated socket buffer. */ 43189f5bdc33SAndreas Gruenbacher 431913e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4320b411b363SPhilipp Reisner desc.flags = 0; 4321b411b363SPhilipp Reisner 432213e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 432313e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4324b411b363SPhilipp Reisner if (rv) { 432513e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4326b10d96cbSJohannes Thoma rv = -1; 4327b411b363SPhilipp Reisner goto fail; 4328b411b363SPhilipp Reisner } 4329b411b363SPhilipp Reisner 4330b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4331b411b363SPhilipp Reisner 43329f5bdc33SAndreas Gruenbacher sock = &tconn->data; 43339f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 43349f5bdc33SAndreas Gruenbacher rv = 0; 43359f5bdc33SAndreas Gruenbacher goto fail; 43369f5bdc33SAndreas Gruenbacher } 4337e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0, 43389f5bdc33SAndreas Gruenbacher my_challenge, CHALLENGE_LEN); 4339b411b363SPhilipp Reisner if (!rv) 4340b411b363SPhilipp Reisner goto fail; 4341b411b363SPhilipp Reisner 434269bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 434369bc7bc3SAndreas Gruenbacher if (err) { 434469bc7bc3SAndreas Gruenbacher rv = 0; 4345b411b363SPhilipp Reisner goto fail; 434669bc7bc3SAndreas Gruenbacher } 4347b411b363SPhilipp Reisner 434877351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 434913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 435077351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4351b411b363SPhilipp Reisner rv = 0; 4352b411b363SPhilipp Reisner goto fail; 4353b411b363SPhilipp Reisner } 4354b411b363SPhilipp Reisner 435577351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 435613e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4357b10d96cbSJohannes Thoma rv = -1; 4358b411b363SPhilipp Reisner goto fail; 4359b411b363SPhilipp Reisner } 4360b411b363SPhilipp Reisner 436177351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4362b411b363SPhilipp Reisner if (peers_ch == NULL) { 436313e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4364b10d96cbSJohannes Thoma rv = -1; 4365b411b363SPhilipp Reisner goto fail; 4366b411b363SPhilipp Reisner } 4367b411b363SPhilipp Reisner 4368a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4369a5c31904SAndreas Gruenbacher if (err) { 4370b411b363SPhilipp Reisner rv = 0; 4371b411b363SPhilipp Reisner goto fail; 4372b411b363SPhilipp Reisner } 4373b411b363SPhilipp Reisner 437413e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4375b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4376b411b363SPhilipp Reisner if (response == NULL) { 437713e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4378b10d96cbSJohannes Thoma rv = -1; 4379b411b363SPhilipp Reisner goto fail; 4380b411b363SPhilipp Reisner } 4381b411b363SPhilipp Reisner 4382b411b363SPhilipp Reisner sg_init_table(&sg, 1); 438377351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4384b411b363SPhilipp Reisner 4385b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4386b411b363SPhilipp Reisner if (rv) { 438713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4388b10d96cbSJohannes Thoma rv = -1; 4389b411b363SPhilipp Reisner goto fail; 4390b411b363SPhilipp Reisner } 4391b411b363SPhilipp Reisner 43929f5bdc33SAndreas Gruenbacher if (!conn_prepare_command(tconn, sock)) { 43939f5bdc33SAndreas Gruenbacher rv = 0; 43949f5bdc33SAndreas Gruenbacher goto fail; 43959f5bdc33SAndreas Gruenbacher } 4396e658983aSAndreas Gruenbacher rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0, 43979f5bdc33SAndreas Gruenbacher response, resp_size); 4398b411b363SPhilipp Reisner if (!rv) 4399b411b363SPhilipp Reisner goto fail; 4400b411b363SPhilipp Reisner 440169bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 440269bc7bc3SAndreas Gruenbacher if (err) { 440369bc7bc3SAndreas Gruenbacher rv = 0; 4404b411b363SPhilipp Reisner goto fail; 440569bc7bc3SAndreas Gruenbacher } 4406b411b363SPhilipp Reisner 440777351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 440813e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 440977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4410b411b363SPhilipp Reisner rv = 0; 4411b411b363SPhilipp Reisner goto fail; 4412b411b363SPhilipp Reisner } 4413b411b363SPhilipp Reisner 441477351055SPhilipp Reisner if (pi.size != resp_size) { 441513e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4416b411b363SPhilipp Reisner rv = 0; 4417b411b363SPhilipp Reisner goto fail; 4418b411b363SPhilipp Reisner } 4419b411b363SPhilipp Reisner 4420a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4421a5c31904SAndreas Gruenbacher if (err) { 4422b411b363SPhilipp Reisner rv = 0; 4423b411b363SPhilipp Reisner goto fail; 4424b411b363SPhilipp Reisner } 4425b411b363SPhilipp Reisner 4426b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 44272d1ee87dSJulia Lawall if (right_response == NULL) { 442813e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4429b10d96cbSJohannes Thoma rv = -1; 4430b411b363SPhilipp Reisner goto fail; 4431b411b363SPhilipp Reisner } 4432b411b363SPhilipp Reisner 4433b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4434b411b363SPhilipp Reisner 4435b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4436b411b363SPhilipp Reisner if (rv) { 443713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4438b10d96cbSJohannes Thoma rv = -1; 4439b411b363SPhilipp Reisner goto fail; 4440b411b363SPhilipp Reisner } 4441b411b363SPhilipp Reisner 4442b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4443b411b363SPhilipp Reisner 4444b411b363SPhilipp Reisner if (rv) 444513e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 444613e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4447b10d96cbSJohannes Thoma else 4448b10d96cbSJohannes Thoma rv = -1; 4449b411b363SPhilipp Reisner 4450b411b363SPhilipp Reisner fail: 4451b411b363SPhilipp Reisner kfree(peers_ch); 4452b411b363SPhilipp Reisner kfree(response); 4453b411b363SPhilipp Reisner kfree(right_response); 4454b411b363SPhilipp Reisner 4455b411b363SPhilipp Reisner return rv; 4456b411b363SPhilipp Reisner } 4457b411b363SPhilipp Reisner #endif 4458b411b363SPhilipp Reisner 4459b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4460b411b363SPhilipp Reisner { 4461392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4462b411b363SPhilipp Reisner int h; 4463b411b363SPhilipp Reisner 44644d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4465b411b363SPhilipp Reisner 4466b411b363SPhilipp Reisner do { 44674d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4468b411b363SPhilipp Reisner if (h == 0) { 44694d641dd7SPhilipp Reisner drbd_disconnect(tconn); 447020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4471b411b363SPhilipp Reisner } 4472b411b363SPhilipp Reisner if (h == -1) { 44734d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4474bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4475b411b363SPhilipp Reisner } 4476b411b363SPhilipp Reisner } while (h == 0); 4477b411b363SPhilipp Reisner 4478b411b363SPhilipp Reisner if (h > 0) { 44794d641dd7SPhilipp Reisner if (get_net_conf(tconn)) { 44804d641dd7SPhilipp Reisner drbdd(tconn); 44814d641dd7SPhilipp Reisner put_net_conf(tconn); 4482b411b363SPhilipp Reisner } 4483b411b363SPhilipp Reisner } 4484b411b363SPhilipp Reisner 44854d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4486b411b363SPhilipp Reisner 44874d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4488b411b363SPhilipp Reisner return 0; 4489b411b363SPhilipp Reisner } 4490b411b363SPhilipp Reisner 4491b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4492b411b363SPhilipp Reisner 4493e05e1e59SAndreas Gruenbacher static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4494b411b363SPhilipp Reisner { 4495e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4496b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4497b411b363SPhilipp Reisner 4498fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4499fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4500fc3b10a4SPhilipp Reisner } else { 4501fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4502fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4503fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4504fc3b10a4SPhilipp Reisner } 4505fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4506e4f78edeSPhilipp Reisner 45072735a594SAndreas Gruenbacher return 0; 4508fc3b10a4SPhilipp Reisner } 4509e4f78edeSPhilipp Reisner 45101952e916SAndreas Gruenbacher static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi) 4511e4f78edeSPhilipp Reisner { 45121952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4513e658983aSAndreas Gruenbacher struct p_req_state_reply *p = pi->data; 4514e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4515e4f78edeSPhilipp Reisner 45161952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 45171952e916SAndreas Gruenbacher if (!mdev) 45182735a594SAndreas Gruenbacher return -EIO; 45191952e916SAndreas Gruenbacher 4520e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4521e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4522e4f78edeSPhilipp Reisner } else { 4523e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4524e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4525e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4526e4f78edeSPhilipp Reisner } 4527e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4528e4f78edeSPhilipp Reisner 45292735a594SAndreas Gruenbacher return 0; 4530b411b363SPhilipp Reisner } 4531b411b363SPhilipp Reisner 4532e05e1e59SAndreas Gruenbacher static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi) 4533b411b363SPhilipp Reisner { 45342735a594SAndreas Gruenbacher return drbd_send_ping_ack(tconn); 4535b411b363SPhilipp Reisner 4536b411b363SPhilipp Reisner } 4537b411b363SPhilipp Reisner 4538e05e1e59SAndreas Gruenbacher static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi) 4539b411b363SPhilipp Reisner { 4540b411b363SPhilipp Reisner /* restore idle timeout */ 45412a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 45422a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 45432a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4544b411b363SPhilipp Reisner 45452735a594SAndreas Gruenbacher return 0; 4546b411b363SPhilipp Reisner } 4547b411b363SPhilipp Reisner 45481952e916SAndreas Gruenbacher static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi) 4549b411b363SPhilipp Reisner { 45501952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4551e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4552b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4553b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4554b411b363SPhilipp Reisner 45551952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 45561952e916SAndreas Gruenbacher if (!mdev) 45572735a594SAndreas Gruenbacher return -EIO; 45581952e916SAndreas Gruenbacher 455931890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4560b411b363SPhilipp Reisner 4561b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4562b411b363SPhilipp Reisner 45631d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4564b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4565b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4566b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4567b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 45681d53f09eSLars Ellenberg put_ldev(mdev); 45691d53f09eSLars Ellenberg } 4570b411b363SPhilipp Reisner dec_rs_pending(mdev); 4571778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4572b411b363SPhilipp Reisner 45732735a594SAndreas Gruenbacher return 0; 4574b411b363SPhilipp Reisner } 4575b411b363SPhilipp Reisner 4576bc9c5c41SAndreas Gruenbacher static int 4577bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4578bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4579bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4580b411b363SPhilipp Reisner { 4581b411b363SPhilipp Reisner struct drbd_request *req; 4582b411b363SPhilipp Reisner struct bio_and_error m; 4583b411b363SPhilipp Reisner 458487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4585bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4586b411b363SPhilipp Reisner if (unlikely(!req)) { 458787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 458885997675SAndreas Gruenbacher return -EIO; 4589b411b363SPhilipp Reisner } 4590b411b363SPhilipp Reisner __req_mod(req, what, &m); 459187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4592b411b363SPhilipp Reisner 4593b411b363SPhilipp Reisner if (m.bio) 4594b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 459585997675SAndreas Gruenbacher return 0; 4596b411b363SPhilipp Reisner } 4597b411b363SPhilipp Reisner 45981952e916SAndreas Gruenbacher static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi) 4599b411b363SPhilipp Reisner { 46001952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4601e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4602b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4603b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4604b411b363SPhilipp Reisner enum drbd_req_event what; 4605b411b363SPhilipp Reisner 46061952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 46071952e916SAndreas Gruenbacher if (!mdev) 46082735a594SAndreas Gruenbacher return -EIO; 46091952e916SAndreas Gruenbacher 4610b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4611b411b363SPhilipp Reisner 4612579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4613b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4614b411b363SPhilipp Reisner dec_rs_pending(mdev); 46152735a594SAndreas Gruenbacher return 0; 4616b411b363SPhilipp Reisner } 4617e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4618b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 461989e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46208554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4621b411b363SPhilipp Reisner break; 4622b411b363SPhilipp Reisner case P_WRITE_ACK: 462389e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46248554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4625b411b363SPhilipp Reisner break; 4626b411b363SPhilipp Reisner case P_RECV_ACK: 462789e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 46288554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4629b411b363SPhilipp Reisner break; 46307be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 463189e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46327be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 46337be8da07SAndreas Gruenbacher break; 46347be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 46357be8da07SAndreas Gruenbacher D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 46367be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4637b411b363SPhilipp Reisner break; 4638b411b363SPhilipp Reisner default: 46392735a594SAndreas Gruenbacher BUG(); 4640b411b363SPhilipp Reisner } 4641b411b363SPhilipp Reisner 46422735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4643bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4644bc9c5c41SAndreas Gruenbacher what, false); 4645b411b363SPhilipp Reisner } 4646b411b363SPhilipp Reisner 46471952e916SAndreas Gruenbacher static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi) 4648b411b363SPhilipp Reisner { 46491952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4650e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4651b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 46522deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 46531952e916SAndreas Gruenbacher bool missing_ok = tconn->net_conf->wire_protocol == DRBD_PROT_A || 46541952e916SAndreas Gruenbacher tconn->net_conf->wire_protocol == DRBD_PROT_B; 465585997675SAndreas Gruenbacher int err; 4656b411b363SPhilipp Reisner 46571952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 46581952e916SAndreas Gruenbacher if (!mdev) 46592735a594SAndreas Gruenbacher return -EIO; 46601952e916SAndreas Gruenbacher 4661b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4662b411b363SPhilipp Reisner 4663579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4664b411b363SPhilipp Reisner dec_rs_pending(mdev); 4665b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 46662735a594SAndreas Gruenbacher return 0; 4667b411b363SPhilipp Reisner } 46682deb8336SPhilipp Reisner 466985997675SAndreas Gruenbacher err = validate_req_change_req_state(mdev, p->block_id, sector, 4670bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 46718554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 467285997675SAndreas Gruenbacher if (err) { 46732deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 46742deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4675c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 46762deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 46772deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4678c3afd8f5SAndreas Gruenbacher if (!missing_ok) 46792735a594SAndreas Gruenbacher return err; 4680c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 46812deb8336SPhilipp Reisner } 46822735a594SAndreas Gruenbacher return 0; 4683b411b363SPhilipp Reisner } 4684b411b363SPhilipp Reisner 46851952e916SAndreas Gruenbacher static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4686b411b363SPhilipp Reisner { 46871952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4688e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4689b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4690b411b363SPhilipp Reisner 46911952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 46921952e916SAndreas Gruenbacher if (!mdev) 46932735a594SAndreas Gruenbacher return -EIO; 46941952e916SAndreas Gruenbacher 4695b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 46967be8da07SAndreas Gruenbacher 4697b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4698b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4699b411b363SPhilipp Reisner 47002735a594SAndreas Gruenbacher return validate_req_change_req_state(mdev, p->block_id, sector, 4701bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 47028554df1cSAndreas Gruenbacher NEG_ACKED, false); 4703b411b363SPhilipp Reisner } 4704b411b363SPhilipp Reisner 47051952e916SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi) 4706b411b363SPhilipp Reisner { 47071952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4708b411b363SPhilipp Reisner sector_t sector; 4709b411b363SPhilipp Reisner int size; 4710e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 47111952e916SAndreas Gruenbacher 47121952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47131952e916SAndreas Gruenbacher if (!mdev) 47142735a594SAndreas Gruenbacher return -EIO; 4715b411b363SPhilipp Reisner 4716b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4717b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4718b411b363SPhilipp Reisner 4719b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4720b411b363SPhilipp Reisner 4721b411b363SPhilipp Reisner dec_rs_pending(mdev); 4722b411b363SPhilipp Reisner 4723b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4724b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4725e05e1e59SAndreas Gruenbacher switch (pi->cmd) { 4726d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4727b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4728d612d309SPhilipp Reisner case P_RS_CANCEL: 4729d612d309SPhilipp Reisner break; 4730d612d309SPhilipp Reisner default: 47312735a594SAndreas Gruenbacher BUG(); 4732d612d309SPhilipp Reisner } 4733b411b363SPhilipp Reisner put_ldev(mdev); 4734b411b363SPhilipp Reisner } 4735b411b363SPhilipp Reisner 47362735a594SAndreas Gruenbacher return 0; 4737b411b363SPhilipp Reisner } 4738b411b363SPhilipp Reisner 47391952e916SAndreas Gruenbacher static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi) 4740b411b363SPhilipp Reisner { 47411952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4742e658983aSAndreas Gruenbacher struct p_barrier_ack *p = pi->data; 47431952e916SAndreas Gruenbacher 47441952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47451952e916SAndreas Gruenbacher if (!mdev) 47462735a594SAndreas Gruenbacher return -EIO; 4747b411b363SPhilipp Reisner 47482f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4749b411b363SPhilipp Reisner 4750c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4751c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4752370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4753370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4754370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4755c4752ef1SPhilipp Reisner } 4756c4752ef1SPhilipp Reisner 47572735a594SAndreas Gruenbacher return 0; 4758b411b363SPhilipp Reisner } 4759b411b363SPhilipp Reisner 47601952e916SAndreas Gruenbacher static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi) 4761b411b363SPhilipp Reisner { 47621952e916SAndreas Gruenbacher struct drbd_conf *mdev; 4763e658983aSAndreas Gruenbacher struct p_block_ack *p = pi->data; 4764b411b363SPhilipp Reisner struct drbd_work *w; 4765b411b363SPhilipp Reisner sector_t sector; 4766b411b363SPhilipp Reisner int size; 4767b411b363SPhilipp Reisner 47681952e916SAndreas Gruenbacher mdev = vnr_to_mdev(tconn, pi->vnr); 47691952e916SAndreas Gruenbacher if (!mdev) 47702735a594SAndreas Gruenbacher return -EIO; 47711952e916SAndreas Gruenbacher 4772b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4773b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4774b411b363SPhilipp Reisner 4775b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4776b411b363SPhilipp Reisner 4777b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 47788f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 4779b411b363SPhilipp Reisner else 47808f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4781b411b363SPhilipp Reisner 47821d53f09eSLars Ellenberg if (!get_ldev(mdev)) 47832735a594SAndreas Gruenbacher return 0; 47841d53f09eSLars Ellenberg 4785b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4786b411b363SPhilipp Reisner dec_rs_pending(mdev); 4787b411b363SPhilipp Reisner 4788ea5442afSLars Ellenberg --mdev->ov_left; 4789ea5442afSLars Ellenberg 4790ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4791ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4792ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4793ea5442afSLars Ellenberg 4794ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4795b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4796b411b363SPhilipp Reisner if (w) { 4797b411b363SPhilipp Reisner w->cb = w_ov_finished; 4798a21e9298SPhilipp Reisner w->mdev = mdev; 4799e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4800b411b363SPhilipp Reisner } else { 4801b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 48028f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4803b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4804b411b363SPhilipp Reisner } 4805b411b363SPhilipp Reisner } 48061d53f09eSLars Ellenberg put_ldev(mdev); 48072735a594SAndreas Gruenbacher return 0; 4808b411b363SPhilipp Reisner } 4809b411b363SPhilipp Reisner 48101952e916SAndreas Gruenbacher static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi) 48110ced55a3SPhilipp Reisner { 48122735a594SAndreas Gruenbacher return 0; 48130ced55a3SPhilipp Reisner } 48140ced55a3SPhilipp Reisner 4815a990be46SAndreas Gruenbacher static int tconn_finish_peer_reqs(struct drbd_tconn *tconn) 481632862ec7SPhilipp Reisner { 4817082a3439SPhilipp Reisner struct drbd_conf *mdev; 4818082a3439SPhilipp Reisner int i, not_empty = 0; 481932862ec7SPhilipp Reisner 482032862ec7SPhilipp Reisner do { 482132862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 482232862ec7SPhilipp Reisner flush_signals(current); 4823082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4824a990be46SAndreas Gruenbacher if (drbd_finish_peer_reqs(mdev)) 4825082a3439SPhilipp Reisner return 1; /* error */ 4826082a3439SPhilipp Reisner } 482732862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 4828082a3439SPhilipp Reisner 4829082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4830082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4831082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 4832082a3439SPhilipp Reisner if (not_empty) 4833082a3439SPhilipp Reisner break; 4834082a3439SPhilipp Reisner } 4835082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 483632862ec7SPhilipp Reisner } while (not_empty); 483732862ec7SPhilipp Reisner 483832862ec7SPhilipp Reisner return 0; 483932862ec7SPhilipp Reisner } 484032862ec7SPhilipp Reisner 48417201b972SAndreas Gruenbacher struct asender_cmd { 48427201b972SAndreas Gruenbacher size_t pkt_size; 48431952e916SAndreas Gruenbacher int (*fn)(struct drbd_tconn *tconn, struct packet_info *); 48447201b972SAndreas Gruenbacher }; 48457201b972SAndreas Gruenbacher 48467201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 4847e658983aSAndreas Gruenbacher [P_PING] = { 0, got_Ping }, 4848e658983aSAndreas Gruenbacher [P_PING_ACK] = { 0, got_PingAck }, 48491952e916SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 48501952e916SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 48511952e916SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 48521952e916SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 48531952e916SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 48541952e916SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 48551952e916SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply }, 48561952e916SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 48571952e916SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 48581952e916SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 48591952e916SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 48601952e916SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 48611952e916SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply }, 48621952e916SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply }, 48631952e916SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 48647201b972SAndreas Gruenbacher }; 48657201b972SAndreas Gruenbacher 4866b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4867b411b363SPhilipp Reisner { 4868392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4869b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 487077351055SPhilipp Reisner struct packet_info pi; 4871257d0af6SPhilipp Reisner int rv; 4872e658983aSAndreas Gruenbacher void *buf = tconn->meta.rbuf; 4873b411b363SPhilipp Reisner int received = 0; 487452b061a4SAndreas Gruenbacher unsigned int header_size = drbd_header_size(tconn); 487552b061a4SAndreas Gruenbacher int expect = header_size; 4876f36af18cSLars Ellenberg int ping_timeout_active = 0; 4877b411b363SPhilipp Reisner 4878b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4879b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4880b411b363SPhilipp Reisner 4881e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 488280822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 488332862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 4884a17647aaSAndreas Gruenbacher if (drbd_send_ping(tconn)) { 488532862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 4886841ce241SAndreas Gruenbacher goto reconnect; 4887841ce241SAndreas Gruenbacher } 488832862ec7SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = 488932862ec7SPhilipp Reisner tconn->net_conf->ping_timeo*HZ/10; 4890f36af18cSLars Ellenberg ping_timeout_active = 1; 4891b411b363SPhilipp Reisner } 4892b411b363SPhilipp Reisner 489332862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 489432862ec7SPhilipp Reisner much to send */ 489532862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 489632862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 4897a990be46SAndreas Gruenbacher if (tconn_finish_peer_reqs(tconn)) { 4898a990be46SAndreas Gruenbacher conn_err(tconn, "tconn_finish_peer_reqs() failed\n"); 4899b411b363SPhilipp Reisner goto reconnect; 4900082a3439SPhilipp Reisner } 4901b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 490232862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 490332862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 4904b411b363SPhilipp Reisner 4905b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4906b411b363SPhilipp Reisner if (signal_pending(current)) 4907b411b363SPhilipp Reisner continue; 4908b411b363SPhilipp Reisner 490932862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 491032862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4911b411b363SPhilipp Reisner 4912b411b363SPhilipp Reisner flush_signals(current); 4913b411b363SPhilipp Reisner 4914b411b363SPhilipp Reisner /* Note: 4915b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4916b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4917b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4918b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4919b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4920b411b363SPhilipp Reisner * rv == expected: full header or command 4921b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4922b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4923b411b363SPhilipp Reisner */ 4924b411b363SPhilipp Reisner if (likely(rv > 0)) { 4925b411b363SPhilipp Reisner received += rv; 4926b411b363SPhilipp Reisner buf += rv; 4927b411b363SPhilipp Reisner } else if (rv == 0) { 492832862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 4929b411b363SPhilipp Reisner goto reconnect; 4930b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4931cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4932cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 493332862ec7SPhilipp Reisner if (time_after(tconn->last_received, 493432862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 4935cb6518cbSLars Ellenberg continue; 4936f36af18cSLars Ellenberg if (ping_timeout_active) { 493732862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 4938b411b363SPhilipp Reisner goto reconnect; 4939b411b363SPhilipp Reisner } 494032862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 4941b411b363SPhilipp Reisner continue; 4942b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4943b411b363SPhilipp Reisner continue; 4944b411b363SPhilipp Reisner } else { 494532862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 4946b411b363SPhilipp Reisner goto reconnect; 4947b411b363SPhilipp Reisner } 4948b411b363SPhilipp Reisner 4949b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 4950e658983aSAndreas Gruenbacher if (decode_header(tconn, tconn->meta.rbuf, &pi)) 4951b411b363SPhilipp Reisner goto reconnect; 49527201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 49531952e916SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) { 495432862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 495577351055SPhilipp Reisner pi.cmd, pi.size); 4956b411b363SPhilipp Reisner goto disconnect; 4957b411b363SPhilipp Reisner } 4958e658983aSAndreas Gruenbacher expect = header_size + cmd->pkt_size; 495952b061a4SAndreas Gruenbacher if (pi.size != expect - header_size) { 496032862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 496177351055SPhilipp Reisner pi.cmd, pi.size); 4962b411b363SPhilipp Reisner goto reconnect; 4963b411b363SPhilipp Reisner } 4964257d0af6SPhilipp Reisner } 4965b411b363SPhilipp Reisner if (received == expect) { 49662735a594SAndreas Gruenbacher bool err; 4967a4fbda8eSPhilipp Reisner 49682735a594SAndreas Gruenbacher err = cmd->fn(tconn, &pi); 49692735a594SAndreas Gruenbacher if (err) { 49701952e916SAndreas Gruenbacher conn_err(tconn, "%pf failed\n", cmd->fn); 4971b411b363SPhilipp Reisner goto reconnect; 49721952e916SAndreas Gruenbacher } 4973b411b363SPhilipp Reisner 4974a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 4975a4fbda8eSPhilipp Reisner 4976f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4977f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 49787201b972SAndreas Gruenbacher if (cmd == &asender_tbl[P_PING_ACK]) 4979f36af18cSLars Ellenberg ping_timeout_active = 0; 4980f36af18cSLars Ellenberg 4981e658983aSAndreas Gruenbacher buf = tconn->meta.rbuf; 4982b411b363SPhilipp Reisner received = 0; 498352b061a4SAndreas Gruenbacher expect = header_size; 4984b411b363SPhilipp Reisner cmd = NULL; 4985b411b363SPhilipp Reisner } 4986b411b363SPhilipp Reisner } 4987b411b363SPhilipp Reisner 4988b411b363SPhilipp Reisner if (0) { 4989b411b363SPhilipp Reisner reconnect: 4990bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4991b411b363SPhilipp Reisner } 4992b411b363SPhilipp Reisner if (0) { 4993b411b363SPhilipp Reisner disconnect: 4994bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4995b411b363SPhilipp Reisner } 499632862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4997b411b363SPhilipp Reisner 499832862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 4999b411b363SPhilipp Reisner 5000b411b363SPhilipp Reisner return 0; 5001b411b363SPhilipp Reisner } 5002