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; 5377351055SPhilipp Reisner int size; 5477351055SPhilipp Reisner int vnr; 5577351055SPhilipp Reisner }; 5677351055SPhilipp Reisner 57b411b363SPhilipp Reisner enum finish_epoch { 58b411b363SPhilipp Reisner FE_STILL_LIVE, 59b411b363SPhilipp Reisner FE_DESTROYED, 60b411b363SPhilipp Reisner FE_RECYCLED, 61b411b363SPhilipp Reisner }; 62b411b363SPhilipp Reisner 6365d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn); 6413e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 65360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data); 66b411b363SPhilipp Reisner 67b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 6800d56944SPhilipp Reisner static int e_end_block(struct drbd_work *, int); 69b411b363SPhilipp Reisner 70b411b363SPhilipp Reisner 71b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 72b411b363SPhilipp Reisner 7345bb912bSLars Ellenberg /* 7445bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 7545bb912bSLars Ellenberg * page->private being our "next" pointer. 7645bb912bSLars Ellenberg */ 7745bb912bSLars Ellenberg 7845bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 7945bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8045bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8145bb912bSLars Ellenberg */ 8245bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8345bb912bSLars Ellenberg { 8445bb912bSLars Ellenberg struct page *page; 8545bb912bSLars Ellenberg struct page *tmp; 8645bb912bSLars Ellenberg 8745bb912bSLars Ellenberg BUG_ON(!n); 8845bb912bSLars Ellenberg BUG_ON(!head); 8945bb912bSLars Ellenberg 9045bb912bSLars Ellenberg page = *head; 9123ce4227SPhilipp Reisner 9223ce4227SPhilipp Reisner if (!page) 9323ce4227SPhilipp Reisner return NULL; 9423ce4227SPhilipp Reisner 9545bb912bSLars Ellenberg while (page) { 9645bb912bSLars Ellenberg tmp = page_chain_next(page); 9745bb912bSLars Ellenberg if (--n == 0) 9845bb912bSLars Ellenberg break; /* found sufficient pages */ 9945bb912bSLars Ellenberg if (tmp == NULL) 10045bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10145bb912bSLars Ellenberg return NULL; 10245bb912bSLars Ellenberg page = tmp; 10345bb912bSLars Ellenberg } 10445bb912bSLars Ellenberg 10545bb912bSLars Ellenberg /* add end of list marker for the returned list */ 10645bb912bSLars Ellenberg set_page_private(page, 0); 10745bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 10845bb912bSLars Ellenberg page = *head; 10945bb912bSLars Ellenberg *head = tmp; 11045bb912bSLars Ellenberg return page; 11145bb912bSLars Ellenberg } 11245bb912bSLars Ellenberg 11345bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11445bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 11545bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 11645bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 11745bb912bSLars Ellenberg { 11845bb912bSLars Ellenberg struct page *tmp; 11945bb912bSLars Ellenberg int i = 1; 12045bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12145bb912bSLars Ellenberg ++i, page = tmp; 12245bb912bSLars Ellenberg if (len) 12345bb912bSLars Ellenberg *len = i; 12445bb912bSLars Ellenberg return page; 12545bb912bSLars Ellenberg } 12645bb912bSLars Ellenberg 12745bb912bSLars Ellenberg static int page_chain_free(struct page *page) 12845bb912bSLars Ellenberg { 12945bb912bSLars Ellenberg struct page *tmp; 13045bb912bSLars Ellenberg int i = 0; 13145bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13245bb912bSLars Ellenberg put_page(page); 13345bb912bSLars Ellenberg ++i; 13445bb912bSLars Ellenberg } 13545bb912bSLars Ellenberg return i; 13645bb912bSLars Ellenberg } 13745bb912bSLars Ellenberg 13845bb912bSLars Ellenberg static void page_chain_add(struct page **head, 13945bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14045bb912bSLars Ellenberg { 14145bb912bSLars Ellenberg #if 1 14245bb912bSLars Ellenberg struct page *tmp; 14345bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14445bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 14545bb912bSLars Ellenberg #endif 14645bb912bSLars Ellenberg 14745bb912bSLars Ellenberg /* add chain to head */ 14845bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 14945bb912bSLars Ellenberg *head = chain_first; 15045bb912bSLars Ellenberg } 15145bb912bSLars Ellenberg 15245bb912bSLars Ellenberg static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number) 153b411b363SPhilipp Reisner { 154b411b363SPhilipp Reisner struct page *page = NULL; 15545bb912bSLars Ellenberg struct page *tmp = NULL; 15645bb912bSLars Ellenberg int i = 0; 157b411b363SPhilipp Reisner 158b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 159b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16045bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 161b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16245bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16345bb912bSLars Ellenberg if (page) 16445bb912bSLars Ellenberg drbd_pp_vacant -= number; 165b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 16645bb912bSLars Ellenberg if (page) 16745bb912bSLars Ellenberg return page; 168b411b363SPhilipp Reisner } 16945bb912bSLars Ellenberg 170b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 171b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 172b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17345bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17445bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 17545bb912bSLars Ellenberg if (!tmp) 17645bb912bSLars Ellenberg break; 17745bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 17845bb912bSLars Ellenberg page = tmp; 17945bb912bSLars Ellenberg } 18045bb912bSLars Ellenberg 18145bb912bSLars Ellenberg if (i == number) 182b411b363SPhilipp Reisner return page; 18345bb912bSLars Ellenberg 18445bb912bSLars Ellenberg /* Not enough pages immediately available this time. 18545bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc will retry this 18645bb912bSLars Ellenberg * function "soon". */ 18745bb912bSLars Ellenberg if (page) { 18845bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 18945bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19045bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19145bb912bSLars Ellenberg drbd_pp_vacant += i; 19245bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19345bb912bSLars Ellenberg } 19445bb912bSLars Ellenberg return NULL; 195b411b363SPhilipp Reisner } 196b411b363SPhilipp Reisner 197b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 198b411b363SPhilipp Reisner { 199db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 200b411b363SPhilipp Reisner struct list_head *le, *tle; 201b411b363SPhilipp Reisner 202b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 203b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 204b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 205b411b363SPhilipp Reisner stop to examine the list... */ 206b411b363SPhilipp Reisner 207b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 208db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 209db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) 210b411b363SPhilipp Reisner break; 211b411b363SPhilipp Reisner list_move(le, to_be_freed); 212b411b363SPhilipp Reisner } 213b411b363SPhilipp Reisner } 214b411b363SPhilipp Reisner 215b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 216b411b363SPhilipp Reisner { 217b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 218db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 219b411b363SPhilipp Reisner 22087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 221b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 22287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 223b411b363SPhilipp Reisner 224db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 225db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 226b411b363SPhilipp Reisner } 227b411b363SPhilipp Reisner 228b411b363SPhilipp Reisner /** 22945bb912bSLars Ellenberg * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled) 230b411b363SPhilipp Reisner * @mdev: DRBD device. 23145bb912bSLars Ellenberg * @number: number of pages requested 23245bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 233b411b363SPhilipp Reisner * 23445bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 23545bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 23645bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 23745bb912bSLars Ellenberg * 23845bb912bSLars Ellenberg * Returns a page chain linked via page->private. 239b411b363SPhilipp Reisner */ 24045bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 241b411b363SPhilipp Reisner { 242b411b363SPhilipp Reisner struct page *page = NULL; 243b411b363SPhilipp Reisner DEFINE_WAIT(wait); 244b411b363SPhilipp Reisner 24545bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 24645bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 24789e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) 24845bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 249b411b363SPhilipp Reisner 25045bb912bSLars Ellenberg while (page == NULL) { 251b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 252b411b363SPhilipp Reisner 253b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 254b411b363SPhilipp Reisner 25589e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) { 25645bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 257b411b363SPhilipp Reisner if (page) 258b411b363SPhilipp Reisner break; 259b411b363SPhilipp Reisner } 260b411b363SPhilipp Reisner 261b411b363SPhilipp Reisner if (!retry) 262b411b363SPhilipp Reisner break; 263b411b363SPhilipp Reisner 264b411b363SPhilipp Reisner if (signal_pending(current)) { 265b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 266b411b363SPhilipp Reisner break; 267b411b363SPhilipp Reisner } 268b411b363SPhilipp Reisner 269b411b363SPhilipp Reisner schedule(); 270b411b363SPhilipp Reisner } 271b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 272b411b363SPhilipp Reisner 27345bb912bSLars Ellenberg if (page) 27445bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 275b411b363SPhilipp Reisner return page; 276b411b363SPhilipp Reisner } 277b411b363SPhilipp Reisner 278b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 27987eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 28045bb912bSLars Ellenberg * Either links the page chain back to the global pool, 28145bb912bSLars Ellenberg * or returns all pages to the system. */ 282435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 283b411b363SPhilipp Reisner { 284435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 285b411b363SPhilipp Reisner int i; 286435f0740SLars Ellenberg 2871816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 28845bb912bSLars Ellenberg i = page_chain_free(page); 28945bb912bSLars Ellenberg else { 29045bb912bSLars Ellenberg struct page *tmp; 29145bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 292b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 29345bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 29445bb912bSLars Ellenberg drbd_pp_vacant += i; 295b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 296b411b363SPhilipp Reisner } 297435f0740SLars Ellenberg i = atomic_sub_return(i, a); 29845bb912bSLars Ellenberg if (i < 0) 299435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 300435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 301b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 302b411b363SPhilipp Reisner } 303b411b363SPhilipp Reisner 304b411b363SPhilipp Reisner /* 305b411b363SPhilipp Reisner You need to hold the req_lock: 306b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 307b411b363SPhilipp Reisner 308b411b363SPhilipp Reisner You must not have the req_lock: 309b411b363SPhilipp Reisner drbd_free_ee() 310b411b363SPhilipp Reisner drbd_alloc_ee() 311b411b363SPhilipp Reisner drbd_init_ee() 312b411b363SPhilipp Reisner drbd_release_ee() 313b411b363SPhilipp Reisner drbd_ee_fix_bhs() 314b411b363SPhilipp Reisner drbd_process_done_ee() 315b411b363SPhilipp Reisner drbd_clear_done_ee() 316b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 317b411b363SPhilipp Reisner */ 318b411b363SPhilipp Reisner 319f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 320f6ffca9fSAndreas Gruenbacher drbd_alloc_ee(struct drbd_conf *mdev, u64 id, sector_t sector, 321f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 322b411b363SPhilipp Reisner { 323db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 324b411b363SPhilipp Reisner struct page *page; 32545bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 326b411b363SPhilipp Reisner 3270cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 328b411b363SPhilipp Reisner return NULL; 329b411b363SPhilipp Reisner 330db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 331db830c46SAndreas Gruenbacher if (!peer_req) { 332b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 333b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 334b411b363SPhilipp Reisner return NULL; 335b411b363SPhilipp Reisner } 336b411b363SPhilipp Reisner 33745bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 33845bb912bSLars Ellenberg if (!page) 33945bb912bSLars Ellenberg goto fail; 340b411b363SPhilipp Reisner 341db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 342db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 343db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 344db830c46SAndreas Gruenbacher peer_req->i.local = false; 345db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 34653840641SAndreas Gruenbacher 347db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 348a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 349db830c46SAndreas Gruenbacher peer_req->pages = page; 350db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 351db830c46SAndreas Gruenbacher peer_req->flags = 0; 3529a8e7753SAndreas Gruenbacher /* 3539a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3549a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3559a8e7753SAndreas Gruenbacher */ 356db830c46SAndreas Gruenbacher peer_req->block_id = id; 357b411b363SPhilipp Reisner 358db830c46SAndreas Gruenbacher return peer_req; 359b411b363SPhilipp Reisner 36045bb912bSLars Ellenberg fail: 361db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 362b411b363SPhilipp Reisner return NULL; 363b411b363SPhilipp Reisner } 364b411b363SPhilipp Reisner 365db830c46SAndreas Gruenbacher void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 366f6ffca9fSAndreas Gruenbacher int is_net) 367b411b363SPhilipp Reisner { 368db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 369db830c46SAndreas Gruenbacher kfree(peer_req->digest); 370db830c46SAndreas Gruenbacher drbd_pp_free(mdev, peer_req->pages, is_net); 371db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 372db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 373db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 374b411b363SPhilipp Reisner } 375b411b363SPhilipp Reisner 376b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 377b411b363SPhilipp Reisner { 378b411b363SPhilipp Reisner LIST_HEAD(work_list); 379db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 380b411b363SPhilipp Reisner int count = 0; 381435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 382b411b363SPhilipp Reisner 38387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 384b411b363SPhilipp Reisner list_splice_init(list, &work_list); 38587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 386b411b363SPhilipp Reisner 387db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 388db830c46SAndreas Gruenbacher drbd_free_some_ee(mdev, peer_req, is_net); 389b411b363SPhilipp Reisner count++; 390b411b363SPhilipp Reisner } 391b411b363SPhilipp Reisner return count; 392b411b363SPhilipp Reisner } 393b411b363SPhilipp Reisner 394b411b363SPhilipp Reisner 39532862ec7SPhilipp Reisner /* See also comments in _req_mod(,BARRIER_ACKED) 396b411b363SPhilipp Reisner * and receive_Barrier. 397b411b363SPhilipp Reisner * 398b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 399b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 400b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 401b411b363SPhilipp Reisner */ 402b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 403b411b363SPhilipp Reisner { 404b411b363SPhilipp Reisner LIST_HEAD(work_list); 405b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 406db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 407082a3439SPhilipp Reisner int ok = 1; 408b411b363SPhilipp Reisner 40987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 410b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 411b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 41287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 413b411b363SPhilipp Reisner 414db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 415db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 416b411b363SPhilipp Reisner 417b411b363SPhilipp Reisner /* possible callbacks here: 4187be8da07SAndreas Gruenbacher * e_end_block, and e_end_resync_block, e_send_discard_write. 419b411b363SPhilipp Reisner * all ignore the last argument. 420b411b363SPhilipp Reisner */ 421db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 422b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 42300d56944SPhilipp Reisner ok = peer_req->w.cb(&peer_req->w, !ok) && ok; 424db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 425b411b363SPhilipp Reisner } 426b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 427b411b363SPhilipp Reisner 428b411b363SPhilipp Reisner return ok; 429b411b363SPhilipp Reisner } 430b411b363SPhilipp Reisner 431b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 432b411b363SPhilipp Reisner { 433b411b363SPhilipp Reisner DEFINE_WAIT(wait); 434b411b363SPhilipp Reisner 435b411b363SPhilipp Reisner /* avoids spin_lock/unlock 436b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 437b411b363SPhilipp Reisner while (!list_empty(head)) { 438b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 43987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4407eaceaccSJens Axboe io_schedule(); 441b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 44287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 443b411b363SPhilipp Reisner } 444b411b363SPhilipp Reisner } 445b411b363SPhilipp Reisner 446b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 447b411b363SPhilipp Reisner { 44887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 449b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 45087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 451b411b363SPhilipp Reisner } 452b411b363SPhilipp Reisner 453b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 454b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4557653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 456b411b363SPhilipp Reisner { 457b411b363SPhilipp Reisner struct sock *sk = sock->sk; 458b411b363SPhilipp Reisner int err = 0; 459b411b363SPhilipp Reisner 460b411b363SPhilipp Reisner *what = "listen"; 461b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 462b411b363SPhilipp Reisner if (err < 0) 463b411b363SPhilipp Reisner goto out; 464b411b363SPhilipp Reisner 465b411b363SPhilipp Reisner *what = "sock_create_lite"; 466b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 467b411b363SPhilipp Reisner newsock); 468b411b363SPhilipp Reisner if (err < 0) 469b411b363SPhilipp Reisner goto out; 470b411b363SPhilipp Reisner 471b411b363SPhilipp Reisner *what = "accept"; 472b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 473b411b363SPhilipp Reisner if (err < 0) { 474b411b363SPhilipp Reisner sock_release(*newsock); 475b411b363SPhilipp Reisner *newsock = NULL; 476b411b363SPhilipp Reisner goto out; 477b411b363SPhilipp Reisner } 478b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 479b411b363SPhilipp Reisner 480b411b363SPhilipp Reisner out: 481b411b363SPhilipp Reisner return err; 482b411b363SPhilipp Reisner } 483b411b363SPhilipp Reisner 484dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 485b411b363SPhilipp Reisner { 486b411b363SPhilipp Reisner mm_segment_t oldfs; 487b411b363SPhilipp Reisner struct kvec iov = { 488b411b363SPhilipp Reisner .iov_base = buf, 489b411b363SPhilipp Reisner .iov_len = size, 490b411b363SPhilipp Reisner }; 491b411b363SPhilipp Reisner struct msghdr msg = { 492b411b363SPhilipp Reisner .msg_iovlen = 1, 493b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 494b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 495b411b363SPhilipp Reisner }; 496b411b363SPhilipp Reisner int rv; 497b411b363SPhilipp Reisner 498b411b363SPhilipp Reisner oldfs = get_fs(); 499b411b363SPhilipp Reisner set_fs(KERNEL_DS); 500b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 501b411b363SPhilipp Reisner set_fs(oldfs); 502b411b363SPhilipp Reisner 503b411b363SPhilipp Reisner return rv; 504b411b363SPhilipp Reisner } 505b411b363SPhilipp Reisner 506de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 507b411b363SPhilipp Reisner { 508b411b363SPhilipp Reisner mm_segment_t oldfs; 509b411b363SPhilipp Reisner struct kvec iov = { 510b411b363SPhilipp Reisner .iov_base = buf, 511b411b363SPhilipp Reisner .iov_len = size, 512b411b363SPhilipp Reisner }; 513b411b363SPhilipp Reisner struct msghdr msg = { 514b411b363SPhilipp Reisner .msg_iovlen = 1, 515b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 516b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 517b411b363SPhilipp Reisner }; 518b411b363SPhilipp Reisner int rv; 519b411b363SPhilipp Reisner 520b411b363SPhilipp Reisner oldfs = get_fs(); 521b411b363SPhilipp Reisner set_fs(KERNEL_DS); 522b411b363SPhilipp Reisner 523b411b363SPhilipp Reisner for (;;) { 524de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 525b411b363SPhilipp Reisner if (rv == size) 526b411b363SPhilipp Reisner break; 527b411b363SPhilipp Reisner 528b411b363SPhilipp Reisner /* Note: 529b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 530b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 531b411b363SPhilipp Reisner */ 532b411b363SPhilipp Reisner 533b411b363SPhilipp Reisner if (rv < 0) { 534b411b363SPhilipp Reisner if (rv == -ECONNRESET) 535de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 536b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 537de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 538b411b363SPhilipp Reisner break; 539b411b363SPhilipp Reisner } else if (rv == 0) { 540de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 541b411b363SPhilipp Reisner break; 542b411b363SPhilipp Reisner } else { 543b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 544b411b363SPhilipp Reisner * after we read a partial message 545b411b363SPhilipp Reisner */ 546b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 547b411b363SPhilipp Reisner break; 548b411b363SPhilipp Reisner } 549b411b363SPhilipp Reisner }; 550b411b363SPhilipp Reisner 551b411b363SPhilipp Reisner set_fs(oldfs); 552b411b363SPhilipp Reisner 553b411b363SPhilipp Reisner if (rv != size) 554bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 555b411b363SPhilipp Reisner 556b411b363SPhilipp Reisner return rv; 557b411b363SPhilipp Reisner } 558b411b363SPhilipp Reisner 5595dbf1673SLars Ellenberg /* quoting tcp(7): 5605dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5615dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5625dbf1673SLars Ellenberg * This is our wrapper to do so. 5635dbf1673SLars Ellenberg */ 5645dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5655dbf1673SLars Ellenberg unsigned int rcv) 5665dbf1673SLars Ellenberg { 5675dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5685dbf1673SLars Ellenberg if (snd) { 5695dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5705dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5715dbf1673SLars Ellenberg } 5725dbf1673SLars Ellenberg if (rcv) { 5735dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5745dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5755dbf1673SLars Ellenberg } 5765dbf1673SLars Ellenberg } 5775dbf1673SLars Ellenberg 578eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 579b411b363SPhilipp Reisner { 580b411b363SPhilipp Reisner const char *what; 581b411b363SPhilipp Reisner struct socket *sock; 582b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 583b411b363SPhilipp Reisner int err; 584b411b363SPhilipp Reisner int disconnect_on_error = 1; 585b411b363SPhilipp Reisner 586eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 587b411b363SPhilipp Reisner return NULL; 588b411b363SPhilipp Reisner 589b411b363SPhilipp Reisner what = "sock_create_kern"; 590eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 591b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 592b411b363SPhilipp Reisner if (err < 0) { 593b411b363SPhilipp Reisner sock = NULL; 594b411b363SPhilipp Reisner goto out; 595b411b363SPhilipp Reisner } 596b411b363SPhilipp Reisner 597b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 598eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 599eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 600eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 601b411b363SPhilipp Reisner 602b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 603b411b363SPhilipp Reisner * for the outgoing connections. 604b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 605b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 606b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 607b411b363SPhilipp Reisner * a free one dynamically. 608b411b363SPhilipp Reisner */ 609eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 610eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 611eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 612b411b363SPhilipp Reisner src_in6.sin6_port = 0; 613b411b363SPhilipp Reisner else 614b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 615b411b363SPhilipp Reisner 616b411b363SPhilipp Reisner what = "bind before connect"; 617b411b363SPhilipp Reisner err = sock->ops->bind(sock, 618b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 619eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 620b411b363SPhilipp Reisner if (err < 0) 621b411b363SPhilipp Reisner goto out; 622b411b363SPhilipp Reisner 623b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 624b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 625b411b363SPhilipp Reisner disconnect_on_error = 0; 626b411b363SPhilipp Reisner what = "connect"; 627b411b363SPhilipp Reisner err = sock->ops->connect(sock, 628eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 629eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 630b411b363SPhilipp Reisner 631b411b363SPhilipp Reisner out: 632b411b363SPhilipp Reisner if (err < 0) { 633b411b363SPhilipp Reisner if (sock) { 634b411b363SPhilipp Reisner sock_release(sock); 635b411b363SPhilipp Reisner sock = NULL; 636b411b363SPhilipp Reisner } 637b411b363SPhilipp Reisner switch (-err) { 638b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 639b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 640b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 641b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 642b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 643b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 644b411b363SPhilipp Reisner disconnect_on_error = 0; 645b411b363SPhilipp Reisner break; 646b411b363SPhilipp Reisner default: 647eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 648b411b363SPhilipp Reisner } 649b411b363SPhilipp Reisner if (disconnect_on_error) 650bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 651b411b363SPhilipp Reisner } 652eac3e990SPhilipp Reisner put_net_conf(tconn); 653b411b363SPhilipp Reisner return sock; 654b411b363SPhilipp Reisner } 655b411b363SPhilipp Reisner 6567653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 657b411b363SPhilipp Reisner { 658b411b363SPhilipp Reisner int timeo, err; 659b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 660b411b363SPhilipp Reisner const char *what; 661b411b363SPhilipp Reisner 6627653620dSPhilipp Reisner if (!get_net_conf(tconn)) 663b411b363SPhilipp Reisner return NULL; 664b411b363SPhilipp Reisner 665b411b363SPhilipp Reisner what = "sock_create_kern"; 6667653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 667b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 668b411b363SPhilipp Reisner if (err) { 669b411b363SPhilipp Reisner s_listen = NULL; 670b411b363SPhilipp Reisner goto out; 671b411b363SPhilipp Reisner } 672b411b363SPhilipp Reisner 6737653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 674b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 675b411b363SPhilipp Reisner 676b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 677b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 678b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 6797653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 6807653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 681b411b363SPhilipp Reisner 682b411b363SPhilipp Reisner what = "bind before listen"; 683b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 6847653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 6857653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 686b411b363SPhilipp Reisner if (err < 0) 687b411b363SPhilipp Reisner goto out; 688b411b363SPhilipp Reisner 6897653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 690b411b363SPhilipp Reisner 691b411b363SPhilipp Reisner out: 692b411b363SPhilipp Reisner if (s_listen) 693b411b363SPhilipp Reisner sock_release(s_listen); 694b411b363SPhilipp Reisner if (err < 0) { 695b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 6967653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 697bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 698b411b363SPhilipp Reisner } 699b411b363SPhilipp Reisner } 7007653620dSPhilipp Reisner put_net_conf(tconn); 701b411b363SPhilipp Reisner 702b411b363SPhilipp Reisner return s_estab; 703b411b363SPhilipp Reisner } 704b411b363SPhilipp Reisner 705d38e787eSPhilipp Reisner static int drbd_send_fp(struct drbd_tconn *tconn, struct socket *sock, enum drbd_packet cmd) 706b411b363SPhilipp Reisner { 707d38e787eSPhilipp Reisner struct p_header *h = &tconn->data.sbuf.header; 708b411b363SPhilipp Reisner 709d38e787eSPhilipp Reisner return _conn_send_cmd(tconn, 0, sock, cmd, h, sizeof(*h), 0); 710b411b363SPhilipp Reisner } 711b411b363SPhilipp Reisner 712a25b63f1SPhilipp Reisner static enum drbd_packet drbd_recv_fp(struct drbd_tconn *tconn, struct socket *sock) 713b411b363SPhilipp Reisner { 714a25b63f1SPhilipp Reisner struct p_header80 *h = &tconn->data.rbuf.header.h80; 715b411b363SPhilipp Reisner int rr; 716b411b363SPhilipp Reisner 717dbd9eea0SPhilipp Reisner rr = drbd_recv_short(sock, h, sizeof(*h), 0); 718b411b363SPhilipp Reisner 719ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 720b411b363SPhilipp Reisner return be16_to_cpu(h->command); 721b411b363SPhilipp Reisner 722b411b363SPhilipp Reisner return 0xffff; 723b411b363SPhilipp Reisner } 724b411b363SPhilipp Reisner 725b411b363SPhilipp Reisner /** 726b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 727b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 728b411b363SPhilipp Reisner */ 729dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 730b411b363SPhilipp Reisner { 731b411b363SPhilipp Reisner int rr; 732b411b363SPhilipp Reisner char tb[4]; 733b411b363SPhilipp Reisner 734b411b363SPhilipp Reisner if (!*sock) 73581e84650SAndreas Gruenbacher return false; 736b411b363SPhilipp Reisner 737dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 738b411b363SPhilipp Reisner 739b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 74081e84650SAndreas Gruenbacher return true; 741b411b363SPhilipp Reisner } else { 742b411b363SPhilipp Reisner sock_release(*sock); 743b411b363SPhilipp Reisner *sock = NULL; 74481e84650SAndreas Gruenbacher return false; 745b411b363SPhilipp Reisner } 746b411b363SPhilipp Reisner } 7472325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 7482325eb66SPhilipp Reisner in a connection */ 7492325eb66SPhilipp Reisner int drbd_connected(int vnr, void *p, void *data) 750907599e0SPhilipp Reisner { 751907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 752907599e0SPhilipp Reisner int ok = 1; 753907599e0SPhilipp Reisner 754907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 755907599e0SPhilipp Reisner mdev->peer_seq = 0; 756907599e0SPhilipp Reisner 7578410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 7588410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 7598410da8fSPhilipp Reisner &mdev->own_state_mutex; 7608410da8fSPhilipp Reisner 761907599e0SPhilipp Reisner ok &= drbd_send_sync_param(mdev, &mdev->sync_conf); 762907599e0SPhilipp Reisner ok &= drbd_send_sizes(mdev, 0, 0); 763907599e0SPhilipp Reisner ok &= drbd_send_uuids(mdev); 764907599e0SPhilipp Reisner ok &= drbd_send_state(mdev); 765907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 766907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 767907599e0SPhilipp Reisner 7688410da8fSPhilipp Reisner 769907599e0SPhilipp Reisner return !ok; 770907599e0SPhilipp Reisner } 771907599e0SPhilipp Reisner 772b411b363SPhilipp Reisner /* 773b411b363SPhilipp Reisner * return values: 774b411b363SPhilipp Reisner * 1 yes, we have a valid connection 775b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 776b411b363SPhilipp Reisner * -1 peer talks different language, 777b411b363SPhilipp Reisner * no point in trying again, please go standalone. 778b411b363SPhilipp Reisner * -2 We do not have a network config... 779b411b363SPhilipp Reisner */ 780907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 781b411b363SPhilipp Reisner { 782b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 783b411b363SPhilipp Reisner int try, h, ok; 784b411b363SPhilipp Reisner 785bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 786b411b363SPhilipp Reisner return -2; 787b411b363SPhilipp Reisner 788907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 789907599e0SPhilipp Reisner tconn->agreed_pro_version = 99; 790fd340c12SPhilipp Reisner /* agreed_pro_version must be smaller than 100 so we send the old 791fd340c12SPhilipp Reisner header (h80) in the first packet and in the handshake packet. */ 792b411b363SPhilipp Reisner 793b411b363SPhilipp Reisner sock = NULL; 794b411b363SPhilipp Reisner msock = NULL; 795b411b363SPhilipp Reisner 796b411b363SPhilipp Reisner do { 797b411b363SPhilipp Reisner for (try = 0;;) { 798b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 799907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 800b411b363SPhilipp Reisner if (s || ++try >= 3) 801b411b363SPhilipp Reisner break; 802b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 80320ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 804b411b363SPhilipp Reisner } 805b411b363SPhilipp Reisner 806b411b363SPhilipp Reisner if (s) { 807b411b363SPhilipp Reisner if (!sock) { 808907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_S); 809b411b363SPhilipp Reisner sock = s; 810b411b363SPhilipp Reisner s = NULL; 811b411b363SPhilipp Reisner } else if (!msock) { 812907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_M); 813b411b363SPhilipp Reisner msock = s; 814b411b363SPhilipp Reisner s = NULL; 815b411b363SPhilipp Reisner } else { 816907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 817b411b363SPhilipp Reisner goto out_release_sockets; 818b411b363SPhilipp Reisner } 819b411b363SPhilipp Reisner } 820b411b363SPhilipp Reisner 821b411b363SPhilipp Reisner if (sock && msock) { 822907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 823dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 824dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 825b411b363SPhilipp Reisner if (ok) 826b411b363SPhilipp Reisner break; 827b411b363SPhilipp Reisner } 828b411b363SPhilipp Reisner 829b411b363SPhilipp Reisner retry: 830907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 831b411b363SPhilipp Reisner if (s) { 832907599e0SPhilipp Reisner try = drbd_recv_fp(tconn, s); 833dbd9eea0SPhilipp Reisner drbd_socket_okay(&sock); 834dbd9eea0SPhilipp Reisner drbd_socket_okay(&msock); 835b411b363SPhilipp Reisner switch (try) { 836b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 837b411b363SPhilipp Reisner if (sock) { 838907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 839b411b363SPhilipp Reisner sock_release(sock); 840b411b363SPhilipp Reisner } 841b411b363SPhilipp Reisner sock = s; 842b411b363SPhilipp Reisner break; 843b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 844b411b363SPhilipp Reisner if (msock) { 845907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 846b411b363SPhilipp Reisner sock_release(msock); 847b411b363SPhilipp Reisner } 848b411b363SPhilipp Reisner msock = s; 849907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 850b411b363SPhilipp Reisner break; 851b411b363SPhilipp Reisner default: 852907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 853b411b363SPhilipp Reisner sock_release(s); 854b411b363SPhilipp Reisner if (random32() & 1) 855b411b363SPhilipp Reisner goto retry; 856b411b363SPhilipp Reisner } 857b411b363SPhilipp Reisner } 858b411b363SPhilipp Reisner 859bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 860b411b363SPhilipp Reisner goto out_release_sockets; 861b411b363SPhilipp Reisner if (signal_pending(current)) { 862b411b363SPhilipp Reisner flush_signals(current); 863b411b363SPhilipp Reisner smp_rmb(); 864907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 865b411b363SPhilipp Reisner goto out_release_sockets; 866b411b363SPhilipp Reisner } 867b411b363SPhilipp Reisner 868b411b363SPhilipp Reisner if (sock && msock) { 869dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 870dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 871b411b363SPhilipp Reisner if (ok) 872b411b363SPhilipp Reisner break; 873b411b363SPhilipp Reisner } 874b411b363SPhilipp Reisner } while (1); 875b411b363SPhilipp Reisner 876b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 877b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 878b411b363SPhilipp Reisner 879b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 880b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 881b411b363SPhilipp Reisner 882b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 883b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 884b411b363SPhilipp Reisner 885b411b363SPhilipp Reisner /* NOT YET ... 886907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 887b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 888b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 889b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 890b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 891907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 892b411b363SPhilipp Reisner 893907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 894907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 895b411b363SPhilipp Reisner 896b411b363SPhilipp Reisner /* we don't want delays. 89725985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 898b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 899b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 900b411b363SPhilipp Reisner 901907599e0SPhilipp Reisner tconn->data.socket = sock; 902907599e0SPhilipp Reisner tconn->meta.socket = msock; 903907599e0SPhilipp Reisner tconn->last_received = jiffies; 904b411b363SPhilipp Reisner 905907599e0SPhilipp Reisner h = drbd_do_handshake(tconn); 906b411b363SPhilipp Reisner if (h <= 0) 907b411b363SPhilipp Reisner return h; 908b411b363SPhilipp Reisner 909907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 910b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 911907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 912b10d96cbSJohannes Thoma case -1: 913907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 914b411b363SPhilipp Reisner return -1; 915b10d96cbSJohannes Thoma case 0: 916907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 917b10d96cbSJohannes Thoma return 0; 918b411b363SPhilipp Reisner } 919b411b363SPhilipp Reisner } 920b411b363SPhilipp Reisner 921bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 922b411b363SPhilipp Reisner return 0; 923b411b363SPhilipp Reisner 924907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 925b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 926b411b363SPhilipp Reisner 927907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 928b411b363SPhilipp Reisner 929907599e0SPhilipp Reisner if (drbd_send_protocol(tconn) == -1) 9307e2455c1SPhilipp Reisner return -1; 931b411b363SPhilipp Reisner 932907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 933b411b363SPhilipp Reisner 934b411b363SPhilipp Reisner out_release_sockets: 935b411b363SPhilipp Reisner if (sock) 936b411b363SPhilipp Reisner sock_release(sock); 937b411b363SPhilipp Reisner if (msock) 938b411b363SPhilipp Reisner sock_release(msock); 939b411b363SPhilipp Reisner return -1; 940b411b363SPhilipp Reisner } 941b411b363SPhilipp Reisner 942ce243853SPhilipp Reisner static bool decode_header(struct drbd_tconn *tconn, struct p_header *h, struct packet_info *pi) 943b411b363SPhilipp Reisner { 944fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 94577351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h80.command); 94677351055SPhilipp Reisner pi->size = be16_to_cpu(h->h80.length); 947eefc2f7dSPhilipp Reisner pi->vnr = 0; 948ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 94977351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h95.command); 95077351055SPhilipp Reisner pi->size = be32_to_cpu(h->h95.length) & 0x00ffffff; 95177351055SPhilipp Reisner pi->vnr = 0; 95202918be2SPhilipp Reisner } else { 953ce243853SPhilipp Reisner conn_err(tconn, "magic?? on data m: 0x%08x c: %d l: %d\n", 954004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 955004352faSLars Ellenberg be16_to_cpu(h->h80.command), 956004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 95781e84650SAndreas Gruenbacher return false; 958b411b363SPhilipp Reisner } 959257d0af6SPhilipp Reisner return true; 960257d0af6SPhilipp Reisner } 961257d0af6SPhilipp Reisner 9629ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 963257d0af6SPhilipp Reisner { 9649ba7aa00SPhilipp Reisner struct p_header *h = &tconn->data.rbuf.header; 965257d0af6SPhilipp Reisner int r; 966257d0af6SPhilipp Reisner 9679ba7aa00SPhilipp Reisner r = drbd_recv(tconn, h, sizeof(*h)); 968257d0af6SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 969257d0af6SPhilipp Reisner if (!signal_pending(current)) 9709ba7aa00SPhilipp Reisner conn_warn(tconn, "short read expecting header on sock: r=%d\n", r); 971257d0af6SPhilipp Reisner return false; 972257d0af6SPhilipp Reisner } 973257d0af6SPhilipp Reisner 9749ba7aa00SPhilipp Reisner r = decode_header(tconn, h, pi); 9759ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 976b411b363SPhilipp Reisner 977257d0af6SPhilipp Reisner return r; 978b411b363SPhilipp Reisner } 979b411b363SPhilipp Reisner 9802451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 981b411b363SPhilipp Reisner { 982b411b363SPhilipp Reisner int rv; 983b411b363SPhilipp Reisner 984b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 985fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 986dd3932edSChristoph Hellwig NULL); 987b411b363SPhilipp Reisner if (rv) { 988b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 989b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 990b411b363SPhilipp Reisner * don't try again for ANY return value != 0 991b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 992b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 993b411b363SPhilipp Reisner } 994b411b363SPhilipp Reisner put_ldev(mdev); 995b411b363SPhilipp Reisner } 996b411b363SPhilipp Reisner } 997b411b363SPhilipp Reisner 998b411b363SPhilipp Reisner /** 999b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1000b411b363SPhilipp Reisner * @mdev: DRBD device. 1001b411b363SPhilipp Reisner * @epoch: Epoch object. 1002b411b363SPhilipp Reisner * @ev: Epoch event. 1003b411b363SPhilipp Reisner */ 1004b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1005b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1006b411b363SPhilipp Reisner enum epoch_event ev) 1007b411b363SPhilipp Reisner { 10082451fc3bSPhilipp Reisner int epoch_size; 1009b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1010b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1011b411b363SPhilipp Reisner 1012b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1013b411b363SPhilipp Reisner do { 1014b411b363SPhilipp Reisner next_epoch = NULL; 1015b411b363SPhilipp Reisner 1016b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1017b411b363SPhilipp Reisner 1018b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1019b411b363SPhilipp Reisner case EV_PUT: 1020b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1021b411b363SPhilipp Reisner break; 1022b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1023b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1024b411b363SPhilipp Reisner break; 1025b411b363SPhilipp Reisner case EV_BECAME_LAST: 1026b411b363SPhilipp Reisner /* nothing to do*/ 1027b411b363SPhilipp Reisner break; 1028b411b363SPhilipp Reisner } 1029b411b363SPhilipp Reisner 1030b411b363SPhilipp Reisner if (epoch_size != 0 && 1031b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10322451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1033b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1034b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1035b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1036b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1037b411b363SPhilipp Reisner } 1038b411b363SPhilipp Reisner dec_unacked(mdev); 1039b411b363SPhilipp Reisner 1040b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1041b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1042b411b363SPhilipp Reisner list_del(&epoch->list); 1043b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1044b411b363SPhilipp Reisner mdev->epochs--; 1045b411b363SPhilipp Reisner kfree(epoch); 1046b411b363SPhilipp Reisner 1047b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1048b411b363SPhilipp Reisner rv = FE_DESTROYED; 1049b411b363SPhilipp Reisner } else { 1050b411b363SPhilipp Reisner epoch->flags = 0; 1051b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1052698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1053b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1054b411b363SPhilipp Reisner rv = FE_RECYCLED; 10552451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1056b411b363SPhilipp Reisner } 1057b411b363SPhilipp Reisner } 1058b411b363SPhilipp Reisner 1059b411b363SPhilipp Reisner if (!next_epoch) 1060b411b363SPhilipp Reisner break; 1061b411b363SPhilipp Reisner 1062b411b363SPhilipp Reisner epoch = next_epoch; 1063b411b363SPhilipp Reisner } while (1); 1064b411b363SPhilipp Reisner 1065b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1066b411b363SPhilipp Reisner 1067b411b363SPhilipp Reisner return rv; 1068b411b363SPhilipp Reisner } 1069b411b363SPhilipp Reisner 1070b411b363SPhilipp Reisner /** 1071b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1072b411b363SPhilipp Reisner * @mdev: DRBD device. 1073b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1074b411b363SPhilipp Reisner */ 1075b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1076b411b363SPhilipp Reisner { 1077b411b363SPhilipp Reisner enum write_ordering_e pwo; 1078b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1079b411b363SPhilipp Reisner [WO_none] = "none", 1080b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1081b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1082b411b363SPhilipp Reisner }; 1083b411b363SPhilipp Reisner 1084b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1085b411b363SPhilipp Reisner wo = min(pwo, wo); 1086b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1087b411b363SPhilipp Reisner wo = WO_drain_io; 1088b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1089b411b363SPhilipp Reisner wo = WO_none; 1090b411b363SPhilipp Reisner mdev->write_ordering = wo; 10912451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1092b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1093b411b363SPhilipp Reisner } 1094b411b363SPhilipp Reisner 1095b411b363SPhilipp Reisner /** 1096fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 109745bb912bSLars Ellenberg * @mdev: DRBD device. 1098db830c46SAndreas Gruenbacher * @peer_req: peer request 109945bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 110010f6d992SLars Ellenberg * 110110f6d992SLars Ellenberg * May spread the pages to multiple bios, 110210f6d992SLars Ellenberg * depending on bio_add_page restrictions. 110310f6d992SLars Ellenberg * 110410f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 110510f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 110610f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 110710f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 110810f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 110910f6d992SLars Ellenberg * on certain Xen deployments. 111045bb912bSLars Ellenberg */ 111145bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1112fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1113fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 111445bb912bSLars Ellenberg const unsigned rw, const int fault_type) 111545bb912bSLars Ellenberg { 111645bb912bSLars Ellenberg struct bio *bios = NULL; 111745bb912bSLars Ellenberg struct bio *bio; 1118db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1119db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1120db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 112145bb912bSLars Ellenberg unsigned n_bios = 0; 112245bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 112310f6d992SLars Ellenberg int err = -ENOMEM; 112445bb912bSLars Ellenberg 112545bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 112645bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 112745bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1128da4a75d2SLars Ellenberg * request in more than one bio. 1129da4a75d2SLars Ellenberg * 1130da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1131da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1132da4a75d2SLars Ellenberg */ 113345bb912bSLars Ellenberg next_bio: 113445bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 113545bb912bSLars Ellenberg if (!bio) { 113645bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 113745bb912bSLars Ellenberg goto fail; 113845bb912bSLars Ellenberg } 1139db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 114045bb912bSLars Ellenberg bio->bi_sector = sector; 114145bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 114245bb912bSLars Ellenberg bio->bi_rw = rw; 1143db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1144fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 114545bb912bSLars Ellenberg 114645bb912bSLars Ellenberg bio->bi_next = bios; 114745bb912bSLars Ellenberg bios = bio; 114845bb912bSLars Ellenberg ++n_bios; 114945bb912bSLars Ellenberg 115045bb912bSLars Ellenberg page_chain_for_each(page) { 115145bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 115245bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 115310f6d992SLars Ellenberg /* A single page must always be possible! 115410f6d992SLars Ellenberg * But in case it fails anyways, 115510f6d992SLars Ellenberg * we deal with it, and complain (below). */ 115610f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 115710f6d992SLars Ellenberg dev_err(DEV, 115810f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 115910f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 116010f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 116110f6d992SLars Ellenberg err = -ENOSPC; 116210f6d992SLars Ellenberg goto fail; 116310f6d992SLars Ellenberg } 116445bb912bSLars Ellenberg goto next_bio; 116545bb912bSLars Ellenberg } 116645bb912bSLars Ellenberg ds -= len; 116745bb912bSLars Ellenberg sector += len >> 9; 116845bb912bSLars Ellenberg --nr_pages; 116945bb912bSLars Ellenberg } 117045bb912bSLars Ellenberg D_ASSERT(page == NULL); 117145bb912bSLars Ellenberg D_ASSERT(ds == 0); 117245bb912bSLars Ellenberg 1173db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 117445bb912bSLars Ellenberg do { 117545bb912bSLars Ellenberg bio = bios; 117645bb912bSLars Ellenberg bios = bios->bi_next; 117745bb912bSLars Ellenberg bio->bi_next = NULL; 117845bb912bSLars Ellenberg 117945bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 118045bb912bSLars Ellenberg } while (bios); 118145bb912bSLars Ellenberg return 0; 118245bb912bSLars Ellenberg 118345bb912bSLars Ellenberg fail: 118445bb912bSLars Ellenberg while (bios) { 118545bb912bSLars Ellenberg bio = bios; 118645bb912bSLars Ellenberg bios = bios->bi_next; 118745bb912bSLars Ellenberg bio_put(bio); 118845bb912bSLars Ellenberg } 118910f6d992SLars Ellenberg return err; 119045bb912bSLars Ellenberg } 119145bb912bSLars Ellenberg 119253840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1193db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 119453840641SAndreas Gruenbacher { 1195db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 119653840641SAndreas Gruenbacher 119753840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 119853840641SAndreas Gruenbacher drbd_clear_interval(i); 119953840641SAndreas Gruenbacher 12006c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 120153840641SAndreas Gruenbacher if (i->waiting) 120253840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 120353840641SAndreas Gruenbacher } 120453840641SAndreas Gruenbacher 1205d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1206d8763023SAndreas Gruenbacher unsigned int data_size) 1207b411b363SPhilipp Reisner { 12082451fc3bSPhilipp Reisner int rv; 1209e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.rbuf.barrier; 1210b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1211b411b363SPhilipp Reisner 1212b411b363SPhilipp Reisner inc_unacked(mdev); 1213b411b363SPhilipp Reisner 1214b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1215b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1216b411b363SPhilipp Reisner 1217b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1218b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1219b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1220b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1221b411b363SPhilipp Reisner * completed. */ 1222b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1223b411b363SPhilipp Reisner case WO_none: 1224b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 122581e84650SAndreas Gruenbacher return true; 1226b411b363SPhilipp Reisner 1227b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1228b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1229b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12302451fc3bSPhilipp Reisner if (epoch) 12312451fc3bSPhilipp Reisner break; 12322451fc3bSPhilipp Reisner else 1233b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12342451fc3bSPhilipp Reisner /* Fall through */ 12352451fc3bSPhilipp Reisner 12362451fc3bSPhilipp Reisner case WO_bdev_flush: 12372451fc3bSPhilipp Reisner case WO_drain_io: 1238b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12392451fc3bSPhilipp Reisner drbd_flush(mdev); 12402451fc3bSPhilipp Reisner 12412451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12422451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12432451fc3bSPhilipp Reisner if (epoch) 12442451fc3bSPhilipp Reisner break; 1245b411b363SPhilipp Reisner } 1246b411b363SPhilipp Reisner 12472451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12482451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12492451fc3bSPhilipp Reisner 12502451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12512451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1252b411b363SPhilipp Reisner 125381e84650SAndreas Gruenbacher return true; 12542451fc3bSPhilipp Reisner default: 12552451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 125681e84650SAndreas Gruenbacher return false; 1257b411b363SPhilipp Reisner } 1258b411b363SPhilipp Reisner 1259b411b363SPhilipp Reisner epoch->flags = 0; 1260b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1261b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1262b411b363SPhilipp Reisner 1263b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1264b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1265b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1266b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1267b411b363SPhilipp Reisner mdev->epochs++; 1268b411b363SPhilipp Reisner } else { 1269b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1270b411b363SPhilipp Reisner kfree(epoch); 1271b411b363SPhilipp Reisner } 1272b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1273b411b363SPhilipp Reisner 127481e84650SAndreas Gruenbacher return true; 1275b411b363SPhilipp Reisner } 1276b411b363SPhilipp Reisner 1277b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1278b411b363SPhilipp Reisner * and from receive_Data */ 1279f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1280f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1281f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1282b411b363SPhilipp Reisner { 12836666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1284db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1285b411b363SPhilipp Reisner struct page *page; 128645bb912bSLars Ellenberg int dgs, ds, rr; 1287a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1288a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 12896b4388acSPhilipp Reisner unsigned long *data; 1290b411b363SPhilipp Reisner 1291a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1292a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1293b411b363SPhilipp Reisner 1294b411b363SPhilipp Reisner if (dgs) { 1295de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1296b411b363SPhilipp Reisner if (rr != dgs) { 12970ddc5549SLars Ellenberg if (!signal_pending(current)) 12980ddc5549SLars Ellenberg dev_warn(DEV, 12990ddc5549SLars Ellenberg "short read receiving data digest: read %d expected %d\n", 1300b411b363SPhilipp Reisner rr, dgs); 1301b411b363SPhilipp Reisner return NULL; 1302b411b363SPhilipp Reisner } 1303b411b363SPhilipp Reisner } 1304b411b363SPhilipp Reisner 1305b411b363SPhilipp Reisner data_size -= dgs; 1306b411b363SPhilipp Reisner 1307841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1308841ce241SAndreas Gruenbacher return NULL; 1309841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1310841ce241SAndreas Gruenbacher return NULL; 1311841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1312841ce241SAndreas Gruenbacher return NULL; 1313b411b363SPhilipp Reisner 13146666032aSLars Ellenberg /* even though we trust out peer, 13156666032aSLars Ellenberg * we sometimes have to double check. */ 13166666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1317fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1318fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13196666032aSLars Ellenberg (unsigned long long)capacity, 13206666032aSLars Ellenberg (unsigned long long)sector, data_size); 13216666032aSLars Ellenberg return NULL; 13226666032aSLars Ellenberg } 13236666032aSLars Ellenberg 1324b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1325b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1326b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1327db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1328db830c46SAndreas Gruenbacher if (!peer_req) 1329b411b363SPhilipp Reisner return NULL; 133045bb912bSLars Ellenberg 1331b411b363SPhilipp Reisner ds = data_size; 1332db830c46SAndreas Gruenbacher page = peer_req->pages; 133345bb912bSLars Ellenberg page_chain_for_each(page) { 133445bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13356b4388acSPhilipp Reisner data = kmap(page); 1336de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, len); 13370cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13386b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13396b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13406b4388acSPhilipp Reisner } 1341b411b363SPhilipp Reisner kunmap(page); 134245bb912bSLars Ellenberg if (rr != len) { 1343db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 13440ddc5549SLars Ellenberg if (!signal_pending(current)) 1345b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 134645bb912bSLars Ellenberg rr, len); 1347b411b363SPhilipp Reisner return NULL; 1348b411b363SPhilipp Reisner } 1349b411b363SPhilipp Reisner ds -= rr; 1350b411b363SPhilipp Reisner } 1351b411b363SPhilipp Reisner 1352b411b363SPhilipp Reisner if (dgs) { 1353db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1354b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1355470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1356470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1357db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1358b411b363SPhilipp Reisner return NULL; 1359b411b363SPhilipp Reisner } 1360b411b363SPhilipp Reisner } 1361b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1362db830c46SAndreas Gruenbacher return peer_req; 1363b411b363SPhilipp Reisner } 1364b411b363SPhilipp Reisner 1365b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1366b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1367b411b363SPhilipp Reisner */ 1368b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1369b411b363SPhilipp Reisner { 1370b411b363SPhilipp Reisner struct page *page; 1371b411b363SPhilipp Reisner int rr, rv = 1; 1372b411b363SPhilipp Reisner void *data; 1373b411b363SPhilipp Reisner 1374c3470cdeSLars Ellenberg if (!data_size) 137581e84650SAndreas Gruenbacher return true; 1376c3470cdeSLars Ellenberg 137745bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1378b411b363SPhilipp Reisner 1379b411b363SPhilipp Reisner data = kmap(page); 1380b411b363SPhilipp Reisner while (data_size) { 1381de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, min_t(int, data_size, PAGE_SIZE)); 1382b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1383b411b363SPhilipp Reisner rv = 0; 13840ddc5549SLars Ellenberg if (!signal_pending(current)) 13850ddc5549SLars Ellenberg dev_warn(DEV, 13860ddc5549SLars Ellenberg "short read receiving data: read %d expected %d\n", 1387b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1388b411b363SPhilipp Reisner break; 1389b411b363SPhilipp Reisner } 1390b411b363SPhilipp Reisner data_size -= rr; 1391b411b363SPhilipp Reisner } 1392b411b363SPhilipp Reisner kunmap(page); 1393435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1394b411b363SPhilipp Reisner return rv; 1395b411b363SPhilipp Reisner } 1396b411b363SPhilipp Reisner 1397b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1398b411b363SPhilipp Reisner sector_t sector, int data_size) 1399b411b363SPhilipp Reisner { 1400b411b363SPhilipp Reisner struct bio_vec *bvec; 1401b411b363SPhilipp Reisner struct bio *bio; 1402b411b363SPhilipp Reisner int dgs, rr, i, expect; 1403a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1404a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1405b411b363SPhilipp Reisner 1406a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1407a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1408b411b363SPhilipp Reisner 1409b411b363SPhilipp Reisner if (dgs) { 1410de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1411b411b363SPhilipp Reisner if (rr != dgs) { 14120ddc5549SLars Ellenberg if (!signal_pending(current)) 14130ddc5549SLars Ellenberg dev_warn(DEV, 14140ddc5549SLars Ellenberg "short read receiving data reply digest: read %d expected %d\n", 1415b411b363SPhilipp Reisner rr, dgs); 1416b411b363SPhilipp Reisner return 0; 1417b411b363SPhilipp Reisner } 1418b411b363SPhilipp Reisner } 1419b411b363SPhilipp Reisner 1420b411b363SPhilipp Reisner data_size -= dgs; 1421b411b363SPhilipp Reisner 1422b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1423b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1424b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1425b411b363SPhilipp Reisner 1426b411b363SPhilipp Reisner bio = req->master_bio; 1427b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1428b411b363SPhilipp Reisner 1429b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1430b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1431de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, 1432b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1433b411b363SPhilipp Reisner expect); 1434b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1435b411b363SPhilipp Reisner if (rr != expect) { 14360ddc5549SLars Ellenberg if (!signal_pending(current)) 1437b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1438b411b363SPhilipp Reisner "read %d expected %d\n", 1439b411b363SPhilipp Reisner rr, expect); 1440b411b363SPhilipp Reisner return 0; 1441b411b363SPhilipp Reisner } 1442b411b363SPhilipp Reisner data_size -= rr; 1443b411b363SPhilipp Reisner } 1444b411b363SPhilipp Reisner 1445b411b363SPhilipp Reisner if (dgs) { 1446a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1447b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1448b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1449b411b363SPhilipp Reisner return 0; 1450b411b363SPhilipp Reisner } 1451b411b363SPhilipp Reisner } 1452b411b363SPhilipp Reisner 1453b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1454b411b363SPhilipp Reisner return 1; 1455b411b363SPhilipp Reisner } 1456b411b363SPhilipp Reisner 1457b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1458b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 145900d56944SPhilipp Reisner static int e_end_resync_block(struct drbd_work *w, int unused) 1460b411b363SPhilipp Reisner { 14618050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 14628050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 146300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1464db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1465b411b363SPhilipp Reisner int ok; 1466b411b363SPhilipp Reisner 1467db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1468b411b363SPhilipp Reisner 1469db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1470db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1471db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1472b411b363SPhilipp Reisner } else { 1473b411b363SPhilipp Reisner /* Record failure to sync */ 1474db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1475b411b363SPhilipp Reisner 1476db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1477b411b363SPhilipp Reisner } 1478b411b363SPhilipp Reisner dec_unacked(mdev); 1479b411b363SPhilipp Reisner 1480b411b363SPhilipp Reisner return ok; 1481b411b363SPhilipp Reisner } 1482b411b363SPhilipp Reisner 1483b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1484b411b363SPhilipp Reisner { 1485db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1486b411b363SPhilipp Reisner 1487db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1488db830c46SAndreas Gruenbacher if (!peer_req) 148945bb912bSLars Ellenberg goto fail; 1490b411b363SPhilipp Reisner 1491b411b363SPhilipp Reisner dec_rs_pending(mdev); 1492b411b363SPhilipp Reisner 1493b411b363SPhilipp Reisner inc_unacked(mdev); 1494b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1495b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1496b411b363SPhilipp Reisner 1497db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 149845bb912bSLars Ellenberg 149987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1500db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 150187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1502b411b363SPhilipp Reisner 15030f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1504fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 150581e84650SAndreas Gruenbacher return true; 150645bb912bSLars Ellenberg 150710f6d992SLars Ellenberg /* don't care for the reason here */ 150810f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 150987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1510db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 151187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 151222cc37a9SLars Ellenberg 1513db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 151445bb912bSLars Ellenberg fail: 151545bb912bSLars Ellenberg put_ldev(mdev); 151681e84650SAndreas Gruenbacher return false; 1517b411b363SPhilipp Reisner } 1518b411b363SPhilipp Reisner 1519668eebc6SAndreas Gruenbacher static struct drbd_request * 1520bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1521bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1522668eebc6SAndreas Gruenbacher { 1523668eebc6SAndreas Gruenbacher struct drbd_request *req; 1524668eebc6SAndreas Gruenbacher 1525bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1526bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15275e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1528668eebc6SAndreas Gruenbacher return req; 1529c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1530c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1531c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1532c3afd8f5SAndreas Gruenbacher } 1533668eebc6SAndreas Gruenbacher return NULL; 1534668eebc6SAndreas Gruenbacher } 1535668eebc6SAndreas Gruenbacher 1536d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1537d8763023SAndreas Gruenbacher unsigned int data_size) 1538b411b363SPhilipp Reisner { 1539b411b363SPhilipp Reisner struct drbd_request *req; 1540b411b363SPhilipp Reisner sector_t sector; 1541b411b363SPhilipp Reisner int ok; 1542e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1543b411b363SPhilipp Reisner 1544b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1545b411b363SPhilipp Reisner 154687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1547bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 154887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1549c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 155081e84650SAndreas Gruenbacher return false; 1551b411b363SPhilipp Reisner 155224c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1553b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1554b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1555b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1556b411b363SPhilipp Reisner 1557b411b363SPhilipp Reisner if (ok) 15588554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1559b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1560b411b363SPhilipp Reisner * I don't think we may complete this just yet 1561b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1562b411b363SPhilipp Reisner 1563b411b363SPhilipp Reisner return ok; 1564b411b363SPhilipp Reisner } 1565b411b363SPhilipp Reisner 1566d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1567d8763023SAndreas Gruenbacher unsigned int data_size) 1568b411b363SPhilipp Reisner { 1569b411b363SPhilipp Reisner sector_t sector; 1570b411b363SPhilipp Reisner int ok; 1571e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1572b411b363SPhilipp Reisner 1573b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1574b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1575b411b363SPhilipp Reisner 1576b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1577b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1578b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1579fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1580b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1581b411b363SPhilipp Reisner } else { 1582b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1583b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1584b411b363SPhilipp Reisner 1585b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1586b411b363SPhilipp Reisner 15872b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1588b411b363SPhilipp Reisner } 1589b411b363SPhilipp Reisner 1590778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1591778f271dSPhilipp Reisner 1592b411b363SPhilipp Reisner return ok; 1593b411b363SPhilipp Reisner } 1594b411b363SPhilipp Reisner 15957be8da07SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 15967be8da07SAndreas Gruenbacher { 15977be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 15987be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 15997be8da07SAndreas Gruenbacher struct bio *bio; 16007be8da07SAndreas Gruenbacher unsigned long start_time; 16017be8da07SAndreas Gruenbacher unsigned long flags; 16027be8da07SAndreas Gruenbacher 16037be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16047be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16057be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16067be8da07SAndreas Gruenbacher return 0; 16077be8da07SAndreas Gruenbacher } 16087be8da07SAndreas Gruenbacher bio = req->master_bio; 16097be8da07SAndreas Gruenbacher start_time = req->start_time; 16107be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 16117be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 16127be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16137be8da07SAndreas Gruenbacher 16147be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 16157be8da07SAndreas Gruenbacher /* retry */ ; 16167be8da07SAndreas Gruenbacher return 1; 16177be8da07SAndreas Gruenbacher } 16187be8da07SAndreas Gruenbacher 16197be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 16207be8da07SAndreas Gruenbacher sector_t sector, int size) 16217be8da07SAndreas Gruenbacher { 16227be8da07SAndreas Gruenbacher struct drbd_interval *i; 16237be8da07SAndreas Gruenbacher struct drbd_request *req; 16247be8da07SAndreas Gruenbacher 16257be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 16267be8da07SAndreas Gruenbacher if (!i->local) 16277be8da07SAndreas Gruenbacher continue; 16287be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 16297be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 16307be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 16317be8da07SAndreas Gruenbacher continue; 16327be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 16337be8da07SAndreas Gruenbacher req->w.mdev = mdev; 16347be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 16357be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 16367be8da07SAndreas Gruenbacher } 16377be8da07SAndreas Gruenbacher } 16387be8da07SAndreas Gruenbacher } 16397be8da07SAndreas Gruenbacher 1640b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1641b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1642b411b363SPhilipp Reisner */ 164300d56944SPhilipp Reisner static int e_end_block(struct drbd_work *w, int cancel) 1644b411b363SPhilipp Reisner { 16458050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16468050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 164700d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1648db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1649b411b363SPhilipp Reisner int ok = 1, pcmd; 1650b411b363SPhilipp Reisner 165189e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1652db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1653b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1654b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1655db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1656b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1657db830c46SAndreas Gruenbacher ok &= drbd_send_ack(mdev, pcmd, peer_req); 1658b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1659db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1660b411b363SPhilipp Reisner } else { 1661db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1662b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1663b411b363SPhilipp Reisner * maybe assert this? */ 1664b411b363SPhilipp Reisner } 1665b411b363SPhilipp Reisner dec_unacked(mdev); 1666b411b363SPhilipp Reisner } 1667b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1668b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 166989e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 167087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1671db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1672db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 16737be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 16747be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 167587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1676bb3bfe96SAndreas Gruenbacher } else 1677db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1678b411b363SPhilipp Reisner 1679db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1680b411b363SPhilipp Reisner 1681b411b363SPhilipp Reisner return ok; 1682b411b363SPhilipp Reisner } 1683b411b363SPhilipp Reisner 16847be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1685b411b363SPhilipp Reisner { 16867be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16878050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16888050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1689206d3589SAndreas Gruenbacher int ok; 1690b411b363SPhilipp Reisner 16917be8da07SAndreas Gruenbacher ok = drbd_send_ack(mdev, ack, peer_req); 1692b411b363SPhilipp Reisner dec_unacked(mdev); 1693b411b363SPhilipp Reisner 1694b411b363SPhilipp Reisner return ok; 1695b411b363SPhilipp Reisner } 1696b411b363SPhilipp Reisner 16977be8da07SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 16987be8da07SAndreas Gruenbacher { 16997be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17007be8da07SAndreas Gruenbacher } 17017be8da07SAndreas Gruenbacher 17027be8da07SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17037be8da07SAndreas Gruenbacher { 17047be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17057be8da07SAndreas Gruenbacher 17067be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 17077be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 17087be8da07SAndreas Gruenbacher } 17097be8da07SAndreas Gruenbacher 17103e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 17113e394da1SAndreas Gruenbacher { 17123e394da1SAndreas Gruenbacher /* 17133e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 17143e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 17153e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 17163e394da1SAndreas Gruenbacher */ 17173e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 17183e394da1SAndreas Gruenbacher } 17193e394da1SAndreas Gruenbacher 17203e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 17213e394da1SAndreas Gruenbacher { 17223e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 17233e394da1SAndreas Gruenbacher } 17243e394da1SAndreas Gruenbacher 17257be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 17267be8da07SAndreas Gruenbacher { 17277be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 17287be8da07SAndreas Gruenbacher 17297be8da07SAndreas Gruenbacher /* 17307be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 17317be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 17327be8da07SAndreas Gruenbacher * handle_write_conflicts(). 17337be8da07SAndreas Gruenbacher */ 17347be8da07SAndreas Gruenbacher return tconn->net_conf->two_primaries && 17357be8da07SAndreas Gruenbacher test_bit(DISCARD_CONCURRENT, &tconn->flags); 17367be8da07SAndreas Gruenbacher } 17377be8da07SAndreas Gruenbacher 173843ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 17393e394da1SAndreas Gruenbacher { 17403c13b680SLars Ellenberg unsigned int newest_peer_seq; 17413e394da1SAndreas Gruenbacher 17427be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 17433e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 17443c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 17453c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 17463e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 17473c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 17483c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 17493e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 17503e394da1SAndreas Gruenbacher } 17517be8da07SAndreas Gruenbacher } 17523e394da1SAndreas Gruenbacher 1753b411b363SPhilipp Reisner /* Called from receive_Data. 1754b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1755b411b363SPhilipp Reisner * 1756b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1757b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1758b411b363SPhilipp Reisner * been sent. 1759b411b363SPhilipp Reisner * 1760b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1761b411b363SPhilipp Reisner * 1762b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1763b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1764b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1765b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1766b411b363SPhilipp Reisner * 1767b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1768b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1769b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1770b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1771b411b363SPhilipp Reisner * 1772b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1773b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 17747be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1775b411b363SPhilipp Reisner { 1776b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1777b411b363SPhilipp Reisner long timeout; 17787be8da07SAndreas Gruenbacher int ret; 17797be8da07SAndreas Gruenbacher 17807be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 17817be8da07SAndreas Gruenbacher return 0; 17827be8da07SAndreas Gruenbacher 1783b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1784b411b363SPhilipp Reisner for (;;) { 17857be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 17867be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 17877be8da07SAndreas Gruenbacher ret = 0; 1788b411b363SPhilipp Reisner break; 17897be8da07SAndreas Gruenbacher } 1790b411b363SPhilipp Reisner if (signal_pending(current)) { 1791b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1792b411b363SPhilipp Reisner break; 1793b411b363SPhilipp Reisner } 17947be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1795b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 179671b1c1ebSAndreas Gruenbacher timeout = mdev->tconn->net_conf->ping_timeo*HZ/10; 179771b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1798b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 17997be8da07SAndreas Gruenbacher if (!timeout) { 1800b411b363SPhilipp Reisner ret = -ETIMEDOUT; 180171b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1802b411b363SPhilipp Reisner break; 1803b411b363SPhilipp Reisner } 1804b411b363SPhilipp Reisner } 1805b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 18067be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1807b411b363SPhilipp Reisner return ret; 1808b411b363SPhilipp Reisner } 1809b411b363SPhilipp Reisner 1810688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1811688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1812688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1813688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 181476d2e7ecSPhilipp Reisner { 181576d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 181676d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1817688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 181876d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 181976d2e7ecSPhilipp Reisner } 182076d2e7ecSPhilipp Reisner 18217be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 18227be8da07SAndreas Gruenbacher unsigned int size) 18237be8da07SAndreas Gruenbacher { 18247be8da07SAndreas Gruenbacher struct drbd_interval *i; 18257be8da07SAndreas Gruenbacher 18267be8da07SAndreas Gruenbacher repeat: 18277be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18287be8da07SAndreas Gruenbacher struct drbd_request *req; 18297be8da07SAndreas Gruenbacher struct bio_and_error m; 18307be8da07SAndreas Gruenbacher 18317be8da07SAndreas Gruenbacher if (!i->local) 18327be8da07SAndreas Gruenbacher continue; 18337be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18347be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 18357be8da07SAndreas Gruenbacher continue; 18367be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 18377be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 18387be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 18397be8da07SAndreas Gruenbacher if (m.bio) 18407be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 18417be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 18427be8da07SAndreas Gruenbacher goto repeat; 18437be8da07SAndreas Gruenbacher } 18447be8da07SAndreas Gruenbacher } 18457be8da07SAndreas Gruenbacher 18467be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 18477be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 18487be8da07SAndreas Gruenbacher { 18497be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 18507be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 18517be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 18527be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 18537be8da07SAndreas Gruenbacher struct drbd_interval *i; 18547be8da07SAndreas Gruenbacher bool equal; 18557be8da07SAndreas Gruenbacher int err; 18567be8da07SAndreas Gruenbacher 18577be8da07SAndreas Gruenbacher /* 18587be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 18597be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 18607be8da07SAndreas Gruenbacher */ 18617be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 18627be8da07SAndreas Gruenbacher 18637be8da07SAndreas Gruenbacher repeat: 18647be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18657be8da07SAndreas Gruenbacher if (i == &peer_req->i) 18667be8da07SAndreas Gruenbacher continue; 18677be8da07SAndreas Gruenbacher 18687be8da07SAndreas Gruenbacher if (!i->local) { 18697be8da07SAndreas Gruenbacher /* 18707be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 18717be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 18727be8da07SAndreas Gruenbacher * earlier peer request to complete. 18737be8da07SAndreas Gruenbacher */ 18747be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 18757be8da07SAndreas Gruenbacher if (err) 18767be8da07SAndreas Gruenbacher goto out; 18777be8da07SAndreas Gruenbacher goto repeat; 18787be8da07SAndreas Gruenbacher } 18797be8da07SAndreas Gruenbacher 18807be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 18817be8da07SAndreas Gruenbacher if (resolve_conflicts) { 18827be8da07SAndreas Gruenbacher /* 18837be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 18847be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 18857be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 18867be8da07SAndreas Gruenbacher * have completed. 18877be8da07SAndreas Gruenbacher */ 18887be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 18897be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 18907be8da07SAndreas Gruenbacher 18917be8da07SAndreas Gruenbacher if (!equal) 18927be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 18937be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 18947be8da07SAndreas Gruenbacher "assuming %s came first\n", 18957be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 18967be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 18977be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 18987be8da07SAndreas Gruenbacher 18997be8da07SAndreas Gruenbacher inc_unacked(mdev); 19007be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 19017be8da07SAndreas Gruenbacher e_send_retry_write; 19027be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 19037be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 19047be8da07SAndreas Gruenbacher 19057be8da07SAndreas Gruenbacher err = -ENOENT; 19067be8da07SAndreas Gruenbacher goto out; 19077be8da07SAndreas Gruenbacher } else { 19087be8da07SAndreas Gruenbacher struct drbd_request *req = 19097be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 19107be8da07SAndreas Gruenbacher 19117be8da07SAndreas Gruenbacher if (!equal) 19127be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19137be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 19147be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19157be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 19167be8da07SAndreas Gruenbacher 19177be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 19187be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 19197be8da07SAndreas Gruenbacher /* 19207be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 19217be8da07SAndreas Gruenbacher * decide if this request will be discarded or 19227be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 19237be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 19247be8da07SAndreas Gruenbacher * 19257be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 19267be8da07SAndreas Gruenbacher * request to finish locally before submitting 19277be8da07SAndreas Gruenbacher * the conflicting peer request. 19287be8da07SAndreas Gruenbacher */ 19297be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 19307be8da07SAndreas Gruenbacher if (err) { 19317be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 19327be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 19337be8da07SAndreas Gruenbacher CS_HARD); 19347be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 19357be8da07SAndreas Gruenbacher goto out; 19367be8da07SAndreas Gruenbacher } 19377be8da07SAndreas Gruenbacher goto repeat; 19387be8da07SAndreas Gruenbacher } 19397be8da07SAndreas Gruenbacher /* 19407be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 19417be8da07SAndreas Gruenbacher * the new peer request has completed. 19427be8da07SAndreas Gruenbacher */ 19437be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 19447be8da07SAndreas Gruenbacher } 19457be8da07SAndreas Gruenbacher } 19467be8da07SAndreas Gruenbacher err = 0; 19477be8da07SAndreas Gruenbacher 19487be8da07SAndreas Gruenbacher out: 19497be8da07SAndreas Gruenbacher if (err) 19507be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 19517be8da07SAndreas Gruenbacher return err; 19527be8da07SAndreas Gruenbacher } 19537be8da07SAndreas Gruenbacher 1954b411b363SPhilipp Reisner /* mirrored write */ 1955d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1956d8763023SAndreas Gruenbacher unsigned int data_size) 1957b411b363SPhilipp Reisner { 1958b411b363SPhilipp Reisner sector_t sector; 1959db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1960e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 19617be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 1962b411b363SPhilipp Reisner int rw = WRITE; 1963b411b363SPhilipp Reisner u32 dp_flags; 19647be8da07SAndreas Gruenbacher int err; 19657be8da07SAndreas Gruenbacher 1966b411b363SPhilipp Reisner 1967b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 19687be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 19692b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1970b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 19717be8da07SAndreas Gruenbacher return drbd_drain_block(mdev, data_size) && err == 0; 1972b411b363SPhilipp Reisner } 1973b411b363SPhilipp Reisner 1974fcefa62eSAndreas Gruenbacher /* 1975fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 1976fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 1977fcefa62eSAndreas Gruenbacher * end of this function. 1978fcefa62eSAndreas Gruenbacher */ 1979b411b363SPhilipp Reisner 1980b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1981db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, data_size); 1982db830c46SAndreas Gruenbacher if (!peer_req) { 1983b411b363SPhilipp Reisner put_ldev(mdev); 198481e84650SAndreas Gruenbacher return false; 1985b411b363SPhilipp Reisner } 1986b411b363SPhilipp Reisner 1987db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 1988b411b363SPhilipp Reisner 1989688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 1990688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 1991688593c5SLars Ellenberg 1992688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 1993db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 1994688593c5SLars Ellenberg 1995b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1996db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 1997db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 1998db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 1999b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2000b411b363SPhilipp Reisner 20017be8da07SAndreas Gruenbacher if (mdev->tconn->net_conf->two_primaries) { 20027be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 20037be8da07SAndreas Gruenbacher if (err) 2004b411b363SPhilipp Reisner goto out_interrupted; 200587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 20067be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 20077be8da07SAndreas Gruenbacher if (err) { 200887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 20097be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2010b411b363SPhilipp Reisner put_ldev(mdev); 201181e84650SAndreas Gruenbacher return true; 2012b411b363SPhilipp Reisner } 2013b411b363SPhilipp Reisner goto out_interrupted; 2014b411b363SPhilipp Reisner } 20157be8da07SAndreas Gruenbacher } else 201687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2017db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 201887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2019b411b363SPhilipp Reisner 202089e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 2021b411b363SPhilipp Reisner case DRBD_PROT_C: 2022b411b363SPhilipp Reisner inc_unacked(mdev); 2023b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2024b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2025b411b363SPhilipp Reisner break; 2026b411b363SPhilipp Reisner case DRBD_PROT_B: 2027b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2028b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2029db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2030b411b363SPhilipp Reisner break; 2031b411b363SPhilipp Reisner case DRBD_PROT_A: 2032b411b363SPhilipp Reisner /* nothing to do */ 2033b411b363SPhilipp Reisner break; 2034b411b363SPhilipp Reisner } 2035b411b363SPhilipp Reisner 20366719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2037b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2038db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2039db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2040db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2041db830c46SAndreas Gruenbacher drbd_al_begin_io(mdev, peer_req->i.sector); 2042b411b363SPhilipp Reisner } 2043b411b363SPhilipp Reisner 2044fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR) == 0) 204581e84650SAndreas Gruenbacher return true; 2046b411b363SPhilipp Reisner 204710f6d992SLars Ellenberg /* don't care for the reason here */ 204810f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 204987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2050db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2051db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 205287eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2053db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2054db830c46SAndreas Gruenbacher drbd_al_complete_io(mdev, peer_req->i.sector); 205522cc37a9SLars Ellenberg 2056b411b363SPhilipp Reisner out_interrupted: 2057db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2058b411b363SPhilipp Reisner put_ldev(mdev); 2059db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 206081e84650SAndreas Gruenbacher return false; 2061b411b363SPhilipp Reisner } 2062b411b363SPhilipp Reisner 20630f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 20640f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 20650f0601f4SLars Ellenberg * 20660f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 20670f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 20680f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 20690f0601f4SLars Ellenberg * activity, it obviously is "busy". 20700f0601f4SLars Ellenberg * 20710f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 20720f0601f4SLars Ellenberg * to have a short time average so we can react faster. 20730f0601f4SLars Ellenberg */ 2074e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 20750f0601f4SLars Ellenberg { 20760f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 20770f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2078e3555d85SPhilipp Reisner struct lc_element *tmp; 20790f0601f4SLars Ellenberg int curr_events; 20800f0601f4SLars Ellenberg int throttle = 0; 20810f0601f4SLars Ellenberg 20820f0601f4SLars Ellenberg /* feature disabled? */ 20830f0601f4SLars Ellenberg if (mdev->sync_conf.c_min_rate == 0) 20840f0601f4SLars Ellenberg return 0; 20850f0601f4SLars Ellenberg 2086e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2087e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2088e3555d85SPhilipp Reisner if (tmp) { 2089e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2090e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2091e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2092e3555d85SPhilipp Reisner return 0; 2093e3555d85SPhilipp Reisner } 2094e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2095e3555d85SPhilipp Reisner } 2096e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2097e3555d85SPhilipp Reisner 20980f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 20990f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 21000f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2101e3555d85SPhilipp Reisner 21020f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 21030f0601f4SLars Ellenberg unsigned long rs_left; 21040f0601f4SLars Ellenberg int i; 21050f0601f4SLars Ellenberg 21060f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 21070f0601f4SLars Ellenberg 21080f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 21090f0601f4SLars Ellenberg * approx. */ 21102649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 21112649f080SLars Ellenberg 21122649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 21132649f080SLars Ellenberg rs_left = mdev->ov_left; 21142649f080SLars Ellenberg else 21150f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 21160f0601f4SLars Ellenberg 21170f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 21180f0601f4SLars Ellenberg if (!dt) 21190f0601f4SLars Ellenberg dt++; 21200f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 21210f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 21220f0601f4SLars Ellenberg 21230f0601f4SLars Ellenberg if (dbdt > mdev->sync_conf.c_min_rate) 21240f0601f4SLars Ellenberg throttle = 1; 21250f0601f4SLars Ellenberg } 21260f0601f4SLars Ellenberg return throttle; 21270f0601f4SLars Ellenberg } 21280f0601f4SLars Ellenberg 21290f0601f4SLars Ellenberg 2130d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2131d8763023SAndreas Gruenbacher unsigned int digest_size) 2132b411b363SPhilipp Reisner { 2133b411b363SPhilipp Reisner sector_t sector; 2134b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2135db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2136b411b363SPhilipp Reisner struct digest_info *di = NULL; 2137b18b37beSPhilipp Reisner int size, verb; 2138b411b363SPhilipp Reisner unsigned int fault_type; 2139e42325a5SPhilipp Reisner struct p_block_req *p = &mdev->tconn->data.rbuf.block_req; 2140b411b363SPhilipp Reisner 2141b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2142b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2143b411b363SPhilipp Reisner 2144c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2145b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2146b411b363SPhilipp Reisner (unsigned long long)sector, size); 214781e84650SAndreas Gruenbacher return false; 2148b411b363SPhilipp Reisner } 2149b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2150b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2151b411b363SPhilipp Reisner (unsigned long long)sector, size); 215281e84650SAndreas Gruenbacher return false; 2153b411b363SPhilipp Reisner } 2154b411b363SPhilipp Reisner 2155b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2156b18b37beSPhilipp Reisner verb = 1; 2157b18b37beSPhilipp Reisner switch (cmd) { 2158b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2159b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2160b18b37beSPhilipp Reisner break; 2161b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2162b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2163b18b37beSPhilipp Reisner case P_OV_REQUEST: 2164b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2165b18b37beSPhilipp Reisner break; 2166b18b37beSPhilipp Reisner case P_OV_REPLY: 2167b18b37beSPhilipp Reisner verb = 0; 2168b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2169b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2170b18b37beSPhilipp Reisner break; 2171b18b37beSPhilipp Reisner default: 2172b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2173b18b37beSPhilipp Reisner cmdname(cmd)); 2174b18b37beSPhilipp Reisner } 2175b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2176b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2177b411b363SPhilipp Reisner "no local data.\n"); 2178b18b37beSPhilipp Reisner 2179a821cc4aSLars Ellenberg /* drain possibly payload */ 2180a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 2181b411b363SPhilipp Reisner } 2182b411b363SPhilipp Reisner 2183b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2184b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2185b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2186db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2187db830c46SAndreas Gruenbacher if (!peer_req) { 2188b411b363SPhilipp Reisner put_ldev(mdev); 218981e84650SAndreas Gruenbacher return false; 2190b411b363SPhilipp Reisner } 2191b411b363SPhilipp Reisner 219202918be2SPhilipp Reisner switch (cmd) { 2193b411b363SPhilipp Reisner case P_DATA_REQUEST: 2194db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2195b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 219680a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 219780a40e43SLars Ellenberg goto submit; 219880a40e43SLars Ellenberg 2199b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2200db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2201b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 22025f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22035f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2204b411b363SPhilipp Reisner break; 2205b411b363SPhilipp Reisner 2206b411b363SPhilipp Reisner case P_OV_REPLY: 2207b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2208b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2209b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2210b411b363SPhilipp Reisner if (!di) 2211b411b363SPhilipp Reisner goto out_free_e; 2212b411b363SPhilipp Reisner 2213b411b363SPhilipp Reisner di->digest_size = digest_size; 2214b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2215b411b363SPhilipp Reisner 2216db830c46SAndreas Gruenbacher peer_req->digest = di; 2217db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2218c36c3cedSLars Ellenberg 2219de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, di->digest, digest_size) != digest_size) 2220b411b363SPhilipp Reisner goto out_free_e; 2221b411b363SPhilipp Reisner 222202918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 222331890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2224db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 22255f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22265f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 222702918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 22282649f080SLars Ellenberg /* track progress, we may need to throttle */ 22292649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2230db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2231b411b363SPhilipp Reisner dec_rs_pending(mdev); 22320f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 22330f0601f4SLars Ellenberg * but accounting still needs to be done. */ 22340f0601f4SLars Ellenberg goto submit_for_resync; 2235b411b363SPhilipp Reisner } 2236b411b363SPhilipp Reisner break; 2237b411b363SPhilipp Reisner 2238b411b363SPhilipp Reisner case P_OV_REQUEST: 2239b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 224031890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2241de228bbaSLars Ellenberg unsigned long now = jiffies; 2242de228bbaSLars Ellenberg int i; 2243b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2244b411b363SPhilipp Reisner mdev->ov_position = sector; 224530b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 224630b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2247de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2248de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2249de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2250de228bbaSLars Ellenberg } 2251b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2252b411b363SPhilipp Reisner (unsigned long long)sector); 2253b411b363SPhilipp Reisner } 2254db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2255b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2256b411b363SPhilipp Reisner break; 2257b411b363SPhilipp Reisner 2258b411b363SPhilipp Reisner default: 2259b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 226002918be2SPhilipp Reisner cmdname(cmd)); 2261b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 226280a40e43SLars Ellenberg goto out_free_e; 2263b411b363SPhilipp Reisner } 2264b411b363SPhilipp Reisner 22650f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 22660f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 22670f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 22680f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 22690f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 22700f0601f4SLars Ellenberg * 22710f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 22720f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 22730f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 22740f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 22750f0601f4SLars Ellenberg * a while, anyways. 22760f0601f4SLars Ellenberg */ 2277b411b363SPhilipp Reisner 22780f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 22790f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 22800f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 22810f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 22820f0601f4SLars Ellenberg * 22830f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 22840f0601f4SLars Ellenberg * we would also throttle its application reads. 22850f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 22860f0601f4SLars Ellenberg */ 2287e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2288e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2289e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 229080a40e43SLars Ellenberg goto out_free_e; 2291b411b363SPhilipp Reisner 22920f0601f4SLars Ellenberg submit_for_resync: 22930f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 22940f0601f4SLars Ellenberg 229580a40e43SLars Ellenberg submit: 2296b411b363SPhilipp Reisner inc_unacked(mdev); 229787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2298db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 229987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2300b411b363SPhilipp Reisner 2301fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 230281e84650SAndreas Gruenbacher return true; 2303b411b363SPhilipp Reisner 230410f6d992SLars Ellenberg /* don't care for the reason here */ 230510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 230687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2307db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 230887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 230922cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 231022cc37a9SLars Ellenberg 2311b411b363SPhilipp Reisner out_free_e: 2312b411b363SPhilipp Reisner put_ldev(mdev); 2313db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 231481e84650SAndreas Gruenbacher return false; 2315b411b363SPhilipp Reisner } 2316b411b363SPhilipp Reisner 2317b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2318b411b363SPhilipp Reisner { 2319b411b363SPhilipp Reisner int self, peer, rv = -100; 2320b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2321b411b363SPhilipp Reisner 2322b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2323b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2324b411b363SPhilipp Reisner 2325b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2326b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2327b411b363SPhilipp Reisner 232889e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2329b411b363SPhilipp Reisner case ASB_CONSENSUS: 2330b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2331b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2332b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2333b411b363SPhilipp Reisner break; 2334b411b363SPhilipp Reisner case ASB_DISCONNECT: 2335b411b363SPhilipp Reisner break; 2336b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2337b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2338b411b363SPhilipp Reisner rv = -1; 2339b411b363SPhilipp Reisner break; 2340b411b363SPhilipp Reisner } 2341b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2342b411b363SPhilipp Reisner rv = 1; 2343b411b363SPhilipp Reisner break; 2344b411b363SPhilipp Reisner } 2345b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2346b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2347b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2348b411b363SPhilipp Reisner rv = 1; 2349b411b363SPhilipp Reisner break; 2350b411b363SPhilipp Reisner } 2351b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2352b411b363SPhilipp Reisner rv = -1; 2353b411b363SPhilipp Reisner break; 2354b411b363SPhilipp Reisner } 2355b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2356ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2357b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2358b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2359b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 236025703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2361b411b363SPhilipp Reisner ? -1 : 1; 2362b411b363SPhilipp Reisner break; 2363b411b363SPhilipp Reisner } else { 2364b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2365b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2366b411b363SPhilipp Reisner } 236789e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2368b411b363SPhilipp Reisner break; 2369b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2370b411b363SPhilipp Reisner if (ch_self < ch_peer) 2371b411b363SPhilipp Reisner rv = -1; 2372b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2373b411b363SPhilipp Reisner rv = 1; 2374b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2375b411b363SPhilipp Reisner /* Well, then use something else. */ 237625703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2377b411b363SPhilipp Reisner ? -1 : 1; 2378b411b363SPhilipp Reisner break; 2379b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2380b411b363SPhilipp Reisner rv = -1; 2381b411b363SPhilipp Reisner break; 2382b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2383b411b363SPhilipp Reisner rv = 1; 2384b411b363SPhilipp Reisner } 2385b411b363SPhilipp Reisner 2386b411b363SPhilipp Reisner return rv; 2387b411b363SPhilipp Reisner } 2388b411b363SPhilipp Reisner 2389b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2390b411b363SPhilipp Reisner { 23916184ea21SAndreas Gruenbacher int hg, rv = -100; 2392b411b363SPhilipp Reisner 239389e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2394b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2395b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2396b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2397b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2398b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2399b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2400b411b363SPhilipp Reisner break; 2401b411b363SPhilipp Reisner case ASB_DISCONNECT: 2402b411b363SPhilipp Reisner break; 2403b411b363SPhilipp Reisner case ASB_CONSENSUS: 2404b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2405b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2406b411b363SPhilipp Reisner rv = hg; 2407b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2408b411b363SPhilipp Reisner rv = hg; 2409b411b363SPhilipp Reisner break; 2410b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2411b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2412b411b363SPhilipp Reisner break; 2413b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2414b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2415b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2416b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2417b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2418bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2419bb437946SAndreas Gruenbacher 2420bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2421b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2422b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2423b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2424bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2425bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2426b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2427b411b363SPhilipp Reisner } else { 2428b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2429b411b363SPhilipp Reisner rv = hg; 2430b411b363SPhilipp Reisner } 2431b411b363SPhilipp Reisner } else 2432b411b363SPhilipp Reisner rv = hg; 2433b411b363SPhilipp Reisner } 2434b411b363SPhilipp Reisner 2435b411b363SPhilipp Reisner return rv; 2436b411b363SPhilipp Reisner } 2437b411b363SPhilipp Reisner 2438b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2439b411b363SPhilipp Reisner { 24406184ea21SAndreas Gruenbacher int hg, rv = -100; 2441b411b363SPhilipp Reisner 244289e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2443b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2444b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2445b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2446b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2447b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2448b411b363SPhilipp Reisner case ASB_CONSENSUS: 2449b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2450b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2451b411b363SPhilipp Reisner break; 2452b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2453b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2454b411b363SPhilipp Reisner break; 2455b411b363SPhilipp Reisner case ASB_DISCONNECT: 2456b411b363SPhilipp Reisner break; 2457b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2458b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2459b411b363SPhilipp Reisner if (hg == -1) { 2460bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2461bb437946SAndreas Gruenbacher 2462b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2463b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2464b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2465bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2466bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2467b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2468b411b363SPhilipp Reisner } else { 2469b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2470b411b363SPhilipp Reisner rv = hg; 2471b411b363SPhilipp Reisner } 2472b411b363SPhilipp Reisner } else 2473b411b363SPhilipp Reisner rv = hg; 2474b411b363SPhilipp Reisner } 2475b411b363SPhilipp Reisner 2476b411b363SPhilipp Reisner return rv; 2477b411b363SPhilipp Reisner } 2478b411b363SPhilipp Reisner 2479b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2480b411b363SPhilipp Reisner u64 bits, u64 flags) 2481b411b363SPhilipp Reisner { 2482b411b363SPhilipp Reisner if (!uuid) { 2483b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2484b411b363SPhilipp Reisner return; 2485b411b363SPhilipp Reisner } 2486b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2487b411b363SPhilipp Reisner text, 2488b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2489b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2490b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2491b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2492b411b363SPhilipp Reisner (unsigned long long)bits, 2493b411b363SPhilipp Reisner (unsigned long long)flags); 2494b411b363SPhilipp Reisner } 2495b411b363SPhilipp Reisner 2496b411b363SPhilipp Reisner /* 2497b411b363SPhilipp Reisner 100 after split brain try auto recover 2498b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2499b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2500b411b363SPhilipp Reisner 0 no Sync 2501b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2502b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2503b411b363SPhilipp Reisner -100 after split brain, disconnect 2504b411b363SPhilipp Reisner -1000 unrelated data 25054a23f264SPhilipp Reisner -1091 requires proto 91 25064a23f264SPhilipp Reisner -1096 requires proto 96 2507b411b363SPhilipp Reisner */ 2508b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2509b411b363SPhilipp Reisner { 2510b411b363SPhilipp Reisner u64 self, peer; 2511b411b363SPhilipp Reisner int i, j; 2512b411b363SPhilipp Reisner 2513b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2514b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2515b411b363SPhilipp Reisner 2516b411b363SPhilipp Reisner *rule_nr = 10; 2517b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2518b411b363SPhilipp Reisner return 0; 2519b411b363SPhilipp Reisner 2520b411b363SPhilipp Reisner *rule_nr = 20; 2521b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2522b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2523b411b363SPhilipp Reisner return -2; 2524b411b363SPhilipp Reisner 2525b411b363SPhilipp Reisner *rule_nr = 30; 2526b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2527b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2528b411b363SPhilipp Reisner return 2; 2529b411b363SPhilipp Reisner 2530b411b363SPhilipp Reisner if (self == peer) { 2531b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2532b411b363SPhilipp Reisner 2533b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2534b411b363SPhilipp Reisner 253531890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25364a23f264SPhilipp Reisner return -1091; 2537b411b363SPhilipp Reisner 2538b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2539b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2540b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2541b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2542b411b363SPhilipp Reisner 2543b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2544b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2545b411b363SPhilipp Reisner *rule_nr = 34; 2546b411b363SPhilipp Reisner } else { 2547b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2548b411b363SPhilipp Reisner *rule_nr = 36; 2549b411b363SPhilipp Reisner } 2550b411b363SPhilipp Reisner 2551b411b363SPhilipp Reisner return 1; 2552b411b363SPhilipp Reisner } 2553b411b363SPhilipp Reisner 2554b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2555b411b363SPhilipp Reisner 255631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25574a23f264SPhilipp Reisner return -1091; 2558b411b363SPhilipp Reisner 2559b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2560b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2561b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2562b411b363SPhilipp Reisner 2563b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2564b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2565b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2566b411b363SPhilipp Reisner 2567b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2568b411b363SPhilipp Reisner *rule_nr = 35; 2569b411b363SPhilipp Reisner } else { 2570b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2571b411b363SPhilipp Reisner *rule_nr = 37; 2572b411b363SPhilipp Reisner } 2573b411b363SPhilipp Reisner 2574b411b363SPhilipp Reisner return -1; 2575b411b363SPhilipp Reisner } 2576b411b363SPhilipp Reisner 2577b411b363SPhilipp Reisner /* Common power [off|failure] */ 2578b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2579b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2580b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2581b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2582b411b363SPhilipp Reisner *rule_nr = 40; 2583b411b363SPhilipp Reisner 2584b411b363SPhilipp Reisner switch (rct) { 2585b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2586b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2587b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2588b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 258925703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2590b411b363SPhilipp Reisner return dc ? -1 : 1; 2591b411b363SPhilipp Reisner } 2592b411b363SPhilipp Reisner } 2593b411b363SPhilipp Reisner 2594b411b363SPhilipp Reisner *rule_nr = 50; 2595b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2596b411b363SPhilipp Reisner if (self == peer) 2597b411b363SPhilipp Reisner return -1; 2598b411b363SPhilipp Reisner 2599b411b363SPhilipp Reisner *rule_nr = 51; 2600b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2601b411b363SPhilipp Reisner if (self == peer) { 260231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26034a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 26044a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 26054a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2606b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2607b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2608b411b363SPhilipp Reisner 260931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26104a23f264SPhilipp Reisner return -1091; 2611b411b363SPhilipp Reisner 2612b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2613b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 26144a23f264SPhilipp Reisner 26154a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 26164a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 26174a23f264SPhilipp Reisner 2618b411b363SPhilipp Reisner return -1; 2619b411b363SPhilipp Reisner } 2620b411b363SPhilipp Reisner } 2621b411b363SPhilipp Reisner 2622b411b363SPhilipp Reisner *rule_nr = 60; 2623b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2624b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2625b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2626b411b363SPhilipp Reisner if (self == peer) 2627b411b363SPhilipp Reisner return -2; 2628b411b363SPhilipp Reisner } 2629b411b363SPhilipp Reisner 2630b411b363SPhilipp Reisner *rule_nr = 70; 2631b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2632b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2633b411b363SPhilipp Reisner if (self == peer) 2634b411b363SPhilipp Reisner return 1; 2635b411b363SPhilipp Reisner 2636b411b363SPhilipp Reisner *rule_nr = 71; 2637b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2638b411b363SPhilipp Reisner if (self == peer) { 263931890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26404a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 26414a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 26424a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2643b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2644b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2645b411b363SPhilipp Reisner 264631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26474a23f264SPhilipp Reisner return -1091; 2648b411b363SPhilipp Reisner 2649b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2650b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2651b411b363SPhilipp Reisner 26524a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2653b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2654b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2655b411b363SPhilipp Reisner 2656b411b363SPhilipp Reisner return 1; 2657b411b363SPhilipp Reisner } 2658b411b363SPhilipp Reisner } 2659b411b363SPhilipp Reisner 2660b411b363SPhilipp Reisner 2661b411b363SPhilipp Reisner *rule_nr = 80; 2662d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2663b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2664b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2665b411b363SPhilipp Reisner if (self == peer) 2666b411b363SPhilipp Reisner return 2; 2667b411b363SPhilipp Reisner } 2668b411b363SPhilipp Reisner 2669b411b363SPhilipp Reisner *rule_nr = 90; 2670b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2671b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2672b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2673b411b363SPhilipp Reisner return 100; 2674b411b363SPhilipp Reisner 2675b411b363SPhilipp Reisner *rule_nr = 100; 2676b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2677b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2678b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2679b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2680b411b363SPhilipp Reisner if (self == peer) 2681b411b363SPhilipp Reisner return -100; 2682b411b363SPhilipp Reisner } 2683b411b363SPhilipp Reisner } 2684b411b363SPhilipp Reisner 2685b411b363SPhilipp Reisner return -1000; 2686b411b363SPhilipp Reisner } 2687b411b363SPhilipp Reisner 2688b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2689b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2690b411b363SPhilipp Reisner */ 2691b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2692b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2693b411b363SPhilipp Reisner { 2694b411b363SPhilipp Reisner int hg, rule_nr; 2695b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2696b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2697b411b363SPhilipp Reisner 2698b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2699b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2700b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2701b411b363SPhilipp Reisner 2702b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2703b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2704b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2705b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2706b411b363SPhilipp Reisner 2707b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2708b411b363SPhilipp Reisner 2709b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2710b411b363SPhilipp Reisner 2711b411b363SPhilipp Reisner if (hg == -1000) { 2712b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2713b411b363SPhilipp Reisner return C_MASK; 2714b411b363SPhilipp Reisner } 27154a23f264SPhilipp Reisner if (hg < -1000) { 27164a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2717b411b363SPhilipp Reisner return C_MASK; 2718b411b363SPhilipp Reisner } 2719b411b363SPhilipp Reisner 2720b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2721b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2722b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2723b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2724b411b363SPhilipp Reisner if (f) 2725b411b363SPhilipp Reisner hg = hg*2; 2726b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2727b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2728b411b363SPhilipp Reisner } 2729b411b363SPhilipp Reisner 27303a11a487SAdam Gandelman if (abs(hg) == 100) 27313a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 27323a11a487SAdam Gandelman 273389e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2734b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2735b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2736b411b363SPhilipp Reisner int forced = (hg == -100); 2737b411b363SPhilipp Reisner 2738b411b363SPhilipp Reisner switch (pcount) { 2739b411b363SPhilipp Reisner case 0: 2740b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2741b411b363SPhilipp Reisner break; 2742b411b363SPhilipp Reisner case 1: 2743b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2744b411b363SPhilipp Reisner break; 2745b411b363SPhilipp Reisner case 2: 2746b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2747b411b363SPhilipp Reisner break; 2748b411b363SPhilipp Reisner } 2749b411b363SPhilipp Reisner if (abs(hg) < 100) { 2750b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2751b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2752b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2753b411b363SPhilipp Reisner if (forced) { 2754b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2755b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2756b411b363SPhilipp Reisner hg = hg*2; 2757b411b363SPhilipp Reisner } 2758b411b363SPhilipp Reisner } 2759b411b363SPhilipp Reisner } 2760b411b363SPhilipp Reisner 2761b411b363SPhilipp Reisner if (hg == -100) { 276289e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2763b411b363SPhilipp Reisner hg = -1; 276489e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2765b411b363SPhilipp Reisner hg = 1; 2766b411b363SPhilipp Reisner 2767b411b363SPhilipp Reisner if (abs(hg) < 100) 2768b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2769b411b363SPhilipp Reisner "Sync from %s node\n", 2770b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2771b411b363SPhilipp Reisner } 2772b411b363SPhilipp Reisner 2773b411b363SPhilipp Reisner if (hg == -100) { 2774580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2775580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2776580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2777580b9767SLars Ellenberg * to that disk, in a way... */ 27783a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2779b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2780b411b363SPhilipp Reisner return C_MASK; 2781b411b363SPhilipp Reisner } 2782b411b363SPhilipp Reisner 2783b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2784b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2785b411b363SPhilipp Reisner return C_MASK; 2786b411b363SPhilipp Reisner } 2787b411b363SPhilipp Reisner 2788b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2789b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 279089e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2791b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2792b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2793b411b363SPhilipp Reisner /* fall through */ 2794b411b363SPhilipp Reisner case ASB_DISCONNECT: 2795b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2796b411b363SPhilipp Reisner return C_MASK; 2797b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2798b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2799b411b363SPhilipp Reisner "assumption\n"); 2800b411b363SPhilipp Reisner } 2801b411b363SPhilipp Reisner } 2802b411b363SPhilipp Reisner 28038169e41bSPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2804cf14c2e9SPhilipp Reisner if (hg == 0) 2805cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2806cf14c2e9SPhilipp Reisner else 2807cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2808cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2809cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2810cf14c2e9SPhilipp Reisner return C_MASK; 2811cf14c2e9SPhilipp Reisner } 2812cf14c2e9SPhilipp Reisner 2813b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2814b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 281520ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 281620ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2817b411b363SPhilipp Reisner return C_MASK; 2818b411b363SPhilipp Reisner } 2819b411b363SPhilipp Reisner 2820b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2821b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2822b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2823b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2824b411b363SPhilipp Reisner } else { 2825b411b363SPhilipp Reisner rv = C_CONNECTED; 2826b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2827b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2828b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2829b411b363SPhilipp Reisner } 2830b411b363SPhilipp Reisner } 2831b411b363SPhilipp Reisner 2832b411b363SPhilipp Reisner return rv; 2833b411b363SPhilipp Reisner } 2834b411b363SPhilipp Reisner 2835b411b363SPhilipp Reisner /* returns 1 if invalid */ 2836b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2837b411b363SPhilipp Reisner { 2838b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2839b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2840b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2841b411b363SPhilipp Reisner return 0; 2842b411b363SPhilipp Reisner 2843b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2844b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2845b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2846b411b363SPhilipp Reisner return 1; 2847b411b363SPhilipp Reisner 2848b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2849b411b363SPhilipp Reisner if (peer == self) 2850b411b363SPhilipp Reisner return 0; 2851b411b363SPhilipp Reisner 2852b411b363SPhilipp Reisner /* everything es is invalid. */ 2853b411b363SPhilipp Reisner return 1; 2854b411b363SPhilipp Reisner } 2855b411b363SPhilipp Reisner 28567204624cSPhilipp Reisner static int receive_protocol(struct drbd_tconn *tconn, enum drbd_packet cmd, 2857d8763023SAndreas Gruenbacher unsigned int data_size) 2858b411b363SPhilipp Reisner { 28597204624cSPhilipp Reisner struct p_protocol *p = &tconn->data.rbuf.protocol; 2860b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2861cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2862b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2863b411b363SPhilipp Reisner 2864b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2865b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2866b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2867b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2868b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2869cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2870cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2871cf14c2e9SPhilipp Reisner 28727204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 2873cf14c2e9SPhilipp Reisner 2874cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 28757204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 2876b411b363SPhilipp Reisner 28777204624cSPhilipp Reisner if (p_proto != tconn->net_conf->wire_protocol) { 28787204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 2879b411b363SPhilipp Reisner goto disconnect; 2880b411b363SPhilipp Reisner } 2881b411b363SPhilipp Reisner 28827204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, tconn->net_conf->after_sb_0p)) { 28837204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 2884b411b363SPhilipp Reisner goto disconnect; 2885b411b363SPhilipp Reisner } 2886b411b363SPhilipp Reisner 28877204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, tconn->net_conf->after_sb_1p)) { 28887204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 2889b411b363SPhilipp Reisner goto disconnect; 2890b411b363SPhilipp Reisner } 2891b411b363SPhilipp Reisner 28927204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, tconn->net_conf->after_sb_2p)) { 28937204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 2894b411b363SPhilipp Reisner goto disconnect; 2895b411b363SPhilipp Reisner } 2896b411b363SPhilipp Reisner 28977204624cSPhilipp Reisner if (p_want_lose && tconn->net_conf->want_lose) { 28987204624cSPhilipp Reisner conn_err(tconn, "both sides have the 'want_lose' flag set\n"); 2899b411b363SPhilipp Reisner goto disconnect; 2900b411b363SPhilipp Reisner } 2901b411b363SPhilipp Reisner 29027204624cSPhilipp Reisner if (p_two_primaries != tconn->net_conf->two_primaries) { 29037204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 2904b411b363SPhilipp Reisner goto disconnect; 2905b411b363SPhilipp Reisner } 2906b411b363SPhilipp Reisner 29077204624cSPhilipp Reisner if (tconn->agreed_pro_version >= 87) { 29087204624cSPhilipp Reisner unsigned char *my_alg = tconn->net_conf->integrity_alg; 2909b411b363SPhilipp Reisner 29107204624cSPhilipp Reisner if (drbd_recv(tconn, p_integrity_alg, data_size) != data_size) 291181e84650SAndreas Gruenbacher return false; 2912b411b363SPhilipp Reisner 2913b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2914b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 29157204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the data-integrity-alg\n"); 2916b411b363SPhilipp Reisner goto disconnect; 2917b411b363SPhilipp Reisner } 29187204624cSPhilipp Reisner conn_info(tconn, "data-integrity-alg: %s\n", 2919b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2920b411b363SPhilipp Reisner } 2921b411b363SPhilipp Reisner 292281e84650SAndreas Gruenbacher return true; 2923b411b363SPhilipp Reisner 2924b411b363SPhilipp Reisner disconnect: 29257204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 292681e84650SAndreas Gruenbacher return false; 2927b411b363SPhilipp Reisner } 2928b411b363SPhilipp Reisner 2929b411b363SPhilipp Reisner /* helper function 2930b411b363SPhilipp Reisner * input: alg name, feature name 2931b411b363SPhilipp Reisner * return: NULL (alg name was "") 2932b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2933b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2934b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2935b411b363SPhilipp Reisner const char *alg, const char *name) 2936b411b363SPhilipp Reisner { 2937b411b363SPhilipp Reisner struct crypto_hash *tfm; 2938b411b363SPhilipp Reisner 2939b411b363SPhilipp Reisner if (!alg[0]) 2940b411b363SPhilipp Reisner return NULL; 2941b411b363SPhilipp Reisner 2942b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2943b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2944b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2945b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2946b411b363SPhilipp Reisner return tfm; 2947b411b363SPhilipp Reisner } 2948b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2949b411b363SPhilipp Reisner crypto_free_hash(tfm); 2950b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2951b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2952b411b363SPhilipp Reisner } 2953b411b363SPhilipp Reisner return tfm; 2954b411b363SPhilipp Reisner } 2955b411b363SPhilipp Reisner 2956d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2957d8763023SAndreas Gruenbacher unsigned int packet_size) 2958b411b363SPhilipp Reisner { 295981e84650SAndreas Gruenbacher int ok = true; 2960e42325a5SPhilipp Reisner struct p_rs_param_95 *p = &mdev->tconn->data.rbuf.rs_param_95; 2961b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2962b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2963b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 296431890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2965778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2966778f271dSPhilipp Reisner int fifo_size = 0; 2967b411b363SPhilipp Reisner 2968b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2969b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2970b411b363SPhilipp Reisner + SHARED_SECRET_MAX 29718e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 29728e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2973b411b363SPhilipp Reisner 297402918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2975b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 297602918be2SPhilipp Reisner packet_size, exp_max_sz); 297781e84650SAndreas Gruenbacher return false; 2978b411b363SPhilipp Reisner } 2979b411b363SPhilipp Reisner 2980b411b363SPhilipp Reisner if (apv <= 88) { 2981257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 298202918be2SPhilipp Reisner data_size = packet_size - header_size; 29838e26f9ccSPhilipp Reisner } else if (apv <= 94) { 2984257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 298502918be2SPhilipp Reisner data_size = packet_size - header_size; 2986b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 29878e26f9ccSPhilipp Reisner } else { 2988257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 298902918be2SPhilipp Reisner data_size = packet_size - header_size; 2990b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2991b411b363SPhilipp Reisner } 2992b411b363SPhilipp Reisner 2993b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2994b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 2995b411b363SPhilipp Reisner 2996de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, &p->head.payload, header_size) != header_size) 299781e84650SAndreas Gruenbacher return false; 2998b411b363SPhilipp Reisner 2999b411b363SPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 3000b411b363SPhilipp Reisner 3001b411b363SPhilipp Reisner if (apv >= 88) { 3002b411b363SPhilipp Reisner if (apv == 88) { 3003b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3004b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3005b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3006b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 300781e84650SAndreas Gruenbacher return false; 3008b411b363SPhilipp Reisner } 3009b411b363SPhilipp Reisner 3010de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->verify_alg, data_size) != data_size) 301181e84650SAndreas Gruenbacher return false; 3012b411b363SPhilipp Reisner 3013b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3014b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3015b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3016b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3017b411b363SPhilipp Reisner 3018b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3019b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3020b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3021b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3022b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3023b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3024b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3025b411b363SPhilipp Reisner } 3026b411b363SPhilipp Reisner 3027b411b363SPhilipp Reisner if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) { 3028b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3029b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 3030b411b363SPhilipp Reisner mdev->sync_conf.verify_alg, p->verify_alg); 3031b411b363SPhilipp Reisner goto disconnect; 3032b411b363SPhilipp Reisner } 3033b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3034b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3035b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3036b411b363SPhilipp Reisner verify_tfm = NULL; 3037b411b363SPhilipp Reisner goto disconnect; 3038b411b363SPhilipp Reisner } 3039b411b363SPhilipp Reisner } 3040b411b363SPhilipp Reisner 3041b411b363SPhilipp Reisner if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) { 3042b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3043b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 3044b411b363SPhilipp Reisner mdev->sync_conf.csums_alg, p->csums_alg); 3045b411b363SPhilipp Reisner goto disconnect; 3046b411b363SPhilipp Reisner } 3047b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3048b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3049b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3050b411b363SPhilipp Reisner csums_tfm = NULL; 3051b411b363SPhilipp Reisner goto disconnect; 3052b411b363SPhilipp Reisner } 3053b411b363SPhilipp Reisner } 3054b411b363SPhilipp Reisner 30558e26f9ccSPhilipp Reisner if (apv > 94) { 30568e26f9ccSPhilipp Reisner mdev->sync_conf.rate = be32_to_cpu(p->rate); 30578e26f9ccSPhilipp Reisner mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 30588e26f9ccSPhilipp Reisner mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target); 30598e26f9ccSPhilipp Reisner mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target); 30608e26f9ccSPhilipp Reisner mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate); 3061778f271dSPhilipp Reisner 3062778f271dSPhilipp Reisner fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3063778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 3064778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 3065778f271dSPhilipp Reisner if (!rs_plan_s) { 3066778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3067778f271dSPhilipp Reisner goto disconnect; 3068778f271dSPhilipp Reisner } 3069778f271dSPhilipp Reisner } 30708e26f9ccSPhilipp Reisner } 3071b411b363SPhilipp Reisner 3072b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 3073b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 3074b411b363SPhilipp Reisner if (verify_tfm) { 3075b411b363SPhilipp Reisner strcpy(mdev->sync_conf.verify_alg, p->verify_alg); 3076b411b363SPhilipp Reisner mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1; 3077b411b363SPhilipp Reisner crypto_free_hash(mdev->verify_tfm); 3078b411b363SPhilipp Reisner mdev->verify_tfm = verify_tfm; 3079b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3080b411b363SPhilipp Reisner } 3081b411b363SPhilipp Reisner if (csums_tfm) { 3082b411b363SPhilipp Reisner strcpy(mdev->sync_conf.csums_alg, p->csums_alg); 3083b411b363SPhilipp Reisner mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1; 3084b411b363SPhilipp Reisner crypto_free_hash(mdev->csums_tfm); 3085b411b363SPhilipp Reisner mdev->csums_tfm = csums_tfm; 3086b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3087b411b363SPhilipp Reisner } 3088778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 3089778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 3090778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 3091778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 3092778f271dSPhilipp Reisner mdev->rs_planed = 0; 3093778f271dSPhilipp Reisner } 3094b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 3095b411b363SPhilipp Reisner } 3096b411b363SPhilipp Reisner 3097b411b363SPhilipp Reisner return ok; 3098b411b363SPhilipp Reisner disconnect: 3099b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3100b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3101b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3102b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3103b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 310438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 310581e84650SAndreas Gruenbacher return false; 3106b411b363SPhilipp Reisner } 3107b411b363SPhilipp Reisner 3108b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3109b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3110b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3111b411b363SPhilipp Reisner { 3112b411b363SPhilipp Reisner sector_t d; 3113b411b363SPhilipp Reisner if (a == 0 || b == 0) 3114b411b363SPhilipp Reisner return; 3115b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3116b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3117b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3118b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3119b411b363SPhilipp Reisner } 3120b411b363SPhilipp Reisner 3121d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 3122d8763023SAndreas Gruenbacher unsigned int data_size) 3123b411b363SPhilipp Reisner { 3124e42325a5SPhilipp Reisner struct p_sizes *p = &mdev->tconn->data.rbuf.sizes; 3125b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3126b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3127b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3128e89b591cSPhilipp Reisner enum dds_flags ddsf; 3129b411b363SPhilipp Reisner 3130b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3131b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3132b411b363SPhilipp Reisner 3133b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3134b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3135b411b363SPhilipp Reisner mdev->p_size = p_size; 3136b411b363SPhilipp Reisner 3137b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3138b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3139b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3140b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3141b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3142b411b363SPhilipp Reisner 3143b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3144b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3145b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3146b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3147b411b363SPhilipp Reisner p_usize); 3148b411b363SPhilipp Reisner 3149b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3150b411b363SPhilipp Reisner 3151b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3152b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3153b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3154b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3155b411b363SPhilipp Reisner } 3156b411b363SPhilipp Reisner 3157b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3158b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3159a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3160b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3161b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3162b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3163b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 316438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3165b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3166b411b363SPhilipp Reisner put_ldev(mdev); 316781e84650SAndreas Gruenbacher return false; 3168b411b363SPhilipp Reisner } 3169b411b363SPhilipp Reisner put_ldev(mdev); 3170b411b363SPhilipp Reisner } 3171b411b363SPhilipp Reisner 3172e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3173b411b363SPhilipp Reisner if (get_ldev(mdev)) { 317424c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3175b411b363SPhilipp Reisner put_ldev(mdev); 3176b411b363SPhilipp Reisner if (dd == dev_size_error) 317781e84650SAndreas Gruenbacher return false; 3178b411b363SPhilipp Reisner drbd_md_sync(mdev); 3179b411b363SPhilipp Reisner } else { 3180b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3181b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3182b411b363SPhilipp Reisner } 3183b411b363SPhilipp Reisner 318499432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 318599432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 318699432fccSPhilipp Reisner 3187b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3188b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3189b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3190b411b363SPhilipp Reisner ldsc = 1; 3191b411b363SPhilipp Reisner } 3192b411b363SPhilipp Reisner 3193b411b363SPhilipp Reisner put_ldev(mdev); 3194b411b363SPhilipp Reisner } 3195b411b363SPhilipp Reisner 3196b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3197b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3198b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3199b411b363SPhilipp Reisner /* we have different sizes, probably peer 3200b411b363SPhilipp Reisner * needs to know my new size... */ 3201e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3202b411b363SPhilipp Reisner } 3203b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3204b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3205b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3206e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3207e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3208e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3209b411b363SPhilipp Reisner else 3210e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3211e89b591cSPhilipp Reisner } else 3212b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3213b411b363SPhilipp Reisner } 3214b411b363SPhilipp Reisner } 3215b411b363SPhilipp Reisner 321681e84650SAndreas Gruenbacher return true; 3217b411b363SPhilipp Reisner } 3218b411b363SPhilipp Reisner 3219d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3220d8763023SAndreas Gruenbacher unsigned int data_size) 3221b411b363SPhilipp Reisner { 3222e42325a5SPhilipp Reisner struct p_uuids *p = &mdev->tconn->data.rbuf.uuids; 3223b411b363SPhilipp Reisner u64 *p_uuid; 322462b0da3aSLars Ellenberg int i, updated_uuids = 0; 3225b411b363SPhilipp Reisner 3226b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3227b411b363SPhilipp Reisner 3228b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3229b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3230b411b363SPhilipp Reisner 3231b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3232b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3233b411b363SPhilipp Reisner 3234b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3235b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3236b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3237b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3238b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3239b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 324038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 324181e84650SAndreas Gruenbacher return false; 3242b411b363SPhilipp Reisner } 3243b411b363SPhilipp Reisner 3244b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3245b411b363SPhilipp Reisner int skip_initial_sync = 3246b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 324731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3248b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3249b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3250b411b363SPhilipp Reisner if (skip_initial_sync) { 3251b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3252b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 325320ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 325420ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3255b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3256b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3257b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3258b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3259b411b363SPhilipp Reisner drbd_md_sync(mdev); 326062b0da3aSLars Ellenberg updated_uuids = 1; 3261b411b363SPhilipp Reisner } 3262b411b363SPhilipp Reisner put_ldev(mdev); 326318a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 326418a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 326518a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 326618a50fa2SPhilipp Reisner for me. */ 326762b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3268b411b363SPhilipp Reisner } 3269b411b363SPhilipp Reisner 3270b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3271b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3272b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3273b411b363SPhilipp Reisner new disk state... */ 32748410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 32758410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3276b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 327762b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 327862b0da3aSLars Ellenberg 327962b0da3aSLars Ellenberg if (updated_uuids) 328062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3281b411b363SPhilipp Reisner 328281e84650SAndreas Gruenbacher return true; 3283b411b363SPhilipp Reisner } 3284b411b363SPhilipp Reisner 3285b411b363SPhilipp Reisner /** 3286b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3287b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3288b411b363SPhilipp Reisner */ 3289b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3290b411b363SPhilipp Reisner { 3291b411b363SPhilipp Reisner union drbd_state ms; 3292b411b363SPhilipp Reisner 3293b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3294b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3295b411b363SPhilipp Reisner 3296b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3297b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3298b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3299b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3300b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3301b411b363SPhilipp Reisner }; 3302b411b363SPhilipp Reisner 3303b411b363SPhilipp Reisner ms.i = ps.i; 3304b411b363SPhilipp Reisner 3305b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3306b411b363SPhilipp Reisner ms.peer = ps.role; 3307b411b363SPhilipp Reisner ms.role = ps.peer; 3308b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3309b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3310b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3311b411b363SPhilipp Reisner 3312b411b363SPhilipp Reisner return ms; 3313b411b363SPhilipp Reisner } 3314b411b363SPhilipp Reisner 3315d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3316d8763023SAndreas Gruenbacher unsigned int data_size) 3317b411b363SPhilipp Reisner { 3318e42325a5SPhilipp Reisner struct p_req_state *p = &mdev->tconn->data.rbuf.req_state; 3319b411b363SPhilipp Reisner union drbd_state mask, val; 3320bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3321b411b363SPhilipp Reisner 3322b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3323b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3324b411b363SPhilipp Reisner 332525703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 33268410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3327b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 332881e84650SAndreas Gruenbacher return true; 3329b411b363SPhilipp Reisner } 3330b411b363SPhilipp Reisner 3331b411b363SPhilipp Reisner mask = convert_state(mask); 3332b411b363SPhilipp Reisner val = convert_state(val); 3333b411b363SPhilipp Reisner 3334b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3335b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3336047cd4a6SPhilipp Reisner 3337b411b363SPhilipp Reisner drbd_md_sync(mdev); 3338b411b363SPhilipp Reisner 333981e84650SAndreas Gruenbacher return true; 3340b411b363SPhilipp Reisner } 3341b411b363SPhilipp Reisner 3342dfafcc8aSPhilipp Reisner static int receive_req_conn_state(struct drbd_tconn *tconn, enum drbd_packet cmd, 3343dfafcc8aSPhilipp Reisner unsigned int data_size) 3344dfafcc8aSPhilipp Reisner { 3345dfafcc8aSPhilipp Reisner struct p_req_state *p = &tconn->data.rbuf.req_state; 3346dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3347dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3348dfafcc8aSPhilipp Reisner 3349dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3350dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3351dfafcc8aSPhilipp Reisner 3352dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3353dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3354dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 3355dfafcc8aSPhilipp Reisner return true; 3356dfafcc8aSPhilipp Reisner } 3357dfafcc8aSPhilipp Reisner 3358dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3359dfafcc8aSPhilipp Reisner val = convert_state(val); 3360dfafcc8aSPhilipp Reisner 3361dfafcc8aSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY); 3362dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3363dfafcc8aSPhilipp Reisner 3364dfafcc8aSPhilipp Reisner return true; 3365dfafcc8aSPhilipp Reisner } 3366dfafcc8aSPhilipp Reisner 3367d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3368d8763023SAndreas Gruenbacher unsigned int data_size) 3369b411b363SPhilipp Reisner { 3370e42325a5SPhilipp Reisner struct p_state *p = &mdev->tconn->data.rbuf.state; 33714ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3372b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 337365d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3374b411b363SPhilipp Reisner int rv; 3375b411b363SPhilipp Reisner 3376b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3377b411b363SPhilipp Reisner 3378b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3379b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3380b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3381b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3382b411b363SPhilipp Reisner } 3383b411b363SPhilipp Reisner 338487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3385b411b363SPhilipp Reisner retry: 33864ac4aadaSLars Ellenberg os = ns = mdev->state; 338787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3388b411b363SPhilipp Reisner 3389e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3390e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3391e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3392e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3393e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3394e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3395e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3396e9ef7bb6SLars Ellenberg * syncing states. 3397e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3398e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3399e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3400e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3401e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3402e9ef7bb6SLars Ellenberg 3403e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3404e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3405e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3406e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3407e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3408e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3409e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 341081e84650SAndreas Gruenbacher return true; 3411e9ef7bb6SLars Ellenberg } 3412e9ef7bb6SLars Ellenberg } 3413e9ef7bb6SLars Ellenberg 3414e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3415e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3416e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3417e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3418e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3419e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3420e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3421e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3422e9ef7bb6SLars Ellenberg 34234ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 34244ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3425b411b363SPhilipp Reisner 342667531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 342767531718SPhilipp Reisner ns.conn = C_BEHIND; 342867531718SPhilipp Reisner 3429b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3430b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3431b411b363SPhilipp Reisner int cr; /* consider resync */ 3432b411b363SPhilipp Reisner 3433b411b363SPhilipp Reisner /* if we established a new connection */ 34344ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3435b411b363SPhilipp Reisner /* if we had an established connection 3436b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 34374ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3438b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 34394ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3440b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3441b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3442b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3443b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3444b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 34454ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3446b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3447b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3448b411b363SPhilipp Reisner 3449b411b363SPhilipp Reisner if (cr) 34504ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3451b411b363SPhilipp Reisner 3452b411b363SPhilipp Reisner put_ldev(mdev); 34534ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 34544ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3455b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 345682f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3457b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3458b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3459b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3460580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3461b411b363SPhilipp Reisner } else { 34628169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 346381e84650SAndreas Gruenbacher return false; 34644ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 346538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 346681e84650SAndreas Gruenbacher return false; 3467b411b363SPhilipp Reisner } 3468b411b363SPhilipp Reisner } 3469b411b363SPhilipp Reisner } 3470b411b363SPhilipp Reisner 347187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 34724ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3473b411b363SPhilipp Reisner goto retry; 3474b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3475b411b363SPhilipp Reisner ns.peer = peer_state.role; 3476b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3477b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 34784ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3479b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 34804ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 34814ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3482481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 34838554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3484481c6f50SPhilipp Reisner for temporal network outages! */ 348587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3486481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 34872f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3488481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3489481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 349038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 349181e84650SAndreas Gruenbacher return false; 3492481c6f50SPhilipp Reisner } 349365d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3494b411b363SPhilipp Reisner ns = mdev->state; 349587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3496b411b363SPhilipp Reisner 3497b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 349838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 349981e84650SAndreas Gruenbacher return false; 3500b411b363SPhilipp Reisner } 3501b411b363SPhilipp Reisner 35024ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 35034ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3504b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3505b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3506b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3507b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3508b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3509b411b363SPhilipp Reisner drbd_send_state(mdev); 3510b411b363SPhilipp Reisner } 3511b411b363SPhilipp Reisner } 3512b411b363SPhilipp Reisner 351389e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3514b411b363SPhilipp Reisner 3515b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3516b411b363SPhilipp Reisner 351781e84650SAndreas Gruenbacher return true; 3518b411b363SPhilipp Reisner } 3519b411b363SPhilipp Reisner 3520d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3521d8763023SAndreas Gruenbacher unsigned int data_size) 3522b411b363SPhilipp Reisner { 3523e42325a5SPhilipp Reisner struct p_rs_uuid *p = &mdev->tconn->data.rbuf.rs_uuid; 3524b411b363SPhilipp Reisner 3525b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3526b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3527c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3528b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3529b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3530b411b363SPhilipp Reisner 3531b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3532b411b363SPhilipp Reisner 3533b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3534b411b363SPhilipp Reisner _not_ be rotated into the history */ 3535b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3536b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3537b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3538b411b363SPhilipp Reisner 353962b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3540b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3541b411b363SPhilipp Reisner 3542b411b363SPhilipp Reisner put_ldev(mdev); 3543b411b363SPhilipp Reisner } else 3544b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3545b411b363SPhilipp Reisner 354681e84650SAndreas Gruenbacher return true; 3547b411b363SPhilipp Reisner } 3548b411b363SPhilipp Reisner 35492c46407dSAndreas Gruenbacher /** 35502c46407dSAndreas Gruenbacher * receive_bitmap_plain 35512c46407dSAndreas Gruenbacher * 35522c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35532c46407dSAndreas Gruenbacher * code upon failure. 35542c46407dSAndreas Gruenbacher */ 35552c46407dSAndreas Gruenbacher static int 355602918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3557b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3558b411b363SPhilipp Reisner { 3559b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3560b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 35612c46407dSAndreas Gruenbacher int err; 3562b411b363SPhilipp Reisner 356302918be2SPhilipp Reisner if (want != data_size) { 356402918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 35652c46407dSAndreas Gruenbacher return -EIO; 3566b411b363SPhilipp Reisner } 3567b411b363SPhilipp Reisner if (want == 0) 35682c46407dSAndreas Gruenbacher return 0; 3569de0ff338SPhilipp Reisner err = drbd_recv(mdev->tconn, buffer, want); 35702c46407dSAndreas Gruenbacher if (err != want) { 35712c46407dSAndreas Gruenbacher if (err >= 0) 35722c46407dSAndreas Gruenbacher err = -EIO; 35732c46407dSAndreas Gruenbacher return err; 35742c46407dSAndreas Gruenbacher } 3575b411b363SPhilipp Reisner 3576b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3577b411b363SPhilipp Reisner 3578b411b363SPhilipp Reisner c->word_offset += num_words; 3579b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3580b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3581b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3582b411b363SPhilipp Reisner 35832c46407dSAndreas Gruenbacher return 1; 3584b411b363SPhilipp Reisner } 3585b411b363SPhilipp Reisner 35862c46407dSAndreas Gruenbacher /** 35872c46407dSAndreas Gruenbacher * recv_bm_rle_bits 35882c46407dSAndreas Gruenbacher * 35892c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35902c46407dSAndreas Gruenbacher * code upon failure. 35912c46407dSAndreas Gruenbacher */ 35922c46407dSAndreas Gruenbacher static int 3593b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3594b411b363SPhilipp Reisner struct p_compressed_bm *p, 3595c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3596c6d25cfeSPhilipp Reisner unsigned int len) 3597b411b363SPhilipp Reisner { 3598b411b363SPhilipp Reisner struct bitstream bs; 3599b411b363SPhilipp Reisner u64 look_ahead; 3600b411b363SPhilipp Reisner u64 rl; 3601b411b363SPhilipp Reisner u64 tmp; 3602b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3603b411b363SPhilipp Reisner unsigned long e; 3604b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3605b411b363SPhilipp Reisner int have; 3606b411b363SPhilipp Reisner int bits; 3607b411b363SPhilipp Reisner 3608b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3609b411b363SPhilipp Reisner 3610b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3611b411b363SPhilipp Reisner if (bits < 0) 36122c46407dSAndreas Gruenbacher return -EIO; 3613b411b363SPhilipp Reisner 3614b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3615b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3616b411b363SPhilipp Reisner if (bits <= 0) 36172c46407dSAndreas Gruenbacher return -EIO; 3618b411b363SPhilipp Reisner 3619b411b363SPhilipp Reisner if (toggle) { 3620b411b363SPhilipp Reisner e = s + rl -1; 3621b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3622b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 36232c46407dSAndreas Gruenbacher return -EIO; 3624b411b363SPhilipp Reisner } 3625b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3626b411b363SPhilipp Reisner } 3627b411b363SPhilipp Reisner 3628b411b363SPhilipp Reisner if (have < bits) { 3629b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3630b411b363SPhilipp Reisner have, bits, look_ahead, 3631b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3632b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 36332c46407dSAndreas Gruenbacher return -EIO; 3634b411b363SPhilipp Reisner } 3635b411b363SPhilipp Reisner look_ahead >>= bits; 3636b411b363SPhilipp Reisner have -= bits; 3637b411b363SPhilipp Reisner 3638b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3639b411b363SPhilipp Reisner if (bits < 0) 36402c46407dSAndreas Gruenbacher return -EIO; 3641b411b363SPhilipp Reisner look_ahead |= tmp << have; 3642b411b363SPhilipp Reisner have += bits; 3643b411b363SPhilipp Reisner } 3644b411b363SPhilipp Reisner 3645b411b363SPhilipp Reisner c->bit_offset = s; 3646b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3647b411b363SPhilipp Reisner 36482c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3649b411b363SPhilipp Reisner } 3650b411b363SPhilipp Reisner 36512c46407dSAndreas Gruenbacher /** 36522c46407dSAndreas Gruenbacher * decode_bitmap_c 36532c46407dSAndreas Gruenbacher * 36542c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36552c46407dSAndreas Gruenbacher * code upon failure. 36562c46407dSAndreas Gruenbacher */ 36572c46407dSAndreas Gruenbacher static int 3658b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3659b411b363SPhilipp Reisner struct p_compressed_bm *p, 3660c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3661c6d25cfeSPhilipp Reisner unsigned int len) 3662b411b363SPhilipp Reisner { 3663b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3664c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3665b411b363SPhilipp Reisner 3666b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3667b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3668b411b363SPhilipp Reisner * during all our tests. */ 3669b411b363SPhilipp Reisner 3670b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 367138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 36722c46407dSAndreas Gruenbacher return -EIO; 3673b411b363SPhilipp Reisner } 3674b411b363SPhilipp Reisner 3675b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3676b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3677b411b363SPhilipp Reisner { 3678b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3679c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3680b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3681b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3682b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3683b411b363SPhilipp Reisner unsigned r; 3684b411b363SPhilipp Reisner 3685b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3686b411b363SPhilipp Reisner if (total == 0) 3687b411b363SPhilipp Reisner return; 3688b411b363SPhilipp Reisner 3689b411b363SPhilipp Reisner /* don't report if not compressed */ 3690b411b363SPhilipp Reisner if (total >= plain) 3691b411b363SPhilipp Reisner return; 3692b411b363SPhilipp Reisner 3693b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3694b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3695b411b363SPhilipp Reisner : (1000 * total / plain); 3696b411b363SPhilipp Reisner 3697b411b363SPhilipp Reisner if (r > 1000) 3698b411b363SPhilipp Reisner r = 1000; 3699b411b363SPhilipp Reisner 3700b411b363SPhilipp Reisner r = 1000 - r; 3701b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3702b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3703b411b363SPhilipp Reisner direction, 3704b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3705b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3706b411b363SPhilipp Reisner total, r/10, r % 10); 3707b411b363SPhilipp Reisner } 3708b411b363SPhilipp Reisner 3709b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3710b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3711b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3712b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3713b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3714b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3715b411b363SPhilipp Reisner 3716b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3717d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3718d8763023SAndreas Gruenbacher unsigned int data_size) 3719b411b363SPhilipp Reisner { 3720b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3721b411b363SPhilipp Reisner void *buffer; 37222c46407dSAndreas Gruenbacher int err; 372381e84650SAndreas Gruenbacher int ok = false; 3724257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 372577351055SPhilipp Reisner struct packet_info pi; 3726b411b363SPhilipp Reisner 372720ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 372820ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 372920ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3730b411b363SPhilipp Reisner 3731b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3732b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3733b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3734b411b363SPhilipp Reisner if (!buffer) { 3735b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3736b411b363SPhilipp Reisner goto out; 3737b411b363SPhilipp Reisner } 3738b411b363SPhilipp Reisner 3739b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3740b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3741b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3742b411b363SPhilipp Reisner }; 3743b411b363SPhilipp Reisner 37442c46407dSAndreas Gruenbacher for(;;) { 374502918be2SPhilipp Reisner if (cmd == P_BITMAP) { 37462c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 374702918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3748b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3749b411b363SPhilipp Reisner * and the feature is enabled! */ 3750b411b363SPhilipp Reisner struct p_compressed_bm *p; 3751b411b363SPhilipp Reisner 375202918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3753b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3754b411b363SPhilipp Reisner goto out; 3755b411b363SPhilipp Reisner } 3756b411b363SPhilipp Reisner /* use the page buff */ 3757b411b363SPhilipp Reisner p = buffer; 3758b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 3759de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->head.payload, data_size) != data_size) 3760b411b363SPhilipp Reisner goto out; 3761004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3762004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 376378fcbdaeSAndreas Gruenbacher goto out; 3764b411b363SPhilipp Reisner } 3765c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3766b411b363SPhilipp Reisner } else { 376702918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3768b411b363SPhilipp Reisner goto out; 3769b411b363SPhilipp Reisner } 3770b411b363SPhilipp Reisner 377102918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3772257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3773b411b363SPhilipp Reisner 37742c46407dSAndreas Gruenbacher if (err <= 0) { 37752c46407dSAndreas Gruenbacher if (err < 0) 37762c46407dSAndreas Gruenbacher goto out; 3777b411b363SPhilipp Reisner break; 37782c46407dSAndreas Gruenbacher } 37799ba7aa00SPhilipp Reisner if (!drbd_recv_header(mdev->tconn, &pi)) 3780b411b363SPhilipp Reisner goto out; 378177351055SPhilipp Reisner cmd = pi.cmd; 378277351055SPhilipp Reisner data_size = pi.size; 37832c46407dSAndreas Gruenbacher } 3784b411b363SPhilipp Reisner 3785b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3786b411b363SPhilipp Reisner 3787b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3788de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3789de1f8e4aSAndreas Gruenbacher 3790b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3791b411b363SPhilipp Reisner if (!ok) 3792b411b363SPhilipp Reisner goto out; 3793b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3794de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3795de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3796b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3797b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3798b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3799b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3800b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3801b411b363SPhilipp Reisner } 3802b411b363SPhilipp Reisner 380381e84650SAndreas Gruenbacher ok = true; 3804b411b363SPhilipp Reisner out: 380520ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 3806b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3807b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3808b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3809b411b363SPhilipp Reisner return ok; 3810b411b363SPhilipp Reisner } 3811b411b363SPhilipp Reisner 38122de876efSPhilipp Reisner static int _tconn_receive_skip(struct drbd_tconn *tconn, unsigned int data_size) 3813b411b363SPhilipp Reisner { 3814b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3815b411b363SPhilipp Reisner static char sink[128]; 3816b411b363SPhilipp Reisner int size, want, r; 3817b411b363SPhilipp Reisner 381802918be2SPhilipp Reisner size = data_size; 3819b411b363SPhilipp Reisner while (size > 0) { 3820b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 38212de876efSPhilipp Reisner r = drbd_recv(tconn, sink, want); 38222de876efSPhilipp Reisner if (r <= 0) 3823841ce241SAndreas Gruenbacher break; 3824b411b363SPhilipp Reisner size -= r; 3825b411b363SPhilipp Reisner } 3826b411b363SPhilipp Reisner return size == 0; 3827b411b363SPhilipp Reisner } 3828b411b363SPhilipp Reisner 38292de876efSPhilipp Reisner static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 38302de876efSPhilipp Reisner unsigned int data_size) 38312de876efSPhilipp Reisner { 38322de876efSPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 38332de876efSPhilipp Reisner cmd, data_size); 38342de876efSPhilipp Reisner 38352de876efSPhilipp Reisner return _tconn_receive_skip(mdev->tconn, data_size); 38362de876efSPhilipp Reisner } 38372de876efSPhilipp Reisner 38382de876efSPhilipp Reisner static int tconn_receive_skip(struct drbd_tconn *tconn, enum drbd_packet cmd, unsigned int data_size) 38392de876efSPhilipp Reisner { 38402de876efSPhilipp Reisner conn_warn(tconn, "skipping packet for non existing volume type %d, l: %d!\n", 38412de876efSPhilipp Reisner cmd, data_size); 38422de876efSPhilipp Reisner 38432de876efSPhilipp Reisner return _tconn_receive_skip(tconn, data_size); 38442de876efSPhilipp Reisner } 38452de876efSPhilipp Reisner 3846d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3847d8763023SAndreas Gruenbacher unsigned int data_size) 3848b411b363SPhilipp Reisner { 3849b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3850b411b363SPhilipp Reisner * with the data requests being unplugged */ 3851e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3852b411b363SPhilipp Reisner 385381e84650SAndreas Gruenbacher return true; 3854b411b363SPhilipp Reisner } 3855b411b363SPhilipp Reisner 3856d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3857d8763023SAndreas Gruenbacher unsigned int data_size) 385873a01a18SPhilipp Reisner { 3859e42325a5SPhilipp Reisner struct p_block_desc *p = &mdev->tconn->data.rbuf.block_desc; 386073a01a18SPhilipp Reisner 3861f735e363SLars Ellenberg switch (mdev->state.conn) { 3862f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3863f735e363SLars Ellenberg case C_WF_BITMAP_T: 3864f735e363SLars Ellenberg case C_BEHIND: 3865f735e363SLars Ellenberg break; 3866f735e363SLars Ellenberg default: 3867f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3868f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3869f735e363SLars Ellenberg } 3870f735e363SLars Ellenberg 387173a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 387273a01a18SPhilipp Reisner 387381e84650SAndreas Gruenbacher return true; 387473a01a18SPhilipp Reisner } 387573a01a18SPhilipp Reisner 387602918be2SPhilipp Reisner struct data_cmd { 387702918be2SPhilipp Reisner int expect_payload; 387802918be2SPhilipp Reisner size_t pkt_size; 3879d9ae84e7SPhilipp Reisner enum { 3880d9ae84e7SPhilipp Reisner MDEV, 3881d9ae84e7SPhilipp Reisner CONN, 3882d9ae84e7SPhilipp Reisner } type; 3883d9ae84e7SPhilipp Reisner union { 3884d9ae84e7SPhilipp Reisner int (*mdev_fn)(struct drbd_conf *, enum drbd_packet cmd, 3885d9ae84e7SPhilipp Reisner unsigned int to_receive); 3886d9ae84e7SPhilipp Reisner int (*conn_fn)(struct drbd_tconn *, enum drbd_packet cmd, 3887d9ae84e7SPhilipp Reisner unsigned int to_receive); 3888d9ae84e7SPhilipp Reisner }; 3889b411b363SPhilipp Reisner }; 3890b411b363SPhilipp Reisner 389102918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 3892d9ae84e7SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), MDEV, { receive_Data } }, 3893d9ae84e7SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_DataReply } }, 3894d9ae84e7SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_RSDataReply } } , 3895d9ae84e7SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), MDEV, { receive_Barrier } } , 3896d9ae84e7SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3897d9ae84e7SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3898d9ae84e7SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), MDEV, { receive_UnplugRemote } }, 3899d9ae84e7SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3900d9ae84e7SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3901d9ae84e7SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 3902d9ae84e7SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 39037204624cSPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), CONN, { .conn_fn = receive_protocol } }, 3904d9ae84e7SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), MDEV, { receive_uuids } }, 3905d9ae84e7SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), MDEV, { receive_sizes } }, 3906d9ae84e7SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), MDEV, { receive_state } }, 3907d9ae84e7SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), MDEV, { receive_req_state } }, 3908d9ae84e7SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), MDEV, { receive_sync_uuid } }, 3909d9ae84e7SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3910d9ae84e7SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3911d9ae84e7SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3912d9ae84e7SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), MDEV, { receive_skip } }, 3913d9ae84e7SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), MDEV, { receive_out_of_sync } }, 3914dfafcc8aSPhilipp Reisner [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), CONN, { .conn_fn = receive_req_conn_state } }, 391502918be2SPhilipp Reisner }; 391602918be2SPhilipp Reisner 391702918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 3918e42325a5SPhilipp Reisner mdev->tconn->data.rbuf.header.head.payload. 391902918be2SPhilipp Reisner 3920e42325a5SPhilipp Reisner Usually in mdev->tconn->data.rbuf.header.head the callback can find the usual 392102918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 392202918be2SPhilipp Reisner */ 3923b411b363SPhilipp Reisner 3924eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 3925b411b363SPhilipp Reisner { 3926eefc2f7dSPhilipp Reisner struct p_header *header = &tconn->data.rbuf.header; 392777351055SPhilipp Reisner struct packet_info pi; 392802918be2SPhilipp Reisner size_t shs; /* sub header size */ 392902918be2SPhilipp Reisner int rv; 3930b411b363SPhilipp Reisner 3931eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 3932eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 3933eefc2f7dSPhilipp Reisner if (!drbd_recv_header(tconn, &pi)) 393402918be2SPhilipp Reisner goto err_out; 393502918be2SPhilipp Reisner 39366e849ce8SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || 3937d9ae84e7SPhilipp Reisner !drbd_cmd_handler[pi.cmd].mdev_fn)) { 3938eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 393902918be2SPhilipp Reisner goto err_out; 39400b33a916SLars Ellenberg } 3941b411b363SPhilipp Reisner 394277351055SPhilipp Reisner shs = drbd_cmd_handler[pi.cmd].pkt_size - sizeof(struct p_header); 394377351055SPhilipp Reisner if (pi.size - shs > 0 && !drbd_cmd_handler[pi.cmd].expect_payload) { 3944eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 3945c13f7e1aSLars Ellenberg goto err_out; 3946c13f7e1aSLars Ellenberg } 3947c13f7e1aSLars Ellenberg 3948c13f7e1aSLars Ellenberg if (shs) { 3949eefc2f7dSPhilipp Reisner rv = drbd_recv(tconn, &header->payload, shs); 395002918be2SPhilipp Reisner if (unlikely(rv != shs)) { 39510ddc5549SLars Ellenberg if (!signal_pending(current)) 3952eefc2f7dSPhilipp Reisner conn_warn(tconn, "short read while reading sub header: rv=%d\n", rv); 395302918be2SPhilipp Reisner goto err_out; 3954b411b363SPhilipp Reisner } 395502918be2SPhilipp Reisner } 395602918be2SPhilipp Reisner 3957d9ae84e7SPhilipp Reisner if (drbd_cmd_handler[pi.cmd].type == CONN) { 3958d9ae84e7SPhilipp Reisner rv = drbd_cmd_handler[pi.cmd].conn_fn(tconn, pi.cmd, pi.size - shs); 3959d9ae84e7SPhilipp Reisner } else { 3960d9ae84e7SPhilipp Reisner struct drbd_conf *mdev = vnr_to_mdev(tconn, pi.vnr); 39612de876efSPhilipp Reisner rv = mdev ? 3962d9ae84e7SPhilipp Reisner drbd_cmd_handler[pi.cmd].mdev_fn(mdev, pi.cmd, pi.size - shs) : 39632de876efSPhilipp Reisner tconn_receive_skip(tconn, pi.cmd, pi.size - shs); 3964d9ae84e7SPhilipp Reisner } 396502918be2SPhilipp Reisner 396602918be2SPhilipp Reisner if (unlikely(!rv)) { 3967eefc2f7dSPhilipp Reisner conn_err(tconn, "error receiving %s, l: %d!\n", 396877351055SPhilipp Reisner cmdname(pi.cmd), pi.size); 396902918be2SPhilipp Reisner goto err_out; 3970b411b363SPhilipp Reisner } 3971b411b363SPhilipp Reisner } 397202918be2SPhilipp Reisner 397302918be2SPhilipp Reisner if (0) { 397402918be2SPhilipp Reisner err_out: 3975bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 3976b411b363SPhilipp Reisner } 3977b411b363SPhilipp Reisner } 3978b411b363SPhilipp Reisner 39790e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 3980b411b363SPhilipp Reisner { 3981b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3982b411b363SPhilipp Reisner 3983b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 39840e29d163SPhilipp Reisner barr.w.tconn = tconn; 3985b411b363SPhilipp Reisner init_completion(&barr.done); 39860e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 3987b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3988b411b363SPhilipp Reisner } 3989b411b363SPhilipp Reisner 3990360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 3991b411b363SPhilipp Reisner { 3992bbeb641cSPhilipp Reisner enum drbd_conns oc; 3993b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 3994b411b363SPhilipp Reisner 3995bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 3996b411b363SPhilipp Reisner return; 3997b411b363SPhilipp Reisner 3998b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 3999360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4000360cc740SPhilipp Reisner drbd_free_sock(tconn); 4001360cc740SPhilipp Reisner 4002360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 4003360cc740SPhilipp Reisner 4004360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4005360cc740SPhilipp Reisner 4006360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4007bbeb641cSPhilipp Reisner oc = tconn->cstate; 4008bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4009bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4010bbeb641cSPhilipp Reisner 4011360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4012360cc740SPhilipp Reisner 4013bbeb641cSPhilipp Reisner if (oc == C_DISCONNECTING) { 4014360cc740SPhilipp Reisner wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0); 4015360cc740SPhilipp Reisner 4016360cc740SPhilipp Reisner crypto_free_hash(tconn->cram_hmac_tfm); 4017360cc740SPhilipp Reisner tconn->cram_hmac_tfm = NULL; 4018360cc740SPhilipp Reisner 4019360cc740SPhilipp Reisner kfree(tconn->net_conf); 4020360cc740SPhilipp Reisner tconn->net_conf = NULL; 4021bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE); 4022360cc740SPhilipp Reisner } 4023360cc740SPhilipp Reisner } 4024360cc740SPhilipp Reisner 4025360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 4026360cc740SPhilipp Reisner { 4027360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 4028360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4029360cc740SPhilipp Reisner unsigned int i; 4030b411b363SPhilipp Reisner 403185719573SPhilipp Reisner /* wait for current activity to cease. */ 403287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4033b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4034b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4035b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 403687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4037b411b363SPhilipp Reisner 4038b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4039b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4040b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4041b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4042b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4043b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4044b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4045b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4046b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4047b411b363SPhilipp Reisner * on the fly. */ 4048b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4049b411b363SPhilipp Reisner mdev->rs_total = 0; 4050b411b363SPhilipp Reisner mdev->rs_failed = 0; 4051b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4052b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4053b411b363SPhilipp Reisner 40547fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 40557fde2be9SPhilipp Reisner 4056b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4057b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4058b411b363SPhilipp Reisner 4059b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4060b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4061b411b363SPhilipp Reisner * to be "canceled" */ 4062a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4063b411b363SPhilipp Reisner 4064b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 4065b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 4066b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 4067b411b363SPhilipp Reisner 4068b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4069b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4070b411b363SPhilipp Reisner 4071fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 40722f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4073b411b363SPhilipp Reisner 4074b411b363SPhilipp Reisner drbd_md_sync(mdev); 4075b411b363SPhilipp Reisner 4076b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4077b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4078b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 4079b411b363SPhilipp Reisner put_ldev(mdev); 4080b411b363SPhilipp Reisner } 4081b411b363SPhilipp Reisner 408287f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 408387f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 4084b411b363SPhilipp Reisner 408520ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 408620ceb2b2SLars Ellenberg * if any. */ 408720ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 408820ceb2b2SLars Ellenberg 4089b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4090b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4091b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4092b411b363SPhilipp Reisner * 4093b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4094b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4095b411b363SPhilipp Reisner */ 4096b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 4097b411b363SPhilipp Reisner if (i) 4098b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4099435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4100435f0740SLars Ellenberg if (i) 4101435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4102b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4103b411b363SPhilipp Reisner if (i) 410445bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4105b411b363SPhilipp Reisner 4106b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4107b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4108b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4109b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4110b411b363SPhilipp Reisner 4111b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4112b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4113b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4114360cc740SPhilipp Reisner 4115360cc740SPhilipp Reisner return 0; 4116b411b363SPhilipp Reisner } 4117b411b363SPhilipp Reisner 4118b411b363SPhilipp Reisner /* 4119b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4120b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4121b411b363SPhilipp Reisner * 4122b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4123b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4124b411b363SPhilipp Reisner * 4125b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4126b411b363SPhilipp Reisner */ 41278a22ccccSPhilipp Reisner static int drbd_send_handshake(struct drbd_tconn *tconn) 4128b411b363SPhilipp Reisner { 4129e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 41308a22ccccSPhilipp Reisner struct p_handshake *p = &tconn->data.sbuf.handshake; 4131b411b363SPhilipp Reisner int ok; 4132b411b363SPhilipp Reisner 41338a22ccccSPhilipp Reisner if (mutex_lock_interruptible(&tconn->data.mutex)) { 41348a22ccccSPhilipp Reisner conn_err(tconn, "interrupted during initial handshake\n"); 4135b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 4136b411b363SPhilipp Reisner } 4137b411b363SPhilipp Reisner 41388a22ccccSPhilipp Reisner if (tconn->data.socket == NULL) { 41398a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4140b411b363SPhilipp Reisner return 0; 4141b411b363SPhilipp Reisner } 4142b411b363SPhilipp Reisner 4143b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4144b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4145b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 41468a22ccccSPhilipp Reisner ok = _conn_send_cmd(tconn, 0, tconn->data.socket, P_HAND_SHAKE, 4147c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 41488a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4149b411b363SPhilipp Reisner return ok; 4150b411b363SPhilipp Reisner } 4151b411b363SPhilipp Reisner 4152b411b363SPhilipp Reisner /* 4153b411b363SPhilipp Reisner * return values: 4154b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4155b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4156b411b363SPhilipp Reisner * -1 peer talks different language, 4157b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4158b411b363SPhilipp Reisner */ 415965d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn) 4160b411b363SPhilipp Reisner { 416165d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 416265d11ed6SPhilipp Reisner struct p_handshake *p = &tconn->data.rbuf.handshake; 416302918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 416477351055SPhilipp Reisner struct packet_info pi; 4165b411b363SPhilipp Reisner int rv; 4166b411b363SPhilipp Reisner 416765d11ed6SPhilipp Reisner rv = drbd_send_handshake(tconn); 4168b411b363SPhilipp Reisner if (!rv) 4169b411b363SPhilipp Reisner return 0; 4170b411b363SPhilipp Reisner 417165d11ed6SPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4172b411b363SPhilipp Reisner if (!rv) 4173b411b363SPhilipp Reisner return 0; 4174b411b363SPhilipp Reisner 417577351055SPhilipp Reisner if (pi.cmd != P_HAND_SHAKE) { 417665d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake packet, received: %s (0x%04x)\n", 417777351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4178b411b363SPhilipp Reisner return -1; 4179b411b363SPhilipp Reisner } 4180b411b363SPhilipp Reisner 418177351055SPhilipp Reisner if (pi.size != expect) { 418265d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake length: %u, received: %u\n", 418377351055SPhilipp Reisner expect, pi.size); 4184b411b363SPhilipp Reisner return -1; 4185b411b363SPhilipp Reisner } 4186b411b363SPhilipp Reisner 418765d11ed6SPhilipp Reisner rv = drbd_recv(tconn, &p->head.payload, expect); 4188b411b363SPhilipp Reisner 4189b411b363SPhilipp Reisner if (rv != expect) { 41900ddc5549SLars Ellenberg if (!signal_pending(current)) 419165d11ed6SPhilipp Reisner conn_warn(tconn, "short read receiving handshake packet: l=%u\n", rv); 4192b411b363SPhilipp Reisner return 0; 4193b411b363SPhilipp Reisner } 4194b411b363SPhilipp Reisner 4195b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4196b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4197b411b363SPhilipp Reisner if (p->protocol_max == 0) 4198b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4199b411b363SPhilipp Reisner 4200b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4201b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4202b411b363SPhilipp Reisner goto incompat; 4203b411b363SPhilipp Reisner 420465d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4205b411b363SPhilipp Reisner 420665d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 420765d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4208b411b363SPhilipp Reisner 4209b411b363SPhilipp Reisner return 1; 4210b411b363SPhilipp Reisner 4211b411b363SPhilipp Reisner incompat: 421265d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4213b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4214b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4215b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4216b411b363SPhilipp Reisner return -1; 4217b411b363SPhilipp Reisner } 4218b411b363SPhilipp Reisner 4219b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 422013e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4221b411b363SPhilipp Reisner { 4222b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4223b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4224b10d96cbSJohannes Thoma return -1; 4225b411b363SPhilipp Reisner } 4226b411b363SPhilipp Reisner #else 4227b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4228b10d96cbSJohannes Thoma 4229b10d96cbSJohannes Thoma /* Return value: 4230b10d96cbSJohannes Thoma 1 - auth succeeded, 4231b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4232b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4233b10d96cbSJohannes Thoma */ 4234b10d96cbSJohannes Thoma 423513e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4236b411b363SPhilipp Reisner { 4237b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4238b411b363SPhilipp Reisner struct scatterlist sg; 4239b411b363SPhilipp Reisner char *response = NULL; 4240b411b363SPhilipp Reisner char *right_response = NULL; 4241b411b363SPhilipp Reisner char *peers_ch = NULL; 424213e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4243b411b363SPhilipp Reisner unsigned int resp_size; 4244b411b363SPhilipp Reisner struct hash_desc desc; 424577351055SPhilipp Reisner struct packet_info pi; 4246b411b363SPhilipp Reisner int rv; 4247b411b363SPhilipp Reisner 424813e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4249b411b363SPhilipp Reisner desc.flags = 0; 4250b411b363SPhilipp Reisner 425113e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 425213e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4253b411b363SPhilipp Reisner if (rv) { 425413e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4255b10d96cbSJohannes Thoma rv = -1; 4256b411b363SPhilipp Reisner goto fail; 4257b411b363SPhilipp Reisner } 4258b411b363SPhilipp Reisner 4259b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4260b411b363SPhilipp Reisner 426113e6037dSPhilipp Reisner rv = conn_send_cmd2(tconn, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4262b411b363SPhilipp Reisner if (!rv) 4263b411b363SPhilipp Reisner goto fail; 4264b411b363SPhilipp Reisner 426513e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4266b411b363SPhilipp Reisner if (!rv) 4267b411b363SPhilipp Reisner goto fail; 4268b411b363SPhilipp Reisner 426977351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 427013e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 427177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4272b411b363SPhilipp Reisner rv = 0; 4273b411b363SPhilipp Reisner goto fail; 4274b411b363SPhilipp Reisner } 4275b411b363SPhilipp Reisner 427677351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 427713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4278b10d96cbSJohannes Thoma rv = -1; 4279b411b363SPhilipp Reisner goto fail; 4280b411b363SPhilipp Reisner } 4281b411b363SPhilipp Reisner 428277351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4283b411b363SPhilipp Reisner if (peers_ch == NULL) { 428413e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4285b10d96cbSJohannes Thoma rv = -1; 4286b411b363SPhilipp Reisner goto fail; 4287b411b363SPhilipp Reisner } 4288b411b363SPhilipp Reisner 428913e6037dSPhilipp Reisner rv = drbd_recv(tconn, peers_ch, pi.size); 4290b411b363SPhilipp Reisner 429177351055SPhilipp Reisner if (rv != pi.size) { 42920ddc5549SLars Ellenberg if (!signal_pending(current)) 429313e6037dSPhilipp Reisner conn_warn(tconn, "short read AuthChallenge: l=%u\n", rv); 4294b411b363SPhilipp Reisner rv = 0; 4295b411b363SPhilipp Reisner goto fail; 4296b411b363SPhilipp Reisner } 4297b411b363SPhilipp Reisner 429813e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4299b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4300b411b363SPhilipp Reisner if (response == NULL) { 430113e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4302b10d96cbSJohannes Thoma rv = -1; 4303b411b363SPhilipp Reisner goto fail; 4304b411b363SPhilipp Reisner } 4305b411b363SPhilipp Reisner 4306b411b363SPhilipp Reisner sg_init_table(&sg, 1); 430777351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4308b411b363SPhilipp Reisner 4309b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4310b411b363SPhilipp Reisner if (rv) { 431113e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4312b10d96cbSJohannes Thoma rv = -1; 4313b411b363SPhilipp Reisner goto fail; 4314b411b363SPhilipp Reisner } 4315b411b363SPhilipp Reisner 431613e6037dSPhilipp Reisner rv = conn_send_cmd2(tconn, P_AUTH_RESPONSE, response, resp_size); 4317b411b363SPhilipp Reisner if (!rv) 4318b411b363SPhilipp Reisner goto fail; 4319b411b363SPhilipp Reisner 432013e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4321b411b363SPhilipp Reisner if (!rv) 4322b411b363SPhilipp Reisner goto fail; 4323b411b363SPhilipp Reisner 432477351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 432513e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 432677351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4327b411b363SPhilipp Reisner rv = 0; 4328b411b363SPhilipp Reisner goto fail; 4329b411b363SPhilipp Reisner } 4330b411b363SPhilipp Reisner 433177351055SPhilipp Reisner if (pi.size != resp_size) { 433213e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4333b411b363SPhilipp Reisner rv = 0; 4334b411b363SPhilipp Reisner goto fail; 4335b411b363SPhilipp Reisner } 4336b411b363SPhilipp Reisner 433713e6037dSPhilipp Reisner rv = drbd_recv(tconn, response , resp_size); 4338b411b363SPhilipp Reisner 4339b411b363SPhilipp Reisner if (rv != resp_size) { 43400ddc5549SLars Ellenberg if (!signal_pending(current)) 434113e6037dSPhilipp Reisner conn_warn(tconn, "short read receiving AuthResponse: l=%u\n", rv); 4342b411b363SPhilipp Reisner rv = 0; 4343b411b363SPhilipp Reisner goto fail; 4344b411b363SPhilipp Reisner } 4345b411b363SPhilipp Reisner 4346b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 43472d1ee87dSJulia Lawall if (right_response == NULL) { 434813e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4349b10d96cbSJohannes Thoma rv = -1; 4350b411b363SPhilipp Reisner goto fail; 4351b411b363SPhilipp Reisner } 4352b411b363SPhilipp Reisner 4353b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4354b411b363SPhilipp Reisner 4355b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4356b411b363SPhilipp Reisner if (rv) { 435713e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4358b10d96cbSJohannes Thoma rv = -1; 4359b411b363SPhilipp Reisner goto fail; 4360b411b363SPhilipp Reisner } 4361b411b363SPhilipp Reisner 4362b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4363b411b363SPhilipp Reisner 4364b411b363SPhilipp Reisner if (rv) 436513e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 436613e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4367b10d96cbSJohannes Thoma else 4368b10d96cbSJohannes Thoma rv = -1; 4369b411b363SPhilipp Reisner 4370b411b363SPhilipp Reisner fail: 4371b411b363SPhilipp Reisner kfree(peers_ch); 4372b411b363SPhilipp Reisner kfree(response); 4373b411b363SPhilipp Reisner kfree(right_response); 4374b411b363SPhilipp Reisner 4375b411b363SPhilipp Reisner return rv; 4376b411b363SPhilipp Reisner } 4377b411b363SPhilipp Reisner #endif 4378b411b363SPhilipp Reisner 4379b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4380b411b363SPhilipp Reisner { 4381392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4382b411b363SPhilipp Reisner int h; 4383b411b363SPhilipp Reisner 43844d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4385b411b363SPhilipp Reisner 4386b411b363SPhilipp Reisner do { 43874d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4388b411b363SPhilipp Reisner if (h == 0) { 43894d641dd7SPhilipp Reisner drbd_disconnect(tconn); 439020ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4391b411b363SPhilipp Reisner } 4392b411b363SPhilipp Reisner if (h == -1) { 43934d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4394bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4395b411b363SPhilipp Reisner } 4396b411b363SPhilipp Reisner } while (h == 0); 4397b411b363SPhilipp Reisner 4398b411b363SPhilipp Reisner if (h > 0) { 43994d641dd7SPhilipp Reisner if (get_net_conf(tconn)) { 44004d641dd7SPhilipp Reisner drbdd(tconn); 44014d641dd7SPhilipp Reisner put_net_conf(tconn); 4402b411b363SPhilipp Reisner } 4403b411b363SPhilipp Reisner } 4404b411b363SPhilipp Reisner 44054d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4406b411b363SPhilipp Reisner 44074d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4408b411b363SPhilipp Reisner return 0; 4409b411b363SPhilipp Reisner } 4410b411b363SPhilipp Reisner 4411b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4412b411b363SPhilipp Reisner 4413d8763023SAndreas Gruenbacher static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4414b411b363SPhilipp Reisner { 4415257d0af6SPhilipp Reisner struct p_req_state_reply *p = &mdev->tconn->meta.rbuf.req_state_reply; 4416fc3b10a4SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 4417b411b363SPhilipp Reisner 4418b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4419b411b363SPhilipp Reisner 4420fc3b10a4SPhilipp Reisner if (cmd == P_STATE_CHG_REPLY) { 4421b411b363SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4422b411b363SPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4423b411b363SPhilipp Reisner } else { 4424b411b363SPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4425b411b363SPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4426b411b363SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4427b411b363SPhilipp Reisner } 4428b411b363SPhilipp Reisner wake_up(&mdev->state_wait); 4429fc3b10a4SPhilipp Reisner } else /* conn == P_CONN_ST_CHG_REPLY */ { 4430fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4431fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4432fc3b10a4SPhilipp Reisner } else { 4433fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4434fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4435fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4436fc3b10a4SPhilipp Reisner } 4437fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4438fc3b10a4SPhilipp Reisner } 443981e84650SAndreas Gruenbacher return true; 4440b411b363SPhilipp Reisner } 4441b411b363SPhilipp Reisner 4442d8763023SAndreas Gruenbacher static int got_Ping(struct drbd_conf *mdev, enum drbd_packet cmd) 4443b411b363SPhilipp Reisner { 44442a67d8b9SPhilipp Reisner return drbd_send_ping_ack(mdev->tconn); 4445b411b363SPhilipp Reisner 4446b411b363SPhilipp Reisner } 4447b411b363SPhilipp Reisner 4448d8763023SAndreas Gruenbacher static int got_PingAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4449b411b363SPhilipp Reisner { 44502a67d8b9SPhilipp Reisner struct drbd_tconn *tconn = mdev->tconn; 4451b411b363SPhilipp Reisner /* restore idle timeout */ 44522a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 44532a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 44542a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4455b411b363SPhilipp Reisner 445681e84650SAndreas Gruenbacher return true; 4457b411b363SPhilipp Reisner } 4458b411b363SPhilipp Reisner 4459d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4460b411b363SPhilipp Reisner { 4461257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4462b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4463b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4464b411b363SPhilipp Reisner 446531890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4466b411b363SPhilipp Reisner 4467b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4468b411b363SPhilipp Reisner 44691d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4470b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4471b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4472b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4473b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 44741d53f09eSLars Ellenberg put_ldev(mdev); 44751d53f09eSLars Ellenberg } 4476b411b363SPhilipp Reisner dec_rs_pending(mdev); 4477778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4478b411b363SPhilipp Reisner 447981e84650SAndreas Gruenbacher return true; 4480b411b363SPhilipp Reisner } 4481b411b363SPhilipp Reisner 4482bc9c5c41SAndreas Gruenbacher static int 4483bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4484bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4485bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4486b411b363SPhilipp Reisner { 4487b411b363SPhilipp Reisner struct drbd_request *req; 4488b411b363SPhilipp Reisner struct bio_and_error m; 4489b411b363SPhilipp Reisner 449087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4491bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4492b411b363SPhilipp Reisner if (unlikely(!req)) { 449387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 449481e84650SAndreas Gruenbacher return false; 4495b411b363SPhilipp Reisner } 4496b411b363SPhilipp Reisner __req_mod(req, what, &m); 449787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4498b411b363SPhilipp Reisner 4499b411b363SPhilipp Reisner if (m.bio) 4500b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 450181e84650SAndreas Gruenbacher return true; 4502b411b363SPhilipp Reisner } 4503b411b363SPhilipp Reisner 4504d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4505b411b363SPhilipp Reisner { 4506257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4507b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4508b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4509b411b363SPhilipp Reisner enum drbd_req_event what; 4510b411b363SPhilipp Reisner 4511b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4512b411b363SPhilipp Reisner 4513579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4514b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4515b411b363SPhilipp Reisner dec_rs_pending(mdev); 451681e84650SAndreas Gruenbacher return true; 4517b411b363SPhilipp Reisner } 4518257d0af6SPhilipp Reisner switch (cmd) { 4519b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 452089e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45218554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4522b411b363SPhilipp Reisner break; 4523b411b363SPhilipp Reisner case P_WRITE_ACK: 452489e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45258554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4526b411b363SPhilipp Reisner break; 4527b411b363SPhilipp Reisner case P_RECV_ACK: 452889e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 45298554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4530b411b363SPhilipp Reisner break; 45317be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 453289e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45337be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 45347be8da07SAndreas Gruenbacher break; 45357be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 45367be8da07SAndreas Gruenbacher D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45377be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4538b411b363SPhilipp Reisner break; 4539b411b363SPhilipp Reisner default: 4540b411b363SPhilipp Reisner D_ASSERT(0); 454181e84650SAndreas Gruenbacher return false; 4542b411b363SPhilipp Reisner } 4543b411b363SPhilipp Reisner 4544b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4545bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4546bc9c5c41SAndreas Gruenbacher what, false); 4547b411b363SPhilipp Reisner } 4548b411b363SPhilipp Reisner 4549d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4550b411b363SPhilipp Reisner { 4551257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4552b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 45532deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 455489e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 455589e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4556c3afd8f5SAndreas Gruenbacher bool found; 4557b411b363SPhilipp Reisner 4558b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4559b411b363SPhilipp Reisner 4560579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4561b411b363SPhilipp Reisner dec_rs_pending(mdev); 4562b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 456381e84650SAndreas Gruenbacher return true; 4564b411b363SPhilipp Reisner } 45652deb8336SPhilipp Reisner 4566c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4567bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 45688554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4569c3afd8f5SAndreas Gruenbacher if (!found) { 45702deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 45712deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4572c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 45732deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 45742deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4575c3afd8f5SAndreas Gruenbacher if (!missing_ok) 45762deb8336SPhilipp Reisner return false; 4577c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 45782deb8336SPhilipp Reisner } 45792deb8336SPhilipp Reisner return true; 4580b411b363SPhilipp Reisner } 4581b411b363SPhilipp Reisner 4582d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4583b411b363SPhilipp Reisner { 4584257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4585b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4586b411b363SPhilipp Reisner 4587b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 45887be8da07SAndreas Gruenbacher 4589b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4590b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4591b411b363SPhilipp Reisner 4592b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4593bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 45948554df1cSAndreas Gruenbacher NEG_ACKED, false); 4595b411b363SPhilipp Reisner } 4596b411b363SPhilipp Reisner 4597d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4598b411b363SPhilipp Reisner { 4599b411b363SPhilipp Reisner sector_t sector; 4600b411b363SPhilipp Reisner int size; 4601257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4602b411b363SPhilipp Reisner 4603b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4604b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4605b411b363SPhilipp Reisner 4606b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4607b411b363SPhilipp Reisner 4608b411b363SPhilipp Reisner dec_rs_pending(mdev); 4609b411b363SPhilipp Reisner 4610b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4611b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4612257d0af6SPhilipp Reisner switch (cmd) { 4613d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4614b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4615d612d309SPhilipp Reisner case P_RS_CANCEL: 4616d612d309SPhilipp Reisner break; 4617d612d309SPhilipp Reisner default: 4618d612d309SPhilipp Reisner D_ASSERT(0); 4619d612d309SPhilipp Reisner put_ldev(mdev); 4620d612d309SPhilipp Reisner return false; 4621d612d309SPhilipp Reisner } 4622b411b363SPhilipp Reisner put_ldev(mdev); 4623b411b363SPhilipp Reisner } 4624b411b363SPhilipp Reisner 462581e84650SAndreas Gruenbacher return true; 4626b411b363SPhilipp Reisner } 4627b411b363SPhilipp Reisner 4628d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4629b411b363SPhilipp Reisner { 4630257d0af6SPhilipp Reisner struct p_barrier_ack *p = &mdev->tconn->meta.rbuf.barrier_ack; 4631b411b363SPhilipp Reisner 46322f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4633b411b363SPhilipp Reisner 4634c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4635c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4636370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4637370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4638370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4639c4752ef1SPhilipp Reisner } 4640c4752ef1SPhilipp Reisner 464181e84650SAndreas Gruenbacher return true; 4642b411b363SPhilipp Reisner } 4643b411b363SPhilipp Reisner 4644d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4645b411b363SPhilipp Reisner { 4646257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4647b411b363SPhilipp Reisner struct drbd_work *w; 4648b411b363SPhilipp Reisner sector_t sector; 4649b411b363SPhilipp Reisner int size; 4650b411b363SPhilipp Reisner 4651b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4652b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4653b411b363SPhilipp Reisner 4654b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4655b411b363SPhilipp Reisner 4656b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4657b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4658b411b363SPhilipp Reisner else 4659b411b363SPhilipp Reisner ov_oos_print(mdev); 4660b411b363SPhilipp Reisner 46611d53f09eSLars Ellenberg if (!get_ldev(mdev)) 466281e84650SAndreas Gruenbacher return true; 46631d53f09eSLars Ellenberg 4664b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4665b411b363SPhilipp Reisner dec_rs_pending(mdev); 4666b411b363SPhilipp Reisner 4667ea5442afSLars Ellenberg --mdev->ov_left; 4668ea5442afSLars Ellenberg 4669ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4670ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4671ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4672ea5442afSLars Ellenberg 4673ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4674b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4675b411b363SPhilipp Reisner if (w) { 4676b411b363SPhilipp Reisner w->cb = w_ov_finished; 4677a21e9298SPhilipp Reisner w->mdev = mdev; 4678e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4679b411b363SPhilipp Reisner } else { 4680b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4681b411b363SPhilipp Reisner ov_oos_print(mdev); 4682b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4683b411b363SPhilipp Reisner } 4684b411b363SPhilipp Reisner } 46851d53f09eSLars Ellenberg put_ldev(mdev); 468681e84650SAndreas Gruenbacher return true; 4687b411b363SPhilipp Reisner } 4688b411b363SPhilipp Reisner 4689d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 46900ced55a3SPhilipp Reisner { 469181e84650SAndreas Gruenbacher return true; 46920ced55a3SPhilipp Reisner } 46930ced55a3SPhilipp Reisner 469432862ec7SPhilipp Reisner static int tconn_process_done_ee(struct drbd_tconn *tconn) 469532862ec7SPhilipp Reisner { 4696082a3439SPhilipp Reisner struct drbd_conf *mdev; 4697082a3439SPhilipp Reisner int i, not_empty = 0; 469832862ec7SPhilipp Reisner 469932862ec7SPhilipp Reisner do { 470032862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 470132862ec7SPhilipp Reisner flush_signals(current); 4702082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4703082a3439SPhilipp Reisner if (!drbd_process_done_ee(mdev)) 4704082a3439SPhilipp Reisner return 1; /* error */ 4705082a3439SPhilipp Reisner } 470632862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 4707082a3439SPhilipp Reisner 4708082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4709082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4710082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 4711082a3439SPhilipp Reisner if (not_empty) 4712082a3439SPhilipp Reisner break; 4713082a3439SPhilipp Reisner } 4714082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 471532862ec7SPhilipp Reisner } while (not_empty); 471632862ec7SPhilipp Reisner 471732862ec7SPhilipp Reisner return 0; 471832862ec7SPhilipp Reisner } 471932862ec7SPhilipp Reisner 47207201b972SAndreas Gruenbacher struct asender_cmd { 47217201b972SAndreas Gruenbacher size_t pkt_size; 47227201b972SAndreas Gruenbacher int (*process)(struct drbd_conf *, enum drbd_packet); 47237201b972SAndreas Gruenbacher }; 47247201b972SAndreas Gruenbacher 47257201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 47267201b972SAndreas Gruenbacher [P_PING] = { sizeof(struct p_header), got_Ping }, 47277201b972SAndreas Gruenbacher [P_PING_ACK] = { sizeof(struct p_header), got_PingAck }, 47287201b972SAndreas Gruenbacher [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 47297201b972SAndreas Gruenbacher [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 47307201b972SAndreas Gruenbacher [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck }, 47317201b972SAndreas Gruenbacher [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 47327201b972SAndreas Gruenbacher [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck }, 47337201b972SAndreas Gruenbacher [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply }, 47347201b972SAndreas Gruenbacher [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply}, 47357201b972SAndreas Gruenbacher [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult }, 47367201b972SAndreas Gruenbacher [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck }, 47377201b972SAndreas Gruenbacher [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply }, 47387201b972SAndreas Gruenbacher [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync }, 47397201b972SAndreas Gruenbacher [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip }, 47407201b972SAndreas Gruenbacher [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply}, 47417201b972SAndreas Gruenbacher [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_RqSReply }, 47427201b972SAndreas Gruenbacher [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck }, 47437201b972SAndreas Gruenbacher }; 47447201b972SAndreas Gruenbacher 4745b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4746b411b363SPhilipp Reisner { 4747392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 474832862ec7SPhilipp Reisner struct p_header *h = &tconn->meta.rbuf.header; 4749b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 475077351055SPhilipp Reisner struct packet_info pi; 4751257d0af6SPhilipp Reisner int rv; 4752b411b363SPhilipp Reisner void *buf = h; 4753b411b363SPhilipp Reisner int received = 0; 4754257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4755f36af18cSLars Ellenberg int ping_timeout_active = 0; 4756b411b363SPhilipp Reisner 4757b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4758b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4759b411b363SPhilipp Reisner 4760e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 476180822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 476232862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 47632a67d8b9SPhilipp Reisner if (!drbd_send_ping(tconn)) { 476432862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 4765841ce241SAndreas Gruenbacher goto reconnect; 4766841ce241SAndreas Gruenbacher } 476732862ec7SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = 476832862ec7SPhilipp Reisner tconn->net_conf->ping_timeo*HZ/10; 4769f36af18cSLars Ellenberg ping_timeout_active = 1; 4770b411b363SPhilipp Reisner } 4771b411b363SPhilipp Reisner 477232862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 477332862ec7SPhilipp Reisner much to send */ 477432862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 477532862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 4776082a3439SPhilipp Reisner if (tconn_process_done_ee(tconn)) { 4777082a3439SPhilipp Reisner conn_err(tconn, "tconn_process_done_ee() failed\n"); 4778b411b363SPhilipp Reisner goto reconnect; 4779082a3439SPhilipp Reisner } 4780b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 478132862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 478232862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 4783b411b363SPhilipp Reisner 4784b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4785b411b363SPhilipp Reisner if (signal_pending(current)) 4786b411b363SPhilipp Reisner continue; 4787b411b363SPhilipp Reisner 478832862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 478932862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4790b411b363SPhilipp Reisner 4791b411b363SPhilipp Reisner flush_signals(current); 4792b411b363SPhilipp Reisner 4793b411b363SPhilipp Reisner /* Note: 4794b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4795b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4796b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4797b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4798b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4799b411b363SPhilipp Reisner * rv == expected: full header or command 4800b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4801b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4802b411b363SPhilipp Reisner */ 4803b411b363SPhilipp Reisner if (likely(rv > 0)) { 4804b411b363SPhilipp Reisner received += rv; 4805b411b363SPhilipp Reisner buf += rv; 4806b411b363SPhilipp Reisner } else if (rv == 0) { 480732862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 4808b411b363SPhilipp Reisner goto reconnect; 4809b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4810cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4811cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 481232862ec7SPhilipp Reisner if (time_after(tconn->last_received, 481332862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 4814cb6518cbSLars Ellenberg continue; 4815f36af18cSLars Ellenberg if (ping_timeout_active) { 481632862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 4817b411b363SPhilipp Reisner goto reconnect; 4818b411b363SPhilipp Reisner } 481932862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 4820b411b363SPhilipp Reisner continue; 4821b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4822b411b363SPhilipp Reisner continue; 4823b411b363SPhilipp Reisner } else { 482432862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 4825b411b363SPhilipp Reisner goto reconnect; 4826b411b363SPhilipp Reisner } 4827b411b363SPhilipp Reisner 4828b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 482932862ec7SPhilipp Reisner if (!decode_header(tconn, h, &pi)) 4830b411b363SPhilipp Reisner goto reconnect; 48317201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 48327201b972SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd) { 483332862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 483477351055SPhilipp Reisner pi.cmd, pi.size); 4835b411b363SPhilipp Reisner goto disconnect; 4836b411b363SPhilipp Reisner } 4837b411b363SPhilipp Reisner expect = cmd->pkt_size; 483877351055SPhilipp Reisner if (pi.size != expect - sizeof(struct p_header)) { 483932862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 484077351055SPhilipp Reisner pi.cmd, pi.size); 4841b411b363SPhilipp Reisner goto reconnect; 4842b411b363SPhilipp Reisner } 4843257d0af6SPhilipp Reisner } 4844b411b363SPhilipp Reisner if (received == expect) { 484532862ec7SPhilipp Reisner tconn->last_received = jiffies; 484632862ec7SPhilipp Reisner if (!cmd->process(vnr_to_mdev(tconn, pi.vnr), pi.cmd)) 4847b411b363SPhilipp Reisner goto reconnect; 4848b411b363SPhilipp Reisner 4849f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4850f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 48517201b972SAndreas Gruenbacher if (cmd == &asender_tbl[P_PING_ACK]) 4852f36af18cSLars Ellenberg ping_timeout_active = 0; 4853f36af18cSLars Ellenberg 4854b411b363SPhilipp Reisner buf = h; 4855b411b363SPhilipp Reisner received = 0; 4856257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4857b411b363SPhilipp Reisner cmd = NULL; 4858b411b363SPhilipp Reisner } 4859b411b363SPhilipp Reisner } 4860b411b363SPhilipp Reisner 4861b411b363SPhilipp Reisner if (0) { 4862b411b363SPhilipp Reisner reconnect: 4863bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4864b411b363SPhilipp Reisner } 4865b411b363SPhilipp Reisner if (0) { 4866b411b363SPhilipp Reisner disconnect: 4867bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4868b411b363SPhilipp Reisner } 486932862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4870b411b363SPhilipp Reisner 487132862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 4872b411b363SPhilipp Reisner 4873b411b363SPhilipp Reisner return 0; 4874b411b363SPhilipp Reisner } 4875