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 63a4fbda8eSPhilipp Reisner enum mdev_or_conn { 64a4fbda8eSPhilipp Reisner MDEV, 65a4fbda8eSPhilipp Reisner CONN, 66a4fbda8eSPhilipp Reisner }; 67a4fbda8eSPhilipp Reisner 6865d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn); 6913e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn); 70360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data); 71b411b363SPhilipp Reisner 72b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event); 7399920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *, int); 74b411b363SPhilipp Reisner 75b411b363SPhilipp Reisner 76b411b363SPhilipp Reisner #define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN) 77b411b363SPhilipp Reisner 7845bb912bSLars Ellenberg /* 7945bb912bSLars Ellenberg * some helper functions to deal with single linked page lists, 8045bb912bSLars Ellenberg * page->private being our "next" pointer. 8145bb912bSLars Ellenberg */ 8245bb912bSLars Ellenberg 8345bb912bSLars Ellenberg /* If at least n pages are linked at head, get n pages off. 8445bb912bSLars Ellenberg * Otherwise, don't modify head, and return NULL. 8545bb912bSLars Ellenberg * Locking is the responsibility of the caller. 8645bb912bSLars Ellenberg */ 8745bb912bSLars Ellenberg static struct page *page_chain_del(struct page **head, int n) 8845bb912bSLars Ellenberg { 8945bb912bSLars Ellenberg struct page *page; 9045bb912bSLars Ellenberg struct page *tmp; 9145bb912bSLars Ellenberg 9245bb912bSLars Ellenberg BUG_ON(!n); 9345bb912bSLars Ellenberg BUG_ON(!head); 9445bb912bSLars Ellenberg 9545bb912bSLars Ellenberg page = *head; 9623ce4227SPhilipp Reisner 9723ce4227SPhilipp Reisner if (!page) 9823ce4227SPhilipp Reisner return NULL; 9923ce4227SPhilipp Reisner 10045bb912bSLars Ellenberg while (page) { 10145bb912bSLars Ellenberg tmp = page_chain_next(page); 10245bb912bSLars Ellenberg if (--n == 0) 10345bb912bSLars Ellenberg break; /* found sufficient pages */ 10445bb912bSLars Ellenberg if (tmp == NULL) 10545bb912bSLars Ellenberg /* insufficient pages, don't use any of them. */ 10645bb912bSLars Ellenberg return NULL; 10745bb912bSLars Ellenberg page = tmp; 10845bb912bSLars Ellenberg } 10945bb912bSLars Ellenberg 11045bb912bSLars Ellenberg /* add end of list marker for the returned list */ 11145bb912bSLars Ellenberg set_page_private(page, 0); 11245bb912bSLars Ellenberg /* actual return value, and adjustment of head */ 11345bb912bSLars Ellenberg page = *head; 11445bb912bSLars Ellenberg *head = tmp; 11545bb912bSLars Ellenberg return page; 11645bb912bSLars Ellenberg } 11745bb912bSLars Ellenberg 11845bb912bSLars Ellenberg /* may be used outside of locks to find the tail of a (usually short) 11945bb912bSLars Ellenberg * "private" page chain, before adding it back to a global chain head 12045bb912bSLars Ellenberg * with page_chain_add() under a spinlock. */ 12145bb912bSLars Ellenberg static struct page *page_chain_tail(struct page *page, int *len) 12245bb912bSLars Ellenberg { 12345bb912bSLars Ellenberg struct page *tmp; 12445bb912bSLars Ellenberg int i = 1; 12545bb912bSLars Ellenberg while ((tmp = page_chain_next(page))) 12645bb912bSLars Ellenberg ++i, page = tmp; 12745bb912bSLars Ellenberg if (len) 12845bb912bSLars Ellenberg *len = i; 12945bb912bSLars Ellenberg return page; 13045bb912bSLars Ellenberg } 13145bb912bSLars Ellenberg 13245bb912bSLars Ellenberg static int page_chain_free(struct page *page) 13345bb912bSLars Ellenberg { 13445bb912bSLars Ellenberg struct page *tmp; 13545bb912bSLars Ellenberg int i = 0; 13645bb912bSLars Ellenberg page_chain_for_each_safe(page, tmp) { 13745bb912bSLars Ellenberg put_page(page); 13845bb912bSLars Ellenberg ++i; 13945bb912bSLars Ellenberg } 14045bb912bSLars Ellenberg return i; 14145bb912bSLars Ellenberg } 14245bb912bSLars Ellenberg 14345bb912bSLars Ellenberg static void page_chain_add(struct page **head, 14445bb912bSLars Ellenberg struct page *chain_first, struct page *chain_last) 14545bb912bSLars Ellenberg { 14645bb912bSLars Ellenberg #if 1 14745bb912bSLars Ellenberg struct page *tmp; 14845bb912bSLars Ellenberg tmp = page_chain_tail(chain_first, NULL); 14945bb912bSLars Ellenberg BUG_ON(tmp != chain_last); 15045bb912bSLars Ellenberg #endif 15145bb912bSLars Ellenberg 15245bb912bSLars Ellenberg /* add chain to head */ 15345bb912bSLars Ellenberg set_page_private(chain_last, (unsigned long)*head); 15445bb912bSLars Ellenberg *head = chain_first; 15545bb912bSLars Ellenberg } 15645bb912bSLars Ellenberg 15745bb912bSLars Ellenberg static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number) 158b411b363SPhilipp Reisner { 159b411b363SPhilipp Reisner struct page *page = NULL; 16045bb912bSLars Ellenberg struct page *tmp = NULL; 16145bb912bSLars Ellenberg int i = 0; 162b411b363SPhilipp Reisner 163b411b363SPhilipp Reisner /* Yes, testing drbd_pp_vacant outside the lock is racy. 164b411b363SPhilipp Reisner * So what. It saves a spin_lock. */ 16545bb912bSLars Ellenberg if (drbd_pp_vacant >= number) { 166b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 16745bb912bSLars Ellenberg page = page_chain_del(&drbd_pp_pool, number); 16845bb912bSLars Ellenberg if (page) 16945bb912bSLars Ellenberg drbd_pp_vacant -= number; 170b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 17145bb912bSLars Ellenberg if (page) 17245bb912bSLars Ellenberg return page; 173b411b363SPhilipp Reisner } 17445bb912bSLars Ellenberg 175b411b363SPhilipp Reisner /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD 176b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 177b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 17845bb912bSLars Ellenberg for (i = 0; i < number; i++) { 17945bb912bSLars Ellenberg tmp = alloc_page(GFP_TRY); 18045bb912bSLars Ellenberg if (!tmp) 18145bb912bSLars Ellenberg break; 18245bb912bSLars Ellenberg set_page_private(tmp, (unsigned long)page); 18345bb912bSLars Ellenberg page = tmp; 18445bb912bSLars Ellenberg } 18545bb912bSLars Ellenberg 18645bb912bSLars Ellenberg if (i == number) 187b411b363SPhilipp Reisner return page; 18845bb912bSLars Ellenberg 18945bb912bSLars Ellenberg /* Not enough pages immediately available this time. 19045bb912bSLars Ellenberg * No need to jump around here, drbd_pp_alloc will retry this 19145bb912bSLars Ellenberg * function "soon". */ 19245bb912bSLars Ellenberg if (page) { 19345bb912bSLars Ellenberg tmp = page_chain_tail(page, NULL); 19445bb912bSLars Ellenberg spin_lock(&drbd_pp_lock); 19545bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 19645bb912bSLars Ellenberg drbd_pp_vacant += i; 19745bb912bSLars Ellenberg spin_unlock(&drbd_pp_lock); 19845bb912bSLars Ellenberg } 19945bb912bSLars Ellenberg return NULL; 200b411b363SPhilipp Reisner } 201b411b363SPhilipp Reisner 202b411b363SPhilipp Reisner static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed) 203b411b363SPhilipp Reisner { 204db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 205b411b363SPhilipp Reisner struct list_head *le, *tle; 206b411b363SPhilipp Reisner 207b411b363SPhilipp Reisner /* The EEs are always appended to the end of the list. Since 208b411b363SPhilipp Reisner they are sent in order over the wire, they have to finish 209b411b363SPhilipp Reisner in order. As soon as we see the first not finished we can 210b411b363SPhilipp Reisner stop to examine the list... */ 211b411b363SPhilipp Reisner 212b411b363SPhilipp Reisner list_for_each_safe(le, tle, &mdev->net_ee) { 213db830c46SAndreas Gruenbacher peer_req = list_entry(le, struct drbd_peer_request, w.list); 214db830c46SAndreas Gruenbacher if (drbd_ee_has_active_page(peer_req)) 215b411b363SPhilipp Reisner break; 216b411b363SPhilipp Reisner list_move(le, to_be_freed); 217b411b363SPhilipp Reisner } 218b411b363SPhilipp Reisner } 219b411b363SPhilipp Reisner 220b411b363SPhilipp Reisner static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev) 221b411b363SPhilipp Reisner { 222b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 223db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 224b411b363SPhilipp Reisner 22587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 226b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 22787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 228b411b363SPhilipp Reisner 229db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 230db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 231b411b363SPhilipp Reisner } 232b411b363SPhilipp Reisner 233b411b363SPhilipp Reisner /** 23445bb912bSLars Ellenberg * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled) 235b411b363SPhilipp Reisner * @mdev: DRBD device. 23645bb912bSLars Ellenberg * @number: number of pages requested 23745bb912bSLars Ellenberg * @retry: whether to retry, if not enough pages are available right now 238b411b363SPhilipp Reisner * 23945bb912bSLars Ellenberg * Tries to allocate number pages, first from our own page pool, then from 24045bb912bSLars Ellenberg * the kernel, unless this allocation would exceed the max_buffers setting. 24145bb912bSLars Ellenberg * Possibly retry until DRBD frees sufficient pages somewhere else. 24245bb912bSLars Ellenberg * 24345bb912bSLars Ellenberg * Returns a page chain linked via page->private. 244b411b363SPhilipp Reisner */ 24545bb912bSLars Ellenberg static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry) 246b411b363SPhilipp Reisner { 247b411b363SPhilipp Reisner struct page *page = NULL; 248b411b363SPhilipp Reisner DEFINE_WAIT(wait); 249b411b363SPhilipp Reisner 25045bb912bSLars Ellenberg /* Yes, we may run up to @number over max_buffers. If we 25145bb912bSLars Ellenberg * follow it strictly, the admin will get it wrong anyways. */ 25289e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) 25345bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 254b411b363SPhilipp Reisner 25545bb912bSLars Ellenberg while (page == NULL) { 256b411b363SPhilipp Reisner prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE); 257b411b363SPhilipp Reisner 258b411b363SPhilipp Reisner drbd_kick_lo_and_reclaim_net(mdev); 259b411b363SPhilipp Reisner 26089e58e75SPhilipp Reisner if (atomic_read(&mdev->pp_in_use) < mdev->tconn->net_conf->max_buffers) { 26145bb912bSLars Ellenberg page = drbd_pp_first_pages_or_try_alloc(mdev, number); 262b411b363SPhilipp Reisner if (page) 263b411b363SPhilipp Reisner break; 264b411b363SPhilipp Reisner } 265b411b363SPhilipp Reisner 266b411b363SPhilipp Reisner if (!retry) 267b411b363SPhilipp Reisner break; 268b411b363SPhilipp Reisner 269b411b363SPhilipp Reisner if (signal_pending(current)) { 270b411b363SPhilipp Reisner dev_warn(DEV, "drbd_pp_alloc interrupted!\n"); 271b411b363SPhilipp Reisner break; 272b411b363SPhilipp Reisner } 273b411b363SPhilipp Reisner 274b411b363SPhilipp Reisner schedule(); 275b411b363SPhilipp Reisner } 276b411b363SPhilipp Reisner finish_wait(&drbd_pp_wait, &wait); 277b411b363SPhilipp Reisner 27845bb912bSLars Ellenberg if (page) 27945bb912bSLars Ellenberg atomic_add(number, &mdev->pp_in_use); 280b411b363SPhilipp Reisner return page; 281b411b363SPhilipp Reisner } 282b411b363SPhilipp Reisner 283b411b363SPhilipp Reisner /* Must not be used from irq, as that may deadlock: see drbd_pp_alloc. 28487eeee41SPhilipp Reisner * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock); 28545bb912bSLars Ellenberg * Either links the page chain back to the global pool, 28645bb912bSLars Ellenberg * or returns all pages to the system. */ 287435f0740SLars Ellenberg static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net) 288b411b363SPhilipp Reisner { 289435f0740SLars Ellenberg atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use; 290b411b363SPhilipp Reisner int i; 291435f0740SLars Ellenberg 2921816a2b4SLars Ellenberg if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count) 29345bb912bSLars Ellenberg i = page_chain_free(page); 29445bb912bSLars Ellenberg else { 29545bb912bSLars Ellenberg struct page *tmp; 29645bb912bSLars Ellenberg tmp = page_chain_tail(page, &i); 297b411b363SPhilipp Reisner spin_lock(&drbd_pp_lock); 29845bb912bSLars Ellenberg page_chain_add(&drbd_pp_pool, page, tmp); 29945bb912bSLars Ellenberg drbd_pp_vacant += i; 300b411b363SPhilipp Reisner spin_unlock(&drbd_pp_lock); 301b411b363SPhilipp Reisner } 302435f0740SLars Ellenberg i = atomic_sub_return(i, a); 30345bb912bSLars Ellenberg if (i < 0) 304435f0740SLars Ellenberg dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n", 305435f0740SLars Ellenberg is_net ? "pp_in_use_by_net" : "pp_in_use", i); 306b411b363SPhilipp Reisner wake_up(&drbd_pp_wait); 307b411b363SPhilipp Reisner } 308b411b363SPhilipp Reisner 309b411b363SPhilipp Reisner /* 310b411b363SPhilipp Reisner You need to hold the req_lock: 311b411b363SPhilipp Reisner _drbd_wait_ee_list_empty() 312b411b363SPhilipp Reisner 313b411b363SPhilipp Reisner You must not have the req_lock: 314b411b363SPhilipp Reisner drbd_free_ee() 315b411b363SPhilipp Reisner drbd_alloc_ee() 316b411b363SPhilipp Reisner drbd_init_ee() 317b411b363SPhilipp Reisner drbd_release_ee() 318b411b363SPhilipp Reisner drbd_ee_fix_bhs() 319b411b363SPhilipp Reisner drbd_process_done_ee() 320b411b363SPhilipp Reisner drbd_clear_done_ee() 321b411b363SPhilipp Reisner drbd_wait_ee_list_empty() 322b411b363SPhilipp Reisner */ 323b411b363SPhilipp Reisner 324f6ffca9fSAndreas Gruenbacher struct drbd_peer_request * 325f6ffca9fSAndreas Gruenbacher drbd_alloc_ee(struct drbd_conf *mdev, u64 id, sector_t sector, 326f6ffca9fSAndreas Gruenbacher unsigned int data_size, gfp_t gfp_mask) __must_hold(local) 327b411b363SPhilipp Reisner { 328db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 329b411b363SPhilipp Reisner struct page *page; 33045bb912bSLars Ellenberg unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT; 331b411b363SPhilipp Reisner 3320cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE)) 333b411b363SPhilipp Reisner return NULL; 334b411b363SPhilipp Reisner 335db830c46SAndreas Gruenbacher peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM); 336db830c46SAndreas Gruenbacher if (!peer_req) { 337b411b363SPhilipp Reisner if (!(gfp_mask & __GFP_NOWARN)) 338b411b363SPhilipp Reisner dev_err(DEV, "alloc_ee: Allocation of an EE failed\n"); 339b411b363SPhilipp Reisner return NULL; 340b411b363SPhilipp Reisner } 341b411b363SPhilipp Reisner 34245bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT)); 34345bb912bSLars Ellenberg if (!page) 34445bb912bSLars Ellenberg goto fail; 345b411b363SPhilipp Reisner 346db830c46SAndreas Gruenbacher drbd_clear_interval(&peer_req->i); 347db830c46SAndreas Gruenbacher peer_req->i.size = data_size; 348db830c46SAndreas Gruenbacher peer_req->i.sector = sector; 349db830c46SAndreas Gruenbacher peer_req->i.local = false; 350db830c46SAndreas Gruenbacher peer_req->i.waiting = false; 35153840641SAndreas Gruenbacher 352db830c46SAndreas Gruenbacher peer_req->epoch = NULL; 353a21e9298SPhilipp Reisner peer_req->w.mdev = mdev; 354db830c46SAndreas Gruenbacher peer_req->pages = page; 355db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, 0); 356db830c46SAndreas Gruenbacher peer_req->flags = 0; 3579a8e7753SAndreas Gruenbacher /* 3589a8e7753SAndreas Gruenbacher * The block_id is opaque to the receiver. It is not endianness 3599a8e7753SAndreas Gruenbacher * converted, and sent back to the sender unchanged. 3609a8e7753SAndreas Gruenbacher */ 361db830c46SAndreas Gruenbacher peer_req->block_id = id; 362b411b363SPhilipp Reisner 363db830c46SAndreas Gruenbacher return peer_req; 364b411b363SPhilipp Reisner 36545bb912bSLars Ellenberg fail: 366db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 367b411b363SPhilipp Reisner return NULL; 368b411b363SPhilipp Reisner } 369b411b363SPhilipp Reisner 370db830c46SAndreas Gruenbacher void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_peer_request *peer_req, 371f6ffca9fSAndreas Gruenbacher int is_net) 372b411b363SPhilipp Reisner { 373db830c46SAndreas Gruenbacher if (peer_req->flags & EE_HAS_DIGEST) 374db830c46SAndreas Gruenbacher kfree(peer_req->digest); 375db830c46SAndreas Gruenbacher drbd_pp_free(mdev, peer_req->pages, is_net); 376db830c46SAndreas Gruenbacher D_ASSERT(atomic_read(&peer_req->pending_bios) == 0); 377db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 378db830c46SAndreas Gruenbacher mempool_free(peer_req, drbd_ee_mempool); 379b411b363SPhilipp Reisner } 380b411b363SPhilipp Reisner 381b411b363SPhilipp Reisner int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list) 382b411b363SPhilipp Reisner { 383b411b363SPhilipp Reisner LIST_HEAD(work_list); 384db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 385b411b363SPhilipp Reisner int count = 0; 386435f0740SLars Ellenberg int is_net = list == &mdev->net_ee; 387b411b363SPhilipp Reisner 38887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 389b411b363SPhilipp Reisner list_splice_init(list, &work_list); 39087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 391b411b363SPhilipp Reisner 392db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 393db830c46SAndreas Gruenbacher drbd_free_some_ee(mdev, peer_req, is_net); 394b411b363SPhilipp Reisner count++; 395b411b363SPhilipp Reisner } 396b411b363SPhilipp Reisner return count; 397b411b363SPhilipp Reisner } 398b411b363SPhilipp Reisner 399b411b363SPhilipp Reisner 40032862ec7SPhilipp Reisner /* See also comments in _req_mod(,BARRIER_ACKED) 401b411b363SPhilipp Reisner * and receive_Barrier. 402b411b363SPhilipp Reisner * 403b411b363SPhilipp Reisner * Move entries from net_ee to done_ee, if ready. 404b411b363SPhilipp Reisner * Grab done_ee, call all callbacks, free the entries. 405b411b363SPhilipp Reisner * The callbacks typically send out ACKs. 406b411b363SPhilipp Reisner */ 407b411b363SPhilipp Reisner static int drbd_process_done_ee(struct drbd_conf *mdev) 408b411b363SPhilipp Reisner { 409b411b363SPhilipp Reisner LIST_HEAD(work_list); 410b411b363SPhilipp Reisner LIST_HEAD(reclaimed); 411db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req, *t; 412e2b3032bSAndreas Gruenbacher int err = 0; 413b411b363SPhilipp Reisner 41487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 415b411b363SPhilipp Reisner reclaim_net_ee(mdev, &reclaimed); 416b411b363SPhilipp Reisner list_splice_init(&mdev->done_ee, &work_list); 41787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 418b411b363SPhilipp Reisner 419db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &reclaimed, w.list) 420db830c46SAndreas Gruenbacher drbd_free_net_ee(mdev, peer_req); 421b411b363SPhilipp Reisner 422b411b363SPhilipp Reisner /* possible callbacks here: 4237be8da07SAndreas Gruenbacher * e_end_block, and e_end_resync_block, e_send_discard_write. 424b411b363SPhilipp Reisner * all ignore the last argument. 425b411b363SPhilipp Reisner */ 426db830c46SAndreas Gruenbacher list_for_each_entry_safe(peer_req, t, &work_list, w.list) { 427e2b3032bSAndreas Gruenbacher int err2; 428e2b3032bSAndreas Gruenbacher 429b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 430e2b3032bSAndreas Gruenbacher err2 = peer_req->w.cb(&peer_req->w, !!err); 431e2b3032bSAndreas Gruenbacher if (!err) 432e2b3032bSAndreas Gruenbacher err = err2; 433db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 434b411b363SPhilipp Reisner } 435b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 436b411b363SPhilipp Reisner 437e2b3032bSAndreas Gruenbacher return err; 438b411b363SPhilipp Reisner } 439b411b363SPhilipp Reisner 440b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 441b411b363SPhilipp Reisner { 442b411b363SPhilipp Reisner DEFINE_WAIT(wait); 443b411b363SPhilipp Reisner 444b411b363SPhilipp Reisner /* avoids spin_lock/unlock 445b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 446b411b363SPhilipp Reisner while (!list_empty(head)) { 447b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 44887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4497eaceaccSJens Axboe io_schedule(); 450b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 45187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 452b411b363SPhilipp Reisner } 453b411b363SPhilipp Reisner } 454b411b363SPhilipp Reisner 455b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 456b411b363SPhilipp Reisner { 45787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 458b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 45987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 460b411b363SPhilipp Reisner } 461b411b363SPhilipp Reisner 462b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 463b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4647653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 465b411b363SPhilipp Reisner { 466b411b363SPhilipp Reisner struct sock *sk = sock->sk; 467b411b363SPhilipp Reisner int err = 0; 468b411b363SPhilipp Reisner 469b411b363SPhilipp Reisner *what = "listen"; 470b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 471b411b363SPhilipp Reisner if (err < 0) 472b411b363SPhilipp Reisner goto out; 473b411b363SPhilipp Reisner 474b411b363SPhilipp Reisner *what = "sock_create_lite"; 475b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 476b411b363SPhilipp Reisner newsock); 477b411b363SPhilipp Reisner if (err < 0) 478b411b363SPhilipp Reisner goto out; 479b411b363SPhilipp Reisner 480b411b363SPhilipp Reisner *what = "accept"; 481b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 482b411b363SPhilipp Reisner if (err < 0) { 483b411b363SPhilipp Reisner sock_release(*newsock); 484b411b363SPhilipp Reisner *newsock = NULL; 485b411b363SPhilipp Reisner goto out; 486b411b363SPhilipp Reisner } 487b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 488b411b363SPhilipp Reisner 489b411b363SPhilipp Reisner out: 490b411b363SPhilipp Reisner return err; 491b411b363SPhilipp Reisner } 492b411b363SPhilipp Reisner 493dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 494b411b363SPhilipp Reisner { 495b411b363SPhilipp Reisner mm_segment_t oldfs; 496b411b363SPhilipp Reisner struct kvec iov = { 497b411b363SPhilipp Reisner .iov_base = buf, 498b411b363SPhilipp Reisner .iov_len = size, 499b411b363SPhilipp Reisner }; 500b411b363SPhilipp Reisner struct msghdr msg = { 501b411b363SPhilipp Reisner .msg_iovlen = 1, 502b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 503b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 504b411b363SPhilipp Reisner }; 505b411b363SPhilipp Reisner int rv; 506b411b363SPhilipp Reisner 507b411b363SPhilipp Reisner oldfs = get_fs(); 508b411b363SPhilipp Reisner set_fs(KERNEL_DS); 509b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 510b411b363SPhilipp Reisner set_fs(oldfs); 511b411b363SPhilipp Reisner 512b411b363SPhilipp Reisner return rv; 513b411b363SPhilipp Reisner } 514b411b363SPhilipp Reisner 515de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 516b411b363SPhilipp Reisner { 517b411b363SPhilipp Reisner mm_segment_t oldfs; 518b411b363SPhilipp Reisner struct kvec iov = { 519b411b363SPhilipp Reisner .iov_base = buf, 520b411b363SPhilipp Reisner .iov_len = size, 521b411b363SPhilipp Reisner }; 522b411b363SPhilipp Reisner struct msghdr msg = { 523b411b363SPhilipp Reisner .msg_iovlen = 1, 524b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 525b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 526b411b363SPhilipp Reisner }; 527b411b363SPhilipp Reisner int rv; 528b411b363SPhilipp Reisner 529b411b363SPhilipp Reisner oldfs = get_fs(); 530b411b363SPhilipp Reisner set_fs(KERNEL_DS); 531b411b363SPhilipp Reisner 532b411b363SPhilipp Reisner for (;;) { 533de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 534b411b363SPhilipp Reisner if (rv == size) 535b411b363SPhilipp Reisner break; 536b411b363SPhilipp Reisner 537b411b363SPhilipp Reisner /* Note: 538b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 539b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 540b411b363SPhilipp Reisner */ 541b411b363SPhilipp Reisner 542b411b363SPhilipp Reisner if (rv < 0) { 543b411b363SPhilipp Reisner if (rv == -ECONNRESET) 544de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 545b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 546de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 547b411b363SPhilipp Reisner break; 548b411b363SPhilipp Reisner } else if (rv == 0) { 549de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 550b411b363SPhilipp Reisner break; 551b411b363SPhilipp Reisner } else { 552b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 553b411b363SPhilipp Reisner * after we read a partial message 554b411b363SPhilipp Reisner */ 555b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 556b411b363SPhilipp Reisner break; 557b411b363SPhilipp Reisner } 558b411b363SPhilipp Reisner }; 559b411b363SPhilipp Reisner 560b411b363SPhilipp Reisner set_fs(oldfs); 561b411b363SPhilipp Reisner 562b411b363SPhilipp Reisner if (rv != size) 563bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 564b411b363SPhilipp Reisner 565b411b363SPhilipp Reisner return rv; 566b411b363SPhilipp Reisner } 567b411b363SPhilipp Reisner 568c6967746SAndreas Gruenbacher static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size) 569c6967746SAndreas Gruenbacher { 570c6967746SAndreas Gruenbacher int err; 571c6967746SAndreas Gruenbacher 572c6967746SAndreas Gruenbacher err = drbd_recv(tconn, buf, size); 573c6967746SAndreas Gruenbacher if (err != size) { 574c6967746SAndreas Gruenbacher if (err >= 0) 575c6967746SAndreas Gruenbacher err = -EIO; 576c6967746SAndreas Gruenbacher } else 577c6967746SAndreas Gruenbacher err = 0; 578c6967746SAndreas Gruenbacher return err; 579c6967746SAndreas Gruenbacher } 580c6967746SAndreas Gruenbacher 5815dbf1673SLars Ellenberg /* quoting tcp(7): 5825dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5835dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5845dbf1673SLars Ellenberg * This is our wrapper to do so. 5855dbf1673SLars Ellenberg */ 5865dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5875dbf1673SLars Ellenberg unsigned int rcv) 5885dbf1673SLars Ellenberg { 5895dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5905dbf1673SLars Ellenberg if (snd) { 5915dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5925dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5935dbf1673SLars Ellenberg } 5945dbf1673SLars Ellenberg if (rcv) { 5955dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5965dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5975dbf1673SLars Ellenberg } 5985dbf1673SLars Ellenberg } 5995dbf1673SLars Ellenberg 600eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 601b411b363SPhilipp Reisner { 602b411b363SPhilipp Reisner const char *what; 603b411b363SPhilipp Reisner struct socket *sock; 604b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 605b411b363SPhilipp Reisner int err; 606b411b363SPhilipp Reisner int disconnect_on_error = 1; 607b411b363SPhilipp Reisner 608eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 609b411b363SPhilipp Reisner return NULL; 610b411b363SPhilipp Reisner 611b411b363SPhilipp Reisner what = "sock_create_kern"; 612eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 613b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 614b411b363SPhilipp Reisner if (err < 0) { 615b411b363SPhilipp Reisner sock = NULL; 616b411b363SPhilipp Reisner goto out; 617b411b363SPhilipp Reisner } 618b411b363SPhilipp Reisner 619b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 620eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 621eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 622eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 623b411b363SPhilipp Reisner 624b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 625b411b363SPhilipp Reisner * for the outgoing connections. 626b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 627b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 628b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 629b411b363SPhilipp Reisner * a free one dynamically. 630b411b363SPhilipp Reisner */ 631eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 632eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 633eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 634b411b363SPhilipp Reisner src_in6.sin6_port = 0; 635b411b363SPhilipp Reisner else 636b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 637b411b363SPhilipp Reisner 638b411b363SPhilipp Reisner what = "bind before connect"; 639b411b363SPhilipp Reisner err = sock->ops->bind(sock, 640b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 641eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 642b411b363SPhilipp Reisner if (err < 0) 643b411b363SPhilipp Reisner goto out; 644b411b363SPhilipp Reisner 645b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 646b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 647b411b363SPhilipp Reisner disconnect_on_error = 0; 648b411b363SPhilipp Reisner what = "connect"; 649b411b363SPhilipp Reisner err = sock->ops->connect(sock, 650eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 651eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 652b411b363SPhilipp Reisner 653b411b363SPhilipp Reisner out: 654b411b363SPhilipp Reisner if (err < 0) { 655b411b363SPhilipp Reisner if (sock) { 656b411b363SPhilipp Reisner sock_release(sock); 657b411b363SPhilipp Reisner sock = NULL; 658b411b363SPhilipp Reisner } 659b411b363SPhilipp Reisner switch (-err) { 660b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 661b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 662b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 663b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 664b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 665b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 666b411b363SPhilipp Reisner disconnect_on_error = 0; 667b411b363SPhilipp Reisner break; 668b411b363SPhilipp Reisner default: 669eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 670b411b363SPhilipp Reisner } 671b411b363SPhilipp Reisner if (disconnect_on_error) 672bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 673b411b363SPhilipp Reisner } 674eac3e990SPhilipp Reisner put_net_conf(tconn); 675b411b363SPhilipp Reisner return sock; 676b411b363SPhilipp Reisner } 677b411b363SPhilipp Reisner 6787653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 679b411b363SPhilipp Reisner { 680b411b363SPhilipp Reisner int timeo, err; 681b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 682b411b363SPhilipp Reisner const char *what; 683b411b363SPhilipp Reisner 6847653620dSPhilipp Reisner if (!get_net_conf(tconn)) 685b411b363SPhilipp Reisner return NULL; 686b411b363SPhilipp Reisner 687b411b363SPhilipp Reisner what = "sock_create_kern"; 6887653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 689b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 690b411b363SPhilipp Reisner if (err) { 691b411b363SPhilipp Reisner s_listen = NULL; 692b411b363SPhilipp Reisner goto out; 693b411b363SPhilipp Reisner } 694b411b363SPhilipp Reisner 6957653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 696b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 697b411b363SPhilipp Reisner 698b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 699b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 700b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 7017653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 7027653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 703b411b363SPhilipp Reisner 704b411b363SPhilipp Reisner what = "bind before listen"; 705b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 7067653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 7077653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 708b411b363SPhilipp Reisner if (err < 0) 709b411b363SPhilipp Reisner goto out; 710b411b363SPhilipp Reisner 7117653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 712b411b363SPhilipp Reisner 713b411b363SPhilipp Reisner out: 714b411b363SPhilipp Reisner if (s_listen) 715b411b363SPhilipp Reisner sock_release(s_listen); 716b411b363SPhilipp Reisner if (err < 0) { 717b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7187653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 719bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 720b411b363SPhilipp Reisner } 721b411b363SPhilipp Reisner } 7227653620dSPhilipp Reisner put_net_conf(tconn); 723b411b363SPhilipp Reisner 724b411b363SPhilipp Reisner return s_estab; 725b411b363SPhilipp Reisner } 726b411b363SPhilipp Reisner 727d38e787eSPhilipp Reisner static int drbd_send_fp(struct drbd_tconn *tconn, struct socket *sock, enum drbd_packet cmd) 728b411b363SPhilipp Reisner { 729d38e787eSPhilipp Reisner struct p_header *h = &tconn->data.sbuf.header; 730b411b363SPhilipp Reisner 731ecf2363cSAndreas Gruenbacher return !_conn_send_cmd(tconn, 0, sock, cmd, h, sizeof(*h), 0); 732b411b363SPhilipp Reisner } 733b411b363SPhilipp Reisner 734a25b63f1SPhilipp Reisner static enum drbd_packet drbd_recv_fp(struct drbd_tconn *tconn, struct socket *sock) 735b411b363SPhilipp Reisner { 736a25b63f1SPhilipp Reisner struct p_header80 *h = &tconn->data.rbuf.header.h80; 737b411b363SPhilipp Reisner int rr; 738b411b363SPhilipp Reisner 739dbd9eea0SPhilipp Reisner rr = drbd_recv_short(sock, h, sizeof(*h), 0); 740b411b363SPhilipp Reisner 741ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 742b411b363SPhilipp Reisner return be16_to_cpu(h->command); 743b411b363SPhilipp Reisner 744b411b363SPhilipp Reisner return 0xffff; 745b411b363SPhilipp Reisner } 746b411b363SPhilipp Reisner 747b411b363SPhilipp Reisner /** 748b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 749b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 750b411b363SPhilipp Reisner */ 751dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 752b411b363SPhilipp Reisner { 753b411b363SPhilipp Reisner int rr; 754b411b363SPhilipp Reisner char tb[4]; 755b411b363SPhilipp Reisner 756b411b363SPhilipp Reisner if (!*sock) 75781e84650SAndreas Gruenbacher return false; 758b411b363SPhilipp Reisner 759dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 760b411b363SPhilipp Reisner 761b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 76281e84650SAndreas Gruenbacher return true; 763b411b363SPhilipp Reisner } else { 764b411b363SPhilipp Reisner sock_release(*sock); 765b411b363SPhilipp Reisner *sock = NULL; 76681e84650SAndreas Gruenbacher return false; 767b411b363SPhilipp Reisner } 768b411b363SPhilipp Reisner } 7692325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 7702325eb66SPhilipp Reisner in a connection */ 7712325eb66SPhilipp Reisner int drbd_connected(int vnr, void *p, void *data) 772907599e0SPhilipp Reisner { 773907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 774907599e0SPhilipp Reisner int ok = 1; 775907599e0SPhilipp Reisner 776907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 777907599e0SPhilipp Reisner mdev->peer_seq = 0; 778907599e0SPhilipp Reisner 7798410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 7808410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 7818410da8fSPhilipp Reisner &mdev->own_state_mutex; 7828410da8fSPhilipp Reisner 783103ea275SAndreas Gruenbacher ok &= !drbd_send_sync_param(mdev); 784f02d4d0aSAndreas Gruenbacher ok &= !drbd_send_sizes(mdev, 0, 0); 7852ae5f95bSAndreas Gruenbacher ok &= !drbd_send_uuids(mdev); 786927036f9SAndreas Gruenbacher ok &= !drbd_send_state(mdev); 787907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 788907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 789907599e0SPhilipp Reisner 7908410da8fSPhilipp Reisner 791907599e0SPhilipp Reisner return !ok; 792907599e0SPhilipp Reisner } 793907599e0SPhilipp Reisner 794b411b363SPhilipp Reisner /* 795b411b363SPhilipp Reisner * return values: 796b411b363SPhilipp Reisner * 1 yes, we have a valid connection 797b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 798b411b363SPhilipp Reisner * -1 peer talks different language, 799b411b363SPhilipp Reisner * no point in trying again, please go standalone. 800b411b363SPhilipp Reisner * -2 We do not have a network config... 801b411b363SPhilipp Reisner */ 802907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 803b411b363SPhilipp Reisner { 804b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 805b411b363SPhilipp Reisner int try, h, ok; 806b411b363SPhilipp Reisner 807bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 808b411b363SPhilipp Reisner return -2; 809b411b363SPhilipp Reisner 810907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 811907599e0SPhilipp Reisner tconn->agreed_pro_version = 99; 812fd340c12SPhilipp Reisner /* agreed_pro_version must be smaller than 100 so we send the old 813fd340c12SPhilipp Reisner header (h80) in the first packet and in the handshake packet. */ 814b411b363SPhilipp Reisner 815b411b363SPhilipp Reisner sock = NULL; 816b411b363SPhilipp Reisner msock = NULL; 817b411b363SPhilipp Reisner 818b411b363SPhilipp Reisner do { 819b411b363SPhilipp Reisner for (try = 0;;) { 820b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 821907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 822b411b363SPhilipp Reisner if (s || ++try >= 3) 823b411b363SPhilipp Reisner break; 824b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 82520ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 826b411b363SPhilipp Reisner } 827b411b363SPhilipp Reisner 828b411b363SPhilipp Reisner if (s) { 829b411b363SPhilipp Reisner if (!sock) { 830907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_S); 831b411b363SPhilipp Reisner sock = s; 832b411b363SPhilipp Reisner s = NULL; 833b411b363SPhilipp Reisner } else if (!msock) { 834907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_M); 835b411b363SPhilipp Reisner msock = s; 836b411b363SPhilipp Reisner s = NULL; 837b411b363SPhilipp Reisner } else { 838907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 839b411b363SPhilipp Reisner goto out_release_sockets; 840b411b363SPhilipp Reisner } 841b411b363SPhilipp Reisner } 842b411b363SPhilipp Reisner 843b411b363SPhilipp Reisner if (sock && msock) { 844907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 845dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 846dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 847b411b363SPhilipp Reisner if (ok) 848b411b363SPhilipp Reisner break; 849b411b363SPhilipp Reisner } 850b411b363SPhilipp Reisner 851b411b363SPhilipp Reisner retry: 852907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 853b411b363SPhilipp Reisner if (s) { 854907599e0SPhilipp Reisner try = drbd_recv_fp(tconn, s); 855dbd9eea0SPhilipp Reisner drbd_socket_okay(&sock); 856dbd9eea0SPhilipp Reisner drbd_socket_okay(&msock); 857b411b363SPhilipp Reisner switch (try) { 858b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 859b411b363SPhilipp Reisner if (sock) { 860907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 861b411b363SPhilipp Reisner sock_release(sock); 862b411b363SPhilipp Reisner } 863b411b363SPhilipp Reisner sock = s; 864b411b363SPhilipp Reisner break; 865b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 866b411b363SPhilipp Reisner if (msock) { 867907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 868b411b363SPhilipp Reisner sock_release(msock); 869b411b363SPhilipp Reisner } 870b411b363SPhilipp Reisner msock = s; 871907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 872b411b363SPhilipp Reisner break; 873b411b363SPhilipp Reisner default: 874907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 875b411b363SPhilipp Reisner sock_release(s); 876b411b363SPhilipp Reisner if (random32() & 1) 877b411b363SPhilipp Reisner goto retry; 878b411b363SPhilipp Reisner } 879b411b363SPhilipp Reisner } 880b411b363SPhilipp Reisner 881bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 882b411b363SPhilipp Reisner goto out_release_sockets; 883b411b363SPhilipp Reisner if (signal_pending(current)) { 884b411b363SPhilipp Reisner flush_signals(current); 885b411b363SPhilipp Reisner smp_rmb(); 886907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 887b411b363SPhilipp Reisner goto out_release_sockets; 888b411b363SPhilipp Reisner } 889b411b363SPhilipp Reisner 890b411b363SPhilipp Reisner if (sock && msock) { 891dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 892dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 893b411b363SPhilipp Reisner if (ok) 894b411b363SPhilipp Reisner break; 895b411b363SPhilipp Reisner } 896b411b363SPhilipp Reisner } while (1); 897b411b363SPhilipp Reisner 898b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 899b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 900b411b363SPhilipp Reisner 901b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 902b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 903b411b363SPhilipp Reisner 904b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 905b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 906b411b363SPhilipp Reisner 907b411b363SPhilipp Reisner /* NOT YET ... 908907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 909b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 910b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 911b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 912b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 913907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 914b411b363SPhilipp Reisner 915907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 916907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 917b411b363SPhilipp Reisner 918b411b363SPhilipp Reisner /* we don't want delays. 91925985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 920b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 921b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 922b411b363SPhilipp Reisner 923907599e0SPhilipp Reisner tconn->data.socket = sock; 924907599e0SPhilipp Reisner tconn->meta.socket = msock; 925907599e0SPhilipp Reisner tconn->last_received = jiffies; 926b411b363SPhilipp Reisner 927907599e0SPhilipp Reisner h = drbd_do_handshake(tconn); 928b411b363SPhilipp Reisner if (h <= 0) 929b411b363SPhilipp Reisner return h; 930b411b363SPhilipp Reisner 931907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 932b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 933907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 934b10d96cbSJohannes Thoma case -1: 935907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 936b411b363SPhilipp Reisner return -1; 937b10d96cbSJohannes Thoma case 0: 938907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 939b10d96cbSJohannes Thoma return 0; 940b411b363SPhilipp Reisner } 941b411b363SPhilipp Reisner } 942b411b363SPhilipp Reisner 943bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 944b411b363SPhilipp Reisner return 0; 945b411b363SPhilipp Reisner 946907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 947b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 948b411b363SPhilipp Reisner 949907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 950b411b363SPhilipp Reisner 951387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 9527e2455c1SPhilipp Reisner return -1; 953b411b363SPhilipp Reisner 954907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 955b411b363SPhilipp Reisner 956b411b363SPhilipp Reisner out_release_sockets: 957b411b363SPhilipp Reisner if (sock) 958b411b363SPhilipp Reisner sock_release(sock); 959b411b363SPhilipp Reisner if (msock) 960b411b363SPhilipp Reisner sock_release(msock); 961b411b363SPhilipp Reisner return -1; 962b411b363SPhilipp Reisner } 963b411b363SPhilipp Reisner 9648172f3e9SAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, struct p_header *h, struct packet_info *pi) 965b411b363SPhilipp Reisner { 966fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 96777351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h80.command); 96877351055SPhilipp Reisner pi->size = be16_to_cpu(h->h80.length); 969eefc2f7dSPhilipp Reisner pi->vnr = 0; 970ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 97177351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h95.command); 97277351055SPhilipp Reisner pi->size = be32_to_cpu(h->h95.length) & 0x00ffffff; 97377351055SPhilipp Reisner pi->vnr = 0; 97402918be2SPhilipp Reisner } else { 975ce243853SPhilipp Reisner conn_err(tconn, "magic?? on data m: 0x%08x c: %d l: %d\n", 976004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 977004352faSLars Ellenberg be16_to_cpu(h->h80.command), 978004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 9798172f3e9SAndreas Gruenbacher return -EINVAL; 980b411b363SPhilipp Reisner } 9818172f3e9SAndreas Gruenbacher return 0; 982257d0af6SPhilipp Reisner } 983257d0af6SPhilipp Reisner 9849ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 985257d0af6SPhilipp Reisner { 9869ba7aa00SPhilipp Reisner struct p_header *h = &tconn->data.rbuf.header; 98769bc7bc3SAndreas Gruenbacher int err; 988257d0af6SPhilipp Reisner 98969bc7bc3SAndreas Gruenbacher err = drbd_recv(tconn, h, sizeof(*h)); 99069bc7bc3SAndreas Gruenbacher if (unlikely(err != sizeof(*h))) { 991257d0af6SPhilipp Reisner if (!signal_pending(current)) 99269bc7bc3SAndreas Gruenbacher conn_warn(tconn, "short read expecting header on sock: r=%d\n", err); 99369bc7bc3SAndreas Gruenbacher if (err >= 0) 99469bc7bc3SAndreas Gruenbacher err = -EIO; 99569bc7bc3SAndreas Gruenbacher return err; 996257d0af6SPhilipp Reisner } 997257d0af6SPhilipp Reisner 99869bc7bc3SAndreas Gruenbacher err = decode_header(tconn, h, pi); 9999ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1000b411b363SPhilipp Reisner 100169bc7bc3SAndreas Gruenbacher return err; 1002b411b363SPhilipp Reisner } 1003b411b363SPhilipp Reisner 10042451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 1005b411b363SPhilipp Reisner { 1006b411b363SPhilipp Reisner int rv; 1007b411b363SPhilipp Reisner 1008b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 1009fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 1010dd3932edSChristoph Hellwig NULL); 1011b411b363SPhilipp Reisner if (rv) { 1012b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 1013b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1014b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1015b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1016b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 1017b411b363SPhilipp Reisner } 1018b411b363SPhilipp Reisner put_ldev(mdev); 1019b411b363SPhilipp Reisner } 1020b411b363SPhilipp Reisner } 1021b411b363SPhilipp Reisner 1022b411b363SPhilipp Reisner /** 1023b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1024b411b363SPhilipp Reisner * @mdev: DRBD device. 1025b411b363SPhilipp Reisner * @epoch: Epoch object. 1026b411b363SPhilipp Reisner * @ev: Epoch event. 1027b411b363SPhilipp Reisner */ 1028b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1029b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1030b411b363SPhilipp Reisner enum epoch_event ev) 1031b411b363SPhilipp Reisner { 10322451fc3bSPhilipp Reisner int epoch_size; 1033b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1034b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1035b411b363SPhilipp Reisner 1036b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1037b411b363SPhilipp Reisner do { 1038b411b363SPhilipp Reisner next_epoch = NULL; 1039b411b363SPhilipp Reisner 1040b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1041b411b363SPhilipp Reisner 1042b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1043b411b363SPhilipp Reisner case EV_PUT: 1044b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1045b411b363SPhilipp Reisner break; 1046b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1047b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1048b411b363SPhilipp Reisner break; 1049b411b363SPhilipp Reisner case EV_BECAME_LAST: 1050b411b363SPhilipp Reisner /* nothing to do*/ 1051b411b363SPhilipp Reisner break; 1052b411b363SPhilipp Reisner } 1053b411b363SPhilipp Reisner 1054b411b363SPhilipp Reisner if (epoch_size != 0 && 1055b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10562451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1057b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1058b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1059b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1060b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1061b411b363SPhilipp Reisner } 1062b411b363SPhilipp Reisner dec_unacked(mdev); 1063b411b363SPhilipp Reisner 1064b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1065b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1066b411b363SPhilipp Reisner list_del(&epoch->list); 1067b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1068b411b363SPhilipp Reisner mdev->epochs--; 1069b411b363SPhilipp Reisner kfree(epoch); 1070b411b363SPhilipp Reisner 1071b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1072b411b363SPhilipp Reisner rv = FE_DESTROYED; 1073b411b363SPhilipp Reisner } else { 1074b411b363SPhilipp Reisner epoch->flags = 0; 1075b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1076698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1077b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1078b411b363SPhilipp Reisner rv = FE_RECYCLED; 10792451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1080b411b363SPhilipp Reisner } 1081b411b363SPhilipp Reisner } 1082b411b363SPhilipp Reisner 1083b411b363SPhilipp Reisner if (!next_epoch) 1084b411b363SPhilipp Reisner break; 1085b411b363SPhilipp Reisner 1086b411b363SPhilipp Reisner epoch = next_epoch; 1087b411b363SPhilipp Reisner } while (1); 1088b411b363SPhilipp Reisner 1089b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1090b411b363SPhilipp Reisner 1091b411b363SPhilipp Reisner return rv; 1092b411b363SPhilipp Reisner } 1093b411b363SPhilipp Reisner 1094b411b363SPhilipp Reisner /** 1095b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1096b411b363SPhilipp Reisner * @mdev: DRBD device. 1097b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1098b411b363SPhilipp Reisner */ 1099b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1100b411b363SPhilipp Reisner { 1101b411b363SPhilipp Reisner enum write_ordering_e pwo; 1102b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1103b411b363SPhilipp Reisner [WO_none] = "none", 1104b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1105b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1106b411b363SPhilipp Reisner }; 1107b411b363SPhilipp Reisner 1108b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1109b411b363SPhilipp Reisner wo = min(pwo, wo); 1110b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1111b411b363SPhilipp Reisner wo = WO_drain_io; 1112b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1113b411b363SPhilipp Reisner wo = WO_none; 1114b411b363SPhilipp Reisner mdev->write_ordering = wo; 11152451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1116b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1117b411b363SPhilipp Reisner } 1118b411b363SPhilipp Reisner 1119b411b363SPhilipp Reisner /** 1120fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 112145bb912bSLars Ellenberg * @mdev: DRBD device. 1122db830c46SAndreas Gruenbacher * @peer_req: peer request 112345bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 112410f6d992SLars Ellenberg * 112510f6d992SLars Ellenberg * May spread the pages to multiple bios, 112610f6d992SLars Ellenberg * depending on bio_add_page restrictions. 112710f6d992SLars Ellenberg * 112810f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 112910f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 113010f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 113110f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 113210f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 113310f6d992SLars Ellenberg * on certain Xen deployments. 113445bb912bSLars Ellenberg */ 113545bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1136fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1137fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 113845bb912bSLars Ellenberg const unsigned rw, const int fault_type) 113945bb912bSLars Ellenberg { 114045bb912bSLars Ellenberg struct bio *bios = NULL; 114145bb912bSLars Ellenberg struct bio *bio; 1142db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1143db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1144db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 114545bb912bSLars Ellenberg unsigned n_bios = 0; 114645bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 114710f6d992SLars Ellenberg int err = -ENOMEM; 114845bb912bSLars Ellenberg 114945bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 115045bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 115145bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1152da4a75d2SLars Ellenberg * request in more than one bio. 1153da4a75d2SLars Ellenberg * 1154da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1155da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1156da4a75d2SLars Ellenberg */ 115745bb912bSLars Ellenberg next_bio: 115845bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 115945bb912bSLars Ellenberg if (!bio) { 116045bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 116145bb912bSLars Ellenberg goto fail; 116245bb912bSLars Ellenberg } 1163db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 116445bb912bSLars Ellenberg bio->bi_sector = sector; 116545bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 116645bb912bSLars Ellenberg bio->bi_rw = rw; 1167db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1168fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 116945bb912bSLars Ellenberg 117045bb912bSLars Ellenberg bio->bi_next = bios; 117145bb912bSLars Ellenberg bios = bio; 117245bb912bSLars Ellenberg ++n_bios; 117345bb912bSLars Ellenberg 117445bb912bSLars Ellenberg page_chain_for_each(page) { 117545bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 117645bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 117710f6d992SLars Ellenberg /* A single page must always be possible! 117810f6d992SLars Ellenberg * But in case it fails anyways, 117910f6d992SLars Ellenberg * we deal with it, and complain (below). */ 118010f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 118110f6d992SLars Ellenberg dev_err(DEV, 118210f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 118310f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 118410f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 118510f6d992SLars Ellenberg err = -ENOSPC; 118610f6d992SLars Ellenberg goto fail; 118710f6d992SLars Ellenberg } 118845bb912bSLars Ellenberg goto next_bio; 118945bb912bSLars Ellenberg } 119045bb912bSLars Ellenberg ds -= len; 119145bb912bSLars Ellenberg sector += len >> 9; 119245bb912bSLars Ellenberg --nr_pages; 119345bb912bSLars Ellenberg } 119445bb912bSLars Ellenberg D_ASSERT(page == NULL); 119545bb912bSLars Ellenberg D_ASSERT(ds == 0); 119645bb912bSLars Ellenberg 1197db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 119845bb912bSLars Ellenberg do { 119945bb912bSLars Ellenberg bio = bios; 120045bb912bSLars Ellenberg bios = bios->bi_next; 120145bb912bSLars Ellenberg bio->bi_next = NULL; 120245bb912bSLars Ellenberg 120345bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 120445bb912bSLars Ellenberg } while (bios); 120545bb912bSLars Ellenberg return 0; 120645bb912bSLars Ellenberg 120745bb912bSLars Ellenberg fail: 120845bb912bSLars Ellenberg while (bios) { 120945bb912bSLars Ellenberg bio = bios; 121045bb912bSLars Ellenberg bios = bios->bi_next; 121145bb912bSLars Ellenberg bio_put(bio); 121245bb912bSLars Ellenberg } 121310f6d992SLars Ellenberg return err; 121445bb912bSLars Ellenberg } 121545bb912bSLars Ellenberg 121653840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1217db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 121853840641SAndreas Gruenbacher { 1219db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 122053840641SAndreas Gruenbacher 122153840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 122253840641SAndreas Gruenbacher drbd_clear_interval(i); 122353840641SAndreas Gruenbacher 12246c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 122553840641SAndreas Gruenbacher if (i->waiting) 122653840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 122753840641SAndreas Gruenbacher } 122853840641SAndreas Gruenbacher 1229d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1230d8763023SAndreas Gruenbacher unsigned int data_size) 1231b411b363SPhilipp Reisner { 12322451fc3bSPhilipp Reisner int rv; 1233e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.rbuf.barrier; 1234b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1235b411b363SPhilipp Reisner 1236b411b363SPhilipp Reisner inc_unacked(mdev); 1237b411b363SPhilipp Reisner 1238b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1239b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1240b411b363SPhilipp Reisner 1241b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1242b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1243b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1244b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1245b411b363SPhilipp Reisner * completed. */ 1246b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1247b411b363SPhilipp Reisner case WO_none: 1248b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 124981e84650SAndreas Gruenbacher return true; 1250b411b363SPhilipp Reisner 1251b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1252b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1253b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12542451fc3bSPhilipp Reisner if (epoch) 12552451fc3bSPhilipp Reisner break; 12562451fc3bSPhilipp Reisner else 1257b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12582451fc3bSPhilipp Reisner /* Fall through */ 12592451fc3bSPhilipp Reisner 12602451fc3bSPhilipp Reisner case WO_bdev_flush: 12612451fc3bSPhilipp Reisner case WO_drain_io: 1262b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12632451fc3bSPhilipp Reisner drbd_flush(mdev); 12642451fc3bSPhilipp Reisner 12652451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12662451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12672451fc3bSPhilipp Reisner if (epoch) 12682451fc3bSPhilipp Reisner break; 1269b411b363SPhilipp Reisner } 1270b411b363SPhilipp Reisner 12712451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12722451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12732451fc3bSPhilipp Reisner 12742451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12752451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1276b411b363SPhilipp Reisner 127781e84650SAndreas Gruenbacher return true; 12782451fc3bSPhilipp Reisner default: 12792451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 128081e84650SAndreas Gruenbacher return false; 1281b411b363SPhilipp Reisner } 1282b411b363SPhilipp Reisner 1283b411b363SPhilipp Reisner epoch->flags = 0; 1284b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1285b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1286b411b363SPhilipp Reisner 1287b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1288b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1289b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1290b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1291b411b363SPhilipp Reisner mdev->epochs++; 1292b411b363SPhilipp Reisner } else { 1293b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1294b411b363SPhilipp Reisner kfree(epoch); 1295b411b363SPhilipp Reisner } 1296b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1297b411b363SPhilipp Reisner 129881e84650SAndreas Gruenbacher return true; 1299b411b363SPhilipp Reisner } 1300b411b363SPhilipp Reisner 1301b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1302b411b363SPhilipp Reisner * and from receive_Data */ 1303f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1304f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1305f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1306b411b363SPhilipp Reisner { 13076666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1308db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1309b411b363SPhilipp Reisner struct page *page; 131045bb912bSLars Ellenberg int dgs, ds, rr; 1311a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1312a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 13136b4388acSPhilipp Reisner unsigned long *data; 1314b411b363SPhilipp Reisner 1315a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1316a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1317b411b363SPhilipp Reisner 1318b411b363SPhilipp Reisner if (dgs) { 1319de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1320b411b363SPhilipp Reisner if (rr != dgs) { 13210ddc5549SLars Ellenberg if (!signal_pending(current)) 13220ddc5549SLars Ellenberg dev_warn(DEV, 13230ddc5549SLars Ellenberg "short read receiving data digest: read %d expected %d\n", 1324b411b363SPhilipp Reisner rr, dgs); 1325b411b363SPhilipp Reisner return NULL; 1326b411b363SPhilipp Reisner } 1327b411b363SPhilipp Reisner } 1328b411b363SPhilipp Reisner 1329b411b363SPhilipp Reisner data_size -= dgs; 1330b411b363SPhilipp Reisner 1331841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1332841ce241SAndreas Gruenbacher return NULL; 1333841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1334841ce241SAndreas Gruenbacher return NULL; 1335841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1336841ce241SAndreas Gruenbacher return NULL; 1337b411b363SPhilipp Reisner 13386666032aSLars Ellenberg /* even though we trust out peer, 13396666032aSLars Ellenberg * we sometimes have to double check. */ 13406666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1341fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1342fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13436666032aSLars Ellenberg (unsigned long long)capacity, 13446666032aSLars Ellenberg (unsigned long long)sector, data_size); 13456666032aSLars Ellenberg return NULL; 13466666032aSLars Ellenberg } 13476666032aSLars Ellenberg 1348b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1349b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1350b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1351db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1352db830c46SAndreas Gruenbacher if (!peer_req) 1353b411b363SPhilipp Reisner return NULL; 135445bb912bSLars Ellenberg 1355b411b363SPhilipp Reisner ds = data_size; 1356db830c46SAndreas Gruenbacher page = peer_req->pages; 135745bb912bSLars Ellenberg page_chain_for_each(page) { 135845bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13596b4388acSPhilipp Reisner data = kmap(page); 1360de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, len); 13610cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13626b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13636b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13646b4388acSPhilipp Reisner } 1365b411b363SPhilipp Reisner kunmap(page); 136645bb912bSLars Ellenberg if (rr != len) { 1367db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 13680ddc5549SLars Ellenberg if (!signal_pending(current)) 1369b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 137045bb912bSLars Ellenberg rr, len); 1371b411b363SPhilipp Reisner return NULL; 1372b411b363SPhilipp Reisner } 1373b411b363SPhilipp Reisner ds -= rr; 1374b411b363SPhilipp Reisner } 1375b411b363SPhilipp Reisner 1376b411b363SPhilipp Reisner if (dgs) { 1377db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1378b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1379470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1380470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1381db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1382b411b363SPhilipp Reisner return NULL; 1383b411b363SPhilipp Reisner } 1384b411b363SPhilipp Reisner } 1385b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1386db830c46SAndreas Gruenbacher return peer_req; 1387b411b363SPhilipp Reisner } 1388b411b363SPhilipp Reisner 1389b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1390b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1391b411b363SPhilipp Reisner */ 1392b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1393b411b363SPhilipp Reisner { 1394b411b363SPhilipp Reisner struct page *page; 1395fc5be839SAndreas Gruenbacher int rr, err = 0; 1396b411b363SPhilipp Reisner void *data; 1397b411b363SPhilipp Reisner 1398c3470cdeSLars Ellenberg if (!data_size) 1399fc5be839SAndreas Gruenbacher return 0; 1400c3470cdeSLars Ellenberg 140145bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1402b411b363SPhilipp Reisner 1403b411b363SPhilipp Reisner data = kmap(page); 1404b411b363SPhilipp Reisner while (data_size) { 1405fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1406fc5be839SAndreas Gruenbacher 1407fc5be839SAndreas Gruenbacher rr = drbd_recv(mdev->tconn, data, len); 1408fc5be839SAndreas Gruenbacher if (rr != len) { 14090ddc5549SLars Ellenberg if (!signal_pending(current)) 14100ddc5549SLars Ellenberg dev_warn(DEV, 14110ddc5549SLars Ellenberg "short read receiving data: read %d expected %d\n", 1412fc5be839SAndreas Gruenbacher rr, len); 1413fc5be839SAndreas Gruenbacher err = (rr < 0) ? rr : -EIO; 1414b411b363SPhilipp Reisner break; 1415b411b363SPhilipp Reisner } 1416b411b363SPhilipp Reisner data_size -= rr; 1417b411b363SPhilipp Reisner } 1418b411b363SPhilipp Reisner kunmap(page); 1419435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1420fc5be839SAndreas Gruenbacher return err; 1421b411b363SPhilipp Reisner } 1422b411b363SPhilipp Reisner 1423b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1424b411b363SPhilipp Reisner sector_t sector, int data_size) 1425b411b363SPhilipp Reisner { 1426b411b363SPhilipp Reisner struct bio_vec *bvec; 1427b411b363SPhilipp Reisner struct bio *bio; 1428b411b363SPhilipp Reisner int dgs, rr, i, expect; 1429a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1430a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1431b411b363SPhilipp Reisner 1432a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1433a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1434b411b363SPhilipp Reisner 1435b411b363SPhilipp Reisner if (dgs) { 1436de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1437b411b363SPhilipp Reisner if (rr != dgs) { 14380ddc5549SLars Ellenberg if (!signal_pending(current)) 14390ddc5549SLars Ellenberg dev_warn(DEV, 14400ddc5549SLars Ellenberg "short read receiving data reply digest: read %d expected %d\n", 1441b411b363SPhilipp Reisner rr, dgs); 144228284cefSAndreas Gruenbacher return rr < 0 ? rr : -EIO; 1443b411b363SPhilipp Reisner } 1444b411b363SPhilipp Reisner } 1445b411b363SPhilipp Reisner 1446b411b363SPhilipp Reisner data_size -= dgs; 1447b411b363SPhilipp Reisner 1448b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1449b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1450b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1451b411b363SPhilipp Reisner 1452b411b363SPhilipp Reisner bio = req->master_bio; 1453b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1454b411b363SPhilipp Reisner 1455b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1456b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1457de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, 1458b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1459b411b363SPhilipp Reisner expect); 1460b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1461b411b363SPhilipp Reisner if (rr != expect) { 14620ddc5549SLars Ellenberg if (!signal_pending(current)) 1463b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1464b411b363SPhilipp Reisner "read %d expected %d\n", 1465b411b363SPhilipp Reisner rr, expect); 146628284cefSAndreas Gruenbacher return rr < 0 ? rr : -EIO; 1467b411b363SPhilipp Reisner } 1468b411b363SPhilipp Reisner data_size -= rr; 1469b411b363SPhilipp Reisner } 1470b411b363SPhilipp Reisner 1471b411b363SPhilipp Reisner if (dgs) { 1472a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1473b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1474b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 147528284cefSAndreas Gruenbacher return -EINVAL; 1476b411b363SPhilipp Reisner } 1477b411b363SPhilipp Reisner } 1478b411b363SPhilipp Reisner 1479b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 148028284cefSAndreas Gruenbacher return 0; 1481b411b363SPhilipp Reisner } 1482b411b363SPhilipp Reisner 1483b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1484b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 148599920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1486b411b363SPhilipp Reisner { 14878050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 14888050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 148900d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1490db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 149199920dc5SAndreas Gruenbacher int err; 1492b411b363SPhilipp Reisner 1493db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1494b411b363SPhilipp Reisner 1495db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1496db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 149799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1498b411b363SPhilipp Reisner } else { 1499b411b363SPhilipp Reisner /* Record failure to sync */ 1500db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1501b411b363SPhilipp Reisner 150299920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1503b411b363SPhilipp Reisner } 1504b411b363SPhilipp Reisner dec_unacked(mdev); 1505b411b363SPhilipp Reisner 150699920dc5SAndreas Gruenbacher return err; 1507b411b363SPhilipp Reisner } 1508b411b363SPhilipp Reisner 1509b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1510b411b363SPhilipp Reisner { 1511db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1512b411b363SPhilipp Reisner 1513db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1514db830c46SAndreas Gruenbacher if (!peer_req) 151545bb912bSLars Ellenberg goto fail; 1516b411b363SPhilipp Reisner 1517b411b363SPhilipp Reisner dec_rs_pending(mdev); 1518b411b363SPhilipp Reisner 1519b411b363SPhilipp Reisner inc_unacked(mdev); 1520b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1521b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1522b411b363SPhilipp Reisner 1523db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 152445bb912bSLars Ellenberg 152587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1526db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 152787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1528b411b363SPhilipp Reisner 15290f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1530fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1531e1c1b0fcSAndreas Gruenbacher return 0; 153245bb912bSLars Ellenberg 153310f6d992SLars Ellenberg /* don't care for the reason here */ 153410f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 153587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1536db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 153787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 153822cc37a9SLars Ellenberg 1539db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 154045bb912bSLars Ellenberg fail: 154145bb912bSLars Ellenberg put_ldev(mdev); 1542e1c1b0fcSAndreas Gruenbacher return -EIO; 1543b411b363SPhilipp Reisner } 1544b411b363SPhilipp Reisner 1545668eebc6SAndreas Gruenbacher static struct drbd_request * 1546bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1547bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1548668eebc6SAndreas Gruenbacher { 1549668eebc6SAndreas Gruenbacher struct drbd_request *req; 1550668eebc6SAndreas Gruenbacher 1551bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1552bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15535e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1554668eebc6SAndreas Gruenbacher return req; 1555c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1556c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1557c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1558c3afd8f5SAndreas Gruenbacher } 1559668eebc6SAndreas Gruenbacher return NULL; 1560668eebc6SAndreas Gruenbacher } 1561668eebc6SAndreas Gruenbacher 1562d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1563d8763023SAndreas Gruenbacher unsigned int data_size) 1564b411b363SPhilipp Reisner { 1565b411b363SPhilipp Reisner struct drbd_request *req; 1566b411b363SPhilipp Reisner sector_t sector; 1567b411b363SPhilipp Reisner int ok; 1568e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1569b411b363SPhilipp Reisner 1570b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1571b411b363SPhilipp Reisner 157287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1573bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 157487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1575c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 157681e84650SAndreas Gruenbacher return false; 1577b411b363SPhilipp Reisner 157824c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1579b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1580b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 158128284cefSAndreas Gruenbacher ok = !recv_dless_read(mdev, req, sector, data_size); 1582b411b363SPhilipp Reisner 1583b411b363SPhilipp Reisner if (ok) 15848554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1585b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1586b411b363SPhilipp Reisner * I don't think we may complete this just yet 1587b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1588b411b363SPhilipp Reisner 1589b411b363SPhilipp Reisner return ok; 1590b411b363SPhilipp Reisner } 1591b411b363SPhilipp Reisner 1592d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1593d8763023SAndreas Gruenbacher unsigned int data_size) 1594b411b363SPhilipp Reisner { 1595b411b363SPhilipp Reisner sector_t sector; 1596b411b363SPhilipp Reisner int ok; 1597e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1598b411b363SPhilipp Reisner 1599b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1600b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1601b411b363SPhilipp Reisner 1602b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1603b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1604b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1605fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1606e1c1b0fcSAndreas Gruenbacher ok = !recv_resync_read(mdev, sector, data_size); 1607b411b363SPhilipp Reisner } else { 1608b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1609b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1610b411b363SPhilipp Reisner 1611fc5be839SAndreas Gruenbacher ok = !drbd_drain_block(mdev, data_size); 1612b411b363SPhilipp Reisner 16132b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1614b411b363SPhilipp Reisner } 1615b411b363SPhilipp Reisner 1616778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1617778f271dSPhilipp Reisner 1618b411b363SPhilipp Reisner return ok; 1619b411b363SPhilipp Reisner } 1620b411b363SPhilipp Reisner 162199920dc5SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 16227be8da07SAndreas Gruenbacher { 16237be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 16247be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16257be8da07SAndreas Gruenbacher struct bio *bio; 16267be8da07SAndreas Gruenbacher unsigned long start_time; 16277be8da07SAndreas Gruenbacher unsigned long flags; 16287be8da07SAndreas Gruenbacher 16297be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16307be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16317be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 163299920dc5SAndreas Gruenbacher return -EIO; 16337be8da07SAndreas Gruenbacher } 16347be8da07SAndreas Gruenbacher bio = req->master_bio; 16357be8da07SAndreas Gruenbacher start_time = req->start_time; 16367be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 16377be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 16387be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16397be8da07SAndreas Gruenbacher 16407be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 16417be8da07SAndreas Gruenbacher /* retry */ ; 164299920dc5SAndreas Gruenbacher return 0; 16437be8da07SAndreas Gruenbacher } 16447be8da07SAndreas Gruenbacher 16457be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 16467be8da07SAndreas Gruenbacher sector_t sector, int size) 16477be8da07SAndreas Gruenbacher { 16487be8da07SAndreas Gruenbacher struct drbd_interval *i; 16497be8da07SAndreas Gruenbacher struct drbd_request *req; 16507be8da07SAndreas Gruenbacher 16517be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 16527be8da07SAndreas Gruenbacher if (!i->local) 16537be8da07SAndreas Gruenbacher continue; 16547be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 16557be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 16567be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 16577be8da07SAndreas Gruenbacher continue; 16587be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 16597be8da07SAndreas Gruenbacher req->w.mdev = mdev; 16607be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 16617be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 16627be8da07SAndreas Gruenbacher } 16637be8da07SAndreas Gruenbacher } 16647be8da07SAndreas Gruenbacher } 16657be8da07SAndreas Gruenbacher 1666b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1667b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1668b411b363SPhilipp Reisner */ 166999920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1670b411b363SPhilipp Reisner { 16718050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16728050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 167300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1674db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 167599920dc5SAndreas Gruenbacher int err = 0, pcmd; 1676b411b363SPhilipp Reisner 167789e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1678db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1679b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1680b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1681db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1682b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 168399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1684b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1685db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1686b411b363SPhilipp Reisner } else { 168799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1688b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1689b411b363SPhilipp Reisner * maybe assert this? */ 1690b411b363SPhilipp Reisner } 1691b411b363SPhilipp Reisner dec_unacked(mdev); 1692b411b363SPhilipp Reisner } 1693b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1694b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 169589e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 169687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1697db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1698db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 16997be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 17007be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 170187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1702bb3bfe96SAndreas Gruenbacher } else 1703db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1704b411b363SPhilipp Reisner 1705db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1706b411b363SPhilipp Reisner 170799920dc5SAndreas Gruenbacher return err; 1708b411b363SPhilipp Reisner } 1709b411b363SPhilipp Reisner 17107be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1711b411b363SPhilipp Reisner { 17127be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 17138050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 17148050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 171599920dc5SAndreas Gruenbacher int err; 1716b411b363SPhilipp Reisner 171799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1718b411b363SPhilipp Reisner dec_unacked(mdev); 1719b411b363SPhilipp Reisner 172099920dc5SAndreas Gruenbacher return err; 1721b411b363SPhilipp Reisner } 1722b411b363SPhilipp Reisner 172399920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 17247be8da07SAndreas Gruenbacher { 17257be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17267be8da07SAndreas Gruenbacher } 17277be8da07SAndreas Gruenbacher 172899920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17297be8da07SAndreas Gruenbacher { 17307be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17317be8da07SAndreas Gruenbacher 17327be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 17337be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 17347be8da07SAndreas Gruenbacher } 17357be8da07SAndreas Gruenbacher 17363e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 17373e394da1SAndreas Gruenbacher { 17383e394da1SAndreas Gruenbacher /* 17393e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 17403e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 17413e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 17423e394da1SAndreas Gruenbacher */ 17433e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 17443e394da1SAndreas Gruenbacher } 17453e394da1SAndreas Gruenbacher 17463e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 17473e394da1SAndreas Gruenbacher { 17483e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 17493e394da1SAndreas Gruenbacher } 17503e394da1SAndreas Gruenbacher 17517be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 17527be8da07SAndreas Gruenbacher { 17537be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 17547be8da07SAndreas Gruenbacher 17557be8da07SAndreas Gruenbacher /* 17567be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 17577be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 17587be8da07SAndreas Gruenbacher * handle_write_conflicts(). 17597be8da07SAndreas Gruenbacher */ 17607be8da07SAndreas Gruenbacher return tconn->net_conf->two_primaries && 17617be8da07SAndreas Gruenbacher test_bit(DISCARD_CONCURRENT, &tconn->flags); 17627be8da07SAndreas Gruenbacher } 17637be8da07SAndreas Gruenbacher 176443ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 17653e394da1SAndreas Gruenbacher { 17663c13b680SLars Ellenberg unsigned int newest_peer_seq; 17673e394da1SAndreas Gruenbacher 17687be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 17693e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 17703c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 17713c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 17723e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 17733c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 17743c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 17753e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 17763e394da1SAndreas Gruenbacher } 17777be8da07SAndreas Gruenbacher } 17783e394da1SAndreas Gruenbacher 1779b411b363SPhilipp Reisner /* Called from receive_Data. 1780b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1781b411b363SPhilipp Reisner * 1782b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1783b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1784b411b363SPhilipp Reisner * been sent. 1785b411b363SPhilipp Reisner * 1786b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1787b411b363SPhilipp Reisner * 1788b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1789b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1790b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1791b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1792b411b363SPhilipp Reisner * 1793b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1794b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1795b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1796b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1797b411b363SPhilipp Reisner * 1798b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1799b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 18007be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1801b411b363SPhilipp Reisner { 1802b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1803b411b363SPhilipp Reisner long timeout; 18047be8da07SAndreas Gruenbacher int ret; 18057be8da07SAndreas Gruenbacher 18067be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 18077be8da07SAndreas Gruenbacher return 0; 18087be8da07SAndreas Gruenbacher 1809b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1810b411b363SPhilipp Reisner for (;;) { 18117be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 18127be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 18137be8da07SAndreas Gruenbacher ret = 0; 1814b411b363SPhilipp Reisner break; 18157be8da07SAndreas Gruenbacher } 1816b411b363SPhilipp Reisner if (signal_pending(current)) { 1817b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1818b411b363SPhilipp Reisner break; 1819b411b363SPhilipp Reisner } 18207be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1821b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 182271b1c1ebSAndreas Gruenbacher timeout = mdev->tconn->net_conf->ping_timeo*HZ/10; 182371b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1824b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 18257be8da07SAndreas Gruenbacher if (!timeout) { 1826b411b363SPhilipp Reisner ret = -ETIMEDOUT; 182771b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1828b411b363SPhilipp Reisner break; 1829b411b363SPhilipp Reisner } 1830b411b363SPhilipp Reisner } 1831b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 18327be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1833b411b363SPhilipp Reisner return ret; 1834b411b363SPhilipp Reisner } 1835b411b363SPhilipp Reisner 1836688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1837688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1838688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1839688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 184076d2e7ecSPhilipp Reisner { 184176d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 184276d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1843688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 184476d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 184576d2e7ecSPhilipp Reisner } 184676d2e7ecSPhilipp Reisner 18477be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 18487be8da07SAndreas Gruenbacher unsigned int size) 18497be8da07SAndreas Gruenbacher { 18507be8da07SAndreas Gruenbacher struct drbd_interval *i; 18517be8da07SAndreas Gruenbacher 18527be8da07SAndreas Gruenbacher repeat: 18537be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18547be8da07SAndreas Gruenbacher struct drbd_request *req; 18557be8da07SAndreas Gruenbacher struct bio_and_error m; 18567be8da07SAndreas Gruenbacher 18577be8da07SAndreas Gruenbacher if (!i->local) 18587be8da07SAndreas Gruenbacher continue; 18597be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18607be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 18617be8da07SAndreas Gruenbacher continue; 18627be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 18637be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 18647be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 18657be8da07SAndreas Gruenbacher if (m.bio) 18667be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 18677be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 18687be8da07SAndreas Gruenbacher goto repeat; 18697be8da07SAndreas Gruenbacher } 18707be8da07SAndreas Gruenbacher } 18717be8da07SAndreas Gruenbacher 18727be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 18737be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 18747be8da07SAndreas Gruenbacher { 18757be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 18767be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 18777be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 18787be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 18797be8da07SAndreas Gruenbacher struct drbd_interval *i; 18807be8da07SAndreas Gruenbacher bool equal; 18817be8da07SAndreas Gruenbacher int err; 18827be8da07SAndreas Gruenbacher 18837be8da07SAndreas Gruenbacher /* 18847be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 18857be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 18867be8da07SAndreas Gruenbacher */ 18877be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 18887be8da07SAndreas Gruenbacher 18897be8da07SAndreas Gruenbacher repeat: 18907be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18917be8da07SAndreas Gruenbacher if (i == &peer_req->i) 18927be8da07SAndreas Gruenbacher continue; 18937be8da07SAndreas Gruenbacher 18947be8da07SAndreas Gruenbacher if (!i->local) { 18957be8da07SAndreas Gruenbacher /* 18967be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 18977be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 18987be8da07SAndreas Gruenbacher * earlier peer request to complete. 18997be8da07SAndreas Gruenbacher */ 19007be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 19017be8da07SAndreas Gruenbacher if (err) 19027be8da07SAndreas Gruenbacher goto out; 19037be8da07SAndreas Gruenbacher goto repeat; 19047be8da07SAndreas Gruenbacher } 19057be8da07SAndreas Gruenbacher 19067be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 19077be8da07SAndreas Gruenbacher if (resolve_conflicts) { 19087be8da07SAndreas Gruenbacher /* 19097be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 19107be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 19117be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 19127be8da07SAndreas Gruenbacher * have completed. 19137be8da07SAndreas Gruenbacher */ 19147be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 19157be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 19167be8da07SAndreas Gruenbacher 19177be8da07SAndreas Gruenbacher if (!equal) 19187be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19197be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 19207be8da07SAndreas Gruenbacher "assuming %s came first\n", 19217be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19227be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 19237be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 19247be8da07SAndreas Gruenbacher 19257be8da07SAndreas Gruenbacher inc_unacked(mdev); 19267be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 19277be8da07SAndreas Gruenbacher e_send_retry_write; 19287be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 19297be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 19307be8da07SAndreas Gruenbacher 19317be8da07SAndreas Gruenbacher err = -ENOENT; 19327be8da07SAndreas Gruenbacher goto out; 19337be8da07SAndreas Gruenbacher } else { 19347be8da07SAndreas Gruenbacher struct drbd_request *req = 19357be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 19367be8da07SAndreas Gruenbacher 19377be8da07SAndreas Gruenbacher if (!equal) 19387be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19397be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 19407be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19417be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 19427be8da07SAndreas Gruenbacher 19437be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 19447be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 19457be8da07SAndreas Gruenbacher /* 19467be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 19477be8da07SAndreas Gruenbacher * decide if this request will be discarded or 19487be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 19497be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 19507be8da07SAndreas Gruenbacher * 19517be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 19527be8da07SAndreas Gruenbacher * request to finish locally before submitting 19537be8da07SAndreas Gruenbacher * the conflicting peer request. 19547be8da07SAndreas Gruenbacher */ 19557be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 19567be8da07SAndreas Gruenbacher if (err) { 19577be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 19587be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 19597be8da07SAndreas Gruenbacher CS_HARD); 19607be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 19617be8da07SAndreas Gruenbacher goto out; 19627be8da07SAndreas Gruenbacher } 19637be8da07SAndreas Gruenbacher goto repeat; 19647be8da07SAndreas Gruenbacher } 19657be8da07SAndreas Gruenbacher /* 19667be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 19677be8da07SAndreas Gruenbacher * the new peer request has completed. 19687be8da07SAndreas Gruenbacher */ 19697be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 19707be8da07SAndreas Gruenbacher } 19717be8da07SAndreas Gruenbacher } 19727be8da07SAndreas Gruenbacher err = 0; 19737be8da07SAndreas Gruenbacher 19747be8da07SAndreas Gruenbacher out: 19757be8da07SAndreas Gruenbacher if (err) 19767be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 19777be8da07SAndreas Gruenbacher return err; 19787be8da07SAndreas Gruenbacher } 19797be8da07SAndreas Gruenbacher 1980b411b363SPhilipp Reisner /* mirrored write */ 1981d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1982d8763023SAndreas Gruenbacher unsigned int data_size) 1983b411b363SPhilipp Reisner { 1984b411b363SPhilipp Reisner sector_t sector; 1985db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1986e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 19877be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 1988b411b363SPhilipp Reisner int rw = WRITE; 1989b411b363SPhilipp Reisner u32 dp_flags; 19907be8da07SAndreas Gruenbacher int err; 19917be8da07SAndreas Gruenbacher 1992b411b363SPhilipp Reisner 1993b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 19947be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 19952b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1996b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 1997fc5be839SAndreas Gruenbacher return !drbd_drain_block(mdev, data_size) && err == 0; 1998b411b363SPhilipp Reisner } 1999b411b363SPhilipp Reisner 2000fcefa62eSAndreas Gruenbacher /* 2001fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 2002fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 2003fcefa62eSAndreas Gruenbacher * end of this function. 2004fcefa62eSAndreas Gruenbacher */ 2005b411b363SPhilipp Reisner 2006b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2007db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, data_size); 2008db830c46SAndreas Gruenbacher if (!peer_req) { 2009b411b363SPhilipp Reisner put_ldev(mdev); 201081e84650SAndreas Gruenbacher return false; 2011b411b363SPhilipp Reisner } 2012b411b363SPhilipp Reisner 2013db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 2014b411b363SPhilipp Reisner 2015688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2016688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2017688593c5SLars Ellenberg 2018688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2019db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2020688593c5SLars Ellenberg 2021b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2022db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2023db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2024db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2025b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2026b411b363SPhilipp Reisner 20277be8da07SAndreas Gruenbacher if (mdev->tconn->net_conf->two_primaries) { 20287be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 20297be8da07SAndreas Gruenbacher if (err) 2030b411b363SPhilipp Reisner goto out_interrupted; 203187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 20327be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 20337be8da07SAndreas Gruenbacher if (err) { 203487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 20357be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2036b411b363SPhilipp Reisner put_ldev(mdev); 203781e84650SAndreas Gruenbacher return true; 2038b411b363SPhilipp Reisner } 2039b411b363SPhilipp Reisner goto out_interrupted; 2040b411b363SPhilipp Reisner } 20417be8da07SAndreas Gruenbacher } else 204287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2043db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 204487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2045b411b363SPhilipp Reisner 204689e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 2047b411b363SPhilipp Reisner case DRBD_PROT_C: 2048b411b363SPhilipp Reisner inc_unacked(mdev); 2049b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2050b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2051b411b363SPhilipp Reisner break; 2052b411b363SPhilipp Reisner case DRBD_PROT_B: 2053b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2054b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2055db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2056b411b363SPhilipp Reisner break; 2057b411b363SPhilipp Reisner case DRBD_PROT_A: 2058b411b363SPhilipp Reisner /* nothing to do */ 2059b411b363SPhilipp Reisner break; 2060b411b363SPhilipp Reisner } 2061b411b363SPhilipp Reisner 20626719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2063b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2064db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2065db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2066db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2067db830c46SAndreas Gruenbacher drbd_al_begin_io(mdev, peer_req->i.sector); 2068b411b363SPhilipp Reisner } 2069b411b363SPhilipp Reisner 2070fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR) == 0) 207181e84650SAndreas Gruenbacher return true; 2072b411b363SPhilipp Reisner 207310f6d992SLars Ellenberg /* don't care for the reason here */ 207410f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 207587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2076db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2077db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 207887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2079db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2080db830c46SAndreas Gruenbacher drbd_al_complete_io(mdev, peer_req->i.sector); 208122cc37a9SLars Ellenberg 2082b411b363SPhilipp Reisner out_interrupted: 2083db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2084b411b363SPhilipp Reisner put_ldev(mdev); 2085db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 208681e84650SAndreas Gruenbacher return false; 2087b411b363SPhilipp Reisner } 2088b411b363SPhilipp Reisner 20890f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 20900f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 20910f0601f4SLars Ellenberg * 20920f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 20930f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 20940f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 20950f0601f4SLars Ellenberg * activity, it obviously is "busy". 20960f0601f4SLars Ellenberg * 20970f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 20980f0601f4SLars Ellenberg * to have a short time average so we can react faster. 20990f0601f4SLars Ellenberg */ 2100e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 21010f0601f4SLars Ellenberg { 21020f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 21030f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2104e3555d85SPhilipp Reisner struct lc_element *tmp; 21050f0601f4SLars Ellenberg int curr_events; 21060f0601f4SLars Ellenberg int throttle = 0; 21070f0601f4SLars Ellenberg 21080f0601f4SLars Ellenberg /* feature disabled? */ 2109f399002eSLars Ellenberg if (mdev->ldev->dc.c_min_rate == 0) 21100f0601f4SLars Ellenberg return 0; 21110f0601f4SLars Ellenberg 2112e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2113e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2114e3555d85SPhilipp Reisner if (tmp) { 2115e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2116e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2117e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2118e3555d85SPhilipp Reisner return 0; 2119e3555d85SPhilipp Reisner } 2120e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2121e3555d85SPhilipp Reisner } 2122e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2123e3555d85SPhilipp Reisner 21240f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 21250f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 21260f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2127e3555d85SPhilipp Reisner 21280f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 21290f0601f4SLars Ellenberg unsigned long rs_left; 21300f0601f4SLars Ellenberg int i; 21310f0601f4SLars Ellenberg 21320f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 21330f0601f4SLars Ellenberg 21340f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 21350f0601f4SLars Ellenberg * approx. */ 21362649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 21372649f080SLars Ellenberg 21382649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 21392649f080SLars Ellenberg rs_left = mdev->ov_left; 21402649f080SLars Ellenberg else 21410f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 21420f0601f4SLars Ellenberg 21430f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 21440f0601f4SLars Ellenberg if (!dt) 21450f0601f4SLars Ellenberg dt++; 21460f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 21470f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 21480f0601f4SLars Ellenberg 2149f399002eSLars Ellenberg if (dbdt > mdev->ldev->dc.c_min_rate) 21500f0601f4SLars Ellenberg throttle = 1; 21510f0601f4SLars Ellenberg } 21520f0601f4SLars Ellenberg return throttle; 21530f0601f4SLars Ellenberg } 21540f0601f4SLars Ellenberg 21550f0601f4SLars Ellenberg 2156d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2157d8763023SAndreas Gruenbacher unsigned int digest_size) 2158b411b363SPhilipp Reisner { 2159b411b363SPhilipp Reisner sector_t sector; 2160b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2161db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2162b411b363SPhilipp Reisner struct digest_info *di = NULL; 2163b18b37beSPhilipp Reisner int size, verb; 2164b411b363SPhilipp Reisner unsigned int fault_type; 2165e42325a5SPhilipp Reisner struct p_block_req *p = &mdev->tconn->data.rbuf.block_req; 2166b411b363SPhilipp Reisner 2167b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2168b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2169b411b363SPhilipp Reisner 2170c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2171b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2172b411b363SPhilipp Reisner (unsigned long long)sector, size); 217381e84650SAndreas Gruenbacher return false; 2174b411b363SPhilipp Reisner } 2175b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2176b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2177b411b363SPhilipp Reisner (unsigned long long)sector, size); 217881e84650SAndreas Gruenbacher return false; 2179b411b363SPhilipp Reisner } 2180b411b363SPhilipp Reisner 2181b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2182b18b37beSPhilipp Reisner verb = 1; 2183b18b37beSPhilipp Reisner switch (cmd) { 2184b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2185b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2186b18b37beSPhilipp Reisner break; 2187b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2188b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2189b18b37beSPhilipp Reisner case P_OV_REQUEST: 2190b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2191b18b37beSPhilipp Reisner break; 2192b18b37beSPhilipp Reisner case P_OV_REPLY: 2193b18b37beSPhilipp Reisner verb = 0; 2194b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2195b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2196b18b37beSPhilipp Reisner break; 2197b18b37beSPhilipp Reisner default: 2198b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2199b18b37beSPhilipp Reisner cmdname(cmd)); 2200b18b37beSPhilipp Reisner } 2201b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2202b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2203b411b363SPhilipp Reisner "no local data.\n"); 2204b18b37beSPhilipp Reisner 2205a821cc4aSLars Ellenberg /* drain possibly payload */ 2206fc5be839SAndreas Gruenbacher return !drbd_drain_block(mdev, digest_size); 2207b411b363SPhilipp Reisner } 2208b411b363SPhilipp Reisner 2209b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2210b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2211b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2212db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2213db830c46SAndreas Gruenbacher if (!peer_req) { 2214b411b363SPhilipp Reisner put_ldev(mdev); 221581e84650SAndreas Gruenbacher return false; 2216b411b363SPhilipp Reisner } 2217b411b363SPhilipp Reisner 221802918be2SPhilipp Reisner switch (cmd) { 2219b411b363SPhilipp Reisner case P_DATA_REQUEST: 2220db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2221b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 222280a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 222380a40e43SLars Ellenberg goto submit; 222480a40e43SLars Ellenberg 2225b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2226db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2227b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 22285f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22295f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2230b411b363SPhilipp Reisner break; 2231b411b363SPhilipp Reisner 2232b411b363SPhilipp Reisner case P_OV_REPLY: 2233b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2234b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2235b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2236b411b363SPhilipp Reisner if (!di) 2237b411b363SPhilipp Reisner goto out_free_e; 2238b411b363SPhilipp Reisner 2239b411b363SPhilipp Reisner di->digest_size = digest_size; 2240b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2241b411b363SPhilipp Reisner 2242db830c46SAndreas Gruenbacher peer_req->digest = di; 2243db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2244c36c3cedSLars Ellenberg 2245de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, di->digest, digest_size) != digest_size) 2246b411b363SPhilipp Reisner goto out_free_e; 2247b411b363SPhilipp Reisner 224802918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 224931890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2250db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 22515f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22525f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 225302918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 22542649f080SLars Ellenberg /* track progress, we may need to throttle */ 22552649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2256db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2257b411b363SPhilipp Reisner dec_rs_pending(mdev); 22580f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 22590f0601f4SLars Ellenberg * but accounting still needs to be done. */ 22600f0601f4SLars Ellenberg goto submit_for_resync; 2261b411b363SPhilipp Reisner } 2262b411b363SPhilipp Reisner break; 2263b411b363SPhilipp Reisner 2264b411b363SPhilipp Reisner case P_OV_REQUEST: 2265b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 226631890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2267de228bbaSLars Ellenberg unsigned long now = jiffies; 2268de228bbaSLars Ellenberg int i; 2269b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2270b411b363SPhilipp Reisner mdev->ov_position = sector; 227130b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 227230b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2273de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2274de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2275de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2276de228bbaSLars Ellenberg } 2277b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2278b411b363SPhilipp Reisner (unsigned long long)sector); 2279b411b363SPhilipp Reisner } 2280db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2281b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2282b411b363SPhilipp Reisner break; 2283b411b363SPhilipp Reisner 2284b411b363SPhilipp Reisner default: 2285b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 228602918be2SPhilipp Reisner cmdname(cmd)); 2287b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 228880a40e43SLars Ellenberg goto out_free_e; 2289b411b363SPhilipp Reisner } 2290b411b363SPhilipp Reisner 22910f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 22920f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 22930f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 22940f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 22950f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 22960f0601f4SLars Ellenberg * 22970f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 22980f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 22990f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 23000f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 23010f0601f4SLars Ellenberg * a while, anyways. 23020f0601f4SLars Ellenberg */ 2303b411b363SPhilipp Reisner 23040f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 23050f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 23060f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 23070f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 23080f0601f4SLars Ellenberg * 23090f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 23100f0601f4SLars Ellenberg * we would also throttle its application reads. 23110f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 23120f0601f4SLars Ellenberg */ 2313e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2314e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2315e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 231680a40e43SLars Ellenberg goto out_free_e; 2317b411b363SPhilipp Reisner 23180f0601f4SLars Ellenberg submit_for_resync: 23190f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 23200f0601f4SLars Ellenberg 232180a40e43SLars Ellenberg submit: 2322b411b363SPhilipp Reisner inc_unacked(mdev); 232387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2324db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 232587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2326b411b363SPhilipp Reisner 2327fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 232881e84650SAndreas Gruenbacher return true; 2329b411b363SPhilipp Reisner 233010f6d992SLars Ellenberg /* don't care for the reason here */ 233110f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 233287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2333db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 233487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 233522cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 233622cc37a9SLars Ellenberg 2337b411b363SPhilipp Reisner out_free_e: 2338b411b363SPhilipp Reisner put_ldev(mdev); 2339db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 234081e84650SAndreas Gruenbacher return false; 2341b411b363SPhilipp Reisner } 2342b411b363SPhilipp Reisner 2343b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2344b411b363SPhilipp Reisner { 2345b411b363SPhilipp Reisner int self, peer, rv = -100; 2346b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2347b411b363SPhilipp Reisner 2348b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2349b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2350b411b363SPhilipp Reisner 2351b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2352b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2353b411b363SPhilipp Reisner 235489e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2355b411b363SPhilipp Reisner case ASB_CONSENSUS: 2356b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2357b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2358b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2359b411b363SPhilipp Reisner break; 2360b411b363SPhilipp Reisner case ASB_DISCONNECT: 2361b411b363SPhilipp Reisner break; 2362b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2363b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2364b411b363SPhilipp Reisner rv = -1; 2365b411b363SPhilipp Reisner break; 2366b411b363SPhilipp Reisner } 2367b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2368b411b363SPhilipp Reisner rv = 1; 2369b411b363SPhilipp Reisner break; 2370b411b363SPhilipp Reisner } 2371b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2372b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2373b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2374b411b363SPhilipp Reisner rv = 1; 2375b411b363SPhilipp Reisner break; 2376b411b363SPhilipp Reisner } 2377b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2378b411b363SPhilipp Reisner rv = -1; 2379b411b363SPhilipp Reisner break; 2380b411b363SPhilipp Reisner } 2381b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2382ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2383b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2384b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2385b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 238625703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2387b411b363SPhilipp Reisner ? -1 : 1; 2388b411b363SPhilipp Reisner break; 2389b411b363SPhilipp Reisner } else { 2390b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2391b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2392b411b363SPhilipp Reisner } 239389e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2394b411b363SPhilipp Reisner break; 2395b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2396b411b363SPhilipp Reisner if (ch_self < ch_peer) 2397b411b363SPhilipp Reisner rv = -1; 2398b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2399b411b363SPhilipp Reisner rv = 1; 2400b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2401b411b363SPhilipp Reisner /* Well, then use something else. */ 240225703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2403b411b363SPhilipp Reisner ? -1 : 1; 2404b411b363SPhilipp Reisner break; 2405b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2406b411b363SPhilipp Reisner rv = -1; 2407b411b363SPhilipp Reisner break; 2408b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2409b411b363SPhilipp Reisner rv = 1; 2410b411b363SPhilipp Reisner } 2411b411b363SPhilipp Reisner 2412b411b363SPhilipp Reisner return rv; 2413b411b363SPhilipp Reisner } 2414b411b363SPhilipp Reisner 2415b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2416b411b363SPhilipp Reisner { 24176184ea21SAndreas Gruenbacher int hg, rv = -100; 2418b411b363SPhilipp Reisner 241989e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2420b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2421b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2422b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2423b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2424b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2425b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2426b411b363SPhilipp Reisner break; 2427b411b363SPhilipp Reisner case ASB_DISCONNECT: 2428b411b363SPhilipp Reisner break; 2429b411b363SPhilipp Reisner case ASB_CONSENSUS: 2430b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2431b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2432b411b363SPhilipp Reisner rv = hg; 2433b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2434b411b363SPhilipp Reisner rv = hg; 2435b411b363SPhilipp Reisner break; 2436b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2437b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2438b411b363SPhilipp Reisner break; 2439b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2440b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2441b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2442b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2443b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2444bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2445bb437946SAndreas Gruenbacher 2446bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2447b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2448b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2449b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2450bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2451bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2452b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2453b411b363SPhilipp Reisner } else { 2454b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2455b411b363SPhilipp Reisner rv = hg; 2456b411b363SPhilipp Reisner } 2457b411b363SPhilipp Reisner } else 2458b411b363SPhilipp Reisner rv = hg; 2459b411b363SPhilipp Reisner } 2460b411b363SPhilipp Reisner 2461b411b363SPhilipp Reisner return rv; 2462b411b363SPhilipp Reisner } 2463b411b363SPhilipp Reisner 2464b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2465b411b363SPhilipp Reisner { 24666184ea21SAndreas Gruenbacher int hg, rv = -100; 2467b411b363SPhilipp Reisner 246889e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2469b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2470b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2471b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2472b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2473b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2474b411b363SPhilipp Reisner case ASB_CONSENSUS: 2475b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2476b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2477b411b363SPhilipp Reisner break; 2478b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2479b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2480b411b363SPhilipp Reisner break; 2481b411b363SPhilipp Reisner case ASB_DISCONNECT: 2482b411b363SPhilipp Reisner break; 2483b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2484b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2485b411b363SPhilipp Reisner if (hg == -1) { 2486bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2487bb437946SAndreas Gruenbacher 2488b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2489b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2490b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2491bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2492bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2493b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2494b411b363SPhilipp Reisner } else { 2495b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2496b411b363SPhilipp Reisner rv = hg; 2497b411b363SPhilipp Reisner } 2498b411b363SPhilipp Reisner } else 2499b411b363SPhilipp Reisner rv = hg; 2500b411b363SPhilipp Reisner } 2501b411b363SPhilipp Reisner 2502b411b363SPhilipp Reisner return rv; 2503b411b363SPhilipp Reisner } 2504b411b363SPhilipp Reisner 2505b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2506b411b363SPhilipp Reisner u64 bits, u64 flags) 2507b411b363SPhilipp Reisner { 2508b411b363SPhilipp Reisner if (!uuid) { 2509b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2510b411b363SPhilipp Reisner return; 2511b411b363SPhilipp Reisner } 2512b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2513b411b363SPhilipp Reisner text, 2514b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2515b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2516b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2517b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2518b411b363SPhilipp Reisner (unsigned long long)bits, 2519b411b363SPhilipp Reisner (unsigned long long)flags); 2520b411b363SPhilipp Reisner } 2521b411b363SPhilipp Reisner 2522b411b363SPhilipp Reisner /* 2523b411b363SPhilipp Reisner 100 after split brain try auto recover 2524b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2525b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2526b411b363SPhilipp Reisner 0 no Sync 2527b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2528b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2529b411b363SPhilipp Reisner -100 after split brain, disconnect 2530b411b363SPhilipp Reisner -1000 unrelated data 25314a23f264SPhilipp Reisner -1091 requires proto 91 25324a23f264SPhilipp Reisner -1096 requires proto 96 2533b411b363SPhilipp Reisner */ 2534b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2535b411b363SPhilipp Reisner { 2536b411b363SPhilipp Reisner u64 self, peer; 2537b411b363SPhilipp Reisner int i, j; 2538b411b363SPhilipp Reisner 2539b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2540b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2541b411b363SPhilipp Reisner 2542b411b363SPhilipp Reisner *rule_nr = 10; 2543b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2544b411b363SPhilipp Reisner return 0; 2545b411b363SPhilipp Reisner 2546b411b363SPhilipp Reisner *rule_nr = 20; 2547b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2548b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2549b411b363SPhilipp Reisner return -2; 2550b411b363SPhilipp Reisner 2551b411b363SPhilipp Reisner *rule_nr = 30; 2552b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2553b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2554b411b363SPhilipp Reisner return 2; 2555b411b363SPhilipp Reisner 2556b411b363SPhilipp Reisner if (self == peer) { 2557b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2558b411b363SPhilipp Reisner 2559b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2560b411b363SPhilipp Reisner 256131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25624a23f264SPhilipp Reisner return -1091; 2563b411b363SPhilipp Reisner 2564b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2565b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2566b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2567b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2568b411b363SPhilipp Reisner 2569b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2570b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2571b411b363SPhilipp Reisner *rule_nr = 34; 2572b411b363SPhilipp Reisner } else { 2573b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2574b411b363SPhilipp Reisner *rule_nr = 36; 2575b411b363SPhilipp Reisner } 2576b411b363SPhilipp Reisner 2577b411b363SPhilipp Reisner return 1; 2578b411b363SPhilipp Reisner } 2579b411b363SPhilipp Reisner 2580b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2581b411b363SPhilipp Reisner 258231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25834a23f264SPhilipp Reisner return -1091; 2584b411b363SPhilipp Reisner 2585b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2586b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2587b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2588b411b363SPhilipp Reisner 2589b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2590b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2591b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2592b411b363SPhilipp Reisner 2593b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2594b411b363SPhilipp Reisner *rule_nr = 35; 2595b411b363SPhilipp Reisner } else { 2596b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2597b411b363SPhilipp Reisner *rule_nr = 37; 2598b411b363SPhilipp Reisner } 2599b411b363SPhilipp Reisner 2600b411b363SPhilipp Reisner return -1; 2601b411b363SPhilipp Reisner } 2602b411b363SPhilipp Reisner 2603b411b363SPhilipp Reisner /* Common power [off|failure] */ 2604b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2605b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2606b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2607b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2608b411b363SPhilipp Reisner *rule_nr = 40; 2609b411b363SPhilipp Reisner 2610b411b363SPhilipp Reisner switch (rct) { 2611b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2612b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2613b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2614b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 261525703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2616b411b363SPhilipp Reisner return dc ? -1 : 1; 2617b411b363SPhilipp Reisner } 2618b411b363SPhilipp Reisner } 2619b411b363SPhilipp Reisner 2620b411b363SPhilipp Reisner *rule_nr = 50; 2621b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2622b411b363SPhilipp Reisner if (self == peer) 2623b411b363SPhilipp Reisner return -1; 2624b411b363SPhilipp Reisner 2625b411b363SPhilipp Reisner *rule_nr = 51; 2626b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2627b411b363SPhilipp Reisner if (self == peer) { 262831890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26294a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 26304a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 26314a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2632b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2633b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2634b411b363SPhilipp Reisner 263531890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26364a23f264SPhilipp Reisner return -1091; 2637b411b363SPhilipp Reisner 2638b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2639b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 26404a23f264SPhilipp Reisner 26414a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 26424a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 26434a23f264SPhilipp Reisner 2644b411b363SPhilipp Reisner return -1; 2645b411b363SPhilipp Reisner } 2646b411b363SPhilipp Reisner } 2647b411b363SPhilipp Reisner 2648b411b363SPhilipp Reisner *rule_nr = 60; 2649b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2650b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2651b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2652b411b363SPhilipp Reisner if (self == peer) 2653b411b363SPhilipp Reisner return -2; 2654b411b363SPhilipp Reisner } 2655b411b363SPhilipp Reisner 2656b411b363SPhilipp Reisner *rule_nr = 70; 2657b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2658b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2659b411b363SPhilipp Reisner if (self == peer) 2660b411b363SPhilipp Reisner return 1; 2661b411b363SPhilipp Reisner 2662b411b363SPhilipp Reisner *rule_nr = 71; 2663b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2664b411b363SPhilipp Reisner if (self == peer) { 266531890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26664a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 26674a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 26684a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2669b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2670b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2671b411b363SPhilipp Reisner 267231890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26734a23f264SPhilipp Reisner return -1091; 2674b411b363SPhilipp Reisner 2675b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2676b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2677b411b363SPhilipp Reisner 26784a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2679b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2680b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2681b411b363SPhilipp Reisner 2682b411b363SPhilipp Reisner return 1; 2683b411b363SPhilipp Reisner } 2684b411b363SPhilipp Reisner } 2685b411b363SPhilipp Reisner 2686b411b363SPhilipp Reisner 2687b411b363SPhilipp Reisner *rule_nr = 80; 2688d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2689b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2690b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2691b411b363SPhilipp Reisner if (self == peer) 2692b411b363SPhilipp Reisner return 2; 2693b411b363SPhilipp Reisner } 2694b411b363SPhilipp Reisner 2695b411b363SPhilipp Reisner *rule_nr = 90; 2696b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2697b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2698b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2699b411b363SPhilipp Reisner return 100; 2700b411b363SPhilipp Reisner 2701b411b363SPhilipp Reisner *rule_nr = 100; 2702b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2703b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2704b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2705b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2706b411b363SPhilipp Reisner if (self == peer) 2707b411b363SPhilipp Reisner return -100; 2708b411b363SPhilipp Reisner } 2709b411b363SPhilipp Reisner } 2710b411b363SPhilipp Reisner 2711b411b363SPhilipp Reisner return -1000; 2712b411b363SPhilipp Reisner } 2713b411b363SPhilipp Reisner 2714b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2715b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2716b411b363SPhilipp Reisner */ 2717b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2718b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2719b411b363SPhilipp Reisner { 2720b411b363SPhilipp Reisner int hg, rule_nr; 2721b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2722b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2723b411b363SPhilipp Reisner 2724b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2725b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2726b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2727b411b363SPhilipp Reisner 2728b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2729b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2730b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2731b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2732b411b363SPhilipp Reisner 2733b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2734b411b363SPhilipp Reisner 2735b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2736b411b363SPhilipp Reisner 2737b411b363SPhilipp Reisner if (hg == -1000) { 2738b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2739b411b363SPhilipp Reisner return C_MASK; 2740b411b363SPhilipp Reisner } 27414a23f264SPhilipp Reisner if (hg < -1000) { 27424a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2743b411b363SPhilipp Reisner return C_MASK; 2744b411b363SPhilipp Reisner } 2745b411b363SPhilipp Reisner 2746b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2747b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2748b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2749b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2750b411b363SPhilipp Reisner if (f) 2751b411b363SPhilipp Reisner hg = hg*2; 2752b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2753b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2754b411b363SPhilipp Reisner } 2755b411b363SPhilipp Reisner 27563a11a487SAdam Gandelman if (abs(hg) == 100) 27573a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 27583a11a487SAdam Gandelman 275989e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2760b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2761b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2762b411b363SPhilipp Reisner int forced = (hg == -100); 2763b411b363SPhilipp Reisner 2764b411b363SPhilipp Reisner switch (pcount) { 2765b411b363SPhilipp Reisner case 0: 2766b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2767b411b363SPhilipp Reisner break; 2768b411b363SPhilipp Reisner case 1: 2769b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2770b411b363SPhilipp Reisner break; 2771b411b363SPhilipp Reisner case 2: 2772b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2773b411b363SPhilipp Reisner break; 2774b411b363SPhilipp Reisner } 2775b411b363SPhilipp Reisner if (abs(hg) < 100) { 2776b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2777b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2778b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2779b411b363SPhilipp Reisner if (forced) { 2780b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2781b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2782b411b363SPhilipp Reisner hg = hg*2; 2783b411b363SPhilipp Reisner } 2784b411b363SPhilipp Reisner } 2785b411b363SPhilipp Reisner } 2786b411b363SPhilipp Reisner 2787b411b363SPhilipp Reisner if (hg == -100) { 278889e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2789b411b363SPhilipp Reisner hg = -1; 279089e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2791b411b363SPhilipp Reisner hg = 1; 2792b411b363SPhilipp Reisner 2793b411b363SPhilipp Reisner if (abs(hg) < 100) 2794b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2795b411b363SPhilipp Reisner "Sync from %s node\n", 2796b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2797b411b363SPhilipp Reisner } 2798b411b363SPhilipp Reisner 2799b411b363SPhilipp Reisner if (hg == -100) { 2800580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2801580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2802580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2803580b9767SLars Ellenberg * to that disk, in a way... */ 28043a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2805b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2806b411b363SPhilipp Reisner return C_MASK; 2807b411b363SPhilipp Reisner } 2808b411b363SPhilipp Reisner 2809b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2810b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2811b411b363SPhilipp Reisner return C_MASK; 2812b411b363SPhilipp Reisner } 2813b411b363SPhilipp Reisner 2814b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2815b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 281689e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2817b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2818b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2819b411b363SPhilipp Reisner /* fall through */ 2820b411b363SPhilipp Reisner case ASB_DISCONNECT: 2821b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2822b411b363SPhilipp Reisner return C_MASK; 2823b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2824b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2825b411b363SPhilipp Reisner "assumption\n"); 2826b411b363SPhilipp Reisner } 2827b411b363SPhilipp Reisner } 2828b411b363SPhilipp Reisner 28298169e41bSPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2830cf14c2e9SPhilipp Reisner if (hg == 0) 2831cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2832cf14c2e9SPhilipp Reisner else 2833cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2834cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2835cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2836cf14c2e9SPhilipp Reisner return C_MASK; 2837cf14c2e9SPhilipp Reisner } 2838cf14c2e9SPhilipp Reisner 2839b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2840b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 284120ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 284220ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2843b411b363SPhilipp Reisner return C_MASK; 2844b411b363SPhilipp Reisner } 2845b411b363SPhilipp Reisner 2846b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2847b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2848b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2849b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2850b411b363SPhilipp Reisner } else { 2851b411b363SPhilipp Reisner rv = C_CONNECTED; 2852b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2853b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2854b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2855b411b363SPhilipp Reisner } 2856b411b363SPhilipp Reisner } 2857b411b363SPhilipp Reisner 2858b411b363SPhilipp Reisner return rv; 2859b411b363SPhilipp Reisner } 2860b411b363SPhilipp Reisner 2861b411b363SPhilipp Reisner /* returns 1 if invalid */ 2862b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2863b411b363SPhilipp Reisner { 2864b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2865b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2866b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2867b411b363SPhilipp Reisner return 0; 2868b411b363SPhilipp Reisner 2869b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2870b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2871b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2872b411b363SPhilipp Reisner return 1; 2873b411b363SPhilipp Reisner 2874b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2875b411b363SPhilipp Reisner if (peer == self) 2876b411b363SPhilipp Reisner return 0; 2877b411b363SPhilipp Reisner 2878b411b363SPhilipp Reisner /* everything es is invalid. */ 2879b411b363SPhilipp Reisner return 1; 2880b411b363SPhilipp Reisner } 2881b411b363SPhilipp Reisner 28827204624cSPhilipp Reisner static int receive_protocol(struct drbd_tconn *tconn, enum drbd_packet cmd, 2883d8763023SAndreas Gruenbacher unsigned int data_size) 2884b411b363SPhilipp Reisner { 28857204624cSPhilipp Reisner struct p_protocol *p = &tconn->data.rbuf.protocol; 2886b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2887cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2888b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2889b411b363SPhilipp Reisner 2890b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2891b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2892b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2893b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2894b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2895cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2896cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2897cf14c2e9SPhilipp Reisner 28987204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 2899cf14c2e9SPhilipp Reisner 2900cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 29017204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 2902b411b363SPhilipp Reisner 29037204624cSPhilipp Reisner if (p_proto != tconn->net_conf->wire_protocol) { 29047204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 2905b411b363SPhilipp Reisner goto disconnect; 2906b411b363SPhilipp Reisner } 2907b411b363SPhilipp Reisner 29087204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, tconn->net_conf->after_sb_0p)) { 29097204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 2910b411b363SPhilipp Reisner goto disconnect; 2911b411b363SPhilipp Reisner } 2912b411b363SPhilipp Reisner 29137204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, tconn->net_conf->after_sb_1p)) { 29147204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 2915b411b363SPhilipp Reisner goto disconnect; 2916b411b363SPhilipp Reisner } 2917b411b363SPhilipp Reisner 29187204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, tconn->net_conf->after_sb_2p)) { 29197204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 2920b411b363SPhilipp Reisner goto disconnect; 2921b411b363SPhilipp Reisner } 2922b411b363SPhilipp Reisner 29237204624cSPhilipp Reisner if (p_want_lose && tconn->net_conf->want_lose) { 29247204624cSPhilipp Reisner conn_err(tconn, "both sides have the 'want_lose' flag set\n"); 2925b411b363SPhilipp Reisner goto disconnect; 2926b411b363SPhilipp Reisner } 2927b411b363SPhilipp Reisner 29287204624cSPhilipp Reisner if (p_two_primaries != tconn->net_conf->two_primaries) { 29297204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 2930b411b363SPhilipp Reisner goto disconnect; 2931b411b363SPhilipp Reisner } 2932b411b363SPhilipp Reisner 29337204624cSPhilipp Reisner if (tconn->agreed_pro_version >= 87) { 29347204624cSPhilipp Reisner unsigned char *my_alg = tconn->net_conf->integrity_alg; 2935b411b363SPhilipp Reisner 29367204624cSPhilipp Reisner if (drbd_recv(tconn, p_integrity_alg, data_size) != data_size) 293781e84650SAndreas Gruenbacher return false; 2938b411b363SPhilipp Reisner 2939b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2940b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 29417204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the data-integrity-alg\n"); 2942b411b363SPhilipp Reisner goto disconnect; 2943b411b363SPhilipp Reisner } 29447204624cSPhilipp Reisner conn_info(tconn, "data-integrity-alg: %s\n", 2945b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2946b411b363SPhilipp Reisner } 2947b411b363SPhilipp Reisner 294881e84650SAndreas Gruenbacher return true; 2949b411b363SPhilipp Reisner 2950b411b363SPhilipp Reisner disconnect: 29517204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 295281e84650SAndreas Gruenbacher return false; 2953b411b363SPhilipp Reisner } 2954b411b363SPhilipp Reisner 2955b411b363SPhilipp Reisner /* helper function 2956b411b363SPhilipp Reisner * input: alg name, feature name 2957b411b363SPhilipp Reisner * return: NULL (alg name was "") 2958b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2959b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2960b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2961b411b363SPhilipp Reisner const char *alg, const char *name) 2962b411b363SPhilipp Reisner { 2963b411b363SPhilipp Reisner struct crypto_hash *tfm; 2964b411b363SPhilipp Reisner 2965b411b363SPhilipp Reisner if (!alg[0]) 2966b411b363SPhilipp Reisner return NULL; 2967b411b363SPhilipp Reisner 2968b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2969b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2970b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2971b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2972b411b363SPhilipp Reisner return tfm; 2973b411b363SPhilipp Reisner } 2974b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2975b411b363SPhilipp Reisner crypto_free_hash(tfm); 2976b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2977b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2978b411b363SPhilipp Reisner } 2979b411b363SPhilipp Reisner return tfm; 2980b411b363SPhilipp Reisner } 2981b411b363SPhilipp Reisner 2982d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2983d8763023SAndreas Gruenbacher unsigned int packet_size) 2984b411b363SPhilipp Reisner { 298581e84650SAndreas Gruenbacher int ok = true; 2986e42325a5SPhilipp Reisner struct p_rs_param_95 *p = &mdev->tconn->data.rbuf.rs_param_95; 2987b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2988b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2989b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 299031890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2991778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2992778f271dSPhilipp Reisner int fifo_size = 0; 2993b411b363SPhilipp Reisner 2994b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2995b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2996b411b363SPhilipp Reisner + SHARED_SECRET_MAX 29978e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 29988e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2999b411b363SPhilipp Reisner 300002918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 3001b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 300202918be2SPhilipp Reisner packet_size, exp_max_sz); 300381e84650SAndreas Gruenbacher return false; 3004b411b363SPhilipp Reisner } 3005b411b363SPhilipp Reisner 3006b411b363SPhilipp Reisner if (apv <= 88) { 3007257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 300802918be2SPhilipp Reisner data_size = packet_size - header_size; 30098e26f9ccSPhilipp Reisner } else if (apv <= 94) { 3010257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 301102918be2SPhilipp Reisner data_size = packet_size - header_size; 3012b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 30138e26f9ccSPhilipp Reisner } else { 3014257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 301502918be2SPhilipp Reisner data_size = packet_size - header_size; 3016b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3017b411b363SPhilipp Reisner } 3018b411b363SPhilipp Reisner 3019b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3020b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3021b411b363SPhilipp Reisner 3022de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, &p->head.payload, header_size) != header_size) 302381e84650SAndreas Gruenbacher return false; 3024b411b363SPhilipp Reisner 3025f399002eSLars Ellenberg if (get_ldev(mdev)) { 3026f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3027f399002eSLars Ellenberg put_ldev(mdev); 3028f399002eSLars Ellenberg } 3029b411b363SPhilipp Reisner 3030b411b363SPhilipp Reisner if (apv >= 88) { 3031b411b363SPhilipp Reisner if (apv == 88) { 3032b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3033b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3034b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3035b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 303681e84650SAndreas Gruenbacher return false; 3037b411b363SPhilipp Reisner } 3038b411b363SPhilipp Reisner 3039de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->verify_alg, data_size) != data_size) 304081e84650SAndreas Gruenbacher return false; 3041b411b363SPhilipp Reisner 3042b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3043b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3044b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3045b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3046b411b363SPhilipp Reisner 3047b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3048b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3049b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3050b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3051b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3052b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3053b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3054b411b363SPhilipp Reisner } 3055b411b363SPhilipp Reisner 3056f399002eSLars Ellenberg if (strcmp(mdev->tconn->net_conf->verify_alg, p->verify_alg)) { 3057b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3058b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 3059f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg, p->verify_alg); 3060b411b363SPhilipp Reisner goto disconnect; 3061b411b363SPhilipp Reisner } 3062b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3063b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3064b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3065b411b363SPhilipp Reisner verify_tfm = NULL; 3066b411b363SPhilipp Reisner goto disconnect; 3067b411b363SPhilipp Reisner } 3068b411b363SPhilipp Reisner } 3069b411b363SPhilipp Reisner 3070f399002eSLars Ellenberg if (apv >= 89 && strcmp(mdev->tconn->net_conf->csums_alg, p->csums_alg)) { 3071b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3072b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 3073f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg, p->csums_alg); 3074b411b363SPhilipp Reisner goto disconnect; 3075b411b363SPhilipp Reisner } 3076b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3077b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3078b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3079b411b363SPhilipp Reisner csums_tfm = NULL; 3080b411b363SPhilipp Reisner goto disconnect; 3081b411b363SPhilipp Reisner } 3082b411b363SPhilipp Reisner } 3083b411b363SPhilipp Reisner 3084f399002eSLars Ellenberg if (apv > 94 && get_ldev(mdev)) { 3085f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3086f399002eSLars Ellenberg mdev->ldev->dc.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3087f399002eSLars Ellenberg mdev->ldev->dc.c_delay_target = be32_to_cpu(p->c_delay_target); 3088f399002eSLars Ellenberg mdev->ldev->dc.c_fill_target = be32_to_cpu(p->c_fill_target); 3089f399002eSLars Ellenberg mdev->ldev->dc.c_max_rate = be32_to_cpu(p->c_max_rate); 3090778f271dSPhilipp Reisner 3091f399002eSLars Ellenberg fifo_size = (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3092778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 3093778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 3094778f271dSPhilipp Reisner if (!rs_plan_s) { 3095778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3096f399002eSLars Ellenberg put_ldev(mdev); 3097778f271dSPhilipp Reisner goto disconnect; 3098778f271dSPhilipp Reisner } 3099778f271dSPhilipp Reisner } 3100f399002eSLars Ellenberg put_ldev(mdev); 31018e26f9ccSPhilipp Reisner } 3102b411b363SPhilipp Reisner 3103b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 3104b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 3105b411b363SPhilipp Reisner if (verify_tfm) { 3106f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->verify_alg, p->verify_alg); 3107f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3108f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3109f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3110b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3111b411b363SPhilipp Reisner } 3112b411b363SPhilipp Reisner if (csums_tfm) { 3113f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->csums_alg, p->csums_alg); 3114f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3115f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3116f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3117b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3118b411b363SPhilipp Reisner } 3119778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 3120778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 3121778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 3122778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 3123778f271dSPhilipp Reisner mdev->rs_planed = 0; 3124778f271dSPhilipp Reisner } 3125b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 3126b411b363SPhilipp Reisner } 3127b411b363SPhilipp Reisner 3128b411b363SPhilipp Reisner return ok; 3129b411b363SPhilipp Reisner disconnect: 3130b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3131b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3132b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3133b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3134b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 313538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 313681e84650SAndreas Gruenbacher return false; 3137b411b363SPhilipp Reisner } 3138b411b363SPhilipp Reisner 3139b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3140b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3141b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3142b411b363SPhilipp Reisner { 3143b411b363SPhilipp Reisner sector_t d; 3144b411b363SPhilipp Reisner if (a == 0 || b == 0) 3145b411b363SPhilipp Reisner return; 3146b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3147b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3148b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3149b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3150b411b363SPhilipp Reisner } 3151b411b363SPhilipp Reisner 3152d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 3153d8763023SAndreas Gruenbacher unsigned int data_size) 3154b411b363SPhilipp Reisner { 3155e42325a5SPhilipp Reisner struct p_sizes *p = &mdev->tconn->data.rbuf.sizes; 3156b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3157b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3158b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3159e89b591cSPhilipp Reisner enum dds_flags ddsf; 3160b411b363SPhilipp Reisner 3161b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3162b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3163b411b363SPhilipp Reisner 3164b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3165b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3166b411b363SPhilipp Reisner mdev->p_size = p_size; 3167b411b363SPhilipp Reisner 3168b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3169b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3170b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3171b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3172b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3173b411b363SPhilipp Reisner 3174b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3175b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3176b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3177b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3178b411b363SPhilipp Reisner p_usize); 3179b411b363SPhilipp Reisner 3180b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3181b411b363SPhilipp Reisner 3182b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3183b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3184b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3185b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3186b411b363SPhilipp Reisner } 3187b411b363SPhilipp Reisner 3188b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3189b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3190a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3191b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3192b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3193b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3194b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 319538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3196b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3197b411b363SPhilipp Reisner put_ldev(mdev); 319881e84650SAndreas Gruenbacher return false; 3199b411b363SPhilipp Reisner } 3200b411b363SPhilipp Reisner put_ldev(mdev); 3201b411b363SPhilipp Reisner } 3202b411b363SPhilipp Reisner 3203e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3204b411b363SPhilipp Reisner if (get_ldev(mdev)) { 320524c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3206b411b363SPhilipp Reisner put_ldev(mdev); 3207b411b363SPhilipp Reisner if (dd == dev_size_error) 320881e84650SAndreas Gruenbacher return false; 3209b411b363SPhilipp Reisner drbd_md_sync(mdev); 3210b411b363SPhilipp Reisner } else { 3211b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3212b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3213b411b363SPhilipp Reisner } 3214b411b363SPhilipp Reisner 321599432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 321699432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 321799432fccSPhilipp Reisner 3218b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3219b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3220b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3221b411b363SPhilipp Reisner ldsc = 1; 3222b411b363SPhilipp Reisner } 3223b411b363SPhilipp Reisner 3224b411b363SPhilipp Reisner put_ldev(mdev); 3225b411b363SPhilipp Reisner } 3226b411b363SPhilipp Reisner 3227b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3228b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3229b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3230b411b363SPhilipp Reisner /* we have different sizes, probably peer 3231b411b363SPhilipp Reisner * needs to know my new size... */ 3232e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3233b411b363SPhilipp Reisner } 3234b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3235b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3236b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3237e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3238e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3239e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3240b411b363SPhilipp Reisner else 3241e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3242e89b591cSPhilipp Reisner } else 3243b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3244b411b363SPhilipp Reisner } 3245b411b363SPhilipp Reisner } 3246b411b363SPhilipp Reisner 324781e84650SAndreas Gruenbacher return true; 3248b411b363SPhilipp Reisner } 3249b411b363SPhilipp Reisner 3250d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3251d8763023SAndreas Gruenbacher unsigned int data_size) 3252b411b363SPhilipp Reisner { 3253e42325a5SPhilipp Reisner struct p_uuids *p = &mdev->tconn->data.rbuf.uuids; 3254b411b363SPhilipp Reisner u64 *p_uuid; 325562b0da3aSLars Ellenberg int i, updated_uuids = 0; 3256b411b363SPhilipp Reisner 3257b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3258b411b363SPhilipp Reisner 3259b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3260b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3261b411b363SPhilipp Reisner 3262b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3263b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3264b411b363SPhilipp Reisner 3265b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3266b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3267b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3268b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3269b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3270b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 327138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 327281e84650SAndreas Gruenbacher return false; 3273b411b363SPhilipp Reisner } 3274b411b363SPhilipp Reisner 3275b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3276b411b363SPhilipp Reisner int skip_initial_sync = 3277b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 327831890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3279b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3280b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3281b411b363SPhilipp Reisner if (skip_initial_sync) { 3282b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3283b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 328420ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 328520ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3286b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3287b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3288b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3289b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3290b411b363SPhilipp Reisner drbd_md_sync(mdev); 329162b0da3aSLars Ellenberg updated_uuids = 1; 3292b411b363SPhilipp Reisner } 3293b411b363SPhilipp Reisner put_ldev(mdev); 329418a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 329518a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 329618a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 329718a50fa2SPhilipp Reisner for me. */ 329862b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3299b411b363SPhilipp Reisner } 3300b411b363SPhilipp Reisner 3301b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3302b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3303b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3304b411b363SPhilipp Reisner new disk state... */ 33058410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 33068410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3307b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 330862b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 330962b0da3aSLars Ellenberg 331062b0da3aSLars Ellenberg if (updated_uuids) 331162b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3312b411b363SPhilipp Reisner 331381e84650SAndreas Gruenbacher return true; 3314b411b363SPhilipp Reisner } 3315b411b363SPhilipp Reisner 3316b411b363SPhilipp Reisner /** 3317b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3318b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3319b411b363SPhilipp Reisner */ 3320b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3321b411b363SPhilipp Reisner { 3322b411b363SPhilipp Reisner union drbd_state ms; 3323b411b363SPhilipp Reisner 3324b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3325b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3326b411b363SPhilipp Reisner 3327b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3328b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3329b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3330b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3331b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3332b411b363SPhilipp Reisner }; 3333b411b363SPhilipp Reisner 3334b411b363SPhilipp Reisner ms.i = ps.i; 3335b411b363SPhilipp Reisner 3336b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3337b411b363SPhilipp Reisner ms.peer = ps.role; 3338b411b363SPhilipp Reisner ms.role = ps.peer; 3339b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3340b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3341b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3342b411b363SPhilipp Reisner 3343b411b363SPhilipp Reisner return ms; 3344b411b363SPhilipp Reisner } 3345b411b363SPhilipp Reisner 3346d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3347d8763023SAndreas Gruenbacher unsigned int data_size) 3348b411b363SPhilipp Reisner { 3349e42325a5SPhilipp Reisner struct p_req_state *p = &mdev->tconn->data.rbuf.req_state; 3350b411b363SPhilipp Reisner union drbd_state mask, val; 3351bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3352b411b363SPhilipp Reisner 3353b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3354b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3355b411b363SPhilipp Reisner 335625703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 33578410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3358b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 335981e84650SAndreas Gruenbacher return true; 3360b411b363SPhilipp Reisner } 3361b411b363SPhilipp Reisner 3362b411b363SPhilipp Reisner mask = convert_state(mask); 3363b411b363SPhilipp Reisner val = convert_state(val); 3364b411b363SPhilipp Reisner 3365b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3366b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3367047cd4a6SPhilipp Reisner 3368b411b363SPhilipp Reisner drbd_md_sync(mdev); 3369b411b363SPhilipp Reisner 337081e84650SAndreas Gruenbacher return true; 3371b411b363SPhilipp Reisner } 3372b411b363SPhilipp Reisner 3373dfafcc8aSPhilipp Reisner static int receive_req_conn_state(struct drbd_tconn *tconn, enum drbd_packet cmd, 3374dfafcc8aSPhilipp Reisner unsigned int data_size) 3375dfafcc8aSPhilipp Reisner { 3376dfafcc8aSPhilipp Reisner struct p_req_state *p = &tconn->data.rbuf.req_state; 3377dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3378dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3379dfafcc8aSPhilipp Reisner 3380dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3381dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3382dfafcc8aSPhilipp Reisner 3383dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3384dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3385dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 3386dfafcc8aSPhilipp Reisner return true; 3387dfafcc8aSPhilipp Reisner } 3388dfafcc8aSPhilipp Reisner 3389dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3390dfafcc8aSPhilipp Reisner val = convert_state(val); 3391dfafcc8aSPhilipp Reisner 3392dfafcc8aSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY); 3393dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3394dfafcc8aSPhilipp Reisner 3395dfafcc8aSPhilipp Reisner return true; 3396dfafcc8aSPhilipp Reisner } 3397dfafcc8aSPhilipp Reisner 3398d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3399d8763023SAndreas Gruenbacher unsigned int data_size) 3400b411b363SPhilipp Reisner { 3401e42325a5SPhilipp Reisner struct p_state *p = &mdev->tconn->data.rbuf.state; 34024ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3403b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 340465d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3405b411b363SPhilipp Reisner int rv; 3406b411b363SPhilipp Reisner 3407b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3408b411b363SPhilipp Reisner 3409b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3410b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3411b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3412b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3413b411b363SPhilipp Reisner } 3414b411b363SPhilipp Reisner 341587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3416b411b363SPhilipp Reisner retry: 34174ac4aadaSLars Ellenberg os = ns = mdev->state; 341887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3419b411b363SPhilipp Reisner 3420e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3421e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3422e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3423e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3424e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3425e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3426e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3427e9ef7bb6SLars Ellenberg * syncing states. 3428e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3429e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3430e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3431e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3432e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3433e9ef7bb6SLars Ellenberg 3434e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3435e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3436e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3437e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3438e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3439e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3440e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 344181e84650SAndreas Gruenbacher return true; 3442e9ef7bb6SLars Ellenberg } 3443e9ef7bb6SLars Ellenberg } 3444e9ef7bb6SLars Ellenberg 3445e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3446e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3447e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3448e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3449e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3450e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3451e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3452e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3453e9ef7bb6SLars Ellenberg 34544ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 34554ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3456b411b363SPhilipp Reisner 345767531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 345867531718SPhilipp Reisner ns.conn = C_BEHIND; 345967531718SPhilipp Reisner 3460b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3461b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3462b411b363SPhilipp Reisner int cr; /* consider resync */ 3463b411b363SPhilipp Reisner 3464b411b363SPhilipp Reisner /* if we established a new connection */ 34654ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3466b411b363SPhilipp Reisner /* if we had an established connection 3467b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 34684ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3469b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 34704ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3471b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3472b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3473b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3474b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3475b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 34764ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3477b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3478b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3479b411b363SPhilipp Reisner 3480b411b363SPhilipp Reisner if (cr) 34814ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3482b411b363SPhilipp Reisner 3483b411b363SPhilipp Reisner put_ldev(mdev); 34844ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 34854ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3486b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 348782f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3488b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3489b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3490b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3491580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3492b411b363SPhilipp Reisner } else { 34938169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 349481e84650SAndreas Gruenbacher return false; 34954ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 349638fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 349781e84650SAndreas Gruenbacher return false; 3498b411b363SPhilipp Reisner } 3499b411b363SPhilipp Reisner } 3500b411b363SPhilipp Reisner } 3501b411b363SPhilipp Reisner 350287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 35034ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3504b411b363SPhilipp Reisner goto retry; 3505b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3506b411b363SPhilipp Reisner ns.peer = peer_state.role; 3507b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3508b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 35094ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3510b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 35114ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 35124ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3513481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 35148554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3515481c6f50SPhilipp Reisner for temporal network outages! */ 351687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3517481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 35182f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3519481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3520481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 352138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 352281e84650SAndreas Gruenbacher return false; 3523481c6f50SPhilipp Reisner } 352465d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3525b411b363SPhilipp Reisner ns = mdev->state; 352687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3527b411b363SPhilipp Reisner 3528b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 352938fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 353081e84650SAndreas Gruenbacher return false; 3531b411b363SPhilipp Reisner } 3532b411b363SPhilipp Reisner 35334ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 35344ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3535b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3536b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3537b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3538b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3539b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3540b411b363SPhilipp Reisner drbd_send_state(mdev); 3541b411b363SPhilipp Reisner } 3542b411b363SPhilipp Reisner } 3543b411b363SPhilipp Reisner 354489e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3545b411b363SPhilipp Reisner 3546b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3547b411b363SPhilipp Reisner 354881e84650SAndreas Gruenbacher return true; 3549b411b363SPhilipp Reisner } 3550b411b363SPhilipp Reisner 3551d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3552d8763023SAndreas Gruenbacher unsigned int data_size) 3553b411b363SPhilipp Reisner { 3554e42325a5SPhilipp Reisner struct p_rs_uuid *p = &mdev->tconn->data.rbuf.rs_uuid; 3555b411b363SPhilipp Reisner 3556b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3557b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3558c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3559b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3560b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3561b411b363SPhilipp Reisner 3562b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3563b411b363SPhilipp Reisner 3564b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3565b411b363SPhilipp Reisner _not_ be rotated into the history */ 3566b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3567b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3568b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3569b411b363SPhilipp Reisner 357062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3571b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3572b411b363SPhilipp Reisner 3573b411b363SPhilipp Reisner put_ldev(mdev); 3574b411b363SPhilipp Reisner } else 3575b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3576b411b363SPhilipp Reisner 357781e84650SAndreas Gruenbacher return true; 3578b411b363SPhilipp Reisner } 3579b411b363SPhilipp Reisner 35802c46407dSAndreas Gruenbacher /** 35812c46407dSAndreas Gruenbacher * receive_bitmap_plain 35822c46407dSAndreas Gruenbacher * 35832c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35842c46407dSAndreas Gruenbacher * code upon failure. 35852c46407dSAndreas Gruenbacher */ 35862c46407dSAndreas Gruenbacher static int 358702918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3588b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3589b411b363SPhilipp Reisner { 3590b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3591b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 35922c46407dSAndreas Gruenbacher int err; 3593b411b363SPhilipp Reisner 359402918be2SPhilipp Reisner if (want != data_size) { 359502918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 35962c46407dSAndreas Gruenbacher return -EIO; 3597b411b363SPhilipp Reisner } 3598b411b363SPhilipp Reisner if (want == 0) 35992c46407dSAndreas Gruenbacher return 0; 3600de0ff338SPhilipp Reisner err = drbd_recv(mdev->tconn, buffer, want); 36012c46407dSAndreas Gruenbacher if (err != want) { 36022c46407dSAndreas Gruenbacher if (err >= 0) 36032c46407dSAndreas Gruenbacher err = -EIO; 36042c46407dSAndreas Gruenbacher return err; 36052c46407dSAndreas Gruenbacher } 3606b411b363SPhilipp Reisner 3607b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3608b411b363SPhilipp Reisner 3609b411b363SPhilipp Reisner c->word_offset += num_words; 3610b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3611b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3612b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3613b411b363SPhilipp Reisner 36142c46407dSAndreas Gruenbacher return 1; 3615b411b363SPhilipp Reisner } 3616b411b363SPhilipp Reisner 36172c46407dSAndreas Gruenbacher /** 36182c46407dSAndreas Gruenbacher * recv_bm_rle_bits 36192c46407dSAndreas Gruenbacher * 36202c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36212c46407dSAndreas Gruenbacher * code upon failure. 36222c46407dSAndreas Gruenbacher */ 36232c46407dSAndreas Gruenbacher static int 3624b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3625b411b363SPhilipp Reisner struct p_compressed_bm *p, 3626c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3627c6d25cfeSPhilipp Reisner unsigned int len) 3628b411b363SPhilipp Reisner { 3629b411b363SPhilipp Reisner struct bitstream bs; 3630b411b363SPhilipp Reisner u64 look_ahead; 3631b411b363SPhilipp Reisner u64 rl; 3632b411b363SPhilipp Reisner u64 tmp; 3633b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3634b411b363SPhilipp Reisner unsigned long e; 3635b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3636b411b363SPhilipp Reisner int have; 3637b411b363SPhilipp Reisner int bits; 3638b411b363SPhilipp Reisner 3639b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3640b411b363SPhilipp Reisner 3641b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3642b411b363SPhilipp Reisner if (bits < 0) 36432c46407dSAndreas Gruenbacher return -EIO; 3644b411b363SPhilipp Reisner 3645b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3646b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3647b411b363SPhilipp Reisner if (bits <= 0) 36482c46407dSAndreas Gruenbacher return -EIO; 3649b411b363SPhilipp Reisner 3650b411b363SPhilipp Reisner if (toggle) { 3651b411b363SPhilipp Reisner e = s + rl -1; 3652b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3653b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 36542c46407dSAndreas Gruenbacher return -EIO; 3655b411b363SPhilipp Reisner } 3656b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3657b411b363SPhilipp Reisner } 3658b411b363SPhilipp Reisner 3659b411b363SPhilipp Reisner if (have < bits) { 3660b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3661b411b363SPhilipp Reisner have, bits, look_ahead, 3662b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3663b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 36642c46407dSAndreas Gruenbacher return -EIO; 3665b411b363SPhilipp Reisner } 3666b411b363SPhilipp Reisner look_ahead >>= bits; 3667b411b363SPhilipp Reisner have -= bits; 3668b411b363SPhilipp Reisner 3669b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3670b411b363SPhilipp Reisner if (bits < 0) 36712c46407dSAndreas Gruenbacher return -EIO; 3672b411b363SPhilipp Reisner look_ahead |= tmp << have; 3673b411b363SPhilipp Reisner have += bits; 3674b411b363SPhilipp Reisner } 3675b411b363SPhilipp Reisner 3676b411b363SPhilipp Reisner c->bit_offset = s; 3677b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3678b411b363SPhilipp Reisner 36792c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3680b411b363SPhilipp Reisner } 3681b411b363SPhilipp Reisner 36822c46407dSAndreas Gruenbacher /** 36832c46407dSAndreas Gruenbacher * decode_bitmap_c 36842c46407dSAndreas Gruenbacher * 36852c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36862c46407dSAndreas Gruenbacher * code upon failure. 36872c46407dSAndreas Gruenbacher */ 36882c46407dSAndreas Gruenbacher static int 3689b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3690b411b363SPhilipp Reisner struct p_compressed_bm *p, 3691c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3692c6d25cfeSPhilipp Reisner unsigned int len) 3693b411b363SPhilipp Reisner { 3694b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3695c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3696b411b363SPhilipp Reisner 3697b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3698b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3699b411b363SPhilipp Reisner * during all our tests. */ 3700b411b363SPhilipp Reisner 3701b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 370238fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 37032c46407dSAndreas Gruenbacher return -EIO; 3704b411b363SPhilipp Reisner } 3705b411b363SPhilipp Reisner 3706b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3707b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3708b411b363SPhilipp Reisner { 3709b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3710c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3711b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3712b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3713b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3714b411b363SPhilipp Reisner unsigned r; 3715b411b363SPhilipp Reisner 3716b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3717b411b363SPhilipp Reisner if (total == 0) 3718b411b363SPhilipp Reisner return; 3719b411b363SPhilipp Reisner 3720b411b363SPhilipp Reisner /* don't report if not compressed */ 3721b411b363SPhilipp Reisner if (total >= plain) 3722b411b363SPhilipp Reisner return; 3723b411b363SPhilipp Reisner 3724b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3725b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3726b411b363SPhilipp Reisner : (1000 * total / plain); 3727b411b363SPhilipp Reisner 3728b411b363SPhilipp Reisner if (r > 1000) 3729b411b363SPhilipp Reisner r = 1000; 3730b411b363SPhilipp Reisner 3731b411b363SPhilipp Reisner r = 1000 - r; 3732b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3733b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3734b411b363SPhilipp Reisner direction, 3735b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3736b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3737b411b363SPhilipp Reisner total, r/10, r % 10); 3738b411b363SPhilipp Reisner } 3739b411b363SPhilipp Reisner 3740b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3741b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3742b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3743b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3744b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3745b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3746b411b363SPhilipp Reisner 3747b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3748d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3749d8763023SAndreas Gruenbacher unsigned int data_size) 3750b411b363SPhilipp Reisner { 3751b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3752b411b363SPhilipp Reisner void *buffer; 37532c46407dSAndreas Gruenbacher int err; 375481e84650SAndreas Gruenbacher int ok = false; 3755257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 375677351055SPhilipp Reisner struct packet_info pi; 3757b411b363SPhilipp Reisner 375820ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 375920ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 376020ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3761b411b363SPhilipp Reisner 3762b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3763b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3764b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3765b411b363SPhilipp Reisner if (!buffer) { 3766b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3767b411b363SPhilipp Reisner goto out; 3768b411b363SPhilipp Reisner } 3769b411b363SPhilipp Reisner 3770b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3771b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3772b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3773b411b363SPhilipp Reisner }; 3774b411b363SPhilipp Reisner 37752c46407dSAndreas Gruenbacher for(;;) { 377602918be2SPhilipp Reisner if (cmd == P_BITMAP) { 37772c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 377802918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3779b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3780b411b363SPhilipp Reisner * and the feature is enabled! */ 3781b411b363SPhilipp Reisner struct p_compressed_bm *p; 3782b411b363SPhilipp Reisner 378302918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3784b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3785b411b363SPhilipp Reisner goto out; 3786b411b363SPhilipp Reisner } 3787b411b363SPhilipp Reisner /* use the page buff */ 3788b411b363SPhilipp Reisner p = buffer; 3789b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 3790de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->head.payload, data_size) != data_size) 3791b411b363SPhilipp Reisner goto out; 3792004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3793004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 379478fcbdaeSAndreas Gruenbacher goto out; 3795b411b363SPhilipp Reisner } 3796c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3797b411b363SPhilipp Reisner } else { 379802918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3799b411b363SPhilipp Reisner goto out; 3800b411b363SPhilipp Reisner } 3801b411b363SPhilipp Reisner 380202918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3803257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3804b411b363SPhilipp Reisner 38052c46407dSAndreas Gruenbacher if (err <= 0) { 38062c46407dSAndreas Gruenbacher if (err < 0) 38072c46407dSAndreas Gruenbacher goto out; 3808b411b363SPhilipp Reisner break; 38092c46407dSAndreas Gruenbacher } 381069bc7bc3SAndreas Gruenbacher if (drbd_recv_header(mdev->tconn, &pi)) 3811b411b363SPhilipp Reisner goto out; 381277351055SPhilipp Reisner cmd = pi.cmd; 381377351055SPhilipp Reisner data_size = pi.size; 38142c46407dSAndreas Gruenbacher } 3815b411b363SPhilipp Reisner 3816b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3817b411b363SPhilipp Reisner 3818b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3819de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3820de1f8e4aSAndreas Gruenbacher 3821b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3822b411b363SPhilipp Reisner if (!ok) 3823b411b363SPhilipp Reisner goto out; 3824b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3825de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3826de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3827b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3828b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3829b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3830b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3831b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3832b411b363SPhilipp Reisner } 3833b411b363SPhilipp Reisner 383481e84650SAndreas Gruenbacher ok = true; 3835b411b363SPhilipp Reisner out: 383620ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 3837b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3838b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3839b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3840b411b363SPhilipp Reisner return ok; 3841b411b363SPhilipp Reisner } 3842b411b363SPhilipp Reisner 38432de876efSPhilipp Reisner static int _tconn_receive_skip(struct drbd_tconn *tconn, unsigned int data_size) 3844b411b363SPhilipp Reisner { 3845b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3846b411b363SPhilipp Reisner static char sink[128]; 3847b411b363SPhilipp Reisner int size, want, r; 3848b411b363SPhilipp Reisner 384902918be2SPhilipp Reisner size = data_size; 3850b411b363SPhilipp Reisner while (size > 0) { 3851b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 38522de876efSPhilipp Reisner r = drbd_recv(tconn, sink, want); 38532de876efSPhilipp Reisner if (r <= 0) 3854841ce241SAndreas Gruenbacher break; 3855b411b363SPhilipp Reisner size -= r; 3856b411b363SPhilipp Reisner } 3857b411b363SPhilipp Reisner return size == 0; 3858b411b363SPhilipp Reisner } 3859b411b363SPhilipp Reisner 38602de876efSPhilipp Reisner static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 38612de876efSPhilipp Reisner unsigned int data_size) 38622de876efSPhilipp Reisner { 38632de876efSPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 38642de876efSPhilipp Reisner cmd, data_size); 38652de876efSPhilipp Reisner 38662de876efSPhilipp Reisner return _tconn_receive_skip(mdev->tconn, data_size); 38672de876efSPhilipp Reisner } 38682de876efSPhilipp Reisner 38692de876efSPhilipp Reisner static int tconn_receive_skip(struct drbd_tconn *tconn, enum drbd_packet cmd, unsigned int data_size) 38702de876efSPhilipp Reisner { 38712de876efSPhilipp Reisner conn_warn(tconn, "skipping packet for non existing volume type %d, l: %d!\n", 38722de876efSPhilipp Reisner cmd, data_size); 38732de876efSPhilipp Reisner 38742de876efSPhilipp Reisner return _tconn_receive_skip(tconn, data_size); 38752de876efSPhilipp Reisner } 38762de876efSPhilipp Reisner 3877d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3878d8763023SAndreas Gruenbacher unsigned int data_size) 3879b411b363SPhilipp Reisner { 3880b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3881b411b363SPhilipp Reisner * with the data requests being unplugged */ 3882e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3883b411b363SPhilipp Reisner 388481e84650SAndreas Gruenbacher return true; 3885b411b363SPhilipp Reisner } 3886b411b363SPhilipp Reisner 3887d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3888d8763023SAndreas Gruenbacher unsigned int data_size) 388973a01a18SPhilipp Reisner { 3890e42325a5SPhilipp Reisner struct p_block_desc *p = &mdev->tconn->data.rbuf.block_desc; 389173a01a18SPhilipp Reisner 3892f735e363SLars Ellenberg switch (mdev->state.conn) { 3893f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3894f735e363SLars Ellenberg case C_WF_BITMAP_T: 3895f735e363SLars Ellenberg case C_BEHIND: 3896f735e363SLars Ellenberg break; 3897f735e363SLars Ellenberg default: 3898f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3899f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3900f735e363SLars Ellenberg } 3901f735e363SLars Ellenberg 390273a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 390373a01a18SPhilipp Reisner 390481e84650SAndreas Gruenbacher return true; 390573a01a18SPhilipp Reisner } 390673a01a18SPhilipp Reisner 390702918be2SPhilipp Reisner struct data_cmd { 390802918be2SPhilipp Reisner int expect_payload; 390902918be2SPhilipp Reisner size_t pkt_size; 3910a4fbda8eSPhilipp Reisner enum mdev_or_conn fa_type; /* first argument's type */ 3911d9ae84e7SPhilipp Reisner union { 3912d9ae84e7SPhilipp Reisner int (*mdev_fn)(struct drbd_conf *, enum drbd_packet cmd, 3913d9ae84e7SPhilipp Reisner unsigned int to_receive); 3914d9ae84e7SPhilipp Reisner int (*conn_fn)(struct drbd_tconn *, enum drbd_packet cmd, 3915d9ae84e7SPhilipp Reisner unsigned int to_receive); 3916d9ae84e7SPhilipp Reisner }; 3917b411b363SPhilipp Reisner }; 3918b411b363SPhilipp Reisner 391902918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 3920d9ae84e7SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), MDEV, { receive_Data } }, 3921d9ae84e7SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_DataReply } }, 3922d9ae84e7SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_RSDataReply } } , 3923d9ae84e7SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), MDEV, { receive_Barrier } } , 3924d9ae84e7SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3925d9ae84e7SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3926d9ae84e7SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), MDEV, { receive_UnplugRemote } }, 3927d9ae84e7SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3928d9ae84e7SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3929d9ae84e7SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 3930d9ae84e7SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 39317204624cSPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), CONN, { .conn_fn = receive_protocol } }, 3932d9ae84e7SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), MDEV, { receive_uuids } }, 3933d9ae84e7SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), MDEV, { receive_sizes } }, 3934d9ae84e7SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), MDEV, { receive_state } }, 3935d9ae84e7SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), MDEV, { receive_req_state } }, 3936d9ae84e7SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), MDEV, { receive_sync_uuid } }, 3937d9ae84e7SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3938d9ae84e7SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3939d9ae84e7SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3940d9ae84e7SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), MDEV, { receive_skip } }, 3941d9ae84e7SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), MDEV, { receive_out_of_sync } }, 3942dfafcc8aSPhilipp Reisner [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), CONN, { .conn_fn = receive_req_conn_state } }, 394302918be2SPhilipp Reisner }; 394402918be2SPhilipp Reisner 394502918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 3946e42325a5SPhilipp Reisner mdev->tconn->data.rbuf.header.head.payload. 394702918be2SPhilipp Reisner 3948e42325a5SPhilipp Reisner Usually in mdev->tconn->data.rbuf.header.head the callback can find the usual 394902918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 395002918be2SPhilipp Reisner */ 3951b411b363SPhilipp Reisner 3952eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 3953b411b363SPhilipp Reisner { 3954eefc2f7dSPhilipp Reisner struct p_header *header = &tconn->data.rbuf.header; 395577351055SPhilipp Reisner struct packet_info pi; 395602918be2SPhilipp Reisner size_t shs; /* sub header size */ 395702918be2SPhilipp Reisner int rv; 3958b411b363SPhilipp Reisner 3959eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 3960eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 396169bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 396202918be2SPhilipp Reisner goto err_out; 396302918be2SPhilipp Reisner 39646e849ce8SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || 3965d9ae84e7SPhilipp Reisner !drbd_cmd_handler[pi.cmd].mdev_fn)) { 3966eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 396702918be2SPhilipp Reisner goto err_out; 39680b33a916SLars Ellenberg } 3969b411b363SPhilipp Reisner 397077351055SPhilipp Reisner shs = drbd_cmd_handler[pi.cmd].pkt_size - sizeof(struct p_header); 397177351055SPhilipp Reisner if (pi.size - shs > 0 && !drbd_cmd_handler[pi.cmd].expect_payload) { 3972eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 3973c13f7e1aSLars Ellenberg goto err_out; 3974c13f7e1aSLars Ellenberg } 3975c13f7e1aSLars Ellenberg 3976c13f7e1aSLars Ellenberg if (shs) { 3977eefc2f7dSPhilipp Reisner rv = drbd_recv(tconn, &header->payload, shs); 397802918be2SPhilipp Reisner if (unlikely(rv != shs)) { 39790ddc5549SLars Ellenberg if (!signal_pending(current)) 3980eefc2f7dSPhilipp Reisner conn_warn(tconn, "short read while reading sub header: rv=%d\n", rv); 398102918be2SPhilipp Reisner goto err_out; 3982b411b363SPhilipp Reisner } 398302918be2SPhilipp Reisner } 398402918be2SPhilipp Reisner 3985a4fbda8eSPhilipp Reisner if (drbd_cmd_handler[pi.cmd].fa_type == CONN) { 3986d9ae84e7SPhilipp Reisner rv = drbd_cmd_handler[pi.cmd].conn_fn(tconn, pi.cmd, pi.size - shs); 3987d9ae84e7SPhilipp Reisner } else { 3988d9ae84e7SPhilipp Reisner struct drbd_conf *mdev = vnr_to_mdev(tconn, pi.vnr); 39892de876efSPhilipp Reisner rv = mdev ? 3990d9ae84e7SPhilipp Reisner drbd_cmd_handler[pi.cmd].mdev_fn(mdev, pi.cmd, pi.size - shs) : 39912de876efSPhilipp Reisner tconn_receive_skip(tconn, pi.cmd, pi.size - shs); 3992d9ae84e7SPhilipp Reisner } 399302918be2SPhilipp Reisner 399402918be2SPhilipp Reisner if (unlikely(!rv)) { 3995eefc2f7dSPhilipp Reisner conn_err(tconn, "error receiving %s, l: %d!\n", 399677351055SPhilipp Reisner cmdname(pi.cmd), pi.size); 399702918be2SPhilipp Reisner goto err_out; 3998b411b363SPhilipp Reisner } 3999b411b363SPhilipp Reisner } 400002918be2SPhilipp Reisner 400102918be2SPhilipp Reisner if (0) { 400202918be2SPhilipp Reisner err_out: 4003bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4004b411b363SPhilipp Reisner } 4005b411b363SPhilipp Reisner } 4006b411b363SPhilipp Reisner 40070e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4008b411b363SPhilipp Reisner { 4009b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4010b411b363SPhilipp Reisner 4011b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 40120e29d163SPhilipp Reisner barr.w.tconn = tconn; 4013b411b363SPhilipp Reisner init_completion(&barr.done); 40140e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4015b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4016b411b363SPhilipp Reisner } 4017b411b363SPhilipp Reisner 4018360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 4019b411b363SPhilipp Reisner { 4020bbeb641cSPhilipp Reisner enum drbd_conns oc; 4021b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 4022b411b363SPhilipp Reisner 4023bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4024b411b363SPhilipp Reisner return; 4025b411b363SPhilipp Reisner 4026b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4027360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4028360cc740SPhilipp Reisner drbd_free_sock(tconn); 4029360cc740SPhilipp Reisner 4030360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 4031360cc740SPhilipp Reisner 4032360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4033360cc740SPhilipp Reisner 4034360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4035bbeb641cSPhilipp Reisner oc = tconn->cstate; 4036bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4037bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4038bbeb641cSPhilipp Reisner 4039360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4040360cc740SPhilipp Reisner 4041bbeb641cSPhilipp Reisner if (oc == C_DISCONNECTING) { 4042360cc740SPhilipp Reisner wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0); 4043360cc740SPhilipp Reisner 4044360cc740SPhilipp Reisner crypto_free_hash(tconn->cram_hmac_tfm); 4045360cc740SPhilipp Reisner tconn->cram_hmac_tfm = NULL; 4046360cc740SPhilipp Reisner 4047360cc740SPhilipp Reisner kfree(tconn->net_conf); 4048360cc740SPhilipp Reisner tconn->net_conf = NULL; 4049bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE); 4050360cc740SPhilipp Reisner } 4051360cc740SPhilipp Reisner } 4052360cc740SPhilipp Reisner 4053360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 4054360cc740SPhilipp Reisner { 4055360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 4056360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4057360cc740SPhilipp Reisner unsigned int i; 4058b411b363SPhilipp Reisner 405985719573SPhilipp Reisner /* wait for current activity to cease. */ 406087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4061b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4062b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4063b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 406487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4065b411b363SPhilipp Reisner 4066b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4067b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4068b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4069b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4070b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4071b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4072b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4073b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4074b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4075b411b363SPhilipp Reisner * on the fly. */ 4076b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4077b411b363SPhilipp Reisner mdev->rs_total = 0; 4078b411b363SPhilipp Reisner mdev->rs_failed = 0; 4079b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4080b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4081b411b363SPhilipp Reisner 40827fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 40837fde2be9SPhilipp Reisner 4084b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4085b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4086b411b363SPhilipp Reisner 4087b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4088b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4089b411b363SPhilipp Reisner * to be "canceled" */ 4090a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4091b411b363SPhilipp Reisner 4092b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 4093b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 4094b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 4095b411b363SPhilipp Reisner 4096b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4097b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4098b411b363SPhilipp Reisner 4099fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 41002f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4101b411b363SPhilipp Reisner 4102b411b363SPhilipp Reisner drbd_md_sync(mdev); 4103b411b363SPhilipp Reisner 4104b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4105b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4106b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 4107b411b363SPhilipp Reisner put_ldev(mdev); 4108b411b363SPhilipp Reisner } 4109b411b363SPhilipp Reisner 411087f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 411187f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 4112b411b363SPhilipp Reisner 411320ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 411420ceb2b2SLars Ellenberg * if any. */ 411520ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 411620ceb2b2SLars Ellenberg 4117b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4118b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4119b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4120b411b363SPhilipp Reisner * 4121b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4122b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4123b411b363SPhilipp Reisner */ 4124b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 4125b411b363SPhilipp Reisner if (i) 4126b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4127435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4128435f0740SLars Ellenberg if (i) 4129435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4130b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4131b411b363SPhilipp Reisner if (i) 413245bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4133b411b363SPhilipp Reisner 4134b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4135b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4136b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4137b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4138b411b363SPhilipp Reisner 4139b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4140b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4141b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4142360cc740SPhilipp Reisner 4143360cc740SPhilipp Reisner return 0; 4144b411b363SPhilipp Reisner } 4145b411b363SPhilipp Reisner 4146b411b363SPhilipp Reisner /* 4147b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4148b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4149b411b363SPhilipp Reisner * 4150b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4151b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4152b411b363SPhilipp Reisner * 4153b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4154b411b363SPhilipp Reisner */ 41558a22ccccSPhilipp Reisner static int drbd_send_handshake(struct drbd_tconn *tconn) 4156b411b363SPhilipp Reisner { 4157e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 41588a22ccccSPhilipp Reisner struct p_handshake *p = &tconn->data.sbuf.handshake; 4159e8d17b01SAndreas Gruenbacher int err; 4160b411b363SPhilipp Reisner 41618a22ccccSPhilipp Reisner if (mutex_lock_interruptible(&tconn->data.mutex)) { 41628a22ccccSPhilipp Reisner conn_err(tconn, "interrupted during initial handshake\n"); 4163e8d17b01SAndreas Gruenbacher return -EINTR; 4164b411b363SPhilipp Reisner } 4165b411b363SPhilipp Reisner 41668a22ccccSPhilipp Reisner if (tconn->data.socket == NULL) { 41678a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4168e8d17b01SAndreas Gruenbacher return -EIO; 4169b411b363SPhilipp Reisner } 4170b411b363SPhilipp Reisner 4171b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4172b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4173b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 4174e8d17b01SAndreas Gruenbacher err = _conn_send_cmd(tconn, 0, tconn->data.socket, P_HAND_SHAKE, 4175c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 41768a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4177e8d17b01SAndreas Gruenbacher return err; 4178b411b363SPhilipp Reisner } 4179b411b363SPhilipp Reisner 4180b411b363SPhilipp Reisner /* 4181b411b363SPhilipp Reisner * return values: 4182b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4183b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4184b411b363SPhilipp Reisner * -1 peer talks different language, 4185b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4186b411b363SPhilipp Reisner */ 418765d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn) 4188b411b363SPhilipp Reisner { 418965d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 419065d11ed6SPhilipp Reisner struct p_handshake *p = &tconn->data.rbuf.handshake; 419102918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 419277351055SPhilipp Reisner struct packet_info pi; 4193e8d17b01SAndreas Gruenbacher int err, rv; 4194b411b363SPhilipp Reisner 4195e8d17b01SAndreas Gruenbacher err = drbd_send_handshake(tconn); 4196e8d17b01SAndreas Gruenbacher if (err) 4197b411b363SPhilipp Reisner return 0; 4198b411b363SPhilipp Reisner 419969bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 420069bc7bc3SAndreas Gruenbacher if (err) 4201b411b363SPhilipp Reisner return 0; 4202b411b363SPhilipp Reisner 420377351055SPhilipp Reisner if (pi.cmd != P_HAND_SHAKE) { 420465d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake packet, received: %s (0x%04x)\n", 420577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4206b411b363SPhilipp Reisner return -1; 4207b411b363SPhilipp Reisner } 4208b411b363SPhilipp Reisner 420977351055SPhilipp Reisner if (pi.size != expect) { 421065d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake length: %u, received: %u\n", 421177351055SPhilipp Reisner expect, pi.size); 4212b411b363SPhilipp Reisner return -1; 4213b411b363SPhilipp Reisner } 4214b411b363SPhilipp Reisner 421565d11ed6SPhilipp Reisner rv = drbd_recv(tconn, &p->head.payload, expect); 4216b411b363SPhilipp Reisner 4217b411b363SPhilipp Reisner if (rv != expect) { 42180ddc5549SLars Ellenberg if (!signal_pending(current)) 421965d11ed6SPhilipp Reisner conn_warn(tconn, "short read receiving handshake packet: l=%u\n", rv); 4220b411b363SPhilipp Reisner return 0; 4221b411b363SPhilipp Reisner } 4222b411b363SPhilipp Reisner 4223b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4224b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4225b411b363SPhilipp Reisner if (p->protocol_max == 0) 4226b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4227b411b363SPhilipp Reisner 4228b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4229b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4230b411b363SPhilipp Reisner goto incompat; 4231b411b363SPhilipp Reisner 423265d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4233b411b363SPhilipp Reisner 423465d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 423565d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4236b411b363SPhilipp Reisner 4237b411b363SPhilipp Reisner return 1; 4238b411b363SPhilipp Reisner 4239b411b363SPhilipp Reisner incompat: 424065d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4241b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4242b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4243b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4244b411b363SPhilipp Reisner return -1; 4245b411b363SPhilipp Reisner } 4246b411b363SPhilipp Reisner 4247b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 424813e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4249b411b363SPhilipp Reisner { 4250b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4251b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4252b10d96cbSJohannes Thoma return -1; 4253b411b363SPhilipp Reisner } 4254b411b363SPhilipp Reisner #else 4255b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4256b10d96cbSJohannes Thoma 4257b10d96cbSJohannes Thoma /* Return value: 4258b10d96cbSJohannes Thoma 1 - auth succeeded, 4259b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4260b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4261b10d96cbSJohannes Thoma */ 4262b10d96cbSJohannes Thoma 426313e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4264b411b363SPhilipp Reisner { 4265b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4266b411b363SPhilipp Reisner struct scatterlist sg; 4267b411b363SPhilipp Reisner char *response = NULL; 4268b411b363SPhilipp Reisner char *right_response = NULL; 4269b411b363SPhilipp Reisner char *peers_ch = NULL; 427013e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4271b411b363SPhilipp Reisner unsigned int resp_size; 4272b411b363SPhilipp Reisner struct hash_desc desc; 427377351055SPhilipp Reisner struct packet_info pi; 427469bc7bc3SAndreas Gruenbacher int err, rv; 4275b411b363SPhilipp Reisner 427613e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4277b411b363SPhilipp Reisner desc.flags = 0; 4278b411b363SPhilipp Reisner 427913e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 428013e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4281b411b363SPhilipp Reisner if (rv) { 428213e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4283b10d96cbSJohannes Thoma rv = -1; 4284b411b363SPhilipp Reisner goto fail; 4285b411b363SPhilipp Reisner } 4286b411b363SPhilipp Reisner 4287b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4288b411b363SPhilipp Reisner 4289ce9879cbSAndreas Gruenbacher rv = !conn_send_cmd2(tconn, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4290b411b363SPhilipp Reisner if (!rv) 4291b411b363SPhilipp Reisner goto fail; 4292b411b363SPhilipp Reisner 429369bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 429469bc7bc3SAndreas Gruenbacher if (err) { 429569bc7bc3SAndreas Gruenbacher rv = 0; 4296b411b363SPhilipp Reisner goto fail; 429769bc7bc3SAndreas Gruenbacher } 4298b411b363SPhilipp Reisner 429977351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 430013e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 430177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4302b411b363SPhilipp Reisner rv = 0; 4303b411b363SPhilipp Reisner goto fail; 4304b411b363SPhilipp Reisner } 4305b411b363SPhilipp Reisner 430677351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 430713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4308b10d96cbSJohannes Thoma rv = -1; 4309b411b363SPhilipp Reisner goto fail; 4310b411b363SPhilipp Reisner } 4311b411b363SPhilipp Reisner 431277351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4313b411b363SPhilipp Reisner if (peers_ch == NULL) { 431413e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4315b10d96cbSJohannes Thoma rv = -1; 4316b411b363SPhilipp Reisner goto fail; 4317b411b363SPhilipp Reisner } 4318b411b363SPhilipp Reisner 431913e6037dSPhilipp Reisner rv = drbd_recv(tconn, peers_ch, pi.size); 4320b411b363SPhilipp Reisner 432177351055SPhilipp Reisner if (rv != pi.size) { 43220ddc5549SLars Ellenberg if (!signal_pending(current)) 432313e6037dSPhilipp Reisner conn_warn(tconn, "short read AuthChallenge: l=%u\n", rv); 4324b411b363SPhilipp Reisner rv = 0; 4325b411b363SPhilipp Reisner goto fail; 4326b411b363SPhilipp Reisner } 4327b411b363SPhilipp Reisner 432813e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4329b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4330b411b363SPhilipp Reisner if (response == NULL) { 433113e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4332b10d96cbSJohannes Thoma rv = -1; 4333b411b363SPhilipp Reisner goto fail; 4334b411b363SPhilipp Reisner } 4335b411b363SPhilipp Reisner 4336b411b363SPhilipp Reisner sg_init_table(&sg, 1); 433777351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4338b411b363SPhilipp Reisner 4339b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4340b411b363SPhilipp Reisner if (rv) { 434113e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4342b10d96cbSJohannes Thoma rv = -1; 4343b411b363SPhilipp Reisner goto fail; 4344b411b363SPhilipp Reisner } 4345b411b363SPhilipp Reisner 4346ce9879cbSAndreas Gruenbacher rv = !conn_send_cmd2(tconn, P_AUTH_RESPONSE, response, resp_size); 4347b411b363SPhilipp Reisner if (!rv) 4348b411b363SPhilipp Reisner goto fail; 4349b411b363SPhilipp Reisner 435069bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 435169bc7bc3SAndreas Gruenbacher if (err) { 435269bc7bc3SAndreas Gruenbacher rv = 0; 4353b411b363SPhilipp Reisner goto fail; 435469bc7bc3SAndreas Gruenbacher } 4355b411b363SPhilipp Reisner 435677351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 435713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 435877351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4359b411b363SPhilipp Reisner rv = 0; 4360b411b363SPhilipp Reisner goto fail; 4361b411b363SPhilipp Reisner } 4362b411b363SPhilipp Reisner 436377351055SPhilipp Reisner if (pi.size != resp_size) { 436413e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4365b411b363SPhilipp Reisner rv = 0; 4366b411b363SPhilipp Reisner goto fail; 4367b411b363SPhilipp Reisner } 4368b411b363SPhilipp Reisner 436913e6037dSPhilipp Reisner rv = drbd_recv(tconn, response , resp_size); 4370b411b363SPhilipp Reisner 4371b411b363SPhilipp Reisner if (rv != resp_size) { 43720ddc5549SLars Ellenberg if (!signal_pending(current)) 437313e6037dSPhilipp Reisner conn_warn(tconn, "short read receiving AuthResponse: l=%u\n", rv); 4374b411b363SPhilipp Reisner rv = 0; 4375b411b363SPhilipp Reisner goto fail; 4376b411b363SPhilipp Reisner } 4377b411b363SPhilipp Reisner 4378b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 43792d1ee87dSJulia Lawall if (right_response == NULL) { 438013e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4381b10d96cbSJohannes Thoma rv = -1; 4382b411b363SPhilipp Reisner goto fail; 4383b411b363SPhilipp Reisner } 4384b411b363SPhilipp Reisner 4385b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4386b411b363SPhilipp Reisner 4387b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4388b411b363SPhilipp Reisner if (rv) { 438913e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4390b10d96cbSJohannes Thoma rv = -1; 4391b411b363SPhilipp Reisner goto fail; 4392b411b363SPhilipp Reisner } 4393b411b363SPhilipp Reisner 4394b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4395b411b363SPhilipp Reisner 4396b411b363SPhilipp Reisner if (rv) 439713e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 439813e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4399b10d96cbSJohannes Thoma else 4400b10d96cbSJohannes Thoma rv = -1; 4401b411b363SPhilipp Reisner 4402b411b363SPhilipp Reisner fail: 4403b411b363SPhilipp Reisner kfree(peers_ch); 4404b411b363SPhilipp Reisner kfree(response); 4405b411b363SPhilipp Reisner kfree(right_response); 4406b411b363SPhilipp Reisner 4407b411b363SPhilipp Reisner return rv; 4408b411b363SPhilipp Reisner } 4409b411b363SPhilipp Reisner #endif 4410b411b363SPhilipp Reisner 4411b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4412b411b363SPhilipp Reisner { 4413392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4414b411b363SPhilipp Reisner int h; 4415b411b363SPhilipp Reisner 44164d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4417b411b363SPhilipp Reisner 4418b411b363SPhilipp Reisner do { 44194d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4420b411b363SPhilipp Reisner if (h == 0) { 44214d641dd7SPhilipp Reisner drbd_disconnect(tconn); 442220ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4423b411b363SPhilipp Reisner } 4424b411b363SPhilipp Reisner if (h == -1) { 44254d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4426bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4427b411b363SPhilipp Reisner } 4428b411b363SPhilipp Reisner } while (h == 0); 4429b411b363SPhilipp Reisner 4430b411b363SPhilipp Reisner if (h > 0) { 44314d641dd7SPhilipp Reisner if (get_net_conf(tconn)) { 44324d641dd7SPhilipp Reisner drbdd(tconn); 44334d641dd7SPhilipp Reisner put_net_conf(tconn); 4434b411b363SPhilipp Reisner } 4435b411b363SPhilipp Reisner } 4436b411b363SPhilipp Reisner 44374d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4438b411b363SPhilipp Reisner 44394d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4440b411b363SPhilipp Reisner return 0; 4441b411b363SPhilipp Reisner } 4442b411b363SPhilipp Reisner 4443b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4444b411b363SPhilipp Reisner 4445e4f78edeSPhilipp Reisner static int got_conn_RqSReply(struct drbd_tconn *tconn, enum drbd_packet cmd) 4446b411b363SPhilipp Reisner { 4447e4f78edeSPhilipp Reisner struct p_req_state_reply *p = &tconn->meta.rbuf.req_state_reply; 4448b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4449b411b363SPhilipp Reisner 4450fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4451fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4452fc3b10a4SPhilipp Reisner } else { 4453fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4454fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4455fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4456fc3b10a4SPhilipp Reisner } 4457fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4458e4f78edeSPhilipp Reisner 4459e4f78edeSPhilipp Reisner return true; 4460fc3b10a4SPhilipp Reisner } 4461e4f78edeSPhilipp Reisner 4462e4f78edeSPhilipp Reisner static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4463e4f78edeSPhilipp Reisner { 4464e4f78edeSPhilipp Reisner struct p_req_state_reply *p = &mdev->tconn->meta.rbuf.req_state_reply; 4465e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4466e4f78edeSPhilipp Reisner 4467e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4468e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4469e4f78edeSPhilipp Reisner } else { 4470e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4471e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4472e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4473e4f78edeSPhilipp Reisner } 4474e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4475e4f78edeSPhilipp Reisner 447681e84650SAndreas Gruenbacher return true; 4477b411b363SPhilipp Reisner } 4478b411b363SPhilipp Reisner 4479f19e4f8bSPhilipp Reisner static int got_Ping(struct drbd_tconn *tconn, enum drbd_packet cmd) 4480b411b363SPhilipp Reisner { 4481f19e4f8bSPhilipp Reisner return drbd_send_ping_ack(tconn); 4482b411b363SPhilipp Reisner 4483b411b363SPhilipp Reisner } 4484b411b363SPhilipp Reisner 4485f19e4f8bSPhilipp Reisner static int got_PingAck(struct drbd_tconn *tconn, enum drbd_packet cmd) 4486b411b363SPhilipp Reisner { 4487b411b363SPhilipp Reisner /* restore idle timeout */ 44882a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 44892a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 44902a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4491b411b363SPhilipp Reisner 449281e84650SAndreas Gruenbacher return true; 4493b411b363SPhilipp Reisner } 4494b411b363SPhilipp Reisner 4495d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4496b411b363SPhilipp Reisner { 4497257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4498b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4499b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4500b411b363SPhilipp Reisner 450131890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4502b411b363SPhilipp Reisner 4503b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4504b411b363SPhilipp Reisner 45051d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4506b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4507b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4508b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4509b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 45101d53f09eSLars Ellenberg put_ldev(mdev); 45111d53f09eSLars Ellenberg } 4512b411b363SPhilipp Reisner dec_rs_pending(mdev); 4513778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4514b411b363SPhilipp Reisner 451581e84650SAndreas Gruenbacher return true; 4516b411b363SPhilipp Reisner } 4517b411b363SPhilipp Reisner 4518bc9c5c41SAndreas Gruenbacher static int 4519bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4520bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4521bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4522b411b363SPhilipp Reisner { 4523b411b363SPhilipp Reisner struct drbd_request *req; 4524b411b363SPhilipp Reisner struct bio_and_error m; 4525b411b363SPhilipp Reisner 452687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4527bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4528b411b363SPhilipp Reisner if (unlikely(!req)) { 452987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 453081e84650SAndreas Gruenbacher return false; 4531b411b363SPhilipp Reisner } 4532b411b363SPhilipp Reisner __req_mod(req, what, &m); 453387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4534b411b363SPhilipp Reisner 4535b411b363SPhilipp Reisner if (m.bio) 4536b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 453781e84650SAndreas Gruenbacher return true; 4538b411b363SPhilipp Reisner } 4539b411b363SPhilipp Reisner 4540d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4541b411b363SPhilipp Reisner { 4542257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4543b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4544b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4545b411b363SPhilipp Reisner enum drbd_req_event what; 4546b411b363SPhilipp Reisner 4547b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4548b411b363SPhilipp Reisner 4549579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4550b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4551b411b363SPhilipp Reisner dec_rs_pending(mdev); 455281e84650SAndreas Gruenbacher return true; 4553b411b363SPhilipp Reisner } 4554257d0af6SPhilipp Reisner switch (cmd) { 4555b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 455689e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45578554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4558b411b363SPhilipp Reisner break; 4559b411b363SPhilipp Reisner case P_WRITE_ACK: 456089e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45618554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4562b411b363SPhilipp Reisner break; 4563b411b363SPhilipp Reisner case P_RECV_ACK: 456489e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 45658554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4566b411b363SPhilipp Reisner break; 45677be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 456889e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45697be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 45707be8da07SAndreas Gruenbacher break; 45717be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 45727be8da07SAndreas Gruenbacher D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45737be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4574b411b363SPhilipp Reisner break; 4575b411b363SPhilipp Reisner default: 4576b411b363SPhilipp Reisner D_ASSERT(0); 457781e84650SAndreas Gruenbacher return false; 4578b411b363SPhilipp Reisner } 4579b411b363SPhilipp Reisner 4580b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4581bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4582bc9c5c41SAndreas Gruenbacher what, false); 4583b411b363SPhilipp Reisner } 4584b411b363SPhilipp Reisner 4585d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4586b411b363SPhilipp Reisner { 4587257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4588b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 45892deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 459089e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 459189e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4592c3afd8f5SAndreas Gruenbacher bool found; 4593b411b363SPhilipp Reisner 4594b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4595b411b363SPhilipp Reisner 4596579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4597b411b363SPhilipp Reisner dec_rs_pending(mdev); 4598b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 459981e84650SAndreas Gruenbacher return true; 4600b411b363SPhilipp Reisner } 46012deb8336SPhilipp Reisner 4602c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4603bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 46048554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4605c3afd8f5SAndreas Gruenbacher if (!found) { 46062deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 46072deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4608c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 46092deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 46102deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4611c3afd8f5SAndreas Gruenbacher if (!missing_ok) 46122deb8336SPhilipp Reisner return false; 4613c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 46142deb8336SPhilipp Reisner } 46152deb8336SPhilipp Reisner return true; 4616b411b363SPhilipp Reisner } 4617b411b363SPhilipp Reisner 4618d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4619b411b363SPhilipp Reisner { 4620257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4621b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4622b411b363SPhilipp Reisner 4623b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 46247be8da07SAndreas Gruenbacher 4625b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4626b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4627b411b363SPhilipp Reisner 4628b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4629bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 46308554df1cSAndreas Gruenbacher NEG_ACKED, false); 4631b411b363SPhilipp Reisner } 4632b411b363SPhilipp Reisner 4633d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4634b411b363SPhilipp Reisner { 4635b411b363SPhilipp Reisner sector_t sector; 4636b411b363SPhilipp Reisner int size; 4637257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4638b411b363SPhilipp Reisner 4639b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4640b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4641b411b363SPhilipp Reisner 4642b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4643b411b363SPhilipp Reisner 4644b411b363SPhilipp Reisner dec_rs_pending(mdev); 4645b411b363SPhilipp Reisner 4646b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4647b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4648257d0af6SPhilipp Reisner switch (cmd) { 4649d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4650b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4651d612d309SPhilipp Reisner case P_RS_CANCEL: 4652d612d309SPhilipp Reisner break; 4653d612d309SPhilipp Reisner default: 4654d612d309SPhilipp Reisner D_ASSERT(0); 4655d612d309SPhilipp Reisner put_ldev(mdev); 4656d612d309SPhilipp Reisner return false; 4657d612d309SPhilipp Reisner } 4658b411b363SPhilipp Reisner put_ldev(mdev); 4659b411b363SPhilipp Reisner } 4660b411b363SPhilipp Reisner 466181e84650SAndreas Gruenbacher return true; 4662b411b363SPhilipp Reisner } 4663b411b363SPhilipp Reisner 4664d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4665b411b363SPhilipp Reisner { 4666257d0af6SPhilipp Reisner struct p_barrier_ack *p = &mdev->tconn->meta.rbuf.barrier_ack; 4667b411b363SPhilipp Reisner 46682f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4669b411b363SPhilipp Reisner 4670c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4671c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4672370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4673370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4674370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4675c4752ef1SPhilipp Reisner } 4676c4752ef1SPhilipp Reisner 467781e84650SAndreas Gruenbacher return true; 4678b411b363SPhilipp Reisner } 4679b411b363SPhilipp Reisner 4680d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4681b411b363SPhilipp Reisner { 4682257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4683b411b363SPhilipp Reisner struct drbd_work *w; 4684b411b363SPhilipp Reisner sector_t sector; 4685b411b363SPhilipp Reisner int size; 4686b411b363SPhilipp Reisner 4687b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4688b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4689b411b363SPhilipp Reisner 4690b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4691b411b363SPhilipp Reisner 4692b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4693b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4694b411b363SPhilipp Reisner else 4695b411b363SPhilipp Reisner ov_oos_print(mdev); 4696b411b363SPhilipp Reisner 46971d53f09eSLars Ellenberg if (!get_ldev(mdev)) 469881e84650SAndreas Gruenbacher return true; 46991d53f09eSLars Ellenberg 4700b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4701b411b363SPhilipp Reisner dec_rs_pending(mdev); 4702b411b363SPhilipp Reisner 4703ea5442afSLars Ellenberg --mdev->ov_left; 4704ea5442afSLars Ellenberg 4705ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4706ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4707ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4708ea5442afSLars Ellenberg 4709ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4710b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4711b411b363SPhilipp Reisner if (w) { 4712b411b363SPhilipp Reisner w->cb = w_ov_finished; 4713a21e9298SPhilipp Reisner w->mdev = mdev; 4714e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4715b411b363SPhilipp Reisner } else { 4716b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4717b411b363SPhilipp Reisner ov_oos_print(mdev); 4718b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4719b411b363SPhilipp Reisner } 4720b411b363SPhilipp Reisner } 47211d53f09eSLars Ellenberg put_ldev(mdev); 472281e84650SAndreas Gruenbacher return true; 4723b411b363SPhilipp Reisner } 4724b411b363SPhilipp Reisner 4725d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 47260ced55a3SPhilipp Reisner { 472781e84650SAndreas Gruenbacher return true; 47280ced55a3SPhilipp Reisner } 47290ced55a3SPhilipp Reisner 473032862ec7SPhilipp Reisner static int tconn_process_done_ee(struct drbd_tconn *tconn) 473132862ec7SPhilipp Reisner { 4732082a3439SPhilipp Reisner struct drbd_conf *mdev; 4733082a3439SPhilipp Reisner int i, not_empty = 0; 473432862ec7SPhilipp Reisner 473532862ec7SPhilipp Reisner do { 473632862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 473732862ec7SPhilipp Reisner flush_signals(current); 4738082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4739e2b3032bSAndreas Gruenbacher if (drbd_process_done_ee(mdev)) 4740082a3439SPhilipp Reisner return 1; /* error */ 4741082a3439SPhilipp Reisner } 474232862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 4743082a3439SPhilipp Reisner 4744082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4745082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4746082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 4747082a3439SPhilipp Reisner if (not_empty) 4748082a3439SPhilipp Reisner break; 4749082a3439SPhilipp Reisner } 4750082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 475132862ec7SPhilipp Reisner } while (not_empty); 475232862ec7SPhilipp Reisner 475332862ec7SPhilipp Reisner return 0; 475432862ec7SPhilipp Reisner } 475532862ec7SPhilipp Reisner 47567201b972SAndreas Gruenbacher struct asender_cmd { 47577201b972SAndreas Gruenbacher size_t pkt_size; 4758a4fbda8eSPhilipp Reisner enum mdev_or_conn fa_type; /* first argument's type */ 4759a4fbda8eSPhilipp Reisner union { 4760a4fbda8eSPhilipp Reisner int (*mdev_fn)(struct drbd_conf *mdev, enum drbd_packet cmd); 4761a4fbda8eSPhilipp Reisner int (*conn_fn)(struct drbd_tconn *tconn, enum drbd_packet cmd); 4762a4fbda8eSPhilipp Reisner }; 47637201b972SAndreas Gruenbacher }; 47647201b972SAndreas Gruenbacher 47657201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 4766f19e4f8bSPhilipp Reisner [P_PING] = { sizeof(struct p_header), CONN, { .conn_fn = got_Ping } }, 4767f19e4f8bSPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), CONN, { .conn_fn = got_PingAck } }, 4768a4fbda8eSPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4769a4fbda8eSPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4770a4fbda8eSPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4771a4fbda8eSPhilipp Reisner [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4772a4fbda8eSPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), MDEV, { got_NegAck } }, 4773a4fbda8eSPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), MDEV, { got_NegDReply } }, 4774a4fbda8eSPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), MDEV, { got_NegRSDReply } }, 4775a4fbda8eSPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), MDEV, { got_OVResult } }, 4776a4fbda8eSPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), MDEV, { got_BarrierAck } }, 4777a4fbda8eSPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), MDEV, { got_RqSReply } }, 4778a4fbda8eSPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), MDEV, { got_IsInSync } }, 4779a4fbda8eSPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), MDEV, { got_skip } }, 4780a4fbda8eSPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), MDEV, { got_NegRSDReply } }, 4781e4f78edeSPhilipp Reisner [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), CONN, {.conn_fn = got_conn_RqSReply}}, 4782a4fbda8eSPhilipp Reisner [P_RETRY_WRITE] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 47837201b972SAndreas Gruenbacher }; 47847201b972SAndreas Gruenbacher 4785b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4786b411b363SPhilipp Reisner { 4787392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 478832862ec7SPhilipp Reisner struct p_header *h = &tconn->meta.rbuf.header; 4789b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 479077351055SPhilipp Reisner struct packet_info pi; 4791257d0af6SPhilipp Reisner int rv; 4792b411b363SPhilipp Reisner void *buf = h; 4793b411b363SPhilipp Reisner int received = 0; 4794257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4795f36af18cSLars Ellenberg int ping_timeout_active = 0; 4796b411b363SPhilipp Reisner 4797b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4798b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4799b411b363SPhilipp Reisner 4800e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 480180822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 480232862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 48032a67d8b9SPhilipp Reisner if (!drbd_send_ping(tconn)) { 480432862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 4805841ce241SAndreas Gruenbacher goto reconnect; 4806841ce241SAndreas Gruenbacher } 480732862ec7SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = 480832862ec7SPhilipp Reisner tconn->net_conf->ping_timeo*HZ/10; 4809f36af18cSLars Ellenberg ping_timeout_active = 1; 4810b411b363SPhilipp Reisner } 4811b411b363SPhilipp Reisner 481232862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 481332862ec7SPhilipp Reisner much to send */ 481432862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 481532862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 4816082a3439SPhilipp Reisner if (tconn_process_done_ee(tconn)) { 4817082a3439SPhilipp Reisner conn_err(tconn, "tconn_process_done_ee() failed\n"); 4818b411b363SPhilipp Reisner goto reconnect; 4819082a3439SPhilipp Reisner } 4820b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 482132862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 482232862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 4823b411b363SPhilipp Reisner 4824b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4825b411b363SPhilipp Reisner if (signal_pending(current)) 4826b411b363SPhilipp Reisner continue; 4827b411b363SPhilipp Reisner 482832862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 482932862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4830b411b363SPhilipp Reisner 4831b411b363SPhilipp Reisner flush_signals(current); 4832b411b363SPhilipp Reisner 4833b411b363SPhilipp Reisner /* Note: 4834b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4835b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4836b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4837b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4838b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4839b411b363SPhilipp Reisner * rv == expected: full header or command 4840b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4841b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4842b411b363SPhilipp Reisner */ 4843b411b363SPhilipp Reisner if (likely(rv > 0)) { 4844b411b363SPhilipp Reisner received += rv; 4845b411b363SPhilipp Reisner buf += rv; 4846b411b363SPhilipp Reisner } else if (rv == 0) { 484732862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 4848b411b363SPhilipp Reisner goto reconnect; 4849b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4850cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4851cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 485232862ec7SPhilipp Reisner if (time_after(tconn->last_received, 485332862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 4854cb6518cbSLars Ellenberg continue; 4855f36af18cSLars Ellenberg if (ping_timeout_active) { 485632862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 4857b411b363SPhilipp Reisner goto reconnect; 4858b411b363SPhilipp Reisner } 485932862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 4860b411b363SPhilipp Reisner continue; 4861b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4862b411b363SPhilipp Reisner continue; 4863b411b363SPhilipp Reisner } else { 486432862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 4865b411b363SPhilipp Reisner goto reconnect; 4866b411b363SPhilipp Reisner } 4867b411b363SPhilipp Reisner 4868b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 48698172f3e9SAndreas Gruenbacher if (decode_header(tconn, h, &pi)) 4870b411b363SPhilipp Reisner goto reconnect; 48717201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 48727201b972SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd) { 487332862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 487477351055SPhilipp Reisner pi.cmd, pi.size); 4875b411b363SPhilipp Reisner goto disconnect; 4876b411b363SPhilipp Reisner } 4877b411b363SPhilipp Reisner expect = cmd->pkt_size; 487877351055SPhilipp Reisner if (pi.size != expect - sizeof(struct p_header)) { 487932862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 488077351055SPhilipp Reisner pi.cmd, pi.size); 4881b411b363SPhilipp Reisner goto reconnect; 4882b411b363SPhilipp Reisner } 4883257d0af6SPhilipp Reisner } 4884b411b363SPhilipp Reisner if (received == expect) { 4885a4fbda8eSPhilipp Reisner bool rv; 4886a4fbda8eSPhilipp Reisner 4887a4fbda8eSPhilipp Reisner if (cmd->fa_type == CONN) { 4888a4fbda8eSPhilipp Reisner rv = cmd->conn_fn(tconn, pi.cmd); 4889a4fbda8eSPhilipp Reisner } else { 4890a4fbda8eSPhilipp Reisner struct drbd_conf *mdev = vnr_to_mdev(tconn, pi.vnr); 4891a4fbda8eSPhilipp Reisner rv = cmd->mdev_fn(mdev, pi.cmd); 4892a4fbda8eSPhilipp Reisner } 4893a4fbda8eSPhilipp Reisner 4894a4fbda8eSPhilipp Reisner if (!rv) 4895b411b363SPhilipp Reisner goto reconnect; 4896b411b363SPhilipp Reisner 4897a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 4898a4fbda8eSPhilipp Reisner 4899f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4900f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 49017201b972SAndreas Gruenbacher if (cmd == &asender_tbl[P_PING_ACK]) 4902f36af18cSLars Ellenberg ping_timeout_active = 0; 4903f36af18cSLars Ellenberg 4904b411b363SPhilipp Reisner buf = h; 4905b411b363SPhilipp Reisner received = 0; 4906257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4907b411b363SPhilipp Reisner cmd = NULL; 4908b411b363SPhilipp Reisner } 4909b411b363SPhilipp Reisner } 4910b411b363SPhilipp Reisner 4911b411b363SPhilipp Reisner if (0) { 4912b411b363SPhilipp Reisner reconnect: 4913bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4914b411b363SPhilipp Reisner } 4915b411b363SPhilipp Reisner if (0) { 4916b411b363SPhilipp Reisner disconnect: 4917bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4918b411b363SPhilipp Reisner } 491932862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4920b411b363SPhilipp Reisner 492132862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 4922b411b363SPhilipp Reisner 4923b411b363SPhilipp Reisner return 0; 4924b411b363SPhilipp Reisner } 4925