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 581a5c31904SAndreas Gruenbacher static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size) 582a5c31904SAndreas Gruenbacher { 583a5c31904SAndreas Gruenbacher int err; 584a5c31904SAndreas Gruenbacher 585a5c31904SAndreas Gruenbacher err = drbd_recv_all(tconn, buf, size); 586a5c31904SAndreas Gruenbacher if (err && !signal_pending(current)) 587a5c31904SAndreas Gruenbacher conn_warn(tconn, "short read (expected size %d)\n", (int)size); 588a5c31904SAndreas Gruenbacher return err; 589a5c31904SAndreas Gruenbacher } 590a5c31904SAndreas Gruenbacher 5915dbf1673SLars Ellenberg /* quoting tcp(7): 5925dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5935dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5945dbf1673SLars Ellenberg * This is our wrapper to do so. 5955dbf1673SLars Ellenberg */ 5965dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5975dbf1673SLars Ellenberg unsigned int rcv) 5985dbf1673SLars Ellenberg { 5995dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 6005dbf1673SLars Ellenberg if (snd) { 6015dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 6025dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 6035dbf1673SLars Ellenberg } 6045dbf1673SLars Ellenberg if (rcv) { 6055dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 6065dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 6075dbf1673SLars Ellenberg } 6085dbf1673SLars Ellenberg } 6095dbf1673SLars Ellenberg 610eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 611b411b363SPhilipp Reisner { 612b411b363SPhilipp Reisner const char *what; 613b411b363SPhilipp Reisner struct socket *sock; 614b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 615b411b363SPhilipp Reisner int err; 616b411b363SPhilipp Reisner int disconnect_on_error = 1; 617b411b363SPhilipp Reisner 618eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 619b411b363SPhilipp Reisner return NULL; 620b411b363SPhilipp Reisner 621b411b363SPhilipp Reisner what = "sock_create_kern"; 622eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 623b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 624b411b363SPhilipp Reisner if (err < 0) { 625b411b363SPhilipp Reisner sock = NULL; 626b411b363SPhilipp Reisner goto out; 627b411b363SPhilipp Reisner } 628b411b363SPhilipp Reisner 629b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 630eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 631eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 632eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 633b411b363SPhilipp Reisner 634b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 635b411b363SPhilipp Reisner * for the outgoing connections. 636b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 637b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 638b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 639b411b363SPhilipp Reisner * a free one dynamically. 640b411b363SPhilipp Reisner */ 641eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 642eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 643eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 644b411b363SPhilipp Reisner src_in6.sin6_port = 0; 645b411b363SPhilipp Reisner else 646b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 647b411b363SPhilipp Reisner 648b411b363SPhilipp Reisner what = "bind before connect"; 649b411b363SPhilipp Reisner err = sock->ops->bind(sock, 650b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 651eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 652b411b363SPhilipp Reisner if (err < 0) 653b411b363SPhilipp Reisner goto out; 654b411b363SPhilipp Reisner 655b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 656b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 657b411b363SPhilipp Reisner disconnect_on_error = 0; 658b411b363SPhilipp Reisner what = "connect"; 659b411b363SPhilipp Reisner err = sock->ops->connect(sock, 660eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 661eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 662b411b363SPhilipp Reisner 663b411b363SPhilipp Reisner out: 664b411b363SPhilipp Reisner if (err < 0) { 665b411b363SPhilipp Reisner if (sock) { 666b411b363SPhilipp Reisner sock_release(sock); 667b411b363SPhilipp Reisner sock = NULL; 668b411b363SPhilipp Reisner } 669b411b363SPhilipp Reisner switch (-err) { 670b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 671b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 672b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 673b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 674b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 675b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 676b411b363SPhilipp Reisner disconnect_on_error = 0; 677b411b363SPhilipp Reisner break; 678b411b363SPhilipp Reisner default: 679eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 680b411b363SPhilipp Reisner } 681b411b363SPhilipp Reisner if (disconnect_on_error) 682bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 683b411b363SPhilipp Reisner } 684eac3e990SPhilipp Reisner put_net_conf(tconn); 685b411b363SPhilipp Reisner return sock; 686b411b363SPhilipp Reisner } 687b411b363SPhilipp Reisner 6887653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 689b411b363SPhilipp Reisner { 690b411b363SPhilipp Reisner int timeo, err; 691b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 692b411b363SPhilipp Reisner const char *what; 693b411b363SPhilipp Reisner 6947653620dSPhilipp Reisner if (!get_net_conf(tconn)) 695b411b363SPhilipp Reisner return NULL; 696b411b363SPhilipp Reisner 697b411b363SPhilipp Reisner what = "sock_create_kern"; 6987653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 699b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 700b411b363SPhilipp Reisner if (err) { 701b411b363SPhilipp Reisner s_listen = NULL; 702b411b363SPhilipp Reisner goto out; 703b411b363SPhilipp Reisner } 704b411b363SPhilipp Reisner 7057653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 706b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 707b411b363SPhilipp Reisner 708b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 709b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 710b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 7117653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 7127653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 713b411b363SPhilipp Reisner 714b411b363SPhilipp Reisner what = "bind before listen"; 715b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 7167653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 7177653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 718b411b363SPhilipp Reisner if (err < 0) 719b411b363SPhilipp Reisner goto out; 720b411b363SPhilipp Reisner 7217653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 722b411b363SPhilipp Reisner 723b411b363SPhilipp Reisner out: 724b411b363SPhilipp Reisner if (s_listen) 725b411b363SPhilipp Reisner sock_release(s_listen); 726b411b363SPhilipp Reisner if (err < 0) { 727b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7287653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 729bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 730b411b363SPhilipp Reisner } 731b411b363SPhilipp Reisner } 7327653620dSPhilipp Reisner put_net_conf(tconn); 733b411b363SPhilipp Reisner 734b411b363SPhilipp Reisner return s_estab; 735b411b363SPhilipp Reisner } 736b411b363SPhilipp Reisner 737d38e787eSPhilipp Reisner static int drbd_send_fp(struct drbd_tconn *tconn, struct socket *sock, enum drbd_packet cmd) 738b411b363SPhilipp Reisner { 739d38e787eSPhilipp Reisner struct p_header *h = &tconn->data.sbuf.header; 740b411b363SPhilipp Reisner 741ecf2363cSAndreas Gruenbacher return !_conn_send_cmd(tconn, 0, sock, cmd, h, sizeof(*h), 0); 742b411b363SPhilipp Reisner } 743b411b363SPhilipp Reisner 744a25b63f1SPhilipp Reisner static enum drbd_packet drbd_recv_fp(struct drbd_tconn *tconn, struct socket *sock) 745b411b363SPhilipp Reisner { 746e6ef8a5cSAndreas Gruenbacher struct p_header80 *h = tconn->data.rbuf; 747b411b363SPhilipp Reisner int rr; 748b411b363SPhilipp Reisner 749dbd9eea0SPhilipp Reisner rr = drbd_recv_short(sock, h, sizeof(*h), 0); 750b411b363SPhilipp Reisner 751ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 752b411b363SPhilipp Reisner return be16_to_cpu(h->command); 753b411b363SPhilipp Reisner 754b411b363SPhilipp Reisner return 0xffff; 755b411b363SPhilipp Reisner } 756b411b363SPhilipp Reisner 757b411b363SPhilipp Reisner /** 758b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 759b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 760b411b363SPhilipp Reisner */ 761dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 762b411b363SPhilipp Reisner { 763b411b363SPhilipp Reisner int rr; 764b411b363SPhilipp Reisner char tb[4]; 765b411b363SPhilipp Reisner 766b411b363SPhilipp Reisner if (!*sock) 76781e84650SAndreas Gruenbacher return false; 768b411b363SPhilipp Reisner 769dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 770b411b363SPhilipp Reisner 771b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 77281e84650SAndreas Gruenbacher return true; 773b411b363SPhilipp Reisner } else { 774b411b363SPhilipp Reisner sock_release(*sock); 775b411b363SPhilipp Reisner *sock = NULL; 77681e84650SAndreas Gruenbacher return false; 777b411b363SPhilipp Reisner } 778b411b363SPhilipp Reisner } 7792325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 7802325eb66SPhilipp Reisner in a connection */ 7812325eb66SPhilipp Reisner int drbd_connected(int vnr, void *p, void *data) 782907599e0SPhilipp Reisner { 783907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 7840829f5edSAndreas Gruenbacher int err; 785907599e0SPhilipp Reisner 786907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 787907599e0SPhilipp Reisner mdev->peer_seq = 0; 788907599e0SPhilipp Reisner 7898410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 7908410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 7918410da8fSPhilipp Reisner &mdev->own_state_mutex; 7928410da8fSPhilipp Reisner 7930829f5edSAndreas Gruenbacher err = drbd_send_sync_param(mdev); 7940829f5edSAndreas Gruenbacher if (!err) 7950829f5edSAndreas Gruenbacher err = drbd_send_sizes(mdev, 0, 0); 7960829f5edSAndreas Gruenbacher if (!err) 7970829f5edSAndreas Gruenbacher err = drbd_send_uuids(mdev); 7980829f5edSAndreas Gruenbacher if (!err) 7990829f5edSAndreas Gruenbacher err = drbd_send_state(mdev); 800907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 801907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 8020829f5edSAndreas Gruenbacher return err; 803907599e0SPhilipp Reisner } 804907599e0SPhilipp Reisner 805b411b363SPhilipp Reisner /* 806b411b363SPhilipp Reisner * return values: 807b411b363SPhilipp Reisner * 1 yes, we have a valid connection 808b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 809b411b363SPhilipp Reisner * -1 peer talks different language, 810b411b363SPhilipp Reisner * no point in trying again, please go standalone. 811b411b363SPhilipp Reisner * -2 We do not have a network config... 812b411b363SPhilipp Reisner */ 813907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 814b411b363SPhilipp Reisner { 815b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 816b411b363SPhilipp Reisner int try, h, ok; 817b411b363SPhilipp Reisner 818bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 819b411b363SPhilipp Reisner return -2; 820b411b363SPhilipp Reisner 821907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 8220916e0e3SAndreas Gruenbacher 8230916e0e3SAndreas Gruenbacher /* Assume that the peer only understands protocol 80 until we know better. */ 8240916e0e3SAndreas Gruenbacher tconn->agreed_pro_version = 80; 825b411b363SPhilipp Reisner 826b411b363SPhilipp Reisner sock = NULL; 827b411b363SPhilipp Reisner msock = NULL; 828b411b363SPhilipp Reisner 829b411b363SPhilipp Reisner do { 830b411b363SPhilipp Reisner for (try = 0;;) { 831b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 832907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 833b411b363SPhilipp Reisner if (s || ++try >= 3) 834b411b363SPhilipp Reisner break; 835b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 83620ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 837b411b363SPhilipp Reisner } 838b411b363SPhilipp Reisner 839b411b363SPhilipp Reisner if (s) { 840b411b363SPhilipp Reisner if (!sock) { 841907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_S); 842b411b363SPhilipp Reisner sock = s; 843b411b363SPhilipp Reisner s = NULL; 844b411b363SPhilipp Reisner } else if (!msock) { 845907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_M); 846b411b363SPhilipp Reisner msock = s; 847b411b363SPhilipp Reisner s = NULL; 848b411b363SPhilipp Reisner } else { 849907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 850b411b363SPhilipp Reisner goto out_release_sockets; 851b411b363SPhilipp Reisner } 852b411b363SPhilipp Reisner } 853b411b363SPhilipp Reisner 854b411b363SPhilipp Reisner if (sock && msock) { 855907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 856dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 857dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 858b411b363SPhilipp Reisner if (ok) 859b411b363SPhilipp Reisner break; 860b411b363SPhilipp Reisner } 861b411b363SPhilipp Reisner 862b411b363SPhilipp Reisner retry: 863907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 864b411b363SPhilipp Reisner if (s) { 865907599e0SPhilipp Reisner try = drbd_recv_fp(tconn, s); 866dbd9eea0SPhilipp Reisner drbd_socket_okay(&sock); 867dbd9eea0SPhilipp Reisner drbd_socket_okay(&msock); 868b411b363SPhilipp Reisner switch (try) { 869b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 870b411b363SPhilipp Reisner if (sock) { 871907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 872b411b363SPhilipp Reisner sock_release(sock); 873b411b363SPhilipp Reisner } 874b411b363SPhilipp Reisner sock = s; 875b411b363SPhilipp Reisner break; 876b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 877b411b363SPhilipp Reisner if (msock) { 878907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 879b411b363SPhilipp Reisner sock_release(msock); 880b411b363SPhilipp Reisner } 881b411b363SPhilipp Reisner msock = s; 882907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 883b411b363SPhilipp Reisner break; 884b411b363SPhilipp Reisner default: 885907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 886b411b363SPhilipp Reisner sock_release(s); 887b411b363SPhilipp Reisner if (random32() & 1) 888b411b363SPhilipp Reisner goto retry; 889b411b363SPhilipp Reisner } 890b411b363SPhilipp Reisner } 891b411b363SPhilipp Reisner 892bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 893b411b363SPhilipp Reisner goto out_release_sockets; 894b411b363SPhilipp Reisner if (signal_pending(current)) { 895b411b363SPhilipp Reisner flush_signals(current); 896b411b363SPhilipp Reisner smp_rmb(); 897907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 898b411b363SPhilipp Reisner goto out_release_sockets; 899b411b363SPhilipp Reisner } 900b411b363SPhilipp Reisner 901b411b363SPhilipp Reisner if (sock && msock) { 902dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 903dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 904b411b363SPhilipp Reisner if (ok) 905b411b363SPhilipp Reisner break; 906b411b363SPhilipp Reisner } 907b411b363SPhilipp Reisner } while (1); 908b411b363SPhilipp Reisner 909b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 910b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 911b411b363SPhilipp Reisner 912b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 913b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 914b411b363SPhilipp Reisner 915b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 916b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 917b411b363SPhilipp Reisner 918b411b363SPhilipp Reisner /* NOT YET ... 919907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 920b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 921b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 922b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 923b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 924907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 925b411b363SPhilipp Reisner 926907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 927907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 928b411b363SPhilipp Reisner 929b411b363SPhilipp Reisner /* we don't want delays. 93025985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 931b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 932b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 933b411b363SPhilipp Reisner 934907599e0SPhilipp Reisner tconn->data.socket = sock; 935907599e0SPhilipp Reisner tconn->meta.socket = msock; 936907599e0SPhilipp Reisner tconn->last_received = jiffies; 937b411b363SPhilipp Reisner 938907599e0SPhilipp Reisner h = drbd_do_handshake(tconn); 939b411b363SPhilipp Reisner if (h <= 0) 940b411b363SPhilipp Reisner return h; 941b411b363SPhilipp Reisner 942907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 943b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 944907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 945b10d96cbSJohannes Thoma case -1: 946907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 947b411b363SPhilipp Reisner return -1; 948b10d96cbSJohannes Thoma case 0: 949907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 950b10d96cbSJohannes Thoma return 0; 951b411b363SPhilipp Reisner } 952b411b363SPhilipp Reisner } 953b411b363SPhilipp Reisner 954bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 955b411b363SPhilipp Reisner return 0; 956b411b363SPhilipp Reisner 957907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 958b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 959b411b363SPhilipp Reisner 960907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 961b411b363SPhilipp Reisner 962387eb308SAndreas Gruenbacher if (drbd_send_protocol(tconn) == -EOPNOTSUPP) 9637e2455c1SPhilipp Reisner return -1; 964b411b363SPhilipp Reisner 965907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 966b411b363SPhilipp Reisner 967b411b363SPhilipp Reisner out_release_sockets: 968b411b363SPhilipp Reisner if (sock) 969b411b363SPhilipp Reisner sock_release(sock); 970b411b363SPhilipp Reisner if (msock) 971b411b363SPhilipp Reisner sock_release(msock); 972b411b363SPhilipp Reisner return -1; 973b411b363SPhilipp Reisner } 974b411b363SPhilipp Reisner 9758172f3e9SAndreas Gruenbacher static int decode_header(struct drbd_tconn *tconn, struct p_header *h, struct packet_info *pi) 976b411b363SPhilipp Reisner { 977fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 97877351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h80.command); 97977351055SPhilipp Reisner pi->size = be16_to_cpu(h->h80.length); 980eefc2f7dSPhilipp Reisner pi->vnr = 0; 981ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 98277351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h95.command); 98377351055SPhilipp Reisner pi->size = be32_to_cpu(h->h95.length) & 0x00ffffff; 98477351055SPhilipp Reisner pi->vnr = 0; 98502918be2SPhilipp Reisner } else { 986ce243853SPhilipp Reisner conn_err(tconn, "magic?? on data m: 0x%08x c: %d l: %d\n", 987004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 988004352faSLars Ellenberg be16_to_cpu(h->h80.command), 989004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 9908172f3e9SAndreas Gruenbacher return -EINVAL; 991b411b363SPhilipp Reisner } 9928172f3e9SAndreas Gruenbacher return 0; 993257d0af6SPhilipp Reisner } 994257d0af6SPhilipp Reisner 9959ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 996257d0af6SPhilipp Reisner { 997e6ef8a5cSAndreas Gruenbacher struct p_header *h = tconn->data.rbuf; 99869bc7bc3SAndreas Gruenbacher int err; 999257d0af6SPhilipp Reisner 1000a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, h, sizeof(*h)); 1001a5c31904SAndreas Gruenbacher if (err) 100269bc7bc3SAndreas Gruenbacher return err; 1003257d0af6SPhilipp Reisner 100469bc7bc3SAndreas Gruenbacher err = decode_header(tconn, h, pi); 10059ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 1006b411b363SPhilipp Reisner 100769bc7bc3SAndreas Gruenbacher return err; 1008b411b363SPhilipp Reisner } 1009b411b363SPhilipp Reisner 10102451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 1011b411b363SPhilipp Reisner { 1012b411b363SPhilipp Reisner int rv; 1013b411b363SPhilipp Reisner 1014b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 1015fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 1016dd3932edSChristoph Hellwig NULL); 1017b411b363SPhilipp Reisner if (rv) { 1018b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 1019b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 1020b411b363SPhilipp Reisner * don't try again for ANY return value != 0 1021b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 1022b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 1023b411b363SPhilipp Reisner } 1024b411b363SPhilipp Reisner put_ldev(mdev); 1025b411b363SPhilipp Reisner } 1026b411b363SPhilipp Reisner } 1027b411b363SPhilipp Reisner 1028b411b363SPhilipp Reisner /** 1029b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1030b411b363SPhilipp Reisner * @mdev: DRBD device. 1031b411b363SPhilipp Reisner * @epoch: Epoch object. 1032b411b363SPhilipp Reisner * @ev: Epoch event. 1033b411b363SPhilipp Reisner */ 1034b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1035b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1036b411b363SPhilipp Reisner enum epoch_event ev) 1037b411b363SPhilipp Reisner { 10382451fc3bSPhilipp Reisner int epoch_size; 1039b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1040b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1041b411b363SPhilipp Reisner 1042b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1043b411b363SPhilipp Reisner do { 1044b411b363SPhilipp Reisner next_epoch = NULL; 1045b411b363SPhilipp Reisner 1046b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1047b411b363SPhilipp Reisner 1048b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1049b411b363SPhilipp Reisner case EV_PUT: 1050b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1051b411b363SPhilipp Reisner break; 1052b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1053b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1054b411b363SPhilipp Reisner break; 1055b411b363SPhilipp Reisner case EV_BECAME_LAST: 1056b411b363SPhilipp Reisner /* nothing to do*/ 1057b411b363SPhilipp Reisner break; 1058b411b363SPhilipp Reisner } 1059b411b363SPhilipp Reisner 1060b411b363SPhilipp Reisner if (epoch_size != 0 && 1061b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10622451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1063b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1064b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1065b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1066b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1067b411b363SPhilipp Reisner } 1068b411b363SPhilipp Reisner dec_unacked(mdev); 1069b411b363SPhilipp Reisner 1070b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1071b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1072b411b363SPhilipp Reisner list_del(&epoch->list); 1073b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1074b411b363SPhilipp Reisner mdev->epochs--; 1075b411b363SPhilipp Reisner kfree(epoch); 1076b411b363SPhilipp Reisner 1077b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1078b411b363SPhilipp Reisner rv = FE_DESTROYED; 1079b411b363SPhilipp Reisner } else { 1080b411b363SPhilipp Reisner epoch->flags = 0; 1081b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1082698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1083b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1084b411b363SPhilipp Reisner rv = FE_RECYCLED; 10852451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1086b411b363SPhilipp Reisner } 1087b411b363SPhilipp Reisner } 1088b411b363SPhilipp Reisner 1089b411b363SPhilipp Reisner if (!next_epoch) 1090b411b363SPhilipp Reisner break; 1091b411b363SPhilipp Reisner 1092b411b363SPhilipp Reisner epoch = next_epoch; 1093b411b363SPhilipp Reisner } while (1); 1094b411b363SPhilipp Reisner 1095b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1096b411b363SPhilipp Reisner 1097b411b363SPhilipp Reisner return rv; 1098b411b363SPhilipp Reisner } 1099b411b363SPhilipp Reisner 1100b411b363SPhilipp Reisner /** 1101b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1102b411b363SPhilipp Reisner * @mdev: DRBD device. 1103b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1104b411b363SPhilipp Reisner */ 1105b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1106b411b363SPhilipp Reisner { 1107b411b363SPhilipp Reisner enum write_ordering_e pwo; 1108b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1109b411b363SPhilipp Reisner [WO_none] = "none", 1110b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1111b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1112b411b363SPhilipp Reisner }; 1113b411b363SPhilipp Reisner 1114b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1115b411b363SPhilipp Reisner wo = min(pwo, wo); 1116b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1117b411b363SPhilipp Reisner wo = WO_drain_io; 1118b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1119b411b363SPhilipp Reisner wo = WO_none; 1120b411b363SPhilipp Reisner mdev->write_ordering = wo; 11212451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1122b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1123b411b363SPhilipp Reisner } 1124b411b363SPhilipp Reisner 1125b411b363SPhilipp Reisner /** 1126fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 112745bb912bSLars Ellenberg * @mdev: DRBD device. 1128db830c46SAndreas Gruenbacher * @peer_req: peer request 112945bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 113010f6d992SLars Ellenberg * 113110f6d992SLars Ellenberg * May spread the pages to multiple bios, 113210f6d992SLars Ellenberg * depending on bio_add_page restrictions. 113310f6d992SLars Ellenberg * 113410f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 113510f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 113610f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 113710f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 113810f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 113910f6d992SLars Ellenberg * on certain Xen deployments. 114045bb912bSLars Ellenberg */ 114145bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1142fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1143fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 114445bb912bSLars Ellenberg const unsigned rw, const int fault_type) 114545bb912bSLars Ellenberg { 114645bb912bSLars Ellenberg struct bio *bios = NULL; 114745bb912bSLars Ellenberg struct bio *bio; 1148db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1149db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1150db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 115145bb912bSLars Ellenberg unsigned n_bios = 0; 115245bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 115310f6d992SLars Ellenberg int err = -ENOMEM; 115445bb912bSLars Ellenberg 115545bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 115645bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 115745bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1158da4a75d2SLars Ellenberg * request in more than one bio. 1159da4a75d2SLars Ellenberg * 1160da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1161da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1162da4a75d2SLars Ellenberg */ 116345bb912bSLars Ellenberg next_bio: 116445bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 116545bb912bSLars Ellenberg if (!bio) { 116645bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 116745bb912bSLars Ellenberg goto fail; 116845bb912bSLars Ellenberg } 1169db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 117045bb912bSLars Ellenberg bio->bi_sector = sector; 117145bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 117245bb912bSLars Ellenberg bio->bi_rw = rw; 1173db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1174fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 117545bb912bSLars Ellenberg 117645bb912bSLars Ellenberg bio->bi_next = bios; 117745bb912bSLars Ellenberg bios = bio; 117845bb912bSLars Ellenberg ++n_bios; 117945bb912bSLars Ellenberg 118045bb912bSLars Ellenberg page_chain_for_each(page) { 118145bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 118245bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 118310f6d992SLars Ellenberg /* A single page must always be possible! 118410f6d992SLars Ellenberg * But in case it fails anyways, 118510f6d992SLars Ellenberg * we deal with it, and complain (below). */ 118610f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 118710f6d992SLars Ellenberg dev_err(DEV, 118810f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 118910f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 119010f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 119110f6d992SLars Ellenberg err = -ENOSPC; 119210f6d992SLars Ellenberg goto fail; 119310f6d992SLars Ellenberg } 119445bb912bSLars Ellenberg goto next_bio; 119545bb912bSLars Ellenberg } 119645bb912bSLars Ellenberg ds -= len; 119745bb912bSLars Ellenberg sector += len >> 9; 119845bb912bSLars Ellenberg --nr_pages; 119945bb912bSLars Ellenberg } 120045bb912bSLars Ellenberg D_ASSERT(page == NULL); 120145bb912bSLars Ellenberg D_ASSERT(ds == 0); 120245bb912bSLars Ellenberg 1203db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 120445bb912bSLars Ellenberg do { 120545bb912bSLars Ellenberg bio = bios; 120645bb912bSLars Ellenberg bios = bios->bi_next; 120745bb912bSLars Ellenberg bio->bi_next = NULL; 120845bb912bSLars Ellenberg 120945bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 121045bb912bSLars Ellenberg } while (bios); 121145bb912bSLars Ellenberg return 0; 121245bb912bSLars Ellenberg 121345bb912bSLars Ellenberg fail: 121445bb912bSLars Ellenberg while (bios) { 121545bb912bSLars Ellenberg bio = bios; 121645bb912bSLars Ellenberg bios = bios->bi_next; 121745bb912bSLars Ellenberg bio_put(bio); 121845bb912bSLars Ellenberg } 121910f6d992SLars Ellenberg return err; 122045bb912bSLars Ellenberg } 122145bb912bSLars Ellenberg 122253840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1223db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 122453840641SAndreas Gruenbacher { 1225db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 122653840641SAndreas Gruenbacher 122753840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 122853840641SAndreas Gruenbacher drbd_clear_interval(i); 122953840641SAndreas Gruenbacher 12306c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 123153840641SAndreas Gruenbacher if (i->waiting) 123253840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 123353840641SAndreas Gruenbacher } 123453840641SAndreas Gruenbacher 1235d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1236d8763023SAndreas Gruenbacher unsigned int data_size) 1237b411b363SPhilipp Reisner { 12382451fc3bSPhilipp Reisner int rv; 1239e6ef8a5cSAndreas Gruenbacher struct p_barrier *p = mdev->tconn->data.rbuf; 1240b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1241b411b363SPhilipp Reisner 1242b411b363SPhilipp Reisner inc_unacked(mdev); 1243b411b363SPhilipp Reisner 1244b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1245b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1246b411b363SPhilipp Reisner 1247b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1248b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1249b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1250b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1251b411b363SPhilipp Reisner * completed. */ 1252b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1253b411b363SPhilipp Reisner case WO_none: 1254b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 125582bc0194SAndreas Gruenbacher return 0; 1256b411b363SPhilipp Reisner 1257b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1258b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1259b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12602451fc3bSPhilipp Reisner if (epoch) 12612451fc3bSPhilipp Reisner break; 12622451fc3bSPhilipp Reisner else 1263b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12642451fc3bSPhilipp Reisner /* Fall through */ 12652451fc3bSPhilipp Reisner 12662451fc3bSPhilipp Reisner case WO_bdev_flush: 12672451fc3bSPhilipp Reisner case WO_drain_io: 1268b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12692451fc3bSPhilipp Reisner drbd_flush(mdev); 12702451fc3bSPhilipp Reisner 12712451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12722451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12732451fc3bSPhilipp Reisner if (epoch) 12742451fc3bSPhilipp Reisner break; 1275b411b363SPhilipp Reisner } 1276b411b363SPhilipp Reisner 12772451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12782451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12792451fc3bSPhilipp Reisner 12802451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12812451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1282b411b363SPhilipp Reisner 128382bc0194SAndreas Gruenbacher return 0; 12842451fc3bSPhilipp Reisner default: 12852451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 128682bc0194SAndreas Gruenbacher return -EIO; 1287b411b363SPhilipp Reisner } 1288b411b363SPhilipp Reisner 1289b411b363SPhilipp Reisner epoch->flags = 0; 1290b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1291b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1292b411b363SPhilipp Reisner 1293b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1294b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1295b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1296b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1297b411b363SPhilipp Reisner mdev->epochs++; 1298b411b363SPhilipp Reisner } else { 1299b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1300b411b363SPhilipp Reisner kfree(epoch); 1301b411b363SPhilipp Reisner } 1302b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1303b411b363SPhilipp Reisner 130482bc0194SAndreas Gruenbacher return 0; 1305b411b363SPhilipp Reisner } 1306b411b363SPhilipp Reisner 1307b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1308b411b363SPhilipp Reisner * and from receive_Data */ 1309f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1310f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1311f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1312b411b363SPhilipp Reisner { 13136666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1314db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1315b411b363SPhilipp Reisner struct page *page; 1316a5c31904SAndreas Gruenbacher int dgs, ds, err; 1317a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1318a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 13196b4388acSPhilipp Reisner unsigned long *data; 1320b411b363SPhilipp Reisner 1321a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1322a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1323b411b363SPhilipp Reisner 1324b411b363SPhilipp Reisner if (dgs) { 1325a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1326a5c31904SAndreas Gruenbacher if (err) 1327b411b363SPhilipp Reisner return NULL; 1328b411b363SPhilipp Reisner } 1329b411b363SPhilipp Reisner 1330b411b363SPhilipp Reisner data_size -= dgs; 1331b411b363SPhilipp Reisner 1332841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1333841ce241SAndreas Gruenbacher return NULL; 1334841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1335841ce241SAndreas Gruenbacher return NULL; 1336841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1337841ce241SAndreas Gruenbacher return NULL; 1338b411b363SPhilipp Reisner 13396666032aSLars Ellenberg /* even though we trust out peer, 13406666032aSLars Ellenberg * we sometimes have to double check. */ 13416666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1342fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1343fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13446666032aSLars Ellenberg (unsigned long long)capacity, 13456666032aSLars Ellenberg (unsigned long long)sector, data_size); 13466666032aSLars Ellenberg return NULL; 13476666032aSLars Ellenberg } 13486666032aSLars Ellenberg 1349b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1350b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1351b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1352db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1353db830c46SAndreas Gruenbacher if (!peer_req) 1354b411b363SPhilipp Reisner return NULL; 135545bb912bSLars Ellenberg 1356b411b363SPhilipp Reisner ds = data_size; 1357db830c46SAndreas Gruenbacher page = peer_req->pages; 135845bb912bSLars Ellenberg page_chain_for_each(page) { 135945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13606b4388acSPhilipp Reisner data = kmap(page); 1361a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 13620cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13636b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13646b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13656b4388acSPhilipp Reisner } 1366b411b363SPhilipp Reisner kunmap(page); 1367a5c31904SAndreas Gruenbacher if (err) { 1368db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1369b411b363SPhilipp Reisner return NULL; 1370b411b363SPhilipp Reisner } 1371a5c31904SAndreas Gruenbacher ds -= len; 1372b411b363SPhilipp Reisner } 1373b411b363SPhilipp Reisner 1374b411b363SPhilipp Reisner if (dgs) { 1375db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1376b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1377470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1378470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1379db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1380b411b363SPhilipp Reisner return NULL; 1381b411b363SPhilipp Reisner } 1382b411b363SPhilipp Reisner } 1383b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1384db830c46SAndreas Gruenbacher return peer_req; 1385b411b363SPhilipp Reisner } 1386b411b363SPhilipp Reisner 1387b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1388b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1389b411b363SPhilipp Reisner */ 1390b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1391b411b363SPhilipp Reisner { 1392b411b363SPhilipp Reisner struct page *page; 1393a5c31904SAndreas Gruenbacher int err = 0; 1394b411b363SPhilipp Reisner void *data; 1395b411b363SPhilipp Reisner 1396c3470cdeSLars Ellenberg if (!data_size) 1397fc5be839SAndreas Gruenbacher return 0; 1398c3470cdeSLars Ellenberg 139945bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1400b411b363SPhilipp Reisner 1401b411b363SPhilipp Reisner data = kmap(page); 1402b411b363SPhilipp Reisner while (data_size) { 1403fc5be839SAndreas Gruenbacher unsigned int len = min_t(int, data_size, PAGE_SIZE); 1404fc5be839SAndreas Gruenbacher 1405a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, data, len); 1406a5c31904SAndreas Gruenbacher if (err) 1407b411b363SPhilipp Reisner break; 1408a5c31904SAndreas Gruenbacher data_size -= len; 1409b411b363SPhilipp Reisner } 1410b411b363SPhilipp Reisner kunmap(page); 1411435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1412fc5be839SAndreas Gruenbacher return err; 1413b411b363SPhilipp Reisner } 1414b411b363SPhilipp Reisner 1415b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1416b411b363SPhilipp Reisner sector_t sector, int data_size) 1417b411b363SPhilipp Reisner { 1418b411b363SPhilipp Reisner struct bio_vec *bvec; 1419b411b363SPhilipp Reisner struct bio *bio; 1420a5c31904SAndreas Gruenbacher int dgs, err, i, expect; 1421a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1422a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1423b411b363SPhilipp Reisner 1424a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1425a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1426b411b363SPhilipp Reisner 1427b411b363SPhilipp Reisner if (dgs) { 1428a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs); 1429a5c31904SAndreas Gruenbacher if (err) 1430a5c31904SAndreas Gruenbacher return err; 1431b411b363SPhilipp Reisner } 1432b411b363SPhilipp Reisner 1433b411b363SPhilipp Reisner data_size -= dgs; 1434b411b363SPhilipp Reisner 1435b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1436b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1437b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1438b411b363SPhilipp Reisner 1439b411b363SPhilipp Reisner bio = req->master_bio; 1440b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1441b411b363SPhilipp Reisner 1442b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1443a5c31904SAndreas Gruenbacher void *mapped = kmap(bvec->bv_page) + bvec->bv_offset; 1444b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1445a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(mdev->tconn, mapped, expect); 1446b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1447a5c31904SAndreas Gruenbacher if (err) 1448a5c31904SAndreas Gruenbacher return err; 1449a5c31904SAndreas Gruenbacher data_size -= expect; 1450b411b363SPhilipp Reisner } 1451b411b363SPhilipp Reisner 1452b411b363SPhilipp Reisner if (dgs) { 1453a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1454b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1455b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 145628284cefSAndreas Gruenbacher return -EINVAL; 1457b411b363SPhilipp Reisner } 1458b411b363SPhilipp Reisner } 1459b411b363SPhilipp Reisner 1460b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 146128284cefSAndreas Gruenbacher return 0; 1462b411b363SPhilipp Reisner } 1463b411b363SPhilipp Reisner 1464b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1465b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 146699920dc5SAndreas Gruenbacher static int e_end_resync_block(struct drbd_work *w, int unused) 1467b411b363SPhilipp Reisner { 14688050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 14698050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 147000d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1471db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 147299920dc5SAndreas Gruenbacher int err; 1473b411b363SPhilipp Reisner 1474db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1475b411b363SPhilipp Reisner 1476db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1477db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 147899920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1479b411b363SPhilipp Reisner } else { 1480b411b363SPhilipp Reisner /* Record failure to sync */ 1481db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1482b411b363SPhilipp Reisner 148399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1484b411b363SPhilipp Reisner } 1485b411b363SPhilipp Reisner dec_unacked(mdev); 1486b411b363SPhilipp Reisner 148799920dc5SAndreas Gruenbacher return err; 1488b411b363SPhilipp Reisner } 1489b411b363SPhilipp Reisner 1490b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1491b411b363SPhilipp Reisner { 1492db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1493b411b363SPhilipp Reisner 1494db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1495db830c46SAndreas Gruenbacher if (!peer_req) 149645bb912bSLars Ellenberg goto fail; 1497b411b363SPhilipp Reisner 1498b411b363SPhilipp Reisner dec_rs_pending(mdev); 1499b411b363SPhilipp Reisner 1500b411b363SPhilipp Reisner inc_unacked(mdev); 1501b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1502b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1503b411b363SPhilipp Reisner 1504db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 150545bb912bSLars Ellenberg 150687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1507db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 150887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1509b411b363SPhilipp Reisner 15100f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1511fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 1512e1c1b0fcSAndreas Gruenbacher return 0; 151345bb912bSLars Ellenberg 151410f6d992SLars Ellenberg /* don't care for the reason here */ 151510f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 151687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1517db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 151887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 151922cc37a9SLars Ellenberg 1520db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 152145bb912bSLars Ellenberg fail: 152245bb912bSLars Ellenberg put_ldev(mdev); 1523e1c1b0fcSAndreas Gruenbacher return -EIO; 1524b411b363SPhilipp Reisner } 1525b411b363SPhilipp Reisner 1526668eebc6SAndreas Gruenbacher static struct drbd_request * 1527bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1528bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1529668eebc6SAndreas Gruenbacher { 1530668eebc6SAndreas Gruenbacher struct drbd_request *req; 1531668eebc6SAndreas Gruenbacher 1532bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1533bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15345e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1535668eebc6SAndreas Gruenbacher return req; 1536c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1537c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1538c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1539c3afd8f5SAndreas Gruenbacher } 1540668eebc6SAndreas Gruenbacher return NULL; 1541668eebc6SAndreas Gruenbacher } 1542668eebc6SAndreas Gruenbacher 1543d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1544d8763023SAndreas Gruenbacher unsigned int data_size) 1545b411b363SPhilipp Reisner { 1546b411b363SPhilipp Reisner struct drbd_request *req; 1547b411b363SPhilipp Reisner sector_t sector; 154882bc0194SAndreas Gruenbacher int err; 1549e6ef8a5cSAndreas Gruenbacher struct p_data *p = mdev->tconn->data.rbuf; 1550b411b363SPhilipp Reisner 1551b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1552b411b363SPhilipp Reisner 155387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1554bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 155587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1556c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 155782bc0194SAndreas Gruenbacher return -EIO; 1558b411b363SPhilipp Reisner 155924c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1560b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1561b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 156282bc0194SAndreas Gruenbacher err = recv_dless_read(mdev, req, sector, data_size); 156382bc0194SAndreas Gruenbacher if (!err) 15648554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1565b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1566b411b363SPhilipp Reisner * I don't think we may complete this just yet 1567b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1568b411b363SPhilipp Reisner 156982bc0194SAndreas Gruenbacher return err; 1570b411b363SPhilipp Reisner } 1571b411b363SPhilipp Reisner 1572d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1573d8763023SAndreas Gruenbacher unsigned int data_size) 1574b411b363SPhilipp Reisner { 1575b411b363SPhilipp Reisner sector_t sector; 157682bc0194SAndreas Gruenbacher int err; 1577e6ef8a5cSAndreas Gruenbacher struct p_data *p = mdev->tconn->data.rbuf; 1578b411b363SPhilipp Reisner 1579b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1580b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1581b411b363SPhilipp Reisner 1582b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1583b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1584b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1585fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 158682bc0194SAndreas Gruenbacher err = recv_resync_read(mdev, sector, data_size); 1587b411b363SPhilipp Reisner } else { 1588b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1589b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1590b411b363SPhilipp Reisner 159182bc0194SAndreas Gruenbacher err = drbd_drain_block(mdev, data_size); 1592b411b363SPhilipp Reisner 15932b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1594b411b363SPhilipp Reisner } 1595b411b363SPhilipp Reisner 1596778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1597778f271dSPhilipp Reisner 159882bc0194SAndreas Gruenbacher return err; 1599b411b363SPhilipp Reisner } 1600b411b363SPhilipp Reisner 160199920dc5SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 16027be8da07SAndreas Gruenbacher { 16037be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 16047be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16057be8da07SAndreas Gruenbacher struct bio *bio; 16067be8da07SAndreas Gruenbacher unsigned long start_time; 16077be8da07SAndreas Gruenbacher unsigned long flags; 16087be8da07SAndreas Gruenbacher 16097be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16107be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16117be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 161299920dc5SAndreas Gruenbacher return -EIO; 16137be8da07SAndreas Gruenbacher } 16147be8da07SAndreas Gruenbacher bio = req->master_bio; 16157be8da07SAndreas Gruenbacher start_time = req->start_time; 16167be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 16177be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 16187be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16197be8da07SAndreas Gruenbacher 16207be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 16217be8da07SAndreas Gruenbacher /* retry */ ; 162299920dc5SAndreas Gruenbacher return 0; 16237be8da07SAndreas Gruenbacher } 16247be8da07SAndreas Gruenbacher 16257be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 16267be8da07SAndreas Gruenbacher sector_t sector, int size) 16277be8da07SAndreas Gruenbacher { 16287be8da07SAndreas Gruenbacher struct drbd_interval *i; 16297be8da07SAndreas Gruenbacher struct drbd_request *req; 16307be8da07SAndreas Gruenbacher 16317be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 16327be8da07SAndreas Gruenbacher if (!i->local) 16337be8da07SAndreas Gruenbacher continue; 16347be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 16357be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 16367be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 16377be8da07SAndreas Gruenbacher continue; 16387be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 16397be8da07SAndreas Gruenbacher req->w.mdev = mdev; 16407be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 16417be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 16427be8da07SAndreas Gruenbacher } 16437be8da07SAndreas Gruenbacher } 16447be8da07SAndreas Gruenbacher } 16457be8da07SAndreas Gruenbacher 1646b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1647b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1648b411b363SPhilipp Reisner */ 164999920dc5SAndreas Gruenbacher static int e_end_block(struct drbd_work *w, int cancel) 1650b411b363SPhilipp Reisner { 16518050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16528050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 165300d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1654db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 165599920dc5SAndreas Gruenbacher int err = 0, pcmd; 1656b411b363SPhilipp Reisner 165789e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1658db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1659b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1660b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1661db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1662b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 166399920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, pcmd, peer_req); 1664b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1665db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1666b411b363SPhilipp Reisner } else { 166799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1668b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1669b411b363SPhilipp Reisner * maybe assert this? */ 1670b411b363SPhilipp Reisner } 1671b411b363SPhilipp Reisner dec_unacked(mdev); 1672b411b363SPhilipp Reisner } 1673b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1674b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 167589e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 167687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1677db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1678db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 16797be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 16807be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 168187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1682bb3bfe96SAndreas Gruenbacher } else 1683db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1684b411b363SPhilipp Reisner 1685db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1686b411b363SPhilipp Reisner 168799920dc5SAndreas Gruenbacher return err; 1688b411b363SPhilipp Reisner } 1689b411b363SPhilipp Reisner 16907be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1691b411b363SPhilipp Reisner { 16927be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16938050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16948050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 169599920dc5SAndreas Gruenbacher int err; 1696b411b363SPhilipp Reisner 169799920dc5SAndreas Gruenbacher err = drbd_send_ack(mdev, ack, peer_req); 1698b411b363SPhilipp Reisner dec_unacked(mdev); 1699b411b363SPhilipp Reisner 170099920dc5SAndreas Gruenbacher return err; 1701b411b363SPhilipp Reisner } 1702b411b363SPhilipp Reisner 170399920dc5SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 17047be8da07SAndreas Gruenbacher { 17057be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17067be8da07SAndreas Gruenbacher } 17077be8da07SAndreas Gruenbacher 170899920dc5SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17097be8da07SAndreas Gruenbacher { 17107be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17117be8da07SAndreas Gruenbacher 17127be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 17137be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 17147be8da07SAndreas Gruenbacher } 17157be8da07SAndreas Gruenbacher 17163e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 17173e394da1SAndreas Gruenbacher { 17183e394da1SAndreas Gruenbacher /* 17193e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 17203e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 17213e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 17223e394da1SAndreas Gruenbacher */ 17233e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 17243e394da1SAndreas Gruenbacher } 17253e394da1SAndreas Gruenbacher 17263e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 17273e394da1SAndreas Gruenbacher { 17283e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 17293e394da1SAndreas Gruenbacher } 17303e394da1SAndreas Gruenbacher 17317be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 17327be8da07SAndreas Gruenbacher { 17337be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 17347be8da07SAndreas Gruenbacher 17357be8da07SAndreas Gruenbacher /* 17367be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 17377be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 17387be8da07SAndreas Gruenbacher * handle_write_conflicts(). 17397be8da07SAndreas Gruenbacher */ 17407be8da07SAndreas Gruenbacher return tconn->net_conf->two_primaries && 17417be8da07SAndreas Gruenbacher test_bit(DISCARD_CONCURRENT, &tconn->flags); 17427be8da07SAndreas Gruenbacher } 17437be8da07SAndreas Gruenbacher 174443ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 17453e394da1SAndreas Gruenbacher { 17463c13b680SLars Ellenberg unsigned int newest_peer_seq; 17473e394da1SAndreas Gruenbacher 17487be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 17493e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 17503c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 17513c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 17523e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 17533c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 17543c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 17553e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 17563e394da1SAndreas Gruenbacher } 17577be8da07SAndreas Gruenbacher } 17583e394da1SAndreas Gruenbacher 1759b411b363SPhilipp Reisner /* Called from receive_Data. 1760b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1761b411b363SPhilipp Reisner * 1762b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1763b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1764b411b363SPhilipp Reisner * been sent. 1765b411b363SPhilipp Reisner * 1766b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1767b411b363SPhilipp Reisner * 1768b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1769b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1770b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1771b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1772b411b363SPhilipp Reisner * 1773b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1774b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1775b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1776b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1777b411b363SPhilipp Reisner * 1778b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1779b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 17807be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1781b411b363SPhilipp Reisner { 1782b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1783b411b363SPhilipp Reisner long timeout; 17847be8da07SAndreas Gruenbacher int ret; 17857be8da07SAndreas Gruenbacher 17867be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 17877be8da07SAndreas Gruenbacher return 0; 17887be8da07SAndreas Gruenbacher 1789b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1790b411b363SPhilipp Reisner for (;;) { 17917be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 17927be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 17937be8da07SAndreas Gruenbacher ret = 0; 1794b411b363SPhilipp Reisner break; 17957be8da07SAndreas Gruenbacher } 1796b411b363SPhilipp Reisner if (signal_pending(current)) { 1797b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1798b411b363SPhilipp Reisner break; 1799b411b363SPhilipp Reisner } 18007be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1801b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 180271b1c1ebSAndreas Gruenbacher timeout = mdev->tconn->net_conf->ping_timeo*HZ/10; 180371b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1804b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 18057be8da07SAndreas Gruenbacher if (!timeout) { 1806b411b363SPhilipp Reisner ret = -ETIMEDOUT; 180771b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1808b411b363SPhilipp Reisner break; 1809b411b363SPhilipp Reisner } 1810b411b363SPhilipp Reisner } 1811b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 18127be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1813b411b363SPhilipp Reisner return ret; 1814b411b363SPhilipp Reisner } 1815b411b363SPhilipp Reisner 1816688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1817688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1818688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1819688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 182076d2e7ecSPhilipp Reisner { 182176d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 182276d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1823688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 182476d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 182576d2e7ecSPhilipp Reisner } 182676d2e7ecSPhilipp Reisner 18277be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 18287be8da07SAndreas Gruenbacher unsigned int size) 18297be8da07SAndreas Gruenbacher { 18307be8da07SAndreas Gruenbacher struct drbd_interval *i; 18317be8da07SAndreas Gruenbacher 18327be8da07SAndreas Gruenbacher repeat: 18337be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18347be8da07SAndreas Gruenbacher struct drbd_request *req; 18357be8da07SAndreas Gruenbacher struct bio_and_error m; 18367be8da07SAndreas Gruenbacher 18377be8da07SAndreas Gruenbacher if (!i->local) 18387be8da07SAndreas Gruenbacher continue; 18397be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18407be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 18417be8da07SAndreas Gruenbacher continue; 18427be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 18437be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 18447be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 18457be8da07SAndreas Gruenbacher if (m.bio) 18467be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 18477be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 18487be8da07SAndreas Gruenbacher goto repeat; 18497be8da07SAndreas Gruenbacher } 18507be8da07SAndreas Gruenbacher } 18517be8da07SAndreas Gruenbacher 18527be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 18537be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 18547be8da07SAndreas Gruenbacher { 18557be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 18567be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 18577be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 18587be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 18597be8da07SAndreas Gruenbacher struct drbd_interval *i; 18607be8da07SAndreas Gruenbacher bool equal; 18617be8da07SAndreas Gruenbacher int err; 18627be8da07SAndreas Gruenbacher 18637be8da07SAndreas Gruenbacher /* 18647be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 18657be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 18667be8da07SAndreas Gruenbacher */ 18677be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 18687be8da07SAndreas Gruenbacher 18697be8da07SAndreas Gruenbacher repeat: 18707be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18717be8da07SAndreas Gruenbacher if (i == &peer_req->i) 18727be8da07SAndreas Gruenbacher continue; 18737be8da07SAndreas Gruenbacher 18747be8da07SAndreas Gruenbacher if (!i->local) { 18757be8da07SAndreas Gruenbacher /* 18767be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 18777be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 18787be8da07SAndreas Gruenbacher * earlier peer request to complete. 18797be8da07SAndreas Gruenbacher */ 18807be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 18817be8da07SAndreas Gruenbacher if (err) 18827be8da07SAndreas Gruenbacher goto out; 18837be8da07SAndreas Gruenbacher goto repeat; 18847be8da07SAndreas Gruenbacher } 18857be8da07SAndreas Gruenbacher 18867be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 18877be8da07SAndreas Gruenbacher if (resolve_conflicts) { 18887be8da07SAndreas Gruenbacher /* 18897be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 18907be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 18917be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 18927be8da07SAndreas Gruenbacher * have completed. 18937be8da07SAndreas Gruenbacher */ 18947be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 18957be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 18967be8da07SAndreas Gruenbacher 18977be8da07SAndreas Gruenbacher if (!equal) 18987be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 18997be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 19007be8da07SAndreas Gruenbacher "assuming %s came first\n", 19017be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19027be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 19037be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 19047be8da07SAndreas Gruenbacher 19057be8da07SAndreas Gruenbacher inc_unacked(mdev); 19067be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 19077be8da07SAndreas Gruenbacher e_send_retry_write; 19087be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 19097be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 19107be8da07SAndreas Gruenbacher 19117be8da07SAndreas Gruenbacher err = -ENOENT; 19127be8da07SAndreas Gruenbacher goto out; 19137be8da07SAndreas Gruenbacher } else { 19147be8da07SAndreas Gruenbacher struct drbd_request *req = 19157be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 19167be8da07SAndreas Gruenbacher 19177be8da07SAndreas Gruenbacher if (!equal) 19187be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19197be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 19207be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19217be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 19227be8da07SAndreas Gruenbacher 19237be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 19247be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 19257be8da07SAndreas Gruenbacher /* 19267be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 19277be8da07SAndreas Gruenbacher * decide if this request will be discarded or 19287be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 19297be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 19307be8da07SAndreas Gruenbacher * 19317be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 19327be8da07SAndreas Gruenbacher * request to finish locally before submitting 19337be8da07SAndreas Gruenbacher * the conflicting peer request. 19347be8da07SAndreas Gruenbacher */ 19357be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 19367be8da07SAndreas Gruenbacher if (err) { 19377be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 19387be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 19397be8da07SAndreas Gruenbacher CS_HARD); 19407be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 19417be8da07SAndreas Gruenbacher goto out; 19427be8da07SAndreas Gruenbacher } 19437be8da07SAndreas Gruenbacher goto repeat; 19447be8da07SAndreas Gruenbacher } 19457be8da07SAndreas Gruenbacher /* 19467be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 19477be8da07SAndreas Gruenbacher * the new peer request has completed. 19487be8da07SAndreas Gruenbacher */ 19497be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 19507be8da07SAndreas Gruenbacher } 19517be8da07SAndreas Gruenbacher } 19527be8da07SAndreas Gruenbacher err = 0; 19537be8da07SAndreas Gruenbacher 19547be8da07SAndreas Gruenbacher out: 19557be8da07SAndreas Gruenbacher if (err) 19567be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 19577be8da07SAndreas Gruenbacher return err; 19587be8da07SAndreas Gruenbacher } 19597be8da07SAndreas Gruenbacher 1960b411b363SPhilipp Reisner /* mirrored write */ 1961d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1962d8763023SAndreas Gruenbacher unsigned int data_size) 1963b411b363SPhilipp Reisner { 1964b411b363SPhilipp Reisner sector_t sector; 1965db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1966e6ef8a5cSAndreas Gruenbacher struct p_data *p = mdev->tconn->data.rbuf; 19677be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 1968b411b363SPhilipp Reisner int rw = WRITE; 1969b411b363SPhilipp Reisner u32 dp_flags; 19707be8da07SAndreas Gruenbacher int err; 19717be8da07SAndreas Gruenbacher 1972b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 197382bc0194SAndreas Gruenbacher int err2; 197482bc0194SAndreas Gruenbacher 19757be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 19762b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1977b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 197882bc0194SAndreas Gruenbacher err2 = drbd_drain_block(mdev, data_size); 197982bc0194SAndreas Gruenbacher if (!err) 198082bc0194SAndreas Gruenbacher err = err2; 198182bc0194SAndreas Gruenbacher return err; 1982b411b363SPhilipp Reisner } 1983b411b363SPhilipp Reisner 1984fcefa62eSAndreas Gruenbacher /* 1985fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 1986fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 1987fcefa62eSAndreas Gruenbacher * end of this function. 1988fcefa62eSAndreas Gruenbacher */ 1989b411b363SPhilipp Reisner 1990b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1991db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, data_size); 1992db830c46SAndreas Gruenbacher if (!peer_req) { 1993b411b363SPhilipp Reisner put_ldev(mdev); 199482bc0194SAndreas Gruenbacher return -EIO; 1995b411b363SPhilipp Reisner } 1996b411b363SPhilipp Reisner 1997db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 1998b411b363SPhilipp Reisner 1999688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 2000688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 2001688593c5SLars Ellenberg 2002688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 2003db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 2004688593c5SLars Ellenberg 2005b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2006db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2007db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2008db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2009b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2010b411b363SPhilipp Reisner 20117be8da07SAndreas Gruenbacher if (mdev->tconn->net_conf->two_primaries) { 20127be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 20137be8da07SAndreas Gruenbacher if (err) 2014b411b363SPhilipp Reisner goto out_interrupted; 201587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 20167be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 20177be8da07SAndreas Gruenbacher if (err) { 201887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 20197be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2020b411b363SPhilipp Reisner put_ldev(mdev); 202182bc0194SAndreas Gruenbacher return 0; 2022b411b363SPhilipp Reisner } 2023b411b363SPhilipp Reisner goto out_interrupted; 2024b411b363SPhilipp Reisner } 20257be8da07SAndreas Gruenbacher } else 202687eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2027db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 202887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2029b411b363SPhilipp Reisner 203089e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 2031b411b363SPhilipp Reisner case DRBD_PROT_C: 2032b411b363SPhilipp Reisner inc_unacked(mdev); 2033b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2034b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2035b411b363SPhilipp Reisner break; 2036b411b363SPhilipp Reisner case DRBD_PROT_B: 2037b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2038b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2039db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2040b411b363SPhilipp Reisner break; 2041b411b363SPhilipp Reisner case DRBD_PROT_A: 2042b411b363SPhilipp Reisner /* nothing to do */ 2043b411b363SPhilipp Reisner break; 2044b411b363SPhilipp Reisner } 2045b411b363SPhilipp Reisner 20466719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2047b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2048db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2049db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2050db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2051db830c46SAndreas Gruenbacher drbd_al_begin_io(mdev, peer_req->i.sector); 2052b411b363SPhilipp Reisner } 2053b411b363SPhilipp Reisner 205482bc0194SAndreas Gruenbacher err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR); 205582bc0194SAndreas Gruenbacher if (!err) 205682bc0194SAndreas Gruenbacher return 0; 2057b411b363SPhilipp Reisner 205810f6d992SLars Ellenberg /* don't care for the reason here */ 205910f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 206087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2061db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2062db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 206387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2064db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2065db830c46SAndreas Gruenbacher drbd_al_complete_io(mdev, peer_req->i.sector); 206622cc37a9SLars Ellenberg 2067b411b363SPhilipp Reisner out_interrupted: 2068db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2069b411b363SPhilipp Reisner put_ldev(mdev); 2070db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 207182bc0194SAndreas Gruenbacher return err; 2072b411b363SPhilipp Reisner } 2073b411b363SPhilipp Reisner 20740f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 20750f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 20760f0601f4SLars Ellenberg * 20770f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 20780f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 20790f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 20800f0601f4SLars Ellenberg * activity, it obviously is "busy". 20810f0601f4SLars Ellenberg * 20820f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 20830f0601f4SLars Ellenberg * to have a short time average so we can react faster. 20840f0601f4SLars Ellenberg */ 2085e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 20860f0601f4SLars Ellenberg { 20870f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 20880f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2089e3555d85SPhilipp Reisner struct lc_element *tmp; 20900f0601f4SLars Ellenberg int curr_events; 20910f0601f4SLars Ellenberg int throttle = 0; 20920f0601f4SLars Ellenberg 20930f0601f4SLars Ellenberg /* feature disabled? */ 2094f399002eSLars Ellenberg if (mdev->ldev->dc.c_min_rate == 0) 20950f0601f4SLars Ellenberg return 0; 20960f0601f4SLars Ellenberg 2097e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2098e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2099e3555d85SPhilipp Reisner if (tmp) { 2100e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2101e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2102e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2103e3555d85SPhilipp Reisner return 0; 2104e3555d85SPhilipp Reisner } 2105e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2106e3555d85SPhilipp Reisner } 2107e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2108e3555d85SPhilipp Reisner 21090f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 21100f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 21110f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2112e3555d85SPhilipp Reisner 21130f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 21140f0601f4SLars Ellenberg unsigned long rs_left; 21150f0601f4SLars Ellenberg int i; 21160f0601f4SLars Ellenberg 21170f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 21180f0601f4SLars Ellenberg 21190f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 21200f0601f4SLars Ellenberg * approx. */ 21212649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 21222649f080SLars Ellenberg 21232649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 21242649f080SLars Ellenberg rs_left = mdev->ov_left; 21252649f080SLars Ellenberg else 21260f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 21270f0601f4SLars Ellenberg 21280f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 21290f0601f4SLars Ellenberg if (!dt) 21300f0601f4SLars Ellenberg dt++; 21310f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 21320f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 21330f0601f4SLars Ellenberg 2134f399002eSLars Ellenberg if (dbdt > mdev->ldev->dc.c_min_rate) 21350f0601f4SLars Ellenberg throttle = 1; 21360f0601f4SLars Ellenberg } 21370f0601f4SLars Ellenberg return throttle; 21380f0601f4SLars Ellenberg } 21390f0601f4SLars Ellenberg 21400f0601f4SLars Ellenberg 2141d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2142d8763023SAndreas Gruenbacher unsigned int digest_size) 2143b411b363SPhilipp Reisner { 2144b411b363SPhilipp Reisner sector_t sector; 2145b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2146db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2147b411b363SPhilipp Reisner struct digest_info *di = NULL; 2148b18b37beSPhilipp Reisner int size, verb; 2149b411b363SPhilipp Reisner unsigned int fault_type; 2150e6ef8a5cSAndreas Gruenbacher struct p_block_req *p = mdev->tconn->data.rbuf; 2151b411b363SPhilipp Reisner 2152b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2153b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2154b411b363SPhilipp Reisner 2155c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2156b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2157b411b363SPhilipp Reisner (unsigned long long)sector, size); 215882bc0194SAndreas Gruenbacher return -EINVAL; 2159b411b363SPhilipp Reisner } 2160b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2161b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2162b411b363SPhilipp Reisner (unsigned long long)sector, size); 216382bc0194SAndreas Gruenbacher return -EINVAL; 2164b411b363SPhilipp Reisner } 2165b411b363SPhilipp Reisner 2166b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2167b18b37beSPhilipp Reisner verb = 1; 2168b18b37beSPhilipp Reisner switch (cmd) { 2169b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2170b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2171b18b37beSPhilipp Reisner break; 2172b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2173b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2174b18b37beSPhilipp Reisner case P_OV_REQUEST: 2175b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2176b18b37beSPhilipp Reisner break; 2177b18b37beSPhilipp Reisner case P_OV_REPLY: 2178b18b37beSPhilipp Reisner verb = 0; 2179b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2180b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2181b18b37beSPhilipp Reisner break; 2182b18b37beSPhilipp Reisner default: 2183b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2184b18b37beSPhilipp Reisner cmdname(cmd)); 2185b18b37beSPhilipp Reisner } 2186b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2187b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2188b411b363SPhilipp Reisner "no local data.\n"); 2189b18b37beSPhilipp Reisner 2190a821cc4aSLars Ellenberg /* drain possibly payload */ 219182bc0194SAndreas Gruenbacher return drbd_drain_block(mdev, digest_size); 2192b411b363SPhilipp Reisner } 2193b411b363SPhilipp Reisner 2194b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2195b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2196b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2197db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2198db830c46SAndreas Gruenbacher if (!peer_req) { 2199b411b363SPhilipp Reisner put_ldev(mdev); 220082bc0194SAndreas Gruenbacher return -ENOMEM; 2201b411b363SPhilipp Reisner } 2202b411b363SPhilipp Reisner 220302918be2SPhilipp Reisner switch (cmd) { 2204b411b363SPhilipp Reisner case P_DATA_REQUEST: 2205db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2206b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 220780a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 220880a40e43SLars Ellenberg goto submit; 220980a40e43SLars Ellenberg 2210b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2211db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2212b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 22135f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22145f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2215b411b363SPhilipp Reisner break; 2216b411b363SPhilipp Reisner 2217b411b363SPhilipp Reisner case P_OV_REPLY: 2218b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2219b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2220b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2221b411b363SPhilipp Reisner if (!di) 2222b411b363SPhilipp Reisner goto out_free_e; 2223b411b363SPhilipp Reisner 2224b411b363SPhilipp Reisner di->digest_size = digest_size; 2225b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2226b411b363SPhilipp Reisner 2227db830c46SAndreas Gruenbacher peer_req->digest = di; 2228db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2229c36c3cedSLars Ellenberg 2230de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, di->digest, digest_size) != digest_size) 2231b411b363SPhilipp Reisner goto out_free_e; 2232b411b363SPhilipp Reisner 223302918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 223431890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2235db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 22365f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22375f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 223802918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 22392649f080SLars Ellenberg /* track progress, we may need to throttle */ 22402649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2241db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2242b411b363SPhilipp Reisner dec_rs_pending(mdev); 22430f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 22440f0601f4SLars Ellenberg * but accounting still needs to be done. */ 22450f0601f4SLars Ellenberg goto submit_for_resync; 2246b411b363SPhilipp Reisner } 2247b411b363SPhilipp Reisner break; 2248b411b363SPhilipp Reisner 2249b411b363SPhilipp Reisner case P_OV_REQUEST: 2250b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 225131890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2252de228bbaSLars Ellenberg unsigned long now = jiffies; 2253de228bbaSLars Ellenberg int i; 2254b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2255b411b363SPhilipp Reisner mdev->ov_position = sector; 225630b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 225730b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2258de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2259de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2260de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2261de228bbaSLars Ellenberg } 2262b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2263b411b363SPhilipp Reisner (unsigned long long)sector); 2264b411b363SPhilipp Reisner } 2265db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2266b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2267b411b363SPhilipp Reisner break; 2268b411b363SPhilipp Reisner 2269b411b363SPhilipp Reisner default: 2270b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 227102918be2SPhilipp Reisner cmdname(cmd)); 2272b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 227380a40e43SLars Ellenberg goto out_free_e; 2274b411b363SPhilipp Reisner } 2275b411b363SPhilipp Reisner 22760f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 22770f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 22780f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 22790f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 22800f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 22810f0601f4SLars Ellenberg * 22820f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 22830f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 22840f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 22850f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 22860f0601f4SLars Ellenberg * a while, anyways. 22870f0601f4SLars Ellenberg */ 2288b411b363SPhilipp Reisner 22890f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 22900f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 22910f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 22920f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 22930f0601f4SLars Ellenberg * 22940f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 22950f0601f4SLars Ellenberg * we would also throttle its application reads. 22960f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 22970f0601f4SLars Ellenberg */ 2298e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2299e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2300e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 230180a40e43SLars Ellenberg goto out_free_e; 2302b411b363SPhilipp Reisner 23030f0601f4SLars Ellenberg submit_for_resync: 23040f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 23050f0601f4SLars Ellenberg 230680a40e43SLars Ellenberg submit: 2307b411b363SPhilipp Reisner inc_unacked(mdev); 230887eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2309db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 231087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2311b411b363SPhilipp Reisner 2312fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 231382bc0194SAndreas Gruenbacher return 0; 2314b411b363SPhilipp Reisner 231510f6d992SLars Ellenberg /* don't care for the reason here */ 231610f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 231787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2318db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 231987eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 232022cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 232122cc37a9SLars Ellenberg 2322b411b363SPhilipp Reisner out_free_e: 2323b411b363SPhilipp Reisner put_ldev(mdev); 2324db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 232582bc0194SAndreas Gruenbacher return -EIO; 2326b411b363SPhilipp Reisner } 2327b411b363SPhilipp Reisner 2328b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2329b411b363SPhilipp Reisner { 2330b411b363SPhilipp Reisner int self, peer, rv = -100; 2331b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2332b411b363SPhilipp Reisner 2333b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2334b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2335b411b363SPhilipp Reisner 2336b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2337b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2338b411b363SPhilipp Reisner 233989e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2340b411b363SPhilipp Reisner case ASB_CONSENSUS: 2341b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2342b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2343b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2344b411b363SPhilipp Reisner break; 2345b411b363SPhilipp Reisner case ASB_DISCONNECT: 2346b411b363SPhilipp Reisner break; 2347b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2348b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2349b411b363SPhilipp Reisner rv = -1; 2350b411b363SPhilipp Reisner break; 2351b411b363SPhilipp Reisner } 2352b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2353b411b363SPhilipp Reisner rv = 1; 2354b411b363SPhilipp Reisner break; 2355b411b363SPhilipp Reisner } 2356b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2357b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2358b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2359b411b363SPhilipp Reisner rv = 1; 2360b411b363SPhilipp Reisner break; 2361b411b363SPhilipp Reisner } 2362b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2363b411b363SPhilipp Reisner rv = -1; 2364b411b363SPhilipp Reisner break; 2365b411b363SPhilipp Reisner } 2366b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2367ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2368b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2369b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2370b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 237125703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2372b411b363SPhilipp Reisner ? -1 : 1; 2373b411b363SPhilipp Reisner break; 2374b411b363SPhilipp Reisner } else { 2375b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2376b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2377b411b363SPhilipp Reisner } 237889e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2379b411b363SPhilipp Reisner break; 2380b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2381b411b363SPhilipp Reisner if (ch_self < ch_peer) 2382b411b363SPhilipp Reisner rv = -1; 2383b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2384b411b363SPhilipp Reisner rv = 1; 2385b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2386b411b363SPhilipp Reisner /* Well, then use something else. */ 238725703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2388b411b363SPhilipp Reisner ? -1 : 1; 2389b411b363SPhilipp Reisner break; 2390b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2391b411b363SPhilipp Reisner rv = -1; 2392b411b363SPhilipp Reisner break; 2393b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2394b411b363SPhilipp Reisner rv = 1; 2395b411b363SPhilipp Reisner } 2396b411b363SPhilipp Reisner 2397b411b363SPhilipp Reisner return rv; 2398b411b363SPhilipp Reisner } 2399b411b363SPhilipp Reisner 2400b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2401b411b363SPhilipp Reisner { 24026184ea21SAndreas Gruenbacher int hg, rv = -100; 2403b411b363SPhilipp Reisner 240489e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2405b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2406b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2407b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2408b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2409b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2410b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2411b411b363SPhilipp Reisner break; 2412b411b363SPhilipp Reisner case ASB_DISCONNECT: 2413b411b363SPhilipp Reisner break; 2414b411b363SPhilipp Reisner case ASB_CONSENSUS: 2415b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2416b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2417b411b363SPhilipp Reisner rv = hg; 2418b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2419b411b363SPhilipp Reisner rv = hg; 2420b411b363SPhilipp Reisner break; 2421b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2422b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2423b411b363SPhilipp Reisner break; 2424b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2425b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2426b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2427b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2428b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2429bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2430bb437946SAndreas Gruenbacher 2431bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2432b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2433b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2434b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2435bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2436bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2437b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2438b411b363SPhilipp Reisner } else { 2439b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2440b411b363SPhilipp Reisner rv = hg; 2441b411b363SPhilipp Reisner } 2442b411b363SPhilipp Reisner } else 2443b411b363SPhilipp Reisner rv = hg; 2444b411b363SPhilipp Reisner } 2445b411b363SPhilipp Reisner 2446b411b363SPhilipp Reisner return rv; 2447b411b363SPhilipp Reisner } 2448b411b363SPhilipp Reisner 2449b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2450b411b363SPhilipp Reisner { 24516184ea21SAndreas Gruenbacher int hg, rv = -100; 2452b411b363SPhilipp Reisner 245389e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2454b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2455b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2456b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2457b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2458b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2459b411b363SPhilipp Reisner case ASB_CONSENSUS: 2460b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2461b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2462b411b363SPhilipp Reisner break; 2463b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2464b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2465b411b363SPhilipp Reisner break; 2466b411b363SPhilipp Reisner case ASB_DISCONNECT: 2467b411b363SPhilipp Reisner break; 2468b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2469b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2470b411b363SPhilipp Reisner if (hg == -1) { 2471bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2472bb437946SAndreas Gruenbacher 2473b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2474b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2475b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2476bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2477bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2478b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2479b411b363SPhilipp Reisner } else { 2480b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2481b411b363SPhilipp Reisner rv = hg; 2482b411b363SPhilipp Reisner } 2483b411b363SPhilipp Reisner } else 2484b411b363SPhilipp Reisner rv = hg; 2485b411b363SPhilipp Reisner } 2486b411b363SPhilipp Reisner 2487b411b363SPhilipp Reisner return rv; 2488b411b363SPhilipp Reisner } 2489b411b363SPhilipp Reisner 2490b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2491b411b363SPhilipp Reisner u64 bits, u64 flags) 2492b411b363SPhilipp Reisner { 2493b411b363SPhilipp Reisner if (!uuid) { 2494b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2495b411b363SPhilipp Reisner return; 2496b411b363SPhilipp Reisner } 2497b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2498b411b363SPhilipp Reisner text, 2499b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2500b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2501b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2502b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2503b411b363SPhilipp Reisner (unsigned long long)bits, 2504b411b363SPhilipp Reisner (unsigned long long)flags); 2505b411b363SPhilipp Reisner } 2506b411b363SPhilipp Reisner 2507b411b363SPhilipp Reisner /* 2508b411b363SPhilipp Reisner 100 after split brain try auto recover 2509b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2510b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2511b411b363SPhilipp Reisner 0 no Sync 2512b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2513b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2514b411b363SPhilipp Reisner -100 after split brain, disconnect 2515b411b363SPhilipp Reisner -1000 unrelated data 25164a23f264SPhilipp Reisner -1091 requires proto 91 25174a23f264SPhilipp Reisner -1096 requires proto 96 2518b411b363SPhilipp Reisner */ 2519b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2520b411b363SPhilipp Reisner { 2521b411b363SPhilipp Reisner u64 self, peer; 2522b411b363SPhilipp Reisner int i, j; 2523b411b363SPhilipp Reisner 2524b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2525b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2526b411b363SPhilipp Reisner 2527b411b363SPhilipp Reisner *rule_nr = 10; 2528b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2529b411b363SPhilipp Reisner return 0; 2530b411b363SPhilipp Reisner 2531b411b363SPhilipp Reisner *rule_nr = 20; 2532b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2533b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2534b411b363SPhilipp Reisner return -2; 2535b411b363SPhilipp Reisner 2536b411b363SPhilipp Reisner *rule_nr = 30; 2537b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2538b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2539b411b363SPhilipp Reisner return 2; 2540b411b363SPhilipp Reisner 2541b411b363SPhilipp Reisner if (self == peer) { 2542b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2543b411b363SPhilipp Reisner 2544b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2545b411b363SPhilipp Reisner 254631890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25474a23f264SPhilipp Reisner return -1091; 2548b411b363SPhilipp Reisner 2549b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2550b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2551b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2552b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2553b411b363SPhilipp Reisner 2554b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2555b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2556b411b363SPhilipp Reisner *rule_nr = 34; 2557b411b363SPhilipp Reisner } else { 2558b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2559b411b363SPhilipp Reisner *rule_nr = 36; 2560b411b363SPhilipp Reisner } 2561b411b363SPhilipp Reisner 2562b411b363SPhilipp Reisner return 1; 2563b411b363SPhilipp Reisner } 2564b411b363SPhilipp Reisner 2565b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2566b411b363SPhilipp Reisner 256731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25684a23f264SPhilipp Reisner return -1091; 2569b411b363SPhilipp Reisner 2570b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2571b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2572b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2573b411b363SPhilipp Reisner 2574b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2575b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2576b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2577b411b363SPhilipp Reisner 2578b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2579b411b363SPhilipp Reisner *rule_nr = 35; 2580b411b363SPhilipp Reisner } else { 2581b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2582b411b363SPhilipp Reisner *rule_nr = 37; 2583b411b363SPhilipp Reisner } 2584b411b363SPhilipp Reisner 2585b411b363SPhilipp Reisner return -1; 2586b411b363SPhilipp Reisner } 2587b411b363SPhilipp Reisner 2588b411b363SPhilipp Reisner /* Common power [off|failure] */ 2589b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2590b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2591b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2592b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2593b411b363SPhilipp Reisner *rule_nr = 40; 2594b411b363SPhilipp Reisner 2595b411b363SPhilipp Reisner switch (rct) { 2596b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2597b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2598b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2599b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 260025703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2601b411b363SPhilipp Reisner return dc ? -1 : 1; 2602b411b363SPhilipp Reisner } 2603b411b363SPhilipp Reisner } 2604b411b363SPhilipp Reisner 2605b411b363SPhilipp Reisner *rule_nr = 50; 2606b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2607b411b363SPhilipp Reisner if (self == peer) 2608b411b363SPhilipp Reisner return -1; 2609b411b363SPhilipp Reisner 2610b411b363SPhilipp Reisner *rule_nr = 51; 2611b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2612b411b363SPhilipp Reisner if (self == peer) { 261331890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26144a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 26154a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 26164a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2617b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2618b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2619b411b363SPhilipp Reisner 262031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26214a23f264SPhilipp Reisner return -1091; 2622b411b363SPhilipp Reisner 2623b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2624b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 26254a23f264SPhilipp Reisner 26264a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 26274a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 26284a23f264SPhilipp Reisner 2629b411b363SPhilipp Reisner return -1; 2630b411b363SPhilipp Reisner } 2631b411b363SPhilipp Reisner } 2632b411b363SPhilipp Reisner 2633b411b363SPhilipp Reisner *rule_nr = 60; 2634b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2635b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2636b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2637b411b363SPhilipp Reisner if (self == peer) 2638b411b363SPhilipp Reisner return -2; 2639b411b363SPhilipp Reisner } 2640b411b363SPhilipp Reisner 2641b411b363SPhilipp Reisner *rule_nr = 70; 2642b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2643b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2644b411b363SPhilipp Reisner if (self == peer) 2645b411b363SPhilipp Reisner return 1; 2646b411b363SPhilipp Reisner 2647b411b363SPhilipp Reisner *rule_nr = 71; 2648b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2649b411b363SPhilipp Reisner if (self == peer) { 265031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26514a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 26524a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 26534a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2654b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2655b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2656b411b363SPhilipp Reisner 265731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26584a23f264SPhilipp Reisner return -1091; 2659b411b363SPhilipp Reisner 2660b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2661b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2662b411b363SPhilipp Reisner 26634a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2664b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2665b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2666b411b363SPhilipp Reisner 2667b411b363SPhilipp Reisner return 1; 2668b411b363SPhilipp Reisner } 2669b411b363SPhilipp Reisner } 2670b411b363SPhilipp Reisner 2671b411b363SPhilipp Reisner 2672b411b363SPhilipp Reisner *rule_nr = 80; 2673d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2674b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2675b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2676b411b363SPhilipp Reisner if (self == peer) 2677b411b363SPhilipp Reisner return 2; 2678b411b363SPhilipp Reisner } 2679b411b363SPhilipp Reisner 2680b411b363SPhilipp Reisner *rule_nr = 90; 2681b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2682b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2683b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2684b411b363SPhilipp Reisner return 100; 2685b411b363SPhilipp Reisner 2686b411b363SPhilipp Reisner *rule_nr = 100; 2687b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2688b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2689b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2690b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2691b411b363SPhilipp Reisner if (self == peer) 2692b411b363SPhilipp Reisner return -100; 2693b411b363SPhilipp Reisner } 2694b411b363SPhilipp Reisner } 2695b411b363SPhilipp Reisner 2696b411b363SPhilipp Reisner return -1000; 2697b411b363SPhilipp Reisner } 2698b411b363SPhilipp Reisner 2699b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2700b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2701b411b363SPhilipp Reisner */ 2702b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2703b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2704b411b363SPhilipp Reisner { 2705b411b363SPhilipp Reisner int hg, rule_nr; 2706b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2707b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2708b411b363SPhilipp Reisner 2709b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2710b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2711b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2712b411b363SPhilipp Reisner 2713b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2714b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2715b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2716b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2717b411b363SPhilipp Reisner 2718b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2719b411b363SPhilipp Reisner 2720b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2721b411b363SPhilipp Reisner 2722b411b363SPhilipp Reisner if (hg == -1000) { 2723b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2724b411b363SPhilipp Reisner return C_MASK; 2725b411b363SPhilipp Reisner } 27264a23f264SPhilipp Reisner if (hg < -1000) { 27274a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2728b411b363SPhilipp Reisner return C_MASK; 2729b411b363SPhilipp Reisner } 2730b411b363SPhilipp Reisner 2731b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2732b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2733b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2734b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2735b411b363SPhilipp Reisner if (f) 2736b411b363SPhilipp Reisner hg = hg*2; 2737b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2738b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2739b411b363SPhilipp Reisner } 2740b411b363SPhilipp Reisner 27413a11a487SAdam Gandelman if (abs(hg) == 100) 27423a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 27433a11a487SAdam Gandelman 274489e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2745b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2746b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2747b411b363SPhilipp Reisner int forced = (hg == -100); 2748b411b363SPhilipp Reisner 2749b411b363SPhilipp Reisner switch (pcount) { 2750b411b363SPhilipp Reisner case 0: 2751b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2752b411b363SPhilipp Reisner break; 2753b411b363SPhilipp Reisner case 1: 2754b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2755b411b363SPhilipp Reisner break; 2756b411b363SPhilipp Reisner case 2: 2757b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2758b411b363SPhilipp Reisner break; 2759b411b363SPhilipp Reisner } 2760b411b363SPhilipp Reisner if (abs(hg) < 100) { 2761b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2762b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2763b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2764b411b363SPhilipp Reisner if (forced) { 2765b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2766b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2767b411b363SPhilipp Reisner hg = hg*2; 2768b411b363SPhilipp Reisner } 2769b411b363SPhilipp Reisner } 2770b411b363SPhilipp Reisner } 2771b411b363SPhilipp Reisner 2772b411b363SPhilipp Reisner if (hg == -100) { 277389e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2774b411b363SPhilipp Reisner hg = -1; 277589e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2776b411b363SPhilipp Reisner hg = 1; 2777b411b363SPhilipp Reisner 2778b411b363SPhilipp Reisner if (abs(hg) < 100) 2779b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2780b411b363SPhilipp Reisner "Sync from %s node\n", 2781b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2782b411b363SPhilipp Reisner } 2783b411b363SPhilipp Reisner 2784b411b363SPhilipp Reisner if (hg == -100) { 2785580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2786580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2787580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2788580b9767SLars Ellenberg * to that disk, in a way... */ 27893a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2790b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2791b411b363SPhilipp Reisner return C_MASK; 2792b411b363SPhilipp Reisner } 2793b411b363SPhilipp Reisner 2794b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2795b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2796b411b363SPhilipp Reisner return C_MASK; 2797b411b363SPhilipp Reisner } 2798b411b363SPhilipp Reisner 2799b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2800b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 280189e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2802b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2803b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2804b411b363SPhilipp Reisner /* fall through */ 2805b411b363SPhilipp Reisner case ASB_DISCONNECT: 2806b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2807b411b363SPhilipp Reisner return C_MASK; 2808b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2809b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2810b411b363SPhilipp Reisner "assumption\n"); 2811b411b363SPhilipp Reisner } 2812b411b363SPhilipp Reisner } 2813b411b363SPhilipp Reisner 28148169e41bSPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2815cf14c2e9SPhilipp Reisner if (hg == 0) 2816cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2817cf14c2e9SPhilipp Reisner else 2818cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2819cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2820cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2821cf14c2e9SPhilipp Reisner return C_MASK; 2822cf14c2e9SPhilipp Reisner } 2823cf14c2e9SPhilipp Reisner 2824b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2825b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 282620ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 282720ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2828b411b363SPhilipp Reisner return C_MASK; 2829b411b363SPhilipp Reisner } 2830b411b363SPhilipp Reisner 2831b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2832b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2833b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2834b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2835b411b363SPhilipp Reisner } else { 2836b411b363SPhilipp Reisner rv = C_CONNECTED; 2837b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2838b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2839b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2840b411b363SPhilipp Reisner } 2841b411b363SPhilipp Reisner } 2842b411b363SPhilipp Reisner 2843b411b363SPhilipp Reisner return rv; 2844b411b363SPhilipp Reisner } 2845b411b363SPhilipp Reisner 2846b411b363SPhilipp Reisner /* returns 1 if invalid */ 2847b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2848b411b363SPhilipp Reisner { 2849b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2850b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2851b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2852b411b363SPhilipp Reisner return 0; 2853b411b363SPhilipp Reisner 2854b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2855b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2856b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2857b411b363SPhilipp Reisner return 1; 2858b411b363SPhilipp Reisner 2859b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2860b411b363SPhilipp Reisner if (peer == self) 2861b411b363SPhilipp Reisner return 0; 2862b411b363SPhilipp Reisner 2863b411b363SPhilipp Reisner /* everything es is invalid. */ 2864b411b363SPhilipp Reisner return 1; 2865b411b363SPhilipp Reisner } 2866b411b363SPhilipp Reisner 28677204624cSPhilipp Reisner static int receive_protocol(struct drbd_tconn *tconn, enum drbd_packet cmd, 2868d8763023SAndreas Gruenbacher unsigned int data_size) 2869b411b363SPhilipp Reisner { 2870e6ef8a5cSAndreas Gruenbacher struct p_protocol *p = tconn->data.rbuf; 2871b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2872cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2873b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2874b411b363SPhilipp Reisner 2875b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2876b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2877b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2878b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2879b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2880cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2881cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2882cf14c2e9SPhilipp Reisner 28837204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 2884cf14c2e9SPhilipp Reisner 2885cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 28867204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 2887b411b363SPhilipp Reisner 28887204624cSPhilipp Reisner if (p_proto != tconn->net_conf->wire_protocol) { 28897204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 2890b411b363SPhilipp Reisner goto disconnect; 2891b411b363SPhilipp Reisner } 2892b411b363SPhilipp Reisner 28937204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, tconn->net_conf->after_sb_0p)) { 28947204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 2895b411b363SPhilipp Reisner goto disconnect; 2896b411b363SPhilipp Reisner } 2897b411b363SPhilipp Reisner 28987204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, tconn->net_conf->after_sb_1p)) { 28997204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 2900b411b363SPhilipp Reisner goto disconnect; 2901b411b363SPhilipp Reisner } 2902b411b363SPhilipp Reisner 29037204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, tconn->net_conf->after_sb_2p)) { 29047204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 2905b411b363SPhilipp Reisner goto disconnect; 2906b411b363SPhilipp Reisner } 2907b411b363SPhilipp Reisner 29087204624cSPhilipp Reisner if (p_want_lose && tconn->net_conf->want_lose) { 29097204624cSPhilipp Reisner conn_err(tconn, "both sides have the 'want_lose' flag set\n"); 2910b411b363SPhilipp Reisner goto disconnect; 2911b411b363SPhilipp Reisner } 2912b411b363SPhilipp Reisner 29137204624cSPhilipp Reisner if (p_two_primaries != tconn->net_conf->two_primaries) { 29147204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 2915b411b363SPhilipp Reisner goto disconnect; 2916b411b363SPhilipp Reisner } 2917b411b363SPhilipp Reisner 29187204624cSPhilipp Reisner if (tconn->agreed_pro_version >= 87) { 29197204624cSPhilipp Reisner unsigned char *my_alg = tconn->net_conf->integrity_alg; 292082bc0194SAndreas Gruenbacher int err; 2921b411b363SPhilipp Reisner 292282bc0194SAndreas Gruenbacher err = drbd_recv_all(tconn, p_integrity_alg, data_size); 292382bc0194SAndreas Gruenbacher if (err) 292482bc0194SAndreas Gruenbacher return err; 2925b411b363SPhilipp Reisner 2926b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2927b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 29287204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the data-integrity-alg\n"); 2929b411b363SPhilipp Reisner goto disconnect; 2930b411b363SPhilipp Reisner } 29317204624cSPhilipp Reisner conn_info(tconn, "data-integrity-alg: %s\n", 2932b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2933b411b363SPhilipp Reisner } 2934b411b363SPhilipp Reisner 293582bc0194SAndreas Gruenbacher return 0; 2936b411b363SPhilipp Reisner 2937b411b363SPhilipp Reisner disconnect: 29387204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 293982bc0194SAndreas Gruenbacher return -EIO; 2940b411b363SPhilipp Reisner } 2941b411b363SPhilipp Reisner 2942b411b363SPhilipp Reisner /* helper function 2943b411b363SPhilipp Reisner * input: alg name, feature name 2944b411b363SPhilipp Reisner * return: NULL (alg name was "") 2945b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2946b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2947b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2948b411b363SPhilipp Reisner const char *alg, const char *name) 2949b411b363SPhilipp Reisner { 2950b411b363SPhilipp Reisner struct crypto_hash *tfm; 2951b411b363SPhilipp Reisner 2952b411b363SPhilipp Reisner if (!alg[0]) 2953b411b363SPhilipp Reisner return NULL; 2954b411b363SPhilipp Reisner 2955b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2956b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2957b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2958b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2959b411b363SPhilipp Reisner return tfm; 2960b411b363SPhilipp Reisner } 2961b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2962b411b363SPhilipp Reisner crypto_free_hash(tfm); 2963b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2964b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2965b411b363SPhilipp Reisner } 2966b411b363SPhilipp Reisner return tfm; 2967b411b363SPhilipp Reisner } 2968b411b363SPhilipp Reisner 2969d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2970d8763023SAndreas Gruenbacher unsigned int packet_size) 2971b411b363SPhilipp Reisner { 2972e6ef8a5cSAndreas Gruenbacher struct p_rs_param_95 *p = mdev->tconn->data.rbuf; 2973b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2974b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2975b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 297631890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2977778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2978778f271dSPhilipp Reisner int fifo_size = 0; 297982bc0194SAndreas Gruenbacher int err; 2980b411b363SPhilipp Reisner 2981b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2982b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2983b411b363SPhilipp Reisner + SHARED_SECRET_MAX 29848e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 29858e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2986b411b363SPhilipp Reisner 298702918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2988b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 298902918be2SPhilipp Reisner packet_size, exp_max_sz); 299082bc0194SAndreas Gruenbacher return -EIO; 2991b411b363SPhilipp Reisner } 2992b411b363SPhilipp Reisner 2993b411b363SPhilipp Reisner if (apv <= 88) { 2994257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 299502918be2SPhilipp Reisner data_size = packet_size - header_size; 29968e26f9ccSPhilipp Reisner } else if (apv <= 94) { 2997257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 299802918be2SPhilipp Reisner data_size = packet_size - header_size; 2999b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 30008e26f9ccSPhilipp Reisner } else { 3001257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 300202918be2SPhilipp Reisner data_size = packet_size - header_size; 3003b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 3004b411b363SPhilipp Reisner } 3005b411b363SPhilipp Reisner 3006b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 3007b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3008b411b363SPhilipp Reisner 300982bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, &p->head.payload, header_size); 301082bc0194SAndreas Gruenbacher if (err) 301182bc0194SAndreas Gruenbacher return err; 3012b411b363SPhilipp Reisner 3013f399002eSLars Ellenberg if (get_ldev(mdev)) { 3014f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3015f399002eSLars Ellenberg put_ldev(mdev); 3016f399002eSLars Ellenberg } 3017b411b363SPhilipp Reisner 3018b411b363SPhilipp Reisner if (apv >= 88) { 3019b411b363SPhilipp Reisner if (apv == 88) { 3020b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3021b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3022b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3023b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 302482bc0194SAndreas Gruenbacher return -EIO; 3025b411b363SPhilipp Reisner } 3026b411b363SPhilipp Reisner 302782bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size); 302882bc0194SAndreas Gruenbacher if (err) 302982bc0194SAndreas Gruenbacher return err; 3030b411b363SPhilipp Reisner 3031b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3032b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3033b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3034b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3035b411b363SPhilipp Reisner 3036b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3037b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3038b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3039b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3040b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3041b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3042b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3043b411b363SPhilipp Reisner } 3044b411b363SPhilipp Reisner 3045f399002eSLars Ellenberg if (strcmp(mdev->tconn->net_conf->verify_alg, p->verify_alg)) { 3046b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3047b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 3048f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg, p->verify_alg); 3049b411b363SPhilipp Reisner goto disconnect; 3050b411b363SPhilipp Reisner } 3051b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3052b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3053b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3054b411b363SPhilipp Reisner verify_tfm = NULL; 3055b411b363SPhilipp Reisner goto disconnect; 3056b411b363SPhilipp Reisner } 3057b411b363SPhilipp Reisner } 3058b411b363SPhilipp Reisner 3059f399002eSLars Ellenberg if (apv >= 89 && strcmp(mdev->tconn->net_conf->csums_alg, p->csums_alg)) { 3060b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3061b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 3062f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg, p->csums_alg); 3063b411b363SPhilipp Reisner goto disconnect; 3064b411b363SPhilipp Reisner } 3065b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3066b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3067b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3068b411b363SPhilipp Reisner csums_tfm = NULL; 3069b411b363SPhilipp Reisner goto disconnect; 3070b411b363SPhilipp Reisner } 3071b411b363SPhilipp Reisner } 3072b411b363SPhilipp Reisner 3073f399002eSLars Ellenberg if (apv > 94 && get_ldev(mdev)) { 3074f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3075f399002eSLars Ellenberg mdev->ldev->dc.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3076f399002eSLars Ellenberg mdev->ldev->dc.c_delay_target = be32_to_cpu(p->c_delay_target); 3077f399002eSLars Ellenberg mdev->ldev->dc.c_fill_target = be32_to_cpu(p->c_fill_target); 3078f399002eSLars Ellenberg mdev->ldev->dc.c_max_rate = be32_to_cpu(p->c_max_rate); 3079778f271dSPhilipp Reisner 3080f399002eSLars Ellenberg fifo_size = (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3081778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 3082778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 3083778f271dSPhilipp Reisner if (!rs_plan_s) { 3084778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3085f399002eSLars Ellenberg put_ldev(mdev); 3086778f271dSPhilipp Reisner goto disconnect; 3087778f271dSPhilipp Reisner } 3088778f271dSPhilipp Reisner } 3089f399002eSLars Ellenberg put_ldev(mdev); 30908e26f9ccSPhilipp Reisner } 3091b411b363SPhilipp Reisner 3092b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 3093b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 3094b411b363SPhilipp Reisner if (verify_tfm) { 3095f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->verify_alg, p->verify_alg); 3096f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3097f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3098f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3099b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3100b411b363SPhilipp Reisner } 3101b411b363SPhilipp Reisner if (csums_tfm) { 3102f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->csums_alg, p->csums_alg); 3103f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3104f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3105f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3106b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3107b411b363SPhilipp Reisner } 3108778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 3109778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 3110778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 3111778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 3112778f271dSPhilipp Reisner mdev->rs_planed = 0; 3113778f271dSPhilipp Reisner } 3114b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 3115b411b363SPhilipp Reisner } 311682bc0194SAndreas Gruenbacher return 0; 3117b411b363SPhilipp Reisner 3118b411b363SPhilipp Reisner disconnect: 3119b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3120b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3121b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3122b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3123b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 312438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 312582bc0194SAndreas Gruenbacher return -EIO; 3126b411b363SPhilipp Reisner } 3127b411b363SPhilipp Reisner 3128b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3129b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3130b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3131b411b363SPhilipp Reisner { 3132b411b363SPhilipp Reisner sector_t d; 3133b411b363SPhilipp Reisner if (a == 0 || b == 0) 3134b411b363SPhilipp Reisner return; 3135b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3136b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3137b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3138b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3139b411b363SPhilipp Reisner } 3140b411b363SPhilipp Reisner 3141d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 3142d8763023SAndreas Gruenbacher unsigned int data_size) 3143b411b363SPhilipp Reisner { 3144e6ef8a5cSAndreas Gruenbacher struct p_sizes *p = mdev->tconn->data.rbuf; 3145b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3146b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3147b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3148e89b591cSPhilipp Reisner enum dds_flags ddsf; 3149b411b363SPhilipp Reisner 3150b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3151b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3152b411b363SPhilipp Reisner 3153b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3154b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3155b411b363SPhilipp Reisner mdev->p_size = p_size; 3156b411b363SPhilipp Reisner 3157b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3158b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3159b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3160b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3161b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3162b411b363SPhilipp Reisner 3163b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3164b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3165b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3166b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3167b411b363SPhilipp Reisner p_usize); 3168b411b363SPhilipp Reisner 3169b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3170b411b363SPhilipp Reisner 3171b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3172b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3173b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3174b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3175b411b363SPhilipp Reisner } 3176b411b363SPhilipp Reisner 3177b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3178b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3179a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3180b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3181b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3182b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3183b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 318438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3185b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3186b411b363SPhilipp Reisner put_ldev(mdev); 318782bc0194SAndreas Gruenbacher return -EIO; 3188b411b363SPhilipp Reisner } 3189b411b363SPhilipp Reisner put_ldev(mdev); 3190b411b363SPhilipp Reisner } 3191b411b363SPhilipp Reisner 3192e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3193b411b363SPhilipp Reisner if (get_ldev(mdev)) { 319424c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3195b411b363SPhilipp Reisner put_ldev(mdev); 3196b411b363SPhilipp Reisner if (dd == dev_size_error) 319782bc0194SAndreas Gruenbacher return -EIO; 3198b411b363SPhilipp Reisner drbd_md_sync(mdev); 3199b411b363SPhilipp Reisner } else { 3200b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3201b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3202b411b363SPhilipp Reisner } 3203b411b363SPhilipp Reisner 320499432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 320599432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 320699432fccSPhilipp Reisner 3207b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3208b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3209b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3210b411b363SPhilipp Reisner ldsc = 1; 3211b411b363SPhilipp Reisner } 3212b411b363SPhilipp Reisner 3213b411b363SPhilipp Reisner put_ldev(mdev); 3214b411b363SPhilipp Reisner } 3215b411b363SPhilipp Reisner 3216b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3217b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3218b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3219b411b363SPhilipp Reisner /* we have different sizes, probably peer 3220b411b363SPhilipp Reisner * needs to know my new size... */ 3221e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3222b411b363SPhilipp Reisner } 3223b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3224b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3225b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3226e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3227e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3228e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3229b411b363SPhilipp Reisner else 3230e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3231e89b591cSPhilipp Reisner } else 3232b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3233b411b363SPhilipp Reisner } 3234b411b363SPhilipp Reisner } 3235b411b363SPhilipp Reisner 323682bc0194SAndreas Gruenbacher return 0; 3237b411b363SPhilipp Reisner } 3238b411b363SPhilipp Reisner 3239d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3240d8763023SAndreas Gruenbacher unsigned int data_size) 3241b411b363SPhilipp Reisner { 3242e6ef8a5cSAndreas Gruenbacher struct p_uuids *p = mdev->tconn->data.rbuf; 3243b411b363SPhilipp Reisner u64 *p_uuid; 324462b0da3aSLars Ellenberg int i, updated_uuids = 0; 3245b411b363SPhilipp Reisner 3246b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3247b411b363SPhilipp Reisner 3248b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3249b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3250b411b363SPhilipp Reisner 3251b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3252b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3253b411b363SPhilipp Reisner 3254b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3255b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3256b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3257b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3258b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3259b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 326038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 326182bc0194SAndreas Gruenbacher return -EIO; 3262b411b363SPhilipp Reisner } 3263b411b363SPhilipp Reisner 3264b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3265b411b363SPhilipp Reisner int skip_initial_sync = 3266b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 326731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3268b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3269b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3270b411b363SPhilipp Reisner if (skip_initial_sync) { 3271b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3272b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 327320ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 327420ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3275b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3276b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3277b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3278b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3279b411b363SPhilipp Reisner drbd_md_sync(mdev); 328062b0da3aSLars Ellenberg updated_uuids = 1; 3281b411b363SPhilipp Reisner } 3282b411b363SPhilipp Reisner put_ldev(mdev); 328318a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 328418a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 328518a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 328618a50fa2SPhilipp Reisner for me. */ 328762b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3288b411b363SPhilipp Reisner } 3289b411b363SPhilipp Reisner 3290b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3291b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3292b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3293b411b363SPhilipp Reisner new disk state... */ 32948410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 32958410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3296b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 329762b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 329862b0da3aSLars Ellenberg 329962b0da3aSLars Ellenberg if (updated_uuids) 330062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3301b411b363SPhilipp Reisner 330282bc0194SAndreas Gruenbacher return 0; 3303b411b363SPhilipp Reisner } 3304b411b363SPhilipp Reisner 3305b411b363SPhilipp Reisner /** 3306b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3307b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3308b411b363SPhilipp Reisner */ 3309b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3310b411b363SPhilipp Reisner { 3311b411b363SPhilipp Reisner union drbd_state ms; 3312b411b363SPhilipp Reisner 3313b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3314b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3315b411b363SPhilipp Reisner 3316b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3317b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3318b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3319b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3320b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3321b411b363SPhilipp Reisner }; 3322b411b363SPhilipp Reisner 3323b411b363SPhilipp Reisner ms.i = ps.i; 3324b411b363SPhilipp Reisner 3325b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3326b411b363SPhilipp Reisner ms.peer = ps.role; 3327b411b363SPhilipp Reisner ms.role = ps.peer; 3328b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3329b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3330b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3331b411b363SPhilipp Reisner 3332b411b363SPhilipp Reisner return ms; 3333b411b363SPhilipp Reisner } 3334b411b363SPhilipp Reisner 3335d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3336d8763023SAndreas Gruenbacher unsigned int data_size) 3337b411b363SPhilipp Reisner { 3338e6ef8a5cSAndreas Gruenbacher struct p_req_state *p = mdev->tconn->data.rbuf; 3339b411b363SPhilipp Reisner union drbd_state mask, val; 3340bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3341b411b363SPhilipp Reisner 3342b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3343b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3344b411b363SPhilipp Reisner 334525703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 33468410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3347b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 334882bc0194SAndreas Gruenbacher return 0; 3349b411b363SPhilipp Reisner } 3350b411b363SPhilipp Reisner 3351b411b363SPhilipp Reisner mask = convert_state(mask); 3352b411b363SPhilipp Reisner val = convert_state(val); 3353b411b363SPhilipp Reisner 3354b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3355b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3356047cd4a6SPhilipp Reisner 3357b411b363SPhilipp Reisner drbd_md_sync(mdev); 3358b411b363SPhilipp Reisner 335982bc0194SAndreas Gruenbacher return 0; 3360b411b363SPhilipp Reisner } 3361b411b363SPhilipp Reisner 3362dfafcc8aSPhilipp Reisner static int receive_req_conn_state(struct drbd_tconn *tconn, enum drbd_packet cmd, 3363dfafcc8aSPhilipp Reisner unsigned int data_size) 3364dfafcc8aSPhilipp Reisner { 3365e6ef8a5cSAndreas Gruenbacher struct p_req_state *p = tconn->data.rbuf; 3366dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3367dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3368dfafcc8aSPhilipp Reisner 3369dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3370dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3371dfafcc8aSPhilipp Reisner 3372dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3373dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3374dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 337582bc0194SAndreas Gruenbacher return 0; 3376dfafcc8aSPhilipp Reisner } 3377dfafcc8aSPhilipp Reisner 3378dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3379dfafcc8aSPhilipp Reisner val = convert_state(val); 3380dfafcc8aSPhilipp Reisner 3381dfafcc8aSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY); 3382dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3383dfafcc8aSPhilipp Reisner 338482bc0194SAndreas Gruenbacher return 0; 3385dfafcc8aSPhilipp Reisner } 3386dfafcc8aSPhilipp Reisner 3387d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3388d8763023SAndreas Gruenbacher unsigned int data_size) 3389b411b363SPhilipp Reisner { 3390e6ef8a5cSAndreas Gruenbacher struct p_state *p = mdev->tconn->data.rbuf; 33914ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3392b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 339365d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3394b411b363SPhilipp Reisner int rv; 3395b411b363SPhilipp Reisner 3396b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3397b411b363SPhilipp Reisner 3398b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3399b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3400b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3401b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3402b411b363SPhilipp Reisner } 3403b411b363SPhilipp Reisner 340487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3405b411b363SPhilipp Reisner retry: 34064ac4aadaSLars Ellenberg os = ns = mdev->state; 340787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3408b411b363SPhilipp Reisner 3409e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3410e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3411e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3412e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3413e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3414e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3415e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3416e9ef7bb6SLars Ellenberg * syncing states. 3417e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3418e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3419e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3420e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3421e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3422e9ef7bb6SLars Ellenberg 3423e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3424e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3425e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3426e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3427e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3428e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3429e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 343082bc0194SAndreas Gruenbacher return 0; 3431e9ef7bb6SLars Ellenberg } 3432e9ef7bb6SLars Ellenberg } 3433e9ef7bb6SLars Ellenberg 3434e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3435e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3436e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3437e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3438e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3439e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3440e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3441e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3442e9ef7bb6SLars Ellenberg 34434ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 34444ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3445b411b363SPhilipp Reisner 344667531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 344767531718SPhilipp Reisner ns.conn = C_BEHIND; 344867531718SPhilipp Reisner 3449b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3450b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3451b411b363SPhilipp Reisner int cr; /* consider resync */ 3452b411b363SPhilipp Reisner 3453b411b363SPhilipp Reisner /* if we established a new connection */ 34544ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3455b411b363SPhilipp Reisner /* if we had an established connection 3456b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 34574ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3458b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 34594ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3460b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3461b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3462b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3463b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3464b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 34654ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3466b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3467b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3468b411b363SPhilipp Reisner 3469b411b363SPhilipp Reisner if (cr) 34704ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3471b411b363SPhilipp Reisner 3472b411b363SPhilipp Reisner put_ldev(mdev); 34734ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 34744ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3475b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 347682f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3477b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3478b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3479b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3480580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3481b411b363SPhilipp Reisner } else { 34828169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 348382bc0194SAndreas Gruenbacher return -EIO; 34844ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 348538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 348682bc0194SAndreas Gruenbacher return -EIO; 3487b411b363SPhilipp Reisner } 3488b411b363SPhilipp Reisner } 3489b411b363SPhilipp Reisner } 3490b411b363SPhilipp Reisner 349187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 34924ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3493b411b363SPhilipp Reisner goto retry; 3494b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3495b411b363SPhilipp Reisner ns.peer = peer_state.role; 3496b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3497b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 34984ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3499b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 35004ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 35014ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3502481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 35038554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3504481c6f50SPhilipp Reisner for temporal network outages! */ 350587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3506481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 35072f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3508481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3509481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 351038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 351182bc0194SAndreas Gruenbacher return -EIO; 3512481c6f50SPhilipp Reisner } 351365d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3514b411b363SPhilipp Reisner ns = mdev->state; 351587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3516b411b363SPhilipp Reisner 3517b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 351838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 351982bc0194SAndreas Gruenbacher return -EIO; 3520b411b363SPhilipp Reisner } 3521b411b363SPhilipp Reisner 35224ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 35234ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3524b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3525b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3526b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3527b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3528b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3529b411b363SPhilipp Reisner drbd_send_state(mdev); 3530b411b363SPhilipp Reisner } 3531b411b363SPhilipp Reisner } 3532b411b363SPhilipp Reisner 353389e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3534b411b363SPhilipp Reisner 3535b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3536b411b363SPhilipp Reisner 353782bc0194SAndreas Gruenbacher return 0; 3538b411b363SPhilipp Reisner } 3539b411b363SPhilipp Reisner 3540d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3541d8763023SAndreas Gruenbacher unsigned int data_size) 3542b411b363SPhilipp Reisner { 3543e6ef8a5cSAndreas Gruenbacher struct p_rs_uuid *p = mdev->tconn->data.rbuf; 3544b411b363SPhilipp Reisner 3545b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3546b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3547c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3548b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3549b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3550b411b363SPhilipp Reisner 3551b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3552b411b363SPhilipp Reisner 3553b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3554b411b363SPhilipp Reisner _not_ be rotated into the history */ 3555b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3556b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3557b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3558b411b363SPhilipp Reisner 355962b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3560b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3561b411b363SPhilipp Reisner 3562b411b363SPhilipp Reisner put_ldev(mdev); 3563b411b363SPhilipp Reisner } else 3564b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3565b411b363SPhilipp Reisner 356682bc0194SAndreas Gruenbacher return 0; 3567b411b363SPhilipp Reisner } 3568b411b363SPhilipp Reisner 35692c46407dSAndreas Gruenbacher /** 35702c46407dSAndreas Gruenbacher * receive_bitmap_plain 35712c46407dSAndreas Gruenbacher * 35722c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35732c46407dSAndreas Gruenbacher * code upon failure. 35742c46407dSAndreas Gruenbacher */ 35752c46407dSAndreas Gruenbacher static int 357602918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3577b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3578b411b363SPhilipp Reisner { 3579b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3580b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 35812c46407dSAndreas Gruenbacher int err; 3582b411b363SPhilipp Reisner 358302918be2SPhilipp Reisner if (want != data_size) { 358402918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 35852c46407dSAndreas Gruenbacher return -EIO; 3586b411b363SPhilipp Reisner } 3587b411b363SPhilipp Reisner if (want == 0) 35882c46407dSAndreas Gruenbacher return 0; 358982bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, buffer, want); 359082bc0194SAndreas Gruenbacher if (err) 35912c46407dSAndreas Gruenbacher return err; 3592b411b363SPhilipp Reisner 3593b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3594b411b363SPhilipp Reisner 3595b411b363SPhilipp Reisner c->word_offset += num_words; 3596b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3597b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3598b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3599b411b363SPhilipp Reisner 36002c46407dSAndreas Gruenbacher return 1; 3601b411b363SPhilipp Reisner } 3602b411b363SPhilipp Reisner 3603a02d1240SAndreas Gruenbacher static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p) 3604a02d1240SAndreas Gruenbacher { 3605a02d1240SAndreas Gruenbacher return (enum drbd_bitmap_code)(p->encoding & 0x0f); 3606a02d1240SAndreas Gruenbacher } 3607a02d1240SAndreas Gruenbacher 3608a02d1240SAndreas Gruenbacher static int dcbp_get_start(struct p_compressed_bm *p) 3609a02d1240SAndreas Gruenbacher { 3610a02d1240SAndreas Gruenbacher return (p->encoding & 0x80) != 0; 3611a02d1240SAndreas Gruenbacher } 3612a02d1240SAndreas Gruenbacher 3613a02d1240SAndreas Gruenbacher static int dcbp_get_pad_bits(struct p_compressed_bm *p) 3614a02d1240SAndreas Gruenbacher { 3615a02d1240SAndreas Gruenbacher return (p->encoding >> 4) & 0x7; 3616a02d1240SAndreas Gruenbacher } 3617a02d1240SAndreas Gruenbacher 36182c46407dSAndreas Gruenbacher /** 36192c46407dSAndreas Gruenbacher * recv_bm_rle_bits 36202c46407dSAndreas Gruenbacher * 36212c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36222c46407dSAndreas Gruenbacher * code upon failure. 36232c46407dSAndreas Gruenbacher */ 36242c46407dSAndreas Gruenbacher static int 3625b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3626b411b363SPhilipp Reisner struct p_compressed_bm *p, 3627c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3628c6d25cfeSPhilipp Reisner unsigned int len) 3629b411b363SPhilipp Reisner { 3630b411b363SPhilipp Reisner struct bitstream bs; 3631b411b363SPhilipp Reisner u64 look_ahead; 3632b411b363SPhilipp Reisner u64 rl; 3633b411b363SPhilipp Reisner u64 tmp; 3634b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3635b411b363SPhilipp Reisner unsigned long e; 3636a02d1240SAndreas Gruenbacher int toggle = dcbp_get_start(p); 3637b411b363SPhilipp Reisner int have; 3638b411b363SPhilipp Reisner int bits; 3639b411b363SPhilipp Reisner 3640a02d1240SAndreas Gruenbacher bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p)); 3641b411b363SPhilipp Reisner 3642b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3643b411b363SPhilipp Reisner if (bits < 0) 36442c46407dSAndreas Gruenbacher return -EIO; 3645b411b363SPhilipp Reisner 3646b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3647b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3648b411b363SPhilipp Reisner if (bits <= 0) 36492c46407dSAndreas Gruenbacher return -EIO; 3650b411b363SPhilipp Reisner 3651b411b363SPhilipp Reisner if (toggle) { 3652b411b363SPhilipp Reisner e = s + rl -1; 3653b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3654b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 36552c46407dSAndreas Gruenbacher return -EIO; 3656b411b363SPhilipp Reisner } 3657b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3658b411b363SPhilipp Reisner } 3659b411b363SPhilipp Reisner 3660b411b363SPhilipp Reisner if (have < bits) { 3661b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3662b411b363SPhilipp Reisner have, bits, look_ahead, 3663b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3664b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 36652c46407dSAndreas Gruenbacher return -EIO; 3666b411b363SPhilipp Reisner } 3667b411b363SPhilipp Reisner look_ahead >>= bits; 3668b411b363SPhilipp Reisner have -= bits; 3669b411b363SPhilipp Reisner 3670b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3671b411b363SPhilipp Reisner if (bits < 0) 36722c46407dSAndreas Gruenbacher return -EIO; 3673b411b363SPhilipp Reisner look_ahead |= tmp << have; 3674b411b363SPhilipp Reisner have += bits; 3675b411b363SPhilipp Reisner } 3676b411b363SPhilipp Reisner 3677b411b363SPhilipp Reisner c->bit_offset = s; 3678b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3679b411b363SPhilipp Reisner 36802c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3681b411b363SPhilipp Reisner } 3682b411b363SPhilipp Reisner 36832c46407dSAndreas Gruenbacher /** 36842c46407dSAndreas Gruenbacher * decode_bitmap_c 36852c46407dSAndreas Gruenbacher * 36862c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36872c46407dSAndreas Gruenbacher * code upon failure. 36882c46407dSAndreas Gruenbacher */ 36892c46407dSAndreas Gruenbacher static int 3690b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3691b411b363SPhilipp Reisner struct p_compressed_bm *p, 3692c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3693c6d25cfeSPhilipp Reisner unsigned int len) 3694b411b363SPhilipp Reisner { 3695a02d1240SAndreas Gruenbacher if (dcbp_get_code(p) == RLE_VLI_Bits) 3696c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3697b411b363SPhilipp Reisner 3698b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3699b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3700b411b363SPhilipp Reisner * during all our tests. */ 3701b411b363SPhilipp Reisner 3702b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 370338fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 37042c46407dSAndreas Gruenbacher return -EIO; 3705b411b363SPhilipp Reisner } 3706b411b363SPhilipp Reisner 3707b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3708b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3709b411b363SPhilipp Reisner { 3710b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3711c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3712b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3713b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3714b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3715b411b363SPhilipp Reisner unsigned r; 3716b411b363SPhilipp Reisner 3717b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3718b411b363SPhilipp Reisner if (total == 0) 3719b411b363SPhilipp Reisner return; 3720b411b363SPhilipp Reisner 3721b411b363SPhilipp Reisner /* don't report if not compressed */ 3722b411b363SPhilipp Reisner if (total >= plain) 3723b411b363SPhilipp Reisner return; 3724b411b363SPhilipp Reisner 3725b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3726b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3727b411b363SPhilipp Reisner : (1000 * total / plain); 3728b411b363SPhilipp Reisner 3729b411b363SPhilipp Reisner if (r > 1000) 3730b411b363SPhilipp Reisner r = 1000; 3731b411b363SPhilipp Reisner 3732b411b363SPhilipp Reisner r = 1000 - r; 3733b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3734b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3735b411b363SPhilipp Reisner direction, 3736b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3737b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3738b411b363SPhilipp Reisner total, r/10, r % 10); 3739b411b363SPhilipp Reisner } 3740b411b363SPhilipp Reisner 3741b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3742b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3743b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3744b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3745b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3746b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3747b411b363SPhilipp Reisner 3748b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3749d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3750d8763023SAndreas Gruenbacher unsigned int data_size) 3751b411b363SPhilipp Reisner { 3752b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3753b411b363SPhilipp Reisner void *buffer; 37542c46407dSAndreas Gruenbacher int err; 3755e6ef8a5cSAndreas Gruenbacher struct p_header *h = mdev->tconn->data.rbuf; 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__); 376782bc0194SAndreas Gruenbacher err = -ENOMEM; 3768b411b363SPhilipp Reisner goto out; 3769b411b363SPhilipp Reisner } 3770b411b363SPhilipp Reisner 3771b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3772b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3773b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3774b411b363SPhilipp Reisner }; 3775b411b363SPhilipp Reisner 37762c46407dSAndreas Gruenbacher for(;;) { 377702918be2SPhilipp Reisner if (cmd == P_BITMAP) { 37782c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 377902918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3780b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3781b411b363SPhilipp Reisner * and the feature is enabled! */ 3782b411b363SPhilipp Reisner struct p_compressed_bm *p; 3783b411b363SPhilipp Reisner 378402918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3785b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 378682bc0194SAndreas Gruenbacher err = -EIO; 3787b411b363SPhilipp Reisner goto out; 3788b411b363SPhilipp Reisner } 3789b411b363SPhilipp Reisner /* use the page buff */ 3790b411b363SPhilipp Reisner p = buffer; 3791b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 379282bc0194SAndreas Gruenbacher err = drbd_recv_all(mdev->tconn, p->head.payload, data_size); 379382bc0194SAndreas Gruenbacher if (err) 3794b411b363SPhilipp Reisner goto out; 3795004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3796004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 379782bc0194SAndreas Gruenbacher err = -EIO; 379878fcbdaeSAndreas Gruenbacher goto out; 3799b411b363SPhilipp Reisner } 3800c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3801b411b363SPhilipp Reisner } else { 380202918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 380382bc0194SAndreas Gruenbacher err = -EIO; 3804b411b363SPhilipp Reisner goto out; 3805b411b363SPhilipp Reisner } 3806b411b363SPhilipp Reisner 380702918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3808257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3809b411b363SPhilipp Reisner 38102c46407dSAndreas Gruenbacher if (err <= 0) { 38112c46407dSAndreas Gruenbacher if (err < 0) 38122c46407dSAndreas Gruenbacher goto out; 3813b411b363SPhilipp Reisner break; 38142c46407dSAndreas Gruenbacher } 381582bc0194SAndreas Gruenbacher err = drbd_recv_header(mdev->tconn, &pi); 381682bc0194SAndreas Gruenbacher if (err) 3817b411b363SPhilipp Reisner goto out; 381877351055SPhilipp Reisner cmd = pi.cmd; 381977351055SPhilipp Reisner data_size = pi.size; 38202c46407dSAndreas Gruenbacher } 3821b411b363SPhilipp Reisner 3822b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3823b411b363SPhilipp Reisner 3824b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3825de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3826de1f8e4aSAndreas Gruenbacher 382782bc0194SAndreas Gruenbacher err = drbd_send_bitmap(mdev); 382882bc0194SAndreas Gruenbacher if (err) 3829b411b363SPhilipp Reisner goto out; 3830b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3831de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3832de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3833b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3834b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3835b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3836b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3837b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3838b411b363SPhilipp Reisner } 383982bc0194SAndreas Gruenbacher err = 0; 3840b411b363SPhilipp Reisner 3841b411b363SPhilipp Reisner out: 384220ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 384382bc0194SAndreas Gruenbacher if (!err && mdev->state.conn == C_WF_BITMAP_S) 3844b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3845b411b363SPhilipp Reisner free_page((unsigned long) buffer); 384682bc0194SAndreas Gruenbacher return err; 3847b411b363SPhilipp Reisner } 3848b411b363SPhilipp Reisner 38492de876efSPhilipp Reisner static int _tconn_receive_skip(struct drbd_tconn *tconn, unsigned int data_size) 3850b411b363SPhilipp Reisner { 3851b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3852b411b363SPhilipp Reisner static char sink[128]; 3853b411b363SPhilipp Reisner int size, want, r; 3854b411b363SPhilipp Reisner 385502918be2SPhilipp Reisner size = data_size; 3856b411b363SPhilipp Reisner while (size > 0) { 3857b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 38582de876efSPhilipp Reisner r = drbd_recv(tconn, sink, want); 38592de876efSPhilipp Reisner if (r <= 0) 3860841ce241SAndreas Gruenbacher break; 3861b411b363SPhilipp Reisner size -= r; 3862b411b363SPhilipp Reisner } 386382bc0194SAndreas Gruenbacher return size ? -EIO : 0; 3864b411b363SPhilipp Reisner } 3865b411b363SPhilipp Reisner 38662de876efSPhilipp Reisner static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 38672de876efSPhilipp Reisner unsigned int data_size) 38682de876efSPhilipp Reisner { 38692de876efSPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 38702de876efSPhilipp Reisner cmd, data_size); 38712de876efSPhilipp Reisner 38722de876efSPhilipp Reisner return _tconn_receive_skip(mdev->tconn, data_size); 38732de876efSPhilipp Reisner } 38742de876efSPhilipp Reisner 38752de876efSPhilipp Reisner static int tconn_receive_skip(struct drbd_tconn *tconn, enum drbd_packet cmd, unsigned int data_size) 38762de876efSPhilipp Reisner { 38772de876efSPhilipp Reisner conn_warn(tconn, "skipping packet for non existing volume type %d, l: %d!\n", 38782de876efSPhilipp Reisner cmd, data_size); 38792de876efSPhilipp Reisner 38802de876efSPhilipp Reisner return _tconn_receive_skip(tconn, data_size); 38812de876efSPhilipp Reisner } 38822de876efSPhilipp Reisner 3883d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3884d8763023SAndreas Gruenbacher unsigned int data_size) 3885b411b363SPhilipp Reisner { 3886b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3887b411b363SPhilipp Reisner * with the data requests being unplugged */ 3888e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3889b411b363SPhilipp Reisner 389082bc0194SAndreas Gruenbacher return 0; 3891b411b363SPhilipp Reisner } 3892b411b363SPhilipp Reisner 3893d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3894d8763023SAndreas Gruenbacher unsigned int data_size) 389573a01a18SPhilipp Reisner { 3896e6ef8a5cSAndreas Gruenbacher struct p_block_desc *p = mdev->tconn->data.rbuf; 389773a01a18SPhilipp Reisner 3898f735e363SLars Ellenberg switch (mdev->state.conn) { 3899f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3900f735e363SLars Ellenberg case C_WF_BITMAP_T: 3901f735e363SLars Ellenberg case C_BEHIND: 3902f735e363SLars Ellenberg break; 3903f735e363SLars Ellenberg default: 3904f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3905f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3906f735e363SLars Ellenberg } 3907f735e363SLars Ellenberg 390873a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 390973a01a18SPhilipp Reisner 391082bc0194SAndreas Gruenbacher return 0; 391173a01a18SPhilipp Reisner } 391273a01a18SPhilipp Reisner 391302918be2SPhilipp Reisner struct data_cmd { 391402918be2SPhilipp Reisner int expect_payload; 391502918be2SPhilipp Reisner size_t pkt_size; 3916a4fbda8eSPhilipp Reisner enum mdev_or_conn fa_type; /* first argument's type */ 3917d9ae84e7SPhilipp Reisner union { 3918d9ae84e7SPhilipp Reisner int (*mdev_fn)(struct drbd_conf *, enum drbd_packet cmd, 3919d9ae84e7SPhilipp Reisner unsigned int to_receive); 3920d9ae84e7SPhilipp Reisner int (*conn_fn)(struct drbd_tconn *, enum drbd_packet cmd, 3921d9ae84e7SPhilipp Reisner unsigned int to_receive); 3922d9ae84e7SPhilipp Reisner }; 3923b411b363SPhilipp Reisner }; 3924b411b363SPhilipp Reisner 392502918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 3926d9ae84e7SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), MDEV, { receive_Data } }, 3927d9ae84e7SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_DataReply } }, 3928d9ae84e7SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_RSDataReply } } , 3929d9ae84e7SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), MDEV, { receive_Barrier } } , 3930d9ae84e7SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3931d9ae84e7SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3932d9ae84e7SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), MDEV, { receive_UnplugRemote } }, 3933d9ae84e7SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3934d9ae84e7SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3935d9ae84e7SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 3936d9ae84e7SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 39377204624cSPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), CONN, { .conn_fn = receive_protocol } }, 3938d9ae84e7SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), MDEV, { receive_uuids } }, 3939d9ae84e7SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), MDEV, { receive_sizes } }, 3940d9ae84e7SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), MDEV, { receive_state } }, 3941d9ae84e7SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), MDEV, { receive_req_state } }, 3942d9ae84e7SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), MDEV, { receive_sync_uuid } }, 3943d9ae84e7SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3944d9ae84e7SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3945d9ae84e7SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3946d9ae84e7SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), MDEV, { receive_skip } }, 3947d9ae84e7SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), MDEV, { receive_out_of_sync } }, 3948dfafcc8aSPhilipp Reisner [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), CONN, { .conn_fn = receive_req_conn_state } }, 394902918be2SPhilipp Reisner }; 395002918be2SPhilipp Reisner 3951eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 3952b411b363SPhilipp Reisner { 3953e6ef8a5cSAndreas Gruenbacher struct p_header *header = tconn->data.rbuf; 395477351055SPhilipp Reisner struct packet_info pi; 395502918be2SPhilipp Reisner size_t shs; /* sub header size */ 395682bc0194SAndreas Gruenbacher int err; 3957b411b363SPhilipp Reisner 3958eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 3959eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 396069bc7bc3SAndreas Gruenbacher if (drbd_recv_header(tconn, &pi)) 396102918be2SPhilipp Reisner goto err_out; 396202918be2SPhilipp Reisner 39636e849ce8SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || 3964d9ae84e7SPhilipp Reisner !drbd_cmd_handler[pi.cmd].mdev_fn)) { 3965eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 396602918be2SPhilipp Reisner goto err_out; 39670b33a916SLars Ellenberg } 3968b411b363SPhilipp Reisner 396977351055SPhilipp Reisner shs = drbd_cmd_handler[pi.cmd].pkt_size - sizeof(struct p_header); 397077351055SPhilipp Reisner if (pi.size - shs > 0 && !drbd_cmd_handler[pi.cmd].expect_payload) { 3971eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 3972c13f7e1aSLars Ellenberg goto err_out; 3973c13f7e1aSLars Ellenberg } 3974c13f7e1aSLars Ellenberg 3975c13f7e1aSLars Ellenberg if (shs) { 3976a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, &header->payload, shs); 3977a5c31904SAndreas Gruenbacher if (err) 397802918be2SPhilipp Reisner goto err_out; 3979b411b363SPhilipp Reisner } 398002918be2SPhilipp Reisner 3981a4fbda8eSPhilipp Reisner if (drbd_cmd_handler[pi.cmd].fa_type == CONN) { 398282bc0194SAndreas Gruenbacher err = drbd_cmd_handler[pi.cmd].conn_fn(tconn, pi.cmd, pi.size - shs); 3983d9ae84e7SPhilipp Reisner } else { 3984d9ae84e7SPhilipp Reisner struct drbd_conf *mdev = vnr_to_mdev(tconn, pi.vnr); 398582bc0194SAndreas Gruenbacher err = mdev ? 3986d9ae84e7SPhilipp Reisner drbd_cmd_handler[pi.cmd].mdev_fn(mdev, pi.cmd, pi.size - shs) : 39872de876efSPhilipp Reisner tconn_receive_skip(tconn, pi.cmd, pi.size - shs); 3988d9ae84e7SPhilipp Reisner } 398902918be2SPhilipp Reisner 399082bc0194SAndreas Gruenbacher if (unlikely(err)) { 3991eefc2f7dSPhilipp Reisner conn_err(tconn, "error receiving %s, l: %d!\n", 399277351055SPhilipp Reisner cmdname(pi.cmd), pi.size); 399302918be2SPhilipp Reisner goto err_out; 3994b411b363SPhilipp Reisner } 3995b411b363SPhilipp Reisner } 399682bc0194SAndreas Gruenbacher return; 399702918be2SPhilipp Reisner 399802918be2SPhilipp Reisner err_out: 3999bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 4000b411b363SPhilipp Reisner } 4001b411b363SPhilipp Reisner 40020e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 4003b411b363SPhilipp Reisner { 4004b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 4005b411b363SPhilipp Reisner 4006b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 40070e29d163SPhilipp Reisner barr.w.tconn = tconn; 4008b411b363SPhilipp Reisner init_completion(&barr.done); 40090e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 4010b411b363SPhilipp Reisner wait_for_completion(&barr.done); 4011b411b363SPhilipp Reisner } 4012b411b363SPhilipp Reisner 4013360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 4014b411b363SPhilipp Reisner { 4015bbeb641cSPhilipp Reisner enum drbd_conns oc; 4016b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 4017b411b363SPhilipp Reisner 4018bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4019b411b363SPhilipp Reisner return; 4020b411b363SPhilipp Reisner 4021b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4022360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4023360cc740SPhilipp Reisner drbd_free_sock(tconn); 4024360cc740SPhilipp Reisner 4025360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 4026360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4027360cc740SPhilipp Reisner 4028cb703454SPhilipp Reisner if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN) 4029cb703454SPhilipp Reisner conn_try_outdate_peer_async(tconn); 4030cb703454SPhilipp Reisner 4031360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4032bbeb641cSPhilipp Reisner oc = tconn->cstate; 4033bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4034bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4035bbeb641cSPhilipp Reisner 4036360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4037360cc740SPhilipp Reisner 4038bbeb641cSPhilipp Reisner if (oc == C_DISCONNECTING) { 4039360cc740SPhilipp Reisner wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0); 4040360cc740SPhilipp Reisner 4041360cc740SPhilipp Reisner crypto_free_hash(tconn->cram_hmac_tfm); 4042360cc740SPhilipp Reisner tconn->cram_hmac_tfm = NULL; 4043360cc740SPhilipp Reisner 4044360cc740SPhilipp Reisner kfree(tconn->net_conf); 4045360cc740SPhilipp Reisner tconn->net_conf = NULL; 4046bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE); 4047360cc740SPhilipp Reisner } 4048360cc740SPhilipp Reisner } 4049360cc740SPhilipp Reisner 4050360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 4051360cc740SPhilipp Reisner { 4052360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 4053360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4054360cc740SPhilipp Reisner unsigned int i; 4055b411b363SPhilipp Reisner 405685719573SPhilipp Reisner /* wait for current activity to cease. */ 405787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4058b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4059b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4060b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 406187eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4062b411b363SPhilipp Reisner 4063b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4064b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4065b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4066b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4067b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4068b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4069b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4070b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4071b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4072b411b363SPhilipp Reisner * on the fly. */ 4073b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4074b411b363SPhilipp Reisner mdev->rs_total = 0; 4075b411b363SPhilipp Reisner mdev->rs_failed = 0; 4076b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4077b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4078b411b363SPhilipp Reisner 40797fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 40807fde2be9SPhilipp Reisner 4081b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4082b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4083b411b363SPhilipp Reisner 4084b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4085b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4086b411b363SPhilipp Reisner * to be "canceled" */ 4087a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4088b411b363SPhilipp Reisner 4089b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 4090b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 4091b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 4092b411b363SPhilipp Reisner 4093b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4094b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4095b411b363SPhilipp Reisner 4096fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 40972f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4098b411b363SPhilipp Reisner 4099b411b363SPhilipp Reisner drbd_md_sync(mdev); 4100b411b363SPhilipp Reisner 4101b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4102b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4103b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 4104b411b363SPhilipp Reisner put_ldev(mdev); 4105b411b363SPhilipp Reisner } 4106b411b363SPhilipp Reisner 410720ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 410820ceb2b2SLars Ellenberg * if any. */ 410920ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 411020ceb2b2SLars Ellenberg 4111b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4112b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4113b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4114b411b363SPhilipp Reisner * 4115b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4116b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4117b411b363SPhilipp Reisner */ 4118b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 4119b411b363SPhilipp Reisner if (i) 4120b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4121435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4122435f0740SLars Ellenberg if (i) 4123435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4124b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4125b411b363SPhilipp Reisner if (i) 412645bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4127b411b363SPhilipp Reisner 4128b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4129b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4130b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4131b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4132b411b363SPhilipp Reisner 4133b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4134b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4135b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4136360cc740SPhilipp Reisner 4137360cc740SPhilipp Reisner return 0; 4138b411b363SPhilipp Reisner } 4139b411b363SPhilipp Reisner 4140b411b363SPhilipp Reisner /* 4141b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4142b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4143b411b363SPhilipp Reisner * 4144b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4145b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4146b411b363SPhilipp Reisner * 4147b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4148b411b363SPhilipp Reisner */ 41498a22ccccSPhilipp Reisner static int drbd_send_handshake(struct drbd_tconn *tconn) 4150b411b363SPhilipp Reisner { 4151e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 41528a22ccccSPhilipp Reisner struct p_handshake *p = &tconn->data.sbuf.handshake; 4153e8d17b01SAndreas Gruenbacher int err; 4154b411b363SPhilipp Reisner 41558a22ccccSPhilipp Reisner if (mutex_lock_interruptible(&tconn->data.mutex)) { 41568a22ccccSPhilipp Reisner conn_err(tconn, "interrupted during initial handshake\n"); 4157e8d17b01SAndreas Gruenbacher return -EINTR; 4158b411b363SPhilipp Reisner } 4159b411b363SPhilipp Reisner 41608a22ccccSPhilipp Reisner if (tconn->data.socket == NULL) { 41618a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4162e8d17b01SAndreas Gruenbacher return -EIO; 4163b411b363SPhilipp Reisner } 4164b411b363SPhilipp Reisner 4165b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4166b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4167b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 4168e8d17b01SAndreas Gruenbacher err = _conn_send_cmd(tconn, 0, tconn->data.socket, P_HAND_SHAKE, 4169c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 41708a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4171e8d17b01SAndreas Gruenbacher return err; 4172b411b363SPhilipp Reisner } 4173b411b363SPhilipp Reisner 4174b411b363SPhilipp Reisner /* 4175b411b363SPhilipp Reisner * return values: 4176b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4177b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4178b411b363SPhilipp Reisner * -1 peer talks different language, 4179b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4180b411b363SPhilipp Reisner */ 418165d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn) 4182b411b363SPhilipp Reisner { 418365d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 4184e6ef8a5cSAndreas Gruenbacher struct p_handshake *p = tconn->data.rbuf; 418502918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 418677351055SPhilipp Reisner struct packet_info pi; 4187a5c31904SAndreas Gruenbacher int err; 4188b411b363SPhilipp Reisner 4189e8d17b01SAndreas Gruenbacher err = drbd_send_handshake(tconn); 4190e8d17b01SAndreas Gruenbacher if (err) 4191b411b363SPhilipp Reisner return 0; 4192b411b363SPhilipp Reisner 419369bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 419469bc7bc3SAndreas Gruenbacher if (err) 4195b411b363SPhilipp Reisner return 0; 4196b411b363SPhilipp Reisner 419777351055SPhilipp Reisner if (pi.cmd != P_HAND_SHAKE) { 419865d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake packet, received: %s (0x%04x)\n", 419977351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4200b411b363SPhilipp Reisner return -1; 4201b411b363SPhilipp Reisner } 4202b411b363SPhilipp Reisner 420377351055SPhilipp Reisner if (pi.size != expect) { 420465d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake length: %u, received: %u\n", 420577351055SPhilipp Reisner expect, pi.size); 4206b411b363SPhilipp Reisner return -1; 4207b411b363SPhilipp Reisner } 4208b411b363SPhilipp Reisner 4209a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, &p->head.payload, expect); 4210a5c31904SAndreas Gruenbacher if (err) 4211b411b363SPhilipp Reisner return 0; 4212b411b363SPhilipp Reisner 4213b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4214b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4215b411b363SPhilipp Reisner if (p->protocol_max == 0) 4216b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4217b411b363SPhilipp Reisner 4218b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4219b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4220b411b363SPhilipp Reisner goto incompat; 4221b411b363SPhilipp Reisner 422265d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4223b411b363SPhilipp Reisner 422465d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 422565d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4226b411b363SPhilipp Reisner 4227b411b363SPhilipp Reisner return 1; 4228b411b363SPhilipp Reisner 4229b411b363SPhilipp Reisner incompat: 423065d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4231b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4232b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4233b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4234b411b363SPhilipp Reisner return -1; 4235b411b363SPhilipp Reisner } 4236b411b363SPhilipp Reisner 4237b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 423813e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4239b411b363SPhilipp Reisner { 4240b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4241b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4242b10d96cbSJohannes Thoma return -1; 4243b411b363SPhilipp Reisner } 4244b411b363SPhilipp Reisner #else 4245b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4246b10d96cbSJohannes Thoma 4247b10d96cbSJohannes Thoma /* Return value: 4248b10d96cbSJohannes Thoma 1 - auth succeeded, 4249b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4250b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4251b10d96cbSJohannes Thoma */ 4252b10d96cbSJohannes Thoma 425313e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4254b411b363SPhilipp Reisner { 4255b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4256b411b363SPhilipp Reisner struct scatterlist sg; 4257b411b363SPhilipp Reisner char *response = NULL; 4258b411b363SPhilipp Reisner char *right_response = NULL; 4259b411b363SPhilipp Reisner char *peers_ch = NULL; 426013e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4261b411b363SPhilipp Reisner unsigned int resp_size; 4262b411b363SPhilipp Reisner struct hash_desc desc; 426377351055SPhilipp Reisner struct packet_info pi; 426469bc7bc3SAndreas Gruenbacher int err, rv; 4265b411b363SPhilipp Reisner 426613e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4267b411b363SPhilipp Reisner desc.flags = 0; 4268b411b363SPhilipp Reisner 426913e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 427013e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4271b411b363SPhilipp Reisner if (rv) { 427213e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4273b10d96cbSJohannes Thoma rv = -1; 4274b411b363SPhilipp Reisner goto fail; 4275b411b363SPhilipp Reisner } 4276b411b363SPhilipp Reisner 4277b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4278b411b363SPhilipp Reisner 4279ce9879cbSAndreas Gruenbacher rv = !conn_send_cmd2(tconn, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4280b411b363SPhilipp Reisner if (!rv) 4281b411b363SPhilipp Reisner goto fail; 4282b411b363SPhilipp Reisner 428369bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 428469bc7bc3SAndreas Gruenbacher if (err) { 428569bc7bc3SAndreas Gruenbacher rv = 0; 4286b411b363SPhilipp Reisner goto fail; 428769bc7bc3SAndreas Gruenbacher } 4288b411b363SPhilipp Reisner 428977351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 429013e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 429177351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4292b411b363SPhilipp Reisner rv = 0; 4293b411b363SPhilipp Reisner goto fail; 4294b411b363SPhilipp Reisner } 4295b411b363SPhilipp Reisner 429677351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 429713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4298b10d96cbSJohannes Thoma rv = -1; 4299b411b363SPhilipp Reisner goto fail; 4300b411b363SPhilipp Reisner } 4301b411b363SPhilipp Reisner 430277351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4303b411b363SPhilipp Reisner if (peers_ch == NULL) { 430413e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4305b10d96cbSJohannes Thoma rv = -1; 4306b411b363SPhilipp Reisner goto fail; 4307b411b363SPhilipp Reisner } 4308b411b363SPhilipp Reisner 4309a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, peers_ch, pi.size); 4310a5c31904SAndreas Gruenbacher if (err) { 4311b411b363SPhilipp Reisner rv = 0; 4312b411b363SPhilipp Reisner goto fail; 4313b411b363SPhilipp Reisner } 4314b411b363SPhilipp Reisner 431513e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4316b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4317b411b363SPhilipp Reisner if (response == NULL) { 431813e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4319b10d96cbSJohannes Thoma rv = -1; 4320b411b363SPhilipp Reisner goto fail; 4321b411b363SPhilipp Reisner } 4322b411b363SPhilipp Reisner 4323b411b363SPhilipp Reisner sg_init_table(&sg, 1); 432477351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4325b411b363SPhilipp Reisner 4326b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4327b411b363SPhilipp Reisner if (rv) { 432813e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4329b10d96cbSJohannes Thoma rv = -1; 4330b411b363SPhilipp Reisner goto fail; 4331b411b363SPhilipp Reisner } 4332b411b363SPhilipp Reisner 4333ce9879cbSAndreas Gruenbacher rv = !conn_send_cmd2(tconn, P_AUTH_RESPONSE, response, resp_size); 4334b411b363SPhilipp Reisner if (!rv) 4335b411b363SPhilipp Reisner goto fail; 4336b411b363SPhilipp Reisner 433769bc7bc3SAndreas Gruenbacher err = drbd_recv_header(tconn, &pi); 433869bc7bc3SAndreas Gruenbacher if (err) { 433969bc7bc3SAndreas Gruenbacher rv = 0; 4340b411b363SPhilipp Reisner goto fail; 434169bc7bc3SAndreas Gruenbacher } 4342b411b363SPhilipp Reisner 434377351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 434413e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 434577351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4346b411b363SPhilipp Reisner rv = 0; 4347b411b363SPhilipp Reisner goto fail; 4348b411b363SPhilipp Reisner } 4349b411b363SPhilipp Reisner 435077351055SPhilipp Reisner if (pi.size != resp_size) { 435113e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4352b411b363SPhilipp Reisner rv = 0; 4353b411b363SPhilipp Reisner goto fail; 4354b411b363SPhilipp Reisner } 4355b411b363SPhilipp Reisner 4356a5c31904SAndreas Gruenbacher err = drbd_recv_all_warn(tconn, response , resp_size); 4357a5c31904SAndreas Gruenbacher if (err) { 4358b411b363SPhilipp Reisner rv = 0; 4359b411b363SPhilipp Reisner goto fail; 4360b411b363SPhilipp Reisner } 4361b411b363SPhilipp Reisner 4362b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 43632d1ee87dSJulia Lawall if (right_response == NULL) { 436413e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4365b10d96cbSJohannes Thoma rv = -1; 4366b411b363SPhilipp Reisner goto fail; 4367b411b363SPhilipp Reisner } 4368b411b363SPhilipp Reisner 4369b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4370b411b363SPhilipp Reisner 4371b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4372b411b363SPhilipp Reisner if (rv) { 437313e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4374b10d96cbSJohannes Thoma rv = -1; 4375b411b363SPhilipp Reisner goto fail; 4376b411b363SPhilipp Reisner } 4377b411b363SPhilipp Reisner 4378b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4379b411b363SPhilipp Reisner 4380b411b363SPhilipp Reisner if (rv) 438113e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 438213e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4383b10d96cbSJohannes Thoma else 4384b10d96cbSJohannes Thoma rv = -1; 4385b411b363SPhilipp Reisner 4386b411b363SPhilipp Reisner fail: 4387b411b363SPhilipp Reisner kfree(peers_ch); 4388b411b363SPhilipp Reisner kfree(response); 4389b411b363SPhilipp Reisner kfree(right_response); 4390b411b363SPhilipp Reisner 4391b411b363SPhilipp Reisner return rv; 4392b411b363SPhilipp Reisner } 4393b411b363SPhilipp Reisner #endif 4394b411b363SPhilipp Reisner 4395b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4396b411b363SPhilipp Reisner { 4397392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4398b411b363SPhilipp Reisner int h; 4399b411b363SPhilipp Reisner 44004d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4401b411b363SPhilipp Reisner 4402b411b363SPhilipp Reisner do { 44034d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4404b411b363SPhilipp Reisner if (h == 0) { 44054d641dd7SPhilipp Reisner drbd_disconnect(tconn); 440620ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4407b411b363SPhilipp Reisner } 4408b411b363SPhilipp Reisner if (h == -1) { 44094d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4410bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4411b411b363SPhilipp Reisner } 4412b411b363SPhilipp Reisner } while (h == 0); 4413b411b363SPhilipp Reisner 4414b411b363SPhilipp Reisner if (h > 0) { 44154d641dd7SPhilipp Reisner if (get_net_conf(tconn)) { 44164d641dd7SPhilipp Reisner drbdd(tconn); 44174d641dd7SPhilipp Reisner put_net_conf(tconn); 4418b411b363SPhilipp Reisner } 4419b411b363SPhilipp Reisner } 4420b411b363SPhilipp Reisner 44214d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4422b411b363SPhilipp Reisner 44234d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4424b411b363SPhilipp Reisner return 0; 4425b411b363SPhilipp Reisner } 4426b411b363SPhilipp Reisner 4427b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4428b411b363SPhilipp Reisner 4429e4f78edeSPhilipp Reisner static int got_conn_RqSReply(struct drbd_tconn *tconn, enum drbd_packet cmd) 4430b411b363SPhilipp Reisner { 4431e6ef8a5cSAndreas Gruenbacher struct p_req_state_reply *p = tconn->meta.rbuf; 4432b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4433b411b363SPhilipp Reisner 4434fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4435fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4436fc3b10a4SPhilipp Reisner } else { 4437fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4438fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4439fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4440fc3b10a4SPhilipp Reisner } 4441fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4442e4f78edeSPhilipp Reisner 4443e4f78edeSPhilipp Reisner return true; 4444fc3b10a4SPhilipp Reisner } 4445e4f78edeSPhilipp Reisner 4446e4f78edeSPhilipp Reisner static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4447e4f78edeSPhilipp Reisner { 4448e6ef8a5cSAndreas Gruenbacher struct p_req_state_reply *p = mdev->tconn->meta.rbuf; 4449e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4450e4f78edeSPhilipp Reisner 4451e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4452e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4453e4f78edeSPhilipp Reisner } else { 4454e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4455e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4456e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4457e4f78edeSPhilipp Reisner } 4458e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4459e4f78edeSPhilipp Reisner 446081e84650SAndreas Gruenbacher return true; 4461b411b363SPhilipp Reisner } 4462b411b363SPhilipp Reisner 4463f19e4f8bSPhilipp Reisner static int got_Ping(struct drbd_tconn *tconn, enum drbd_packet cmd) 4464b411b363SPhilipp Reisner { 4465f19e4f8bSPhilipp Reisner return drbd_send_ping_ack(tconn); 4466b411b363SPhilipp Reisner 4467b411b363SPhilipp Reisner } 4468b411b363SPhilipp Reisner 4469f19e4f8bSPhilipp Reisner static int got_PingAck(struct drbd_tconn *tconn, enum drbd_packet cmd) 4470b411b363SPhilipp Reisner { 4471b411b363SPhilipp Reisner /* restore idle timeout */ 44722a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 44732a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 44742a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4475b411b363SPhilipp Reisner 447681e84650SAndreas Gruenbacher return true; 4477b411b363SPhilipp Reisner } 4478b411b363SPhilipp Reisner 4479d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4480b411b363SPhilipp Reisner { 4481e6ef8a5cSAndreas Gruenbacher struct p_block_ack *p = mdev->tconn->meta.rbuf; 4482b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4483b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4484b411b363SPhilipp Reisner 448531890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4486b411b363SPhilipp Reisner 4487b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4488b411b363SPhilipp Reisner 44891d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4490b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4491b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4492b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4493b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 44941d53f09eSLars Ellenberg put_ldev(mdev); 44951d53f09eSLars Ellenberg } 4496b411b363SPhilipp Reisner dec_rs_pending(mdev); 4497778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4498b411b363SPhilipp Reisner 449981e84650SAndreas Gruenbacher return true; 4500b411b363SPhilipp Reisner } 4501b411b363SPhilipp Reisner 4502bc9c5c41SAndreas Gruenbacher static int 4503bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4504bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4505bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4506b411b363SPhilipp Reisner { 4507b411b363SPhilipp Reisner struct drbd_request *req; 4508b411b363SPhilipp Reisner struct bio_and_error m; 4509b411b363SPhilipp Reisner 451087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4511bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4512b411b363SPhilipp Reisner if (unlikely(!req)) { 451387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 451481e84650SAndreas Gruenbacher return false; 4515b411b363SPhilipp Reisner } 4516b411b363SPhilipp Reisner __req_mod(req, what, &m); 451787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4518b411b363SPhilipp Reisner 4519b411b363SPhilipp Reisner if (m.bio) 4520b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 452181e84650SAndreas Gruenbacher return true; 4522b411b363SPhilipp Reisner } 4523b411b363SPhilipp Reisner 4524d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4525b411b363SPhilipp Reisner { 4526e6ef8a5cSAndreas Gruenbacher struct p_block_ack *p = mdev->tconn->meta.rbuf; 4527b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4528b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4529b411b363SPhilipp Reisner enum drbd_req_event what; 4530b411b363SPhilipp Reisner 4531b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4532b411b363SPhilipp Reisner 4533579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4534b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4535b411b363SPhilipp Reisner dec_rs_pending(mdev); 453681e84650SAndreas Gruenbacher return true; 4537b411b363SPhilipp Reisner } 4538257d0af6SPhilipp Reisner switch (cmd) { 4539b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 454089e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45418554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4542b411b363SPhilipp Reisner break; 4543b411b363SPhilipp Reisner case P_WRITE_ACK: 454489e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45458554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4546b411b363SPhilipp Reisner break; 4547b411b363SPhilipp Reisner case P_RECV_ACK: 454889e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 45498554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4550b411b363SPhilipp Reisner break; 45517be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 455289e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45537be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 45547be8da07SAndreas Gruenbacher break; 45557be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 45567be8da07SAndreas Gruenbacher D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45577be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4558b411b363SPhilipp Reisner break; 4559b411b363SPhilipp Reisner default: 4560b411b363SPhilipp Reisner D_ASSERT(0); 456181e84650SAndreas Gruenbacher return false; 4562b411b363SPhilipp Reisner } 4563b411b363SPhilipp Reisner 4564b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4565bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4566bc9c5c41SAndreas Gruenbacher what, false); 4567b411b363SPhilipp Reisner } 4568b411b363SPhilipp Reisner 4569d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4570b411b363SPhilipp Reisner { 4571e6ef8a5cSAndreas Gruenbacher struct p_block_ack *p = mdev->tconn->meta.rbuf; 4572b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 45732deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 457489e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 457589e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4576c3afd8f5SAndreas Gruenbacher bool found; 4577b411b363SPhilipp Reisner 4578b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4579b411b363SPhilipp Reisner 4580579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4581b411b363SPhilipp Reisner dec_rs_pending(mdev); 4582b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 458381e84650SAndreas Gruenbacher return true; 4584b411b363SPhilipp Reisner } 45852deb8336SPhilipp Reisner 4586c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4587bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 45888554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4589c3afd8f5SAndreas Gruenbacher if (!found) { 45902deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 45912deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4592c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 45932deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 45942deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4595c3afd8f5SAndreas Gruenbacher if (!missing_ok) 45962deb8336SPhilipp Reisner return false; 4597c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 45982deb8336SPhilipp Reisner } 45992deb8336SPhilipp Reisner return true; 4600b411b363SPhilipp Reisner } 4601b411b363SPhilipp Reisner 4602d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4603b411b363SPhilipp Reisner { 4604e6ef8a5cSAndreas Gruenbacher struct p_block_ack *p = mdev->tconn->meta.rbuf; 4605b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4606b411b363SPhilipp Reisner 4607b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 46087be8da07SAndreas Gruenbacher 4609b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4610b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4611b411b363SPhilipp Reisner 4612b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4613bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 46148554df1cSAndreas Gruenbacher NEG_ACKED, false); 4615b411b363SPhilipp Reisner } 4616b411b363SPhilipp Reisner 4617d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4618b411b363SPhilipp Reisner { 4619b411b363SPhilipp Reisner sector_t sector; 4620b411b363SPhilipp Reisner int size; 4621e6ef8a5cSAndreas Gruenbacher struct p_block_ack *p = mdev->tconn->meta.rbuf; 4622b411b363SPhilipp Reisner 4623b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4624b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4625b411b363SPhilipp Reisner 4626b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4627b411b363SPhilipp Reisner 4628b411b363SPhilipp Reisner dec_rs_pending(mdev); 4629b411b363SPhilipp Reisner 4630b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4631b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4632257d0af6SPhilipp Reisner switch (cmd) { 4633d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4634b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4635d612d309SPhilipp Reisner case P_RS_CANCEL: 4636d612d309SPhilipp Reisner break; 4637d612d309SPhilipp Reisner default: 4638d612d309SPhilipp Reisner D_ASSERT(0); 4639d612d309SPhilipp Reisner put_ldev(mdev); 4640d612d309SPhilipp Reisner return false; 4641d612d309SPhilipp Reisner } 4642b411b363SPhilipp Reisner put_ldev(mdev); 4643b411b363SPhilipp Reisner } 4644b411b363SPhilipp Reisner 464581e84650SAndreas Gruenbacher return true; 4646b411b363SPhilipp Reisner } 4647b411b363SPhilipp Reisner 4648d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4649b411b363SPhilipp Reisner { 4650e6ef8a5cSAndreas Gruenbacher struct p_barrier_ack *p = mdev->tconn->meta.rbuf; 4651b411b363SPhilipp Reisner 46522f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4653b411b363SPhilipp Reisner 4654c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4655c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4656370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4657370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4658370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4659c4752ef1SPhilipp Reisner } 4660c4752ef1SPhilipp Reisner 466181e84650SAndreas Gruenbacher return true; 4662b411b363SPhilipp Reisner } 4663b411b363SPhilipp Reisner 4664d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4665b411b363SPhilipp Reisner { 4666e6ef8a5cSAndreas Gruenbacher struct p_block_ack *p = mdev->tconn->meta.rbuf; 4667b411b363SPhilipp Reisner struct drbd_work *w; 4668b411b363SPhilipp Reisner sector_t sector; 4669b411b363SPhilipp Reisner int size; 4670b411b363SPhilipp Reisner 4671b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4672b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4673b411b363SPhilipp Reisner 4674b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4675b411b363SPhilipp Reisner 4676b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 46778f7bed77SAndreas Gruenbacher drbd_ov_out_of_sync_found(mdev, sector, size); 4678b411b363SPhilipp Reisner else 46798f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4680b411b363SPhilipp Reisner 46811d53f09eSLars Ellenberg if (!get_ldev(mdev)) 468281e84650SAndreas Gruenbacher return true; 46831d53f09eSLars Ellenberg 4684b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4685b411b363SPhilipp Reisner dec_rs_pending(mdev); 4686b411b363SPhilipp Reisner 4687ea5442afSLars Ellenberg --mdev->ov_left; 4688ea5442afSLars Ellenberg 4689ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4690ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4691ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4692ea5442afSLars Ellenberg 4693ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4694b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4695b411b363SPhilipp Reisner if (w) { 4696b411b363SPhilipp Reisner w->cb = w_ov_finished; 4697a21e9298SPhilipp Reisner w->mdev = mdev; 4698e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4699b411b363SPhilipp Reisner } else { 4700b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 47018f7bed77SAndreas Gruenbacher ov_out_of_sync_print(mdev); 4702b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4703b411b363SPhilipp Reisner } 4704b411b363SPhilipp Reisner } 47051d53f09eSLars Ellenberg put_ldev(mdev); 470681e84650SAndreas Gruenbacher return true; 4707b411b363SPhilipp Reisner } 4708b411b363SPhilipp Reisner 4709d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 47100ced55a3SPhilipp Reisner { 471181e84650SAndreas Gruenbacher return true; 47120ced55a3SPhilipp Reisner } 47130ced55a3SPhilipp Reisner 471432862ec7SPhilipp Reisner static int tconn_process_done_ee(struct drbd_tconn *tconn) 471532862ec7SPhilipp Reisner { 4716082a3439SPhilipp Reisner struct drbd_conf *mdev; 4717082a3439SPhilipp Reisner int i, not_empty = 0; 471832862ec7SPhilipp Reisner 471932862ec7SPhilipp Reisner do { 472032862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 472132862ec7SPhilipp Reisner flush_signals(current); 4722082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4723e2b3032bSAndreas Gruenbacher if (drbd_process_done_ee(mdev)) 4724082a3439SPhilipp Reisner return 1; /* error */ 4725082a3439SPhilipp Reisner } 472632862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 4727082a3439SPhilipp Reisner 4728082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4729082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4730082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 4731082a3439SPhilipp Reisner if (not_empty) 4732082a3439SPhilipp Reisner break; 4733082a3439SPhilipp Reisner } 4734082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 473532862ec7SPhilipp Reisner } while (not_empty); 473632862ec7SPhilipp Reisner 473732862ec7SPhilipp Reisner return 0; 473832862ec7SPhilipp Reisner } 473932862ec7SPhilipp Reisner 47407201b972SAndreas Gruenbacher struct asender_cmd { 47417201b972SAndreas Gruenbacher size_t pkt_size; 4742a4fbda8eSPhilipp Reisner enum mdev_or_conn fa_type; /* first argument's type */ 4743a4fbda8eSPhilipp Reisner union { 4744a4fbda8eSPhilipp Reisner int (*mdev_fn)(struct drbd_conf *mdev, enum drbd_packet cmd); 4745a4fbda8eSPhilipp Reisner int (*conn_fn)(struct drbd_tconn *tconn, enum drbd_packet cmd); 4746a4fbda8eSPhilipp Reisner }; 47477201b972SAndreas Gruenbacher }; 47487201b972SAndreas Gruenbacher 47497201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 4750f19e4f8bSPhilipp Reisner [P_PING] = { sizeof(struct p_header), CONN, { .conn_fn = got_Ping } }, 4751f19e4f8bSPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), CONN, { .conn_fn = got_PingAck } }, 4752a4fbda8eSPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4753a4fbda8eSPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4754a4fbda8eSPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4755a4fbda8eSPhilipp Reisner [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4756a4fbda8eSPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), MDEV, { got_NegAck } }, 4757a4fbda8eSPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), MDEV, { got_NegDReply } }, 4758a4fbda8eSPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), MDEV, { got_NegRSDReply } }, 4759a4fbda8eSPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), MDEV, { got_OVResult } }, 4760a4fbda8eSPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), MDEV, { got_BarrierAck } }, 4761a4fbda8eSPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), MDEV, { got_RqSReply } }, 4762a4fbda8eSPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), MDEV, { got_IsInSync } }, 4763a4fbda8eSPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), MDEV, { got_skip } }, 4764a4fbda8eSPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), MDEV, { got_NegRSDReply } }, 4765e4f78edeSPhilipp Reisner [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), CONN, {.conn_fn = got_conn_RqSReply}}, 4766a4fbda8eSPhilipp Reisner [P_RETRY_WRITE] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 47677201b972SAndreas Gruenbacher }; 47687201b972SAndreas Gruenbacher 4769b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4770b411b363SPhilipp Reisner { 4771392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4772e6ef8a5cSAndreas Gruenbacher struct p_header *h = tconn->meta.rbuf; 4773b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 477477351055SPhilipp Reisner struct packet_info pi; 4775257d0af6SPhilipp Reisner int rv; 4776b411b363SPhilipp Reisner void *buf = h; 4777b411b363SPhilipp Reisner int received = 0; 4778257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4779f36af18cSLars Ellenberg int ping_timeout_active = 0; 4780b411b363SPhilipp Reisner 4781b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4782b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4783b411b363SPhilipp Reisner 4784e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 478580822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 478632862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 47872a67d8b9SPhilipp Reisner if (!drbd_send_ping(tconn)) { 478832862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 4789841ce241SAndreas Gruenbacher goto reconnect; 4790841ce241SAndreas Gruenbacher } 479132862ec7SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = 479232862ec7SPhilipp Reisner tconn->net_conf->ping_timeo*HZ/10; 4793f36af18cSLars Ellenberg ping_timeout_active = 1; 4794b411b363SPhilipp Reisner } 4795b411b363SPhilipp Reisner 479632862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 479732862ec7SPhilipp Reisner much to send */ 479832862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 479932862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 4800082a3439SPhilipp Reisner if (tconn_process_done_ee(tconn)) { 4801082a3439SPhilipp Reisner conn_err(tconn, "tconn_process_done_ee() failed\n"); 4802b411b363SPhilipp Reisner goto reconnect; 4803082a3439SPhilipp Reisner } 4804b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 480532862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 480632862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 4807b411b363SPhilipp Reisner 4808b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4809b411b363SPhilipp Reisner if (signal_pending(current)) 4810b411b363SPhilipp Reisner continue; 4811b411b363SPhilipp Reisner 481232862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 481332862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4814b411b363SPhilipp Reisner 4815b411b363SPhilipp Reisner flush_signals(current); 4816b411b363SPhilipp Reisner 4817b411b363SPhilipp Reisner /* Note: 4818b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4819b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4820b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4821b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4822b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4823b411b363SPhilipp Reisner * rv == expected: full header or command 4824b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4825b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4826b411b363SPhilipp Reisner */ 4827b411b363SPhilipp Reisner if (likely(rv > 0)) { 4828b411b363SPhilipp Reisner received += rv; 4829b411b363SPhilipp Reisner buf += rv; 4830b411b363SPhilipp Reisner } else if (rv == 0) { 483132862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 4832b411b363SPhilipp Reisner goto reconnect; 4833b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4834cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4835cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 483632862ec7SPhilipp Reisner if (time_after(tconn->last_received, 483732862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 4838cb6518cbSLars Ellenberg continue; 4839f36af18cSLars Ellenberg if (ping_timeout_active) { 484032862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 4841b411b363SPhilipp Reisner goto reconnect; 4842b411b363SPhilipp Reisner } 484332862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 4844b411b363SPhilipp Reisner continue; 4845b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4846b411b363SPhilipp Reisner continue; 4847b411b363SPhilipp Reisner } else { 484832862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 4849b411b363SPhilipp Reisner goto reconnect; 4850b411b363SPhilipp Reisner } 4851b411b363SPhilipp Reisner 4852b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 48538172f3e9SAndreas Gruenbacher if (decode_header(tconn, h, &pi)) 4854b411b363SPhilipp Reisner goto reconnect; 48557201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 48567201b972SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd) { 485732862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 485877351055SPhilipp Reisner pi.cmd, pi.size); 4859b411b363SPhilipp Reisner goto disconnect; 4860b411b363SPhilipp Reisner } 4861b411b363SPhilipp Reisner expect = cmd->pkt_size; 486277351055SPhilipp Reisner if (pi.size != expect - sizeof(struct p_header)) { 486332862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 486477351055SPhilipp Reisner pi.cmd, pi.size); 4865b411b363SPhilipp Reisner goto reconnect; 4866b411b363SPhilipp Reisner } 4867257d0af6SPhilipp Reisner } 4868b411b363SPhilipp Reisner if (received == expect) { 4869a4fbda8eSPhilipp Reisner bool rv; 4870a4fbda8eSPhilipp Reisner 4871a4fbda8eSPhilipp Reisner if (cmd->fa_type == CONN) { 4872a4fbda8eSPhilipp Reisner rv = cmd->conn_fn(tconn, pi.cmd); 4873a4fbda8eSPhilipp Reisner } else { 4874a4fbda8eSPhilipp Reisner struct drbd_conf *mdev = vnr_to_mdev(tconn, pi.vnr); 4875a4fbda8eSPhilipp Reisner rv = cmd->mdev_fn(mdev, pi.cmd); 4876a4fbda8eSPhilipp Reisner } 4877a4fbda8eSPhilipp Reisner 4878a4fbda8eSPhilipp Reisner if (!rv) 4879b411b363SPhilipp Reisner goto reconnect; 4880b411b363SPhilipp Reisner 4881a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 4882a4fbda8eSPhilipp Reisner 4883f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4884f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 48857201b972SAndreas Gruenbacher if (cmd == &asender_tbl[P_PING_ACK]) 4886f36af18cSLars Ellenberg ping_timeout_active = 0; 4887f36af18cSLars Ellenberg 4888b411b363SPhilipp Reisner buf = h; 4889b411b363SPhilipp Reisner received = 0; 4890257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4891b411b363SPhilipp Reisner cmd = NULL; 4892b411b363SPhilipp Reisner } 4893b411b363SPhilipp Reisner } 4894b411b363SPhilipp Reisner 4895b411b363SPhilipp Reisner if (0) { 4896b411b363SPhilipp Reisner reconnect: 4897bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4898b411b363SPhilipp Reisner } 4899b411b363SPhilipp Reisner if (0) { 4900b411b363SPhilipp Reisner disconnect: 4901bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4902b411b363SPhilipp Reisner } 490332862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4904b411b363SPhilipp Reisner 490532862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 4906b411b363SPhilipp Reisner 4907b411b363SPhilipp Reisner return 0; 4908b411b363SPhilipp Reisner } 4909