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); 7300d56944SPhilipp Reisner 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; 412082a3439SPhilipp Reisner int ok = 1; 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) { 427b411b363SPhilipp Reisner /* list_del not necessary, next/prev members not touched */ 42800d56944SPhilipp Reisner ok = peer_req->w.cb(&peer_req->w, !ok) && ok; 429db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 430b411b363SPhilipp Reisner } 431b411b363SPhilipp Reisner wake_up(&mdev->ee_wait); 432b411b363SPhilipp Reisner 433b411b363SPhilipp Reisner return ok; 434b411b363SPhilipp Reisner } 435b411b363SPhilipp Reisner 436b411b363SPhilipp Reisner void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 437b411b363SPhilipp Reisner { 438b411b363SPhilipp Reisner DEFINE_WAIT(wait); 439b411b363SPhilipp Reisner 440b411b363SPhilipp Reisner /* avoids spin_lock/unlock 441b411b363SPhilipp Reisner * and calling prepare_to_wait in the fast path */ 442b411b363SPhilipp Reisner while (!list_empty(head)) { 443b411b363SPhilipp Reisner prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE); 44487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4457eaceaccSJens Axboe io_schedule(); 446b411b363SPhilipp Reisner finish_wait(&mdev->ee_wait, &wait); 44787eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 448b411b363SPhilipp Reisner } 449b411b363SPhilipp Reisner } 450b411b363SPhilipp Reisner 451b411b363SPhilipp Reisner void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head) 452b411b363SPhilipp Reisner { 45387eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 454b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, head); 45587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 456b411b363SPhilipp Reisner } 457b411b363SPhilipp Reisner 458b411b363SPhilipp Reisner /* see also kernel_accept; which is only present since 2.6.18. 459b411b363SPhilipp Reisner * also we want to log which part of it failed, exactly */ 4607653620dSPhilipp Reisner static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock) 461b411b363SPhilipp Reisner { 462b411b363SPhilipp Reisner struct sock *sk = sock->sk; 463b411b363SPhilipp Reisner int err = 0; 464b411b363SPhilipp Reisner 465b411b363SPhilipp Reisner *what = "listen"; 466b411b363SPhilipp Reisner err = sock->ops->listen(sock, 5); 467b411b363SPhilipp Reisner if (err < 0) 468b411b363SPhilipp Reisner goto out; 469b411b363SPhilipp Reisner 470b411b363SPhilipp Reisner *what = "sock_create_lite"; 471b411b363SPhilipp Reisner err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 472b411b363SPhilipp Reisner newsock); 473b411b363SPhilipp Reisner if (err < 0) 474b411b363SPhilipp Reisner goto out; 475b411b363SPhilipp Reisner 476b411b363SPhilipp Reisner *what = "accept"; 477b411b363SPhilipp Reisner err = sock->ops->accept(sock, *newsock, 0); 478b411b363SPhilipp Reisner if (err < 0) { 479b411b363SPhilipp Reisner sock_release(*newsock); 480b411b363SPhilipp Reisner *newsock = NULL; 481b411b363SPhilipp Reisner goto out; 482b411b363SPhilipp Reisner } 483b411b363SPhilipp Reisner (*newsock)->ops = sock->ops; 484b411b363SPhilipp Reisner 485b411b363SPhilipp Reisner out: 486b411b363SPhilipp Reisner return err; 487b411b363SPhilipp Reisner } 488b411b363SPhilipp Reisner 489dbd9eea0SPhilipp Reisner static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags) 490b411b363SPhilipp Reisner { 491b411b363SPhilipp Reisner mm_segment_t oldfs; 492b411b363SPhilipp Reisner struct kvec iov = { 493b411b363SPhilipp Reisner .iov_base = buf, 494b411b363SPhilipp Reisner .iov_len = size, 495b411b363SPhilipp Reisner }; 496b411b363SPhilipp Reisner struct msghdr msg = { 497b411b363SPhilipp Reisner .msg_iovlen = 1, 498b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 499b411b363SPhilipp Reisner .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL) 500b411b363SPhilipp Reisner }; 501b411b363SPhilipp Reisner int rv; 502b411b363SPhilipp Reisner 503b411b363SPhilipp Reisner oldfs = get_fs(); 504b411b363SPhilipp Reisner set_fs(KERNEL_DS); 505b411b363SPhilipp Reisner rv = sock_recvmsg(sock, &msg, size, msg.msg_flags); 506b411b363SPhilipp Reisner set_fs(oldfs); 507b411b363SPhilipp Reisner 508b411b363SPhilipp Reisner return rv; 509b411b363SPhilipp Reisner } 510b411b363SPhilipp Reisner 511de0ff338SPhilipp Reisner static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size) 512b411b363SPhilipp Reisner { 513b411b363SPhilipp Reisner mm_segment_t oldfs; 514b411b363SPhilipp Reisner struct kvec iov = { 515b411b363SPhilipp Reisner .iov_base = buf, 516b411b363SPhilipp Reisner .iov_len = size, 517b411b363SPhilipp Reisner }; 518b411b363SPhilipp Reisner struct msghdr msg = { 519b411b363SPhilipp Reisner .msg_iovlen = 1, 520b411b363SPhilipp Reisner .msg_iov = (struct iovec *)&iov, 521b411b363SPhilipp Reisner .msg_flags = MSG_WAITALL | MSG_NOSIGNAL 522b411b363SPhilipp Reisner }; 523b411b363SPhilipp Reisner int rv; 524b411b363SPhilipp Reisner 525b411b363SPhilipp Reisner oldfs = get_fs(); 526b411b363SPhilipp Reisner set_fs(KERNEL_DS); 527b411b363SPhilipp Reisner 528b411b363SPhilipp Reisner for (;;) { 529de0ff338SPhilipp Reisner rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags); 530b411b363SPhilipp Reisner if (rv == size) 531b411b363SPhilipp Reisner break; 532b411b363SPhilipp Reisner 533b411b363SPhilipp Reisner /* Note: 534b411b363SPhilipp Reisner * ECONNRESET other side closed the connection 535b411b363SPhilipp Reisner * ERESTARTSYS (on sock) we got a signal 536b411b363SPhilipp Reisner */ 537b411b363SPhilipp Reisner 538b411b363SPhilipp Reisner if (rv < 0) { 539b411b363SPhilipp Reisner if (rv == -ECONNRESET) 540de0ff338SPhilipp Reisner conn_info(tconn, "sock was reset by peer\n"); 541b411b363SPhilipp Reisner else if (rv != -ERESTARTSYS) 542de0ff338SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 543b411b363SPhilipp Reisner break; 544b411b363SPhilipp Reisner } else if (rv == 0) { 545de0ff338SPhilipp Reisner conn_info(tconn, "sock was shut down by peer\n"); 546b411b363SPhilipp Reisner break; 547b411b363SPhilipp Reisner } else { 548b411b363SPhilipp Reisner /* signal came in, or peer/link went down, 549b411b363SPhilipp Reisner * after we read a partial message 550b411b363SPhilipp Reisner */ 551b411b363SPhilipp Reisner /* D_ASSERT(signal_pending(current)); */ 552b411b363SPhilipp Reisner break; 553b411b363SPhilipp Reisner } 554b411b363SPhilipp Reisner }; 555b411b363SPhilipp Reisner 556b411b363SPhilipp Reisner set_fs(oldfs); 557b411b363SPhilipp Reisner 558b411b363SPhilipp Reisner if (rv != size) 559bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD); 560b411b363SPhilipp Reisner 561b411b363SPhilipp Reisner return rv; 562b411b363SPhilipp Reisner } 563b411b363SPhilipp Reisner 5645dbf1673SLars Ellenberg /* quoting tcp(7): 5655dbf1673SLars Ellenberg * On individual connections, the socket buffer size must be set prior to the 5665dbf1673SLars Ellenberg * listen(2) or connect(2) calls in order to have it take effect. 5675dbf1673SLars Ellenberg * This is our wrapper to do so. 5685dbf1673SLars Ellenberg */ 5695dbf1673SLars Ellenberg static void drbd_setbufsize(struct socket *sock, unsigned int snd, 5705dbf1673SLars Ellenberg unsigned int rcv) 5715dbf1673SLars Ellenberg { 5725dbf1673SLars Ellenberg /* open coded SO_SNDBUF, SO_RCVBUF */ 5735dbf1673SLars Ellenberg if (snd) { 5745dbf1673SLars Ellenberg sock->sk->sk_sndbuf = snd; 5755dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 5765dbf1673SLars Ellenberg } 5775dbf1673SLars Ellenberg if (rcv) { 5785dbf1673SLars Ellenberg sock->sk->sk_rcvbuf = rcv; 5795dbf1673SLars Ellenberg sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 5805dbf1673SLars Ellenberg } 5815dbf1673SLars Ellenberg } 5825dbf1673SLars Ellenberg 583eac3e990SPhilipp Reisner static struct socket *drbd_try_connect(struct drbd_tconn *tconn) 584b411b363SPhilipp Reisner { 585b411b363SPhilipp Reisner const char *what; 586b411b363SPhilipp Reisner struct socket *sock; 587b411b363SPhilipp Reisner struct sockaddr_in6 src_in6; 588b411b363SPhilipp Reisner int err; 589b411b363SPhilipp Reisner int disconnect_on_error = 1; 590b411b363SPhilipp Reisner 591eac3e990SPhilipp Reisner if (!get_net_conf(tconn)) 592b411b363SPhilipp Reisner return NULL; 593b411b363SPhilipp Reisner 594b411b363SPhilipp Reisner what = "sock_create_kern"; 595eac3e990SPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 596b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &sock); 597b411b363SPhilipp Reisner if (err < 0) { 598b411b363SPhilipp Reisner sock = NULL; 599b411b363SPhilipp Reisner goto out; 600b411b363SPhilipp Reisner } 601b411b363SPhilipp Reisner 602b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = 603eac3e990SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->try_connect_int*HZ; 604eac3e990SPhilipp Reisner drbd_setbufsize(sock, tconn->net_conf->sndbuf_size, 605eac3e990SPhilipp Reisner tconn->net_conf->rcvbuf_size); 606b411b363SPhilipp Reisner 607b411b363SPhilipp Reisner /* explicitly bind to the configured IP as source IP 608b411b363SPhilipp Reisner * for the outgoing connections. 609b411b363SPhilipp Reisner * This is needed for multihomed hosts and to be 610b411b363SPhilipp Reisner * able to use lo: interfaces for drbd. 611b411b363SPhilipp Reisner * Make sure to use 0 as port number, so linux selects 612b411b363SPhilipp Reisner * a free one dynamically. 613b411b363SPhilipp Reisner */ 614eac3e990SPhilipp Reisner memcpy(&src_in6, tconn->net_conf->my_addr, 615eac3e990SPhilipp Reisner min_t(int, tconn->net_conf->my_addr_len, sizeof(src_in6))); 616eac3e990SPhilipp Reisner if (((struct sockaddr *)tconn->net_conf->my_addr)->sa_family == AF_INET6) 617b411b363SPhilipp Reisner src_in6.sin6_port = 0; 618b411b363SPhilipp Reisner else 619b411b363SPhilipp Reisner ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */ 620b411b363SPhilipp Reisner 621b411b363SPhilipp Reisner what = "bind before connect"; 622b411b363SPhilipp Reisner err = sock->ops->bind(sock, 623b411b363SPhilipp Reisner (struct sockaddr *) &src_in6, 624eac3e990SPhilipp Reisner tconn->net_conf->my_addr_len); 625b411b363SPhilipp Reisner if (err < 0) 626b411b363SPhilipp Reisner goto out; 627b411b363SPhilipp Reisner 628b411b363SPhilipp Reisner /* connect may fail, peer not yet available. 629b411b363SPhilipp Reisner * stay C_WF_CONNECTION, don't go Disconnecting! */ 630b411b363SPhilipp Reisner disconnect_on_error = 0; 631b411b363SPhilipp Reisner what = "connect"; 632b411b363SPhilipp Reisner err = sock->ops->connect(sock, 633eac3e990SPhilipp Reisner (struct sockaddr *)tconn->net_conf->peer_addr, 634eac3e990SPhilipp Reisner tconn->net_conf->peer_addr_len, 0); 635b411b363SPhilipp Reisner 636b411b363SPhilipp Reisner out: 637b411b363SPhilipp Reisner if (err < 0) { 638b411b363SPhilipp Reisner if (sock) { 639b411b363SPhilipp Reisner sock_release(sock); 640b411b363SPhilipp Reisner sock = NULL; 641b411b363SPhilipp Reisner } 642b411b363SPhilipp Reisner switch (-err) { 643b411b363SPhilipp Reisner /* timeout, busy, signal pending */ 644b411b363SPhilipp Reisner case ETIMEDOUT: case EAGAIN: case EINPROGRESS: 645b411b363SPhilipp Reisner case EINTR: case ERESTARTSYS: 646b411b363SPhilipp Reisner /* peer not (yet) available, network problem */ 647b411b363SPhilipp Reisner case ECONNREFUSED: case ENETUNREACH: 648b411b363SPhilipp Reisner case EHOSTDOWN: case EHOSTUNREACH: 649b411b363SPhilipp Reisner disconnect_on_error = 0; 650b411b363SPhilipp Reisner break; 651b411b363SPhilipp Reisner default: 652eac3e990SPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 653b411b363SPhilipp Reisner } 654b411b363SPhilipp Reisner if (disconnect_on_error) 655bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 656b411b363SPhilipp Reisner } 657eac3e990SPhilipp Reisner put_net_conf(tconn); 658b411b363SPhilipp Reisner return sock; 659b411b363SPhilipp Reisner } 660b411b363SPhilipp Reisner 6617653620dSPhilipp Reisner static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn) 662b411b363SPhilipp Reisner { 663b411b363SPhilipp Reisner int timeo, err; 664b411b363SPhilipp Reisner struct socket *s_estab = NULL, *s_listen; 665b411b363SPhilipp Reisner const char *what; 666b411b363SPhilipp Reisner 6677653620dSPhilipp Reisner if (!get_net_conf(tconn)) 668b411b363SPhilipp Reisner return NULL; 669b411b363SPhilipp Reisner 670b411b363SPhilipp Reisner what = "sock_create_kern"; 6717653620dSPhilipp Reisner err = sock_create_kern(((struct sockaddr *)tconn->net_conf->my_addr)->sa_family, 672b411b363SPhilipp Reisner SOCK_STREAM, IPPROTO_TCP, &s_listen); 673b411b363SPhilipp Reisner if (err) { 674b411b363SPhilipp Reisner s_listen = NULL; 675b411b363SPhilipp Reisner goto out; 676b411b363SPhilipp Reisner } 677b411b363SPhilipp Reisner 6787653620dSPhilipp Reisner timeo = tconn->net_conf->try_connect_int * HZ; 679b411b363SPhilipp Reisner timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */ 680b411b363SPhilipp Reisner 681b411b363SPhilipp Reisner s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */ 682b411b363SPhilipp Reisner s_listen->sk->sk_rcvtimeo = timeo; 683b411b363SPhilipp Reisner s_listen->sk->sk_sndtimeo = timeo; 6847653620dSPhilipp Reisner drbd_setbufsize(s_listen, tconn->net_conf->sndbuf_size, 6857653620dSPhilipp Reisner tconn->net_conf->rcvbuf_size); 686b411b363SPhilipp Reisner 687b411b363SPhilipp Reisner what = "bind before listen"; 688b411b363SPhilipp Reisner err = s_listen->ops->bind(s_listen, 6897653620dSPhilipp Reisner (struct sockaddr *) tconn->net_conf->my_addr, 6907653620dSPhilipp Reisner tconn->net_conf->my_addr_len); 691b411b363SPhilipp Reisner if (err < 0) 692b411b363SPhilipp Reisner goto out; 693b411b363SPhilipp Reisner 6947653620dSPhilipp Reisner err = drbd_accept(&what, s_listen, &s_estab); 695b411b363SPhilipp Reisner 696b411b363SPhilipp Reisner out: 697b411b363SPhilipp Reisner if (s_listen) 698b411b363SPhilipp Reisner sock_release(s_listen); 699b411b363SPhilipp Reisner if (err < 0) { 700b411b363SPhilipp Reisner if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) { 7017653620dSPhilipp Reisner conn_err(tconn, "%s failed, err = %d\n", what, err); 702bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 703b411b363SPhilipp Reisner } 704b411b363SPhilipp Reisner } 7057653620dSPhilipp Reisner put_net_conf(tconn); 706b411b363SPhilipp Reisner 707b411b363SPhilipp Reisner return s_estab; 708b411b363SPhilipp Reisner } 709b411b363SPhilipp Reisner 710d38e787eSPhilipp Reisner static int drbd_send_fp(struct drbd_tconn *tconn, struct socket *sock, enum drbd_packet cmd) 711b411b363SPhilipp Reisner { 712d38e787eSPhilipp Reisner struct p_header *h = &tconn->data.sbuf.header; 713b411b363SPhilipp Reisner 714d38e787eSPhilipp Reisner return _conn_send_cmd(tconn, 0, sock, cmd, h, sizeof(*h), 0); 715b411b363SPhilipp Reisner } 716b411b363SPhilipp Reisner 717a25b63f1SPhilipp Reisner static enum drbd_packet drbd_recv_fp(struct drbd_tconn *tconn, struct socket *sock) 718b411b363SPhilipp Reisner { 719a25b63f1SPhilipp Reisner struct p_header80 *h = &tconn->data.rbuf.header.h80; 720b411b363SPhilipp Reisner int rr; 721b411b363SPhilipp Reisner 722dbd9eea0SPhilipp Reisner rr = drbd_recv_short(sock, h, sizeof(*h), 0); 723b411b363SPhilipp Reisner 724ca9bc12bSAndreas Gruenbacher if (rr == sizeof(*h) && h->magic == cpu_to_be32(DRBD_MAGIC)) 725b411b363SPhilipp Reisner return be16_to_cpu(h->command); 726b411b363SPhilipp Reisner 727b411b363SPhilipp Reisner return 0xffff; 728b411b363SPhilipp Reisner } 729b411b363SPhilipp Reisner 730b411b363SPhilipp Reisner /** 731b411b363SPhilipp Reisner * drbd_socket_okay() - Free the socket if its connection is not okay 732b411b363SPhilipp Reisner * @sock: pointer to the pointer to the socket. 733b411b363SPhilipp Reisner */ 734dbd9eea0SPhilipp Reisner static int drbd_socket_okay(struct socket **sock) 735b411b363SPhilipp Reisner { 736b411b363SPhilipp Reisner int rr; 737b411b363SPhilipp Reisner char tb[4]; 738b411b363SPhilipp Reisner 739b411b363SPhilipp Reisner if (!*sock) 74081e84650SAndreas Gruenbacher return false; 741b411b363SPhilipp Reisner 742dbd9eea0SPhilipp Reisner rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK); 743b411b363SPhilipp Reisner 744b411b363SPhilipp Reisner if (rr > 0 || rr == -EAGAIN) { 74581e84650SAndreas Gruenbacher return true; 746b411b363SPhilipp Reisner } else { 747b411b363SPhilipp Reisner sock_release(*sock); 748b411b363SPhilipp Reisner *sock = NULL; 74981e84650SAndreas Gruenbacher return false; 750b411b363SPhilipp Reisner } 751b411b363SPhilipp Reisner } 7522325eb66SPhilipp Reisner /* Gets called if a connection is established, or if a new minor gets created 7532325eb66SPhilipp Reisner in a connection */ 7542325eb66SPhilipp Reisner int drbd_connected(int vnr, void *p, void *data) 755907599e0SPhilipp Reisner { 756907599e0SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 757907599e0SPhilipp Reisner int ok = 1; 758907599e0SPhilipp Reisner 759907599e0SPhilipp Reisner atomic_set(&mdev->packet_seq, 0); 760907599e0SPhilipp Reisner mdev->peer_seq = 0; 761907599e0SPhilipp Reisner 7628410da8fSPhilipp Reisner mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ? 7638410da8fSPhilipp Reisner &mdev->tconn->cstate_mutex : 7648410da8fSPhilipp Reisner &mdev->own_state_mutex; 7658410da8fSPhilipp Reisner 766f399002eSLars Ellenberg ok &= drbd_send_sync_param(mdev); 767907599e0SPhilipp Reisner ok &= drbd_send_sizes(mdev, 0, 0); 768907599e0SPhilipp Reisner ok &= drbd_send_uuids(mdev); 769907599e0SPhilipp Reisner ok &= drbd_send_state(mdev); 770907599e0SPhilipp Reisner clear_bit(USE_DEGR_WFC_T, &mdev->flags); 771907599e0SPhilipp Reisner clear_bit(RESIZE_PENDING, &mdev->flags); 772907599e0SPhilipp Reisner 7738410da8fSPhilipp Reisner 774907599e0SPhilipp Reisner return !ok; 775907599e0SPhilipp Reisner } 776907599e0SPhilipp Reisner 777b411b363SPhilipp Reisner /* 778b411b363SPhilipp Reisner * return values: 779b411b363SPhilipp Reisner * 1 yes, we have a valid connection 780b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 781b411b363SPhilipp Reisner * -1 peer talks different language, 782b411b363SPhilipp Reisner * no point in trying again, please go standalone. 783b411b363SPhilipp Reisner * -2 We do not have a network config... 784b411b363SPhilipp Reisner */ 785907599e0SPhilipp Reisner static int drbd_connect(struct drbd_tconn *tconn) 786b411b363SPhilipp Reisner { 787b411b363SPhilipp Reisner struct socket *s, *sock, *msock; 788b411b363SPhilipp Reisner int try, h, ok; 789b411b363SPhilipp Reisner 790bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS) 791b411b363SPhilipp Reisner return -2; 792b411b363SPhilipp Reisner 793907599e0SPhilipp Reisner clear_bit(DISCARD_CONCURRENT, &tconn->flags); 794907599e0SPhilipp Reisner tconn->agreed_pro_version = 99; 795fd340c12SPhilipp Reisner /* agreed_pro_version must be smaller than 100 so we send the old 796fd340c12SPhilipp Reisner header (h80) in the first packet and in the handshake packet. */ 797b411b363SPhilipp Reisner 798b411b363SPhilipp Reisner sock = NULL; 799b411b363SPhilipp Reisner msock = NULL; 800b411b363SPhilipp Reisner 801b411b363SPhilipp Reisner do { 802b411b363SPhilipp Reisner for (try = 0;;) { 803b411b363SPhilipp Reisner /* 3 tries, this should take less than a second! */ 804907599e0SPhilipp Reisner s = drbd_try_connect(tconn); 805b411b363SPhilipp Reisner if (s || ++try >= 3) 806b411b363SPhilipp Reisner break; 807b411b363SPhilipp Reisner /* give the other side time to call bind() & listen() */ 80820ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ / 10); 809b411b363SPhilipp Reisner } 810b411b363SPhilipp Reisner 811b411b363SPhilipp Reisner if (s) { 812b411b363SPhilipp Reisner if (!sock) { 813907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_S); 814b411b363SPhilipp Reisner sock = s; 815b411b363SPhilipp Reisner s = NULL; 816b411b363SPhilipp Reisner } else if (!msock) { 817907599e0SPhilipp Reisner drbd_send_fp(tconn, s, P_HAND_SHAKE_M); 818b411b363SPhilipp Reisner msock = s; 819b411b363SPhilipp Reisner s = NULL; 820b411b363SPhilipp Reisner } else { 821907599e0SPhilipp Reisner conn_err(tconn, "Logic error in drbd_connect()\n"); 822b411b363SPhilipp Reisner goto out_release_sockets; 823b411b363SPhilipp Reisner } 824b411b363SPhilipp Reisner } 825b411b363SPhilipp Reisner 826b411b363SPhilipp Reisner if (sock && msock) { 827907599e0SPhilipp Reisner schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10); 828dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 829dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 830b411b363SPhilipp Reisner if (ok) 831b411b363SPhilipp Reisner break; 832b411b363SPhilipp Reisner } 833b411b363SPhilipp Reisner 834b411b363SPhilipp Reisner retry: 835907599e0SPhilipp Reisner s = drbd_wait_for_connect(tconn); 836b411b363SPhilipp Reisner if (s) { 837907599e0SPhilipp Reisner try = drbd_recv_fp(tconn, s); 838dbd9eea0SPhilipp Reisner drbd_socket_okay(&sock); 839dbd9eea0SPhilipp Reisner drbd_socket_okay(&msock); 840b411b363SPhilipp Reisner switch (try) { 841b411b363SPhilipp Reisner case P_HAND_SHAKE_S: 842b411b363SPhilipp Reisner if (sock) { 843907599e0SPhilipp Reisner conn_warn(tconn, "initial packet S crossed\n"); 844b411b363SPhilipp Reisner sock_release(sock); 845b411b363SPhilipp Reisner } 846b411b363SPhilipp Reisner sock = s; 847b411b363SPhilipp Reisner break; 848b411b363SPhilipp Reisner case P_HAND_SHAKE_M: 849b411b363SPhilipp Reisner if (msock) { 850907599e0SPhilipp Reisner conn_warn(tconn, "initial packet M crossed\n"); 851b411b363SPhilipp Reisner sock_release(msock); 852b411b363SPhilipp Reisner } 853b411b363SPhilipp Reisner msock = s; 854907599e0SPhilipp Reisner set_bit(DISCARD_CONCURRENT, &tconn->flags); 855b411b363SPhilipp Reisner break; 856b411b363SPhilipp Reisner default: 857907599e0SPhilipp Reisner conn_warn(tconn, "Error receiving initial packet\n"); 858b411b363SPhilipp Reisner sock_release(s); 859b411b363SPhilipp Reisner if (random32() & 1) 860b411b363SPhilipp Reisner goto retry; 861b411b363SPhilipp Reisner } 862b411b363SPhilipp Reisner } 863b411b363SPhilipp Reisner 864bbeb641cSPhilipp Reisner if (tconn->cstate <= C_DISCONNECTING) 865b411b363SPhilipp Reisner goto out_release_sockets; 866b411b363SPhilipp Reisner if (signal_pending(current)) { 867b411b363SPhilipp Reisner flush_signals(current); 868b411b363SPhilipp Reisner smp_rmb(); 869907599e0SPhilipp Reisner if (get_t_state(&tconn->receiver) == EXITING) 870b411b363SPhilipp Reisner goto out_release_sockets; 871b411b363SPhilipp Reisner } 872b411b363SPhilipp Reisner 873b411b363SPhilipp Reisner if (sock && msock) { 874dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&sock); 875dbd9eea0SPhilipp Reisner ok = drbd_socket_okay(&msock) && ok; 876b411b363SPhilipp Reisner if (ok) 877b411b363SPhilipp Reisner break; 878b411b363SPhilipp Reisner } 879b411b363SPhilipp Reisner } while (1); 880b411b363SPhilipp Reisner 881b411b363SPhilipp Reisner msock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 882b411b363SPhilipp Reisner sock->sk->sk_reuse = 1; /* SO_REUSEADDR */ 883b411b363SPhilipp Reisner 884b411b363SPhilipp Reisner sock->sk->sk_allocation = GFP_NOIO; 885b411b363SPhilipp Reisner msock->sk->sk_allocation = GFP_NOIO; 886b411b363SPhilipp Reisner 887b411b363SPhilipp Reisner sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK; 888b411b363SPhilipp Reisner msock->sk->sk_priority = TC_PRIO_INTERACTIVE; 889b411b363SPhilipp Reisner 890b411b363SPhilipp Reisner /* NOT YET ... 891907599e0SPhilipp Reisner * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 892b411b363SPhilipp Reisner * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 893b411b363SPhilipp Reisner * first set it to the P_HAND_SHAKE timeout, 894b411b363SPhilipp Reisner * which we set to 4x the configured ping_timeout. */ 895b411b363SPhilipp Reisner sock->sk->sk_sndtimeo = 896907599e0SPhilipp Reisner sock->sk->sk_rcvtimeo = tconn->net_conf->ping_timeo*4*HZ/10; 897b411b363SPhilipp Reisner 898907599e0SPhilipp Reisner msock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 899907599e0SPhilipp Reisner msock->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 900b411b363SPhilipp Reisner 901b411b363SPhilipp Reisner /* we don't want delays. 90225985edcSLucas De Marchi * we use TCP_CORK where appropriate, though */ 903b411b363SPhilipp Reisner drbd_tcp_nodelay(sock); 904b411b363SPhilipp Reisner drbd_tcp_nodelay(msock); 905b411b363SPhilipp Reisner 906907599e0SPhilipp Reisner tconn->data.socket = sock; 907907599e0SPhilipp Reisner tconn->meta.socket = msock; 908907599e0SPhilipp Reisner tconn->last_received = jiffies; 909b411b363SPhilipp Reisner 910907599e0SPhilipp Reisner h = drbd_do_handshake(tconn); 911b411b363SPhilipp Reisner if (h <= 0) 912b411b363SPhilipp Reisner return h; 913b411b363SPhilipp Reisner 914907599e0SPhilipp Reisner if (tconn->cram_hmac_tfm) { 915b411b363SPhilipp Reisner /* drbd_request_state(mdev, NS(conn, WFAuth)); */ 916907599e0SPhilipp Reisner switch (drbd_do_auth(tconn)) { 917b10d96cbSJohannes Thoma case -1: 918907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed\n"); 919b411b363SPhilipp Reisner return -1; 920b10d96cbSJohannes Thoma case 0: 921907599e0SPhilipp Reisner conn_err(tconn, "Authentication of peer failed, trying again.\n"); 922b10d96cbSJohannes Thoma return 0; 923b411b363SPhilipp Reisner } 924b411b363SPhilipp Reisner } 925b411b363SPhilipp Reisner 926bbeb641cSPhilipp Reisner if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS) 927b411b363SPhilipp Reisner return 0; 928b411b363SPhilipp Reisner 929907599e0SPhilipp Reisner sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10; 930b411b363SPhilipp Reisner sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT; 931b411b363SPhilipp Reisner 932907599e0SPhilipp Reisner drbd_thread_start(&tconn->asender); 933b411b363SPhilipp Reisner 934907599e0SPhilipp Reisner if (drbd_send_protocol(tconn) == -1) 9357e2455c1SPhilipp Reisner return -1; 936b411b363SPhilipp Reisner 937907599e0SPhilipp Reisner return !idr_for_each(&tconn->volumes, drbd_connected, tconn); 938b411b363SPhilipp Reisner 939b411b363SPhilipp Reisner out_release_sockets: 940b411b363SPhilipp Reisner if (sock) 941b411b363SPhilipp Reisner sock_release(sock); 942b411b363SPhilipp Reisner if (msock) 943b411b363SPhilipp Reisner sock_release(msock); 944b411b363SPhilipp Reisner return -1; 945b411b363SPhilipp Reisner } 946b411b363SPhilipp Reisner 947ce243853SPhilipp Reisner static bool decode_header(struct drbd_tconn *tconn, struct p_header *h, struct packet_info *pi) 948b411b363SPhilipp Reisner { 949fd340c12SPhilipp Reisner if (h->h80.magic == cpu_to_be32(DRBD_MAGIC)) { 95077351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h80.command); 95177351055SPhilipp Reisner pi->size = be16_to_cpu(h->h80.length); 952eefc2f7dSPhilipp Reisner pi->vnr = 0; 953ca9bc12bSAndreas Gruenbacher } else if (h->h95.magic == cpu_to_be16(DRBD_MAGIC_BIG)) { 95477351055SPhilipp Reisner pi->cmd = be16_to_cpu(h->h95.command); 95577351055SPhilipp Reisner pi->size = be32_to_cpu(h->h95.length) & 0x00ffffff; 95677351055SPhilipp Reisner pi->vnr = 0; 95702918be2SPhilipp Reisner } else { 958ce243853SPhilipp Reisner conn_err(tconn, "magic?? on data m: 0x%08x c: %d l: %d\n", 959004352faSLars Ellenberg be32_to_cpu(h->h80.magic), 960004352faSLars Ellenberg be16_to_cpu(h->h80.command), 961004352faSLars Ellenberg be16_to_cpu(h->h80.length)); 96281e84650SAndreas Gruenbacher return false; 963b411b363SPhilipp Reisner } 964257d0af6SPhilipp Reisner return true; 965257d0af6SPhilipp Reisner } 966257d0af6SPhilipp Reisner 9679ba7aa00SPhilipp Reisner static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi) 968257d0af6SPhilipp Reisner { 9699ba7aa00SPhilipp Reisner struct p_header *h = &tconn->data.rbuf.header; 970257d0af6SPhilipp Reisner int r; 971257d0af6SPhilipp Reisner 9729ba7aa00SPhilipp Reisner r = drbd_recv(tconn, h, sizeof(*h)); 973257d0af6SPhilipp Reisner if (unlikely(r != sizeof(*h))) { 974257d0af6SPhilipp Reisner if (!signal_pending(current)) 9759ba7aa00SPhilipp Reisner conn_warn(tconn, "short read expecting header on sock: r=%d\n", r); 976257d0af6SPhilipp Reisner return false; 977257d0af6SPhilipp Reisner } 978257d0af6SPhilipp Reisner 9799ba7aa00SPhilipp Reisner r = decode_header(tconn, h, pi); 9809ba7aa00SPhilipp Reisner tconn->last_received = jiffies; 981b411b363SPhilipp Reisner 982257d0af6SPhilipp Reisner return r; 983b411b363SPhilipp Reisner } 984b411b363SPhilipp Reisner 9852451fc3bSPhilipp Reisner static void drbd_flush(struct drbd_conf *mdev) 986b411b363SPhilipp Reisner { 987b411b363SPhilipp Reisner int rv; 988b411b363SPhilipp Reisner 989b411b363SPhilipp Reisner if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { 990fbd9b09aSDmitry Monakhov rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL, 991dd3932edSChristoph Hellwig NULL); 992b411b363SPhilipp Reisner if (rv) { 993b411b363SPhilipp Reisner dev_err(DEV, "local disk flush failed with status %d\n", rv); 994b411b363SPhilipp Reisner /* would rather check on EOPNOTSUPP, but that is not reliable. 995b411b363SPhilipp Reisner * don't try again for ANY return value != 0 996b411b363SPhilipp Reisner * if (rv == -EOPNOTSUPP) */ 997b411b363SPhilipp Reisner drbd_bump_write_ordering(mdev, WO_drain_io); 998b411b363SPhilipp Reisner } 999b411b363SPhilipp Reisner put_ldev(mdev); 1000b411b363SPhilipp Reisner } 1001b411b363SPhilipp Reisner } 1002b411b363SPhilipp Reisner 1003b411b363SPhilipp Reisner /** 1004b411b363SPhilipp Reisner * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it. 1005b411b363SPhilipp Reisner * @mdev: DRBD device. 1006b411b363SPhilipp Reisner * @epoch: Epoch object. 1007b411b363SPhilipp Reisner * @ev: Epoch event. 1008b411b363SPhilipp Reisner */ 1009b411b363SPhilipp Reisner static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev, 1010b411b363SPhilipp Reisner struct drbd_epoch *epoch, 1011b411b363SPhilipp Reisner enum epoch_event ev) 1012b411b363SPhilipp Reisner { 10132451fc3bSPhilipp Reisner int epoch_size; 1014b411b363SPhilipp Reisner struct drbd_epoch *next_epoch; 1015b411b363SPhilipp Reisner enum finish_epoch rv = FE_STILL_LIVE; 1016b411b363SPhilipp Reisner 1017b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1018b411b363SPhilipp Reisner do { 1019b411b363SPhilipp Reisner next_epoch = NULL; 1020b411b363SPhilipp Reisner 1021b411b363SPhilipp Reisner epoch_size = atomic_read(&epoch->epoch_size); 1022b411b363SPhilipp Reisner 1023b411b363SPhilipp Reisner switch (ev & ~EV_CLEANUP) { 1024b411b363SPhilipp Reisner case EV_PUT: 1025b411b363SPhilipp Reisner atomic_dec(&epoch->active); 1026b411b363SPhilipp Reisner break; 1027b411b363SPhilipp Reisner case EV_GOT_BARRIER_NR: 1028b411b363SPhilipp Reisner set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags); 1029b411b363SPhilipp Reisner break; 1030b411b363SPhilipp Reisner case EV_BECAME_LAST: 1031b411b363SPhilipp Reisner /* nothing to do*/ 1032b411b363SPhilipp Reisner break; 1033b411b363SPhilipp Reisner } 1034b411b363SPhilipp Reisner 1035b411b363SPhilipp Reisner if (epoch_size != 0 && 1036b411b363SPhilipp Reisner atomic_read(&epoch->active) == 0 && 10372451fc3bSPhilipp Reisner test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) { 1038b411b363SPhilipp Reisner if (!(ev & EV_CLEANUP)) { 1039b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1040b411b363SPhilipp Reisner drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size); 1041b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1042b411b363SPhilipp Reisner } 1043b411b363SPhilipp Reisner dec_unacked(mdev); 1044b411b363SPhilipp Reisner 1045b411b363SPhilipp Reisner if (mdev->current_epoch != epoch) { 1046b411b363SPhilipp Reisner next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list); 1047b411b363SPhilipp Reisner list_del(&epoch->list); 1048b411b363SPhilipp Reisner ev = EV_BECAME_LAST | (ev & EV_CLEANUP); 1049b411b363SPhilipp Reisner mdev->epochs--; 1050b411b363SPhilipp Reisner kfree(epoch); 1051b411b363SPhilipp Reisner 1052b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1053b411b363SPhilipp Reisner rv = FE_DESTROYED; 1054b411b363SPhilipp Reisner } else { 1055b411b363SPhilipp Reisner epoch->flags = 0; 1056b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1057698f9315SUwe Kleine-König /* atomic_set(&epoch->active, 0); is already zero */ 1058b411b363SPhilipp Reisner if (rv == FE_STILL_LIVE) 1059b411b363SPhilipp Reisner rv = FE_RECYCLED; 10602451fc3bSPhilipp Reisner wake_up(&mdev->ee_wait); 1061b411b363SPhilipp Reisner } 1062b411b363SPhilipp Reisner } 1063b411b363SPhilipp Reisner 1064b411b363SPhilipp Reisner if (!next_epoch) 1065b411b363SPhilipp Reisner break; 1066b411b363SPhilipp Reisner 1067b411b363SPhilipp Reisner epoch = next_epoch; 1068b411b363SPhilipp Reisner } while (1); 1069b411b363SPhilipp Reisner 1070b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1071b411b363SPhilipp Reisner 1072b411b363SPhilipp Reisner return rv; 1073b411b363SPhilipp Reisner } 1074b411b363SPhilipp Reisner 1075b411b363SPhilipp Reisner /** 1076b411b363SPhilipp Reisner * drbd_bump_write_ordering() - Fall back to an other write ordering method 1077b411b363SPhilipp Reisner * @mdev: DRBD device. 1078b411b363SPhilipp Reisner * @wo: Write ordering method to try. 1079b411b363SPhilipp Reisner */ 1080b411b363SPhilipp Reisner void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local) 1081b411b363SPhilipp Reisner { 1082b411b363SPhilipp Reisner enum write_ordering_e pwo; 1083b411b363SPhilipp Reisner static char *write_ordering_str[] = { 1084b411b363SPhilipp Reisner [WO_none] = "none", 1085b411b363SPhilipp Reisner [WO_drain_io] = "drain", 1086b411b363SPhilipp Reisner [WO_bdev_flush] = "flush", 1087b411b363SPhilipp Reisner }; 1088b411b363SPhilipp Reisner 1089b411b363SPhilipp Reisner pwo = mdev->write_ordering; 1090b411b363SPhilipp Reisner wo = min(pwo, wo); 1091b411b363SPhilipp Reisner if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush) 1092b411b363SPhilipp Reisner wo = WO_drain_io; 1093b411b363SPhilipp Reisner if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain) 1094b411b363SPhilipp Reisner wo = WO_none; 1095b411b363SPhilipp Reisner mdev->write_ordering = wo; 10962451fc3bSPhilipp Reisner if (pwo != mdev->write_ordering || wo == WO_bdev_flush) 1097b411b363SPhilipp Reisner dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]); 1098b411b363SPhilipp Reisner } 1099b411b363SPhilipp Reisner 1100b411b363SPhilipp Reisner /** 1101fbe29decSAndreas Gruenbacher * drbd_submit_peer_request() 110245bb912bSLars Ellenberg * @mdev: DRBD device. 1103db830c46SAndreas Gruenbacher * @peer_req: peer request 110445bb912bSLars Ellenberg * @rw: flag field, see bio->bi_rw 110510f6d992SLars Ellenberg * 110610f6d992SLars Ellenberg * May spread the pages to multiple bios, 110710f6d992SLars Ellenberg * depending on bio_add_page restrictions. 110810f6d992SLars Ellenberg * 110910f6d992SLars Ellenberg * Returns 0 if all bios have been submitted, 111010f6d992SLars Ellenberg * -ENOMEM if we could not allocate enough bios, 111110f6d992SLars Ellenberg * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a 111210f6d992SLars Ellenberg * single page to an empty bio (which should never happen and likely indicates 111310f6d992SLars Ellenberg * that the lower level IO stack is in some way broken). This has been observed 111410f6d992SLars Ellenberg * on certain Xen deployments. 111545bb912bSLars Ellenberg */ 111645bb912bSLars Ellenberg /* TODO allocate from our own bio_set. */ 1117fbe29decSAndreas Gruenbacher int drbd_submit_peer_request(struct drbd_conf *mdev, 1118fbe29decSAndreas Gruenbacher struct drbd_peer_request *peer_req, 111945bb912bSLars Ellenberg const unsigned rw, const int fault_type) 112045bb912bSLars Ellenberg { 112145bb912bSLars Ellenberg struct bio *bios = NULL; 112245bb912bSLars Ellenberg struct bio *bio; 1123db830c46SAndreas Gruenbacher struct page *page = peer_req->pages; 1124db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1125db830c46SAndreas Gruenbacher unsigned ds = peer_req->i.size; 112645bb912bSLars Ellenberg unsigned n_bios = 0; 112745bb912bSLars Ellenberg unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT; 112810f6d992SLars Ellenberg int err = -ENOMEM; 112945bb912bSLars Ellenberg 113045bb912bSLars Ellenberg /* In most cases, we will only need one bio. But in case the lower 113145bb912bSLars Ellenberg * level restrictions happen to be different at this offset on this 113245bb912bSLars Ellenberg * side than those of the sending peer, we may need to submit the 1133da4a75d2SLars Ellenberg * request in more than one bio. 1134da4a75d2SLars Ellenberg * 1135da4a75d2SLars Ellenberg * Plain bio_alloc is good enough here, this is no DRBD internally 1136da4a75d2SLars Ellenberg * generated bio, but a bio allocated on behalf of the peer. 1137da4a75d2SLars Ellenberg */ 113845bb912bSLars Ellenberg next_bio: 113945bb912bSLars Ellenberg bio = bio_alloc(GFP_NOIO, nr_pages); 114045bb912bSLars Ellenberg if (!bio) { 114145bb912bSLars Ellenberg dev_err(DEV, "submit_ee: Allocation of a bio failed\n"); 114245bb912bSLars Ellenberg goto fail; 114345bb912bSLars Ellenberg } 1144db830c46SAndreas Gruenbacher /* > peer_req->i.sector, unless this is the first bio */ 114545bb912bSLars Ellenberg bio->bi_sector = sector; 114645bb912bSLars Ellenberg bio->bi_bdev = mdev->ldev->backing_bdev; 114745bb912bSLars Ellenberg bio->bi_rw = rw; 1148db830c46SAndreas Gruenbacher bio->bi_private = peer_req; 1149fcefa62eSAndreas Gruenbacher bio->bi_end_io = drbd_peer_request_endio; 115045bb912bSLars Ellenberg 115145bb912bSLars Ellenberg bio->bi_next = bios; 115245bb912bSLars Ellenberg bios = bio; 115345bb912bSLars Ellenberg ++n_bios; 115445bb912bSLars Ellenberg 115545bb912bSLars Ellenberg page_chain_for_each(page) { 115645bb912bSLars Ellenberg unsigned len = min_t(unsigned, ds, PAGE_SIZE); 115745bb912bSLars Ellenberg if (!bio_add_page(bio, page, len, 0)) { 115810f6d992SLars Ellenberg /* A single page must always be possible! 115910f6d992SLars Ellenberg * But in case it fails anyways, 116010f6d992SLars Ellenberg * we deal with it, and complain (below). */ 116110f6d992SLars Ellenberg if (bio->bi_vcnt == 0) { 116210f6d992SLars Ellenberg dev_err(DEV, 116310f6d992SLars Ellenberg "bio_add_page failed for len=%u, " 116410f6d992SLars Ellenberg "bi_vcnt=0 (bi_sector=%llu)\n", 116510f6d992SLars Ellenberg len, (unsigned long long)bio->bi_sector); 116610f6d992SLars Ellenberg err = -ENOSPC; 116710f6d992SLars Ellenberg goto fail; 116810f6d992SLars Ellenberg } 116945bb912bSLars Ellenberg goto next_bio; 117045bb912bSLars Ellenberg } 117145bb912bSLars Ellenberg ds -= len; 117245bb912bSLars Ellenberg sector += len >> 9; 117345bb912bSLars Ellenberg --nr_pages; 117445bb912bSLars Ellenberg } 117545bb912bSLars Ellenberg D_ASSERT(page == NULL); 117645bb912bSLars Ellenberg D_ASSERT(ds == 0); 117745bb912bSLars Ellenberg 1178db830c46SAndreas Gruenbacher atomic_set(&peer_req->pending_bios, n_bios); 117945bb912bSLars Ellenberg do { 118045bb912bSLars Ellenberg bio = bios; 118145bb912bSLars Ellenberg bios = bios->bi_next; 118245bb912bSLars Ellenberg bio->bi_next = NULL; 118345bb912bSLars Ellenberg 118445bb912bSLars Ellenberg drbd_generic_make_request(mdev, fault_type, bio); 118545bb912bSLars Ellenberg } while (bios); 118645bb912bSLars Ellenberg return 0; 118745bb912bSLars Ellenberg 118845bb912bSLars Ellenberg fail: 118945bb912bSLars Ellenberg while (bios) { 119045bb912bSLars Ellenberg bio = bios; 119145bb912bSLars Ellenberg bios = bios->bi_next; 119245bb912bSLars Ellenberg bio_put(bio); 119345bb912bSLars Ellenberg } 119410f6d992SLars Ellenberg return err; 119545bb912bSLars Ellenberg } 119645bb912bSLars Ellenberg 119753840641SAndreas Gruenbacher static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev, 1198db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req) 119953840641SAndreas Gruenbacher { 1200db830c46SAndreas Gruenbacher struct drbd_interval *i = &peer_req->i; 120153840641SAndreas Gruenbacher 120253840641SAndreas Gruenbacher drbd_remove_interval(&mdev->write_requests, i); 120353840641SAndreas Gruenbacher drbd_clear_interval(i); 120453840641SAndreas Gruenbacher 12056c852becSAndreas Gruenbacher /* Wake up any processes waiting for this peer request to complete. */ 120653840641SAndreas Gruenbacher if (i->waiting) 120753840641SAndreas Gruenbacher wake_up(&mdev->misc_wait); 120853840641SAndreas Gruenbacher } 120953840641SAndreas Gruenbacher 1210d8763023SAndreas Gruenbacher static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packet cmd, 1211d8763023SAndreas Gruenbacher unsigned int data_size) 1212b411b363SPhilipp Reisner { 12132451fc3bSPhilipp Reisner int rv; 1214e42325a5SPhilipp Reisner struct p_barrier *p = &mdev->tconn->data.rbuf.barrier; 1215b411b363SPhilipp Reisner struct drbd_epoch *epoch; 1216b411b363SPhilipp Reisner 1217b411b363SPhilipp Reisner inc_unacked(mdev); 1218b411b363SPhilipp Reisner 1219b411b363SPhilipp Reisner mdev->current_epoch->barrier_nr = p->barrier; 1220b411b363SPhilipp Reisner rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR); 1221b411b363SPhilipp Reisner 1222b411b363SPhilipp Reisner /* P_BARRIER_ACK may imply that the corresponding extent is dropped from 1223b411b363SPhilipp Reisner * the activity log, which means it would not be resynced in case the 1224b411b363SPhilipp Reisner * R_PRIMARY crashes now. 1225b411b363SPhilipp Reisner * Therefore we must send the barrier_ack after the barrier request was 1226b411b363SPhilipp Reisner * completed. */ 1227b411b363SPhilipp Reisner switch (mdev->write_ordering) { 1228b411b363SPhilipp Reisner case WO_none: 1229b411b363SPhilipp Reisner if (rv == FE_RECYCLED) 123081e84650SAndreas Gruenbacher return true; 1231b411b363SPhilipp Reisner 1232b411b363SPhilipp Reisner /* receiver context, in the writeout path of the other node. 1233b411b363SPhilipp Reisner * avoid potential distributed deadlock */ 1234b411b363SPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12352451fc3bSPhilipp Reisner if (epoch) 12362451fc3bSPhilipp Reisner break; 12372451fc3bSPhilipp Reisner else 1238b411b363SPhilipp Reisner dev_warn(DEV, "Allocation of an epoch failed, slowing down\n"); 12392451fc3bSPhilipp Reisner /* Fall through */ 12402451fc3bSPhilipp Reisner 12412451fc3bSPhilipp Reisner case WO_bdev_flush: 12422451fc3bSPhilipp Reisner case WO_drain_io: 1243b411b363SPhilipp Reisner drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 12442451fc3bSPhilipp Reisner drbd_flush(mdev); 12452451fc3bSPhilipp Reisner 12462451fc3bSPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 12472451fc3bSPhilipp Reisner epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO); 12482451fc3bSPhilipp Reisner if (epoch) 12492451fc3bSPhilipp Reisner break; 1250b411b363SPhilipp Reisner } 1251b411b363SPhilipp Reisner 12522451fc3bSPhilipp Reisner epoch = mdev->current_epoch; 12532451fc3bSPhilipp Reisner wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0); 12542451fc3bSPhilipp Reisner 12552451fc3bSPhilipp Reisner D_ASSERT(atomic_read(&epoch->active) == 0); 12562451fc3bSPhilipp Reisner D_ASSERT(epoch->flags == 0); 1257b411b363SPhilipp Reisner 125881e84650SAndreas Gruenbacher return true; 12592451fc3bSPhilipp Reisner default: 12602451fc3bSPhilipp Reisner dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering); 126181e84650SAndreas Gruenbacher return false; 1262b411b363SPhilipp Reisner } 1263b411b363SPhilipp Reisner 1264b411b363SPhilipp Reisner epoch->flags = 0; 1265b411b363SPhilipp Reisner atomic_set(&epoch->epoch_size, 0); 1266b411b363SPhilipp Reisner atomic_set(&epoch->active, 0); 1267b411b363SPhilipp Reisner 1268b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 1269b411b363SPhilipp Reisner if (atomic_read(&mdev->current_epoch->epoch_size)) { 1270b411b363SPhilipp Reisner list_add(&epoch->list, &mdev->current_epoch->list); 1271b411b363SPhilipp Reisner mdev->current_epoch = epoch; 1272b411b363SPhilipp Reisner mdev->epochs++; 1273b411b363SPhilipp Reisner } else { 1274b411b363SPhilipp Reisner /* The current_epoch got recycled while we allocated this one... */ 1275b411b363SPhilipp Reisner kfree(epoch); 1276b411b363SPhilipp Reisner } 1277b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 1278b411b363SPhilipp Reisner 127981e84650SAndreas Gruenbacher return true; 1280b411b363SPhilipp Reisner } 1281b411b363SPhilipp Reisner 1282b411b363SPhilipp Reisner /* used from receive_RSDataReply (recv_resync_read) 1283b411b363SPhilipp Reisner * and from receive_Data */ 1284f6ffca9fSAndreas Gruenbacher static struct drbd_peer_request * 1285f6ffca9fSAndreas Gruenbacher read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, 1286f6ffca9fSAndreas Gruenbacher int data_size) __must_hold(local) 1287b411b363SPhilipp Reisner { 12886666032aSLars Ellenberg const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 1289db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1290b411b363SPhilipp Reisner struct page *page; 129145bb912bSLars Ellenberg int dgs, ds, rr; 1292a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1293a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 12946b4388acSPhilipp Reisner unsigned long *data; 1295b411b363SPhilipp Reisner 1296a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1297a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1298b411b363SPhilipp Reisner 1299b411b363SPhilipp Reisner if (dgs) { 1300de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1301b411b363SPhilipp Reisner if (rr != dgs) { 13020ddc5549SLars Ellenberg if (!signal_pending(current)) 13030ddc5549SLars Ellenberg dev_warn(DEV, 13040ddc5549SLars Ellenberg "short read receiving data digest: read %d expected %d\n", 1305b411b363SPhilipp Reisner rr, dgs); 1306b411b363SPhilipp Reisner return NULL; 1307b411b363SPhilipp Reisner } 1308b411b363SPhilipp Reisner } 1309b411b363SPhilipp Reisner 1310b411b363SPhilipp Reisner data_size -= dgs; 1311b411b363SPhilipp Reisner 1312841ce241SAndreas Gruenbacher if (!expect(data_size != 0)) 1313841ce241SAndreas Gruenbacher return NULL; 1314841ce241SAndreas Gruenbacher if (!expect(IS_ALIGNED(data_size, 512))) 1315841ce241SAndreas Gruenbacher return NULL; 1316841ce241SAndreas Gruenbacher if (!expect(data_size <= DRBD_MAX_BIO_SIZE)) 1317841ce241SAndreas Gruenbacher return NULL; 1318b411b363SPhilipp Reisner 13196666032aSLars Ellenberg /* even though we trust out peer, 13206666032aSLars Ellenberg * we sometimes have to double check. */ 13216666032aSLars Ellenberg if (sector + (data_size>>9) > capacity) { 1322fdda6544SLars Ellenberg dev_err(DEV, "request from peer beyond end of local disk: " 1323fdda6544SLars Ellenberg "capacity: %llus < sector: %llus + size: %u\n", 13246666032aSLars Ellenberg (unsigned long long)capacity, 13256666032aSLars Ellenberg (unsigned long long)sector, data_size); 13266666032aSLars Ellenberg return NULL; 13276666032aSLars Ellenberg } 13286666032aSLars Ellenberg 1329b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 1330b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 1331b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 1332db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO); 1333db830c46SAndreas Gruenbacher if (!peer_req) 1334b411b363SPhilipp Reisner return NULL; 133545bb912bSLars Ellenberg 1336b411b363SPhilipp Reisner ds = data_size; 1337db830c46SAndreas Gruenbacher page = peer_req->pages; 133845bb912bSLars Ellenberg page_chain_for_each(page) { 133945bb912bSLars Ellenberg unsigned len = min_t(int, ds, PAGE_SIZE); 13406b4388acSPhilipp Reisner data = kmap(page); 1341de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, len); 13420cf9d27eSAndreas Gruenbacher if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) { 13436b4388acSPhilipp Reisner dev_err(DEV, "Fault injection: Corrupting data on receive\n"); 13446b4388acSPhilipp Reisner data[0] = data[0] ^ (unsigned long)-1; 13456b4388acSPhilipp Reisner } 1346b411b363SPhilipp Reisner kunmap(page); 134745bb912bSLars Ellenberg if (rr != len) { 1348db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 13490ddc5549SLars Ellenberg if (!signal_pending(current)) 1350b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data: read %d expected %d\n", 135145bb912bSLars Ellenberg rr, len); 1352b411b363SPhilipp Reisner return NULL; 1353b411b363SPhilipp Reisner } 1354b411b363SPhilipp Reisner ds -= rr; 1355b411b363SPhilipp Reisner } 1356b411b363SPhilipp Reisner 1357b411b363SPhilipp Reisner if (dgs) { 1358db830c46SAndreas Gruenbacher drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv); 1359b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1360470be44aSLars Ellenberg dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n", 1361470be44aSLars Ellenberg (unsigned long long)sector, data_size); 1362db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 1363b411b363SPhilipp Reisner return NULL; 1364b411b363SPhilipp Reisner } 1365b411b363SPhilipp Reisner } 1366b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1367db830c46SAndreas Gruenbacher return peer_req; 1368b411b363SPhilipp Reisner } 1369b411b363SPhilipp Reisner 1370b411b363SPhilipp Reisner /* drbd_drain_block() just takes a data block 1371b411b363SPhilipp Reisner * out of the socket input buffer, and discards it. 1372b411b363SPhilipp Reisner */ 1373b411b363SPhilipp Reisner static int drbd_drain_block(struct drbd_conf *mdev, int data_size) 1374b411b363SPhilipp Reisner { 1375b411b363SPhilipp Reisner struct page *page; 1376b411b363SPhilipp Reisner int rr, rv = 1; 1377b411b363SPhilipp Reisner void *data; 1378b411b363SPhilipp Reisner 1379c3470cdeSLars Ellenberg if (!data_size) 138081e84650SAndreas Gruenbacher return true; 1381c3470cdeSLars Ellenberg 138245bb912bSLars Ellenberg page = drbd_pp_alloc(mdev, 1, 1); 1383b411b363SPhilipp Reisner 1384b411b363SPhilipp Reisner data = kmap(page); 1385b411b363SPhilipp Reisner while (data_size) { 1386de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, data, min_t(int, data_size, PAGE_SIZE)); 1387b411b363SPhilipp Reisner if (rr != min_t(int, data_size, PAGE_SIZE)) { 1388b411b363SPhilipp Reisner rv = 0; 13890ddc5549SLars Ellenberg if (!signal_pending(current)) 13900ddc5549SLars Ellenberg dev_warn(DEV, 13910ddc5549SLars Ellenberg "short read receiving data: read %d expected %d\n", 1392b411b363SPhilipp Reisner rr, min_t(int, data_size, PAGE_SIZE)); 1393b411b363SPhilipp Reisner break; 1394b411b363SPhilipp Reisner } 1395b411b363SPhilipp Reisner data_size -= rr; 1396b411b363SPhilipp Reisner } 1397b411b363SPhilipp Reisner kunmap(page); 1398435f0740SLars Ellenberg drbd_pp_free(mdev, page, 0); 1399b411b363SPhilipp Reisner return rv; 1400b411b363SPhilipp Reisner } 1401b411b363SPhilipp Reisner 1402b411b363SPhilipp Reisner static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req, 1403b411b363SPhilipp Reisner sector_t sector, int data_size) 1404b411b363SPhilipp Reisner { 1405b411b363SPhilipp Reisner struct bio_vec *bvec; 1406b411b363SPhilipp Reisner struct bio *bio; 1407b411b363SPhilipp Reisner int dgs, rr, i, expect; 1408a0638456SPhilipp Reisner void *dig_in = mdev->tconn->int_dig_in; 1409a0638456SPhilipp Reisner void *dig_vv = mdev->tconn->int_dig_vv; 1410b411b363SPhilipp Reisner 1411a0638456SPhilipp Reisner dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ? 1412a0638456SPhilipp Reisner crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0; 1413b411b363SPhilipp Reisner 1414b411b363SPhilipp Reisner if (dgs) { 1415de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, dig_in, dgs); 1416b411b363SPhilipp Reisner if (rr != dgs) { 14170ddc5549SLars Ellenberg if (!signal_pending(current)) 14180ddc5549SLars Ellenberg dev_warn(DEV, 14190ddc5549SLars Ellenberg "short read receiving data reply digest: read %d expected %d\n", 1420b411b363SPhilipp Reisner rr, dgs); 1421b411b363SPhilipp Reisner return 0; 1422b411b363SPhilipp Reisner } 1423b411b363SPhilipp Reisner } 1424b411b363SPhilipp Reisner 1425b411b363SPhilipp Reisner data_size -= dgs; 1426b411b363SPhilipp Reisner 1427b411b363SPhilipp Reisner /* optimistically update recv_cnt. if receiving fails below, 1428b411b363SPhilipp Reisner * we disconnect anyways, and counters will be reset. */ 1429b411b363SPhilipp Reisner mdev->recv_cnt += data_size>>9; 1430b411b363SPhilipp Reisner 1431b411b363SPhilipp Reisner bio = req->master_bio; 1432b411b363SPhilipp Reisner D_ASSERT(sector == bio->bi_sector); 1433b411b363SPhilipp Reisner 1434b411b363SPhilipp Reisner bio_for_each_segment(bvec, bio, i) { 1435b411b363SPhilipp Reisner expect = min_t(int, data_size, bvec->bv_len); 1436de0ff338SPhilipp Reisner rr = drbd_recv(mdev->tconn, 1437b411b363SPhilipp Reisner kmap(bvec->bv_page)+bvec->bv_offset, 1438b411b363SPhilipp Reisner expect); 1439b411b363SPhilipp Reisner kunmap(bvec->bv_page); 1440b411b363SPhilipp Reisner if (rr != expect) { 14410ddc5549SLars Ellenberg if (!signal_pending(current)) 1442b411b363SPhilipp Reisner dev_warn(DEV, "short read receiving data reply: " 1443b411b363SPhilipp Reisner "read %d expected %d\n", 1444b411b363SPhilipp Reisner rr, expect); 1445b411b363SPhilipp Reisner return 0; 1446b411b363SPhilipp Reisner } 1447b411b363SPhilipp Reisner data_size -= rr; 1448b411b363SPhilipp Reisner } 1449b411b363SPhilipp Reisner 1450b411b363SPhilipp Reisner if (dgs) { 1451a0638456SPhilipp Reisner drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv); 1452b411b363SPhilipp Reisner if (memcmp(dig_in, dig_vv, dgs)) { 1453b411b363SPhilipp Reisner dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n"); 1454b411b363SPhilipp Reisner return 0; 1455b411b363SPhilipp Reisner } 1456b411b363SPhilipp Reisner } 1457b411b363SPhilipp Reisner 1458b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 1459b411b363SPhilipp Reisner return 1; 1460b411b363SPhilipp Reisner } 1461b411b363SPhilipp Reisner 1462b411b363SPhilipp Reisner /* e_end_resync_block() is called via 1463b411b363SPhilipp Reisner * drbd_process_done_ee() by asender only */ 146400d56944SPhilipp Reisner static int e_end_resync_block(struct drbd_work *w, int unused) 1465b411b363SPhilipp Reisner { 14668050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 14678050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 146800d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1469db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1470b411b363SPhilipp Reisner int ok; 1471b411b363SPhilipp Reisner 1472db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1473b411b363SPhilipp Reisner 1474db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1475db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1476db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req); 1477b411b363SPhilipp Reisner } else { 1478b411b363SPhilipp Reisner /* Record failure to sync */ 1479db830c46SAndreas Gruenbacher drbd_rs_failed_io(mdev, sector, peer_req->i.size); 1480b411b363SPhilipp Reisner 1481db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1482b411b363SPhilipp Reisner } 1483b411b363SPhilipp Reisner dec_unacked(mdev); 1484b411b363SPhilipp Reisner 1485b411b363SPhilipp Reisner return ok; 1486b411b363SPhilipp Reisner } 1487b411b363SPhilipp Reisner 1488b411b363SPhilipp Reisner static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local) 1489b411b363SPhilipp Reisner { 1490db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1491b411b363SPhilipp Reisner 1492db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size); 1493db830c46SAndreas Gruenbacher if (!peer_req) 149445bb912bSLars Ellenberg goto fail; 1495b411b363SPhilipp Reisner 1496b411b363SPhilipp Reisner dec_rs_pending(mdev); 1497b411b363SPhilipp Reisner 1498b411b363SPhilipp Reisner inc_unacked(mdev); 1499b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_resync_block() 1500b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 1501b411b363SPhilipp Reisner 1502db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_resync_block; 150345bb912bSLars Ellenberg 150487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1505db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->sync_ee); 150687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1507b411b363SPhilipp Reisner 15080f0601f4SLars Ellenberg atomic_add(data_size >> 9, &mdev->rs_sect_ev); 1509fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0) 151081e84650SAndreas Gruenbacher return true; 151145bb912bSLars Ellenberg 151210f6d992SLars Ellenberg /* don't care for the reason here */ 151310f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 151487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1515db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 151687eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 151722cc37a9SLars Ellenberg 1518db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 151945bb912bSLars Ellenberg fail: 152045bb912bSLars Ellenberg put_ldev(mdev); 152181e84650SAndreas Gruenbacher return false; 1522b411b363SPhilipp Reisner } 1523b411b363SPhilipp Reisner 1524668eebc6SAndreas Gruenbacher static struct drbd_request * 1525bc9c5c41SAndreas Gruenbacher find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id, 1526bc9c5c41SAndreas Gruenbacher sector_t sector, bool missing_ok, const char *func) 1527668eebc6SAndreas Gruenbacher { 1528668eebc6SAndreas Gruenbacher struct drbd_request *req; 1529668eebc6SAndreas Gruenbacher 1530bc9c5c41SAndreas Gruenbacher /* Request object according to our peer */ 1531bc9c5c41SAndreas Gruenbacher req = (struct drbd_request *)(unsigned long)id; 15325e472264SAndreas Gruenbacher if (drbd_contains_interval(root, sector, &req->i) && req->i.local) 1533668eebc6SAndreas Gruenbacher return req; 1534c3afd8f5SAndreas Gruenbacher if (!missing_ok) { 1535c3afd8f5SAndreas Gruenbacher dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func, 1536c3afd8f5SAndreas Gruenbacher (unsigned long)id, (unsigned long long)sector); 1537c3afd8f5SAndreas Gruenbacher } 1538668eebc6SAndreas Gruenbacher return NULL; 1539668eebc6SAndreas Gruenbacher } 1540668eebc6SAndreas Gruenbacher 1541d8763023SAndreas Gruenbacher static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1542d8763023SAndreas Gruenbacher unsigned int data_size) 1543b411b363SPhilipp Reisner { 1544b411b363SPhilipp Reisner struct drbd_request *req; 1545b411b363SPhilipp Reisner sector_t sector; 1546b411b363SPhilipp Reisner int ok; 1547e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1548b411b363SPhilipp Reisner 1549b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1550b411b363SPhilipp Reisner 155187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1552bc9c5c41SAndreas Gruenbacher req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__); 155387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1554c3afd8f5SAndreas Gruenbacher if (unlikely(!req)) 155581e84650SAndreas Gruenbacher return false; 1556b411b363SPhilipp Reisner 155724c4830cSBart Van Assche /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid 1558b411b363SPhilipp Reisner * special casing it there for the various failure cases. 1559b411b363SPhilipp Reisner * still no race with drbd_fail_pending_reads */ 1560b411b363SPhilipp Reisner ok = recv_dless_read(mdev, req, sector, data_size); 1561b411b363SPhilipp Reisner 1562b411b363SPhilipp Reisner if (ok) 15638554df1cSAndreas Gruenbacher req_mod(req, DATA_RECEIVED); 1564b411b363SPhilipp Reisner /* else: nothing. handled from drbd_disconnect... 1565b411b363SPhilipp Reisner * I don't think we may complete this just yet 1566b411b363SPhilipp Reisner * in case we are "on-disconnect: freeze" */ 1567b411b363SPhilipp Reisner 1568b411b363SPhilipp Reisner return ok; 1569b411b363SPhilipp Reisner } 1570b411b363SPhilipp Reisner 1571d8763023SAndreas Gruenbacher static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packet cmd, 1572d8763023SAndreas Gruenbacher unsigned int data_size) 1573b411b363SPhilipp Reisner { 1574b411b363SPhilipp Reisner sector_t sector; 1575b411b363SPhilipp Reisner int ok; 1576e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 1577b411b363SPhilipp Reisner 1578b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1579b411b363SPhilipp Reisner D_ASSERT(p->block_id == ID_SYNCER); 1580b411b363SPhilipp Reisner 1581b411b363SPhilipp Reisner if (get_ldev(mdev)) { 1582b411b363SPhilipp Reisner /* data is submitted to disk within recv_resync_read. 1583b411b363SPhilipp Reisner * corresponding put_ldev done below on error, 1584fcefa62eSAndreas Gruenbacher * or in drbd_peer_request_endio. */ 1585b411b363SPhilipp Reisner ok = recv_resync_read(mdev, sector, data_size); 1586b411b363SPhilipp Reisner } else { 1587b411b363SPhilipp Reisner if (__ratelimit(&drbd_ratelimit_state)) 1588b411b363SPhilipp Reisner dev_err(DEV, "Can not write resync data to local disk.\n"); 1589b411b363SPhilipp Reisner 1590b411b363SPhilipp Reisner ok = drbd_drain_block(mdev, data_size); 1591b411b363SPhilipp Reisner 15922b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1593b411b363SPhilipp Reisner } 1594b411b363SPhilipp Reisner 1595778f271dSPhilipp Reisner atomic_add(data_size >> 9, &mdev->rs_sect_in); 1596778f271dSPhilipp Reisner 1597b411b363SPhilipp Reisner return ok; 1598b411b363SPhilipp Reisner } 1599b411b363SPhilipp Reisner 16007be8da07SAndreas Gruenbacher static int w_restart_write(struct drbd_work *w, int cancel) 16017be8da07SAndreas Gruenbacher { 16027be8da07SAndreas Gruenbacher struct drbd_request *req = container_of(w, struct drbd_request, w); 16037be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16047be8da07SAndreas Gruenbacher struct bio *bio; 16057be8da07SAndreas Gruenbacher unsigned long start_time; 16067be8da07SAndreas Gruenbacher unsigned long flags; 16077be8da07SAndreas Gruenbacher 16087be8da07SAndreas Gruenbacher spin_lock_irqsave(&mdev->tconn->req_lock, flags); 16097be8da07SAndreas Gruenbacher if (!expect(req->rq_state & RQ_POSTPONED)) { 16107be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16117be8da07SAndreas Gruenbacher return 0; 16127be8da07SAndreas Gruenbacher } 16137be8da07SAndreas Gruenbacher bio = req->master_bio; 16147be8da07SAndreas Gruenbacher start_time = req->start_time; 16157be8da07SAndreas Gruenbacher /* Postponed requests will not have their master_bio completed! */ 16167be8da07SAndreas Gruenbacher __req_mod(req, DISCARD_WRITE, NULL); 16177be8da07SAndreas Gruenbacher spin_unlock_irqrestore(&mdev->tconn->req_lock, flags); 16187be8da07SAndreas Gruenbacher 16197be8da07SAndreas Gruenbacher while (__drbd_make_request(mdev, bio, start_time)) 16207be8da07SAndreas Gruenbacher /* retry */ ; 16217be8da07SAndreas Gruenbacher return 1; 16227be8da07SAndreas Gruenbacher } 16237be8da07SAndreas Gruenbacher 16247be8da07SAndreas Gruenbacher static void restart_conflicting_writes(struct drbd_conf *mdev, 16257be8da07SAndreas Gruenbacher sector_t sector, int size) 16267be8da07SAndreas Gruenbacher { 16277be8da07SAndreas Gruenbacher struct drbd_interval *i; 16287be8da07SAndreas Gruenbacher struct drbd_request *req; 16297be8da07SAndreas Gruenbacher 16307be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 16317be8da07SAndreas Gruenbacher if (!i->local) 16327be8da07SAndreas Gruenbacher continue; 16337be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 16347be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 16357be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) 16367be8da07SAndreas Gruenbacher continue; 16377be8da07SAndreas Gruenbacher if (expect(list_empty(&req->w.list))) { 16387be8da07SAndreas Gruenbacher req->w.mdev = mdev; 16397be8da07SAndreas Gruenbacher req->w.cb = w_restart_write; 16407be8da07SAndreas Gruenbacher drbd_queue_work(&mdev->tconn->data.work, &req->w); 16417be8da07SAndreas Gruenbacher } 16427be8da07SAndreas Gruenbacher } 16437be8da07SAndreas Gruenbacher } 16447be8da07SAndreas Gruenbacher 1645b411b363SPhilipp Reisner /* e_end_block() is called via drbd_process_done_ee(). 1646b411b363SPhilipp Reisner * this means this function only runs in the asender thread 1647b411b363SPhilipp Reisner */ 164800d56944SPhilipp Reisner static int e_end_block(struct drbd_work *w, int cancel) 1649b411b363SPhilipp Reisner { 16508050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16518050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 165200d56944SPhilipp Reisner struct drbd_conf *mdev = w->mdev; 1653db830c46SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 1654b411b363SPhilipp Reisner int ok = 1, pcmd; 1655b411b363SPhilipp Reisner 165689e58e75SPhilipp Reisner if (mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C) { 1657db830c46SAndreas Gruenbacher if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) { 1658b411b363SPhilipp Reisner pcmd = (mdev->state.conn >= C_SYNC_SOURCE && 1659b411b363SPhilipp Reisner mdev->state.conn <= C_PAUSED_SYNC_T && 1660db830c46SAndreas Gruenbacher peer_req->flags & EE_MAY_SET_IN_SYNC) ? 1661b411b363SPhilipp Reisner P_RS_WRITE_ACK : P_WRITE_ACK; 1662db830c46SAndreas Gruenbacher ok &= drbd_send_ack(mdev, pcmd, peer_req); 1663b411b363SPhilipp Reisner if (pcmd == P_RS_WRITE_ACK) 1664db830c46SAndreas Gruenbacher drbd_set_in_sync(mdev, sector, peer_req->i.size); 1665b411b363SPhilipp Reisner } else { 1666db830c46SAndreas Gruenbacher ok = drbd_send_ack(mdev, P_NEG_ACK, peer_req); 1667b411b363SPhilipp Reisner /* we expect it to be marked out of sync anyways... 1668b411b363SPhilipp Reisner * maybe assert this? */ 1669b411b363SPhilipp Reisner } 1670b411b363SPhilipp Reisner dec_unacked(mdev); 1671b411b363SPhilipp Reisner } 1672b411b363SPhilipp Reisner /* we delete from the conflict detection hash _after_ we sent out the 1673b411b363SPhilipp Reisner * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */ 167489e58e75SPhilipp Reisner if (mdev->tconn->net_conf->two_primaries) { 167587eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 1676db830c46SAndreas Gruenbacher D_ASSERT(!drbd_interval_empty(&peer_req->i)); 1677db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 16787be8da07SAndreas Gruenbacher if (peer_req->flags & EE_RESTART_REQUESTS) 16797be8da07SAndreas Gruenbacher restart_conflicting_writes(mdev, sector, peer_req->i.size); 168087eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 1681bb3bfe96SAndreas Gruenbacher } else 1682db830c46SAndreas Gruenbacher D_ASSERT(drbd_interval_empty(&peer_req->i)); 1683b411b363SPhilipp Reisner 1684db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0)); 1685b411b363SPhilipp Reisner 1686b411b363SPhilipp Reisner return ok; 1687b411b363SPhilipp Reisner } 1688b411b363SPhilipp Reisner 16897be8da07SAndreas Gruenbacher static int e_send_ack(struct drbd_work *w, enum drbd_packet ack) 1690b411b363SPhilipp Reisner { 16917be8da07SAndreas Gruenbacher struct drbd_conf *mdev = w->mdev; 16928050e6d0SAndreas Gruenbacher struct drbd_peer_request *peer_req = 16938050e6d0SAndreas Gruenbacher container_of(w, struct drbd_peer_request, w); 1694206d3589SAndreas Gruenbacher int ok; 1695b411b363SPhilipp Reisner 16967be8da07SAndreas Gruenbacher ok = drbd_send_ack(mdev, ack, peer_req); 1697b411b363SPhilipp Reisner dec_unacked(mdev); 1698b411b363SPhilipp Reisner 1699b411b363SPhilipp Reisner return ok; 1700b411b363SPhilipp Reisner } 1701b411b363SPhilipp Reisner 17027be8da07SAndreas Gruenbacher static int e_send_discard_write(struct drbd_work *w, int unused) 17037be8da07SAndreas Gruenbacher { 17047be8da07SAndreas Gruenbacher return e_send_ack(w, P_DISCARD_WRITE); 17057be8da07SAndreas Gruenbacher } 17067be8da07SAndreas Gruenbacher 17077be8da07SAndreas Gruenbacher static int e_send_retry_write(struct drbd_work *w, int unused) 17087be8da07SAndreas Gruenbacher { 17097be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = w->mdev->tconn; 17107be8da07SAndreas Gruenbacher 17117be8da07SAndreas Gruenbacher return e_send_ack(w, tconn->agreed_pro_version >= 100 ? 17127be8da07SAndreas Gruenbacher P_RETRY_WRITE : P_DISCARD_WRITE); 17137be8da07SAndreas Gruenbacher } 17147be8da07SAndreas Gruenbacher 17153e394da1SAndreas Gruenbacher static bool seq_greater(u32 a, u32 b) 17163e394da1SAndreas Gruenbacher { 17173e394da1SAndreas Gruenbacher /* 17183e394da1SAndreas Gruenbacher * We assume 32-bit wrap-around here. 17193e394da1SAndreas Gruenbacher * For 24-bit wrap-around, we would have to shift: 17203e394da1SAndreas Gruenbacher * a <<= 8; b <<= 8; 17213e394da1SAndreas Gruenbacher */ 17223e394da1SAndreas Gruenbacher return (s32)a - (s32)b > 0; 17233e394da1SAndreas Gruenbacher } 17243e394da1SAndreas Gruenbacher 17253e394da1SAndreas Gruenbacher static u32 seq_max(u32 a, u32 b) 17263e394da1SAndreas Gruenbacher { 17273e394da1SAndreas Gruenbacher return seq_greater(a, b) ? a : b; 17283e394da1SAndreas Gruenbacher } 17293e394da1SAndreas Gruenbacher 17307be8da07SAndreas Gruenbacher static bool need_peer_seq(struct drbd_conf *mdev) 17317be8da07SAndreas Gruenbacher { 17327be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 17337be8da07SAndreas Gruenbacher 17347be8da07SAndreas Gruenbacher /* 17357be8da07SAndreas Gruenbacher * We only need to keep track of the last packet_seq number of our peer 17367be8da07SAndreas Gruenbacher * if we are in dual-primary mode and we have the discard flag set; see 17377be8da07SAndreas Gruenbacher * handle_write_conflicts(). 17387be8da07SAndreas Gruenbacher */ 17397be8da07SAndreas Gruenbacher return tconn->net_conf->two_primaries && 17407be8da07SAndreas Gruenbacher test_bit(DISCARD_CONCURRENT, &tconn->flags); 17417be8da07SAndreas Gruenbacher } 17427be8da07SAndreas Gruenbacher 174343ae077dSAndreas Gruenbacher static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq) 17443e394da1SAndreas Gruenbacher { 17453c13b680SLars Ellenberg unsigned int newest_peer_seq; 17463e394da1SAndreas Gruenbacher 17477be8da07SAndreas Gruenbacher if (need_peer_seq(mdev)) { 17483e394da1SAndreas Gruenbacher spin_lock(&mdev->peer_seq_lock); 17493c13b680SLars Ellenberg newest_peer_seq = seq_max(mdev->peer_seq, peer_seq); 17503c13b680SLars Ellenberg mdev->peer_seq = newest_peer_seq; 17513e394da1SAndreas Gruenbacher spin_unlock(&mdev->peer_seq_lock); 17523c13b680SLars Ellenberg /* wake up only if we actually changed mdev->peer_seq */ 17533c13b680SLars Ellenberg if (peer_seq == newest_peer_seq) 17543e394da1SAndreas Gruenbacher wake_up(&mdev->seq_wait); 17553e394da1SAndreas Gruenbacher } 17567be8da07SAndreas Gruenbacher } 17573e394da1SAndreas Gruenbacher 1758b411b363SPhilipp Reisner /* Called from receive_Data. 1759b411b363SPhilipp Reisner * Synchronize packets on sock with packets on msock. 1760b411b363SPhilipp Reisner * 1761b411b363SPhilipp Reisner * This is here so even when a P_DATA packet traveling via sock overtook an Ack 1762b411b363SPhilipp Reisner * packet traveling on msock, they are still processed in the order they have 1763b411b363SPhilipp Reisner * been sent. 1764b411b363SPhilipp Reisner * 1765b411b363SPhilipp Reisner * Note: we don't care for Ack packets overtaking P_DATA packets. 1766b411b363SPhilipp Reisner * 1767b411b363SPhilipp Reisner * In case packet_seq is larger than mdev->peer_seq number, there are 1768b411b363SPhilipp Reisner * outstanding packets on the msock. We wait for them to arrive. 1769b411b363SPhilipp Reisner * In case we are the logically next packet, we update mdev->peer_seq 1770b411b363SPhilipp Reisner * ourselves. Correctly handles 32bit wrap around. 1771b411b363SPhilipp Reisner * 1772b411b363SPhilipp Reisner * Assume we have a 10 GBit connection, that is about 1<<30 byte per second, 1773b411b363SPhilipp Reisner * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds 1774b411b363SPhilipp Reisner * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have 1775b411b363SPhilipp Reisner * 1<<9 == 512 seconds aka ages for the 32bit wrap around... 1776b411b363SPhilipp Reisner * 1777b411b363SPhilipp Reisner * returns 0 if we may process the packet, 1778b411b363SPhilipp Reisner * -ERESTARTSYS if we were interrupted (by disconnect signal). */ 17797be8da07SAndreas Gruenbacher static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq) 1780b411b363SPhilipp Reisner { 1781b411b363SPhilipp Reisner DEFINE_WAIT(wait); 1782b411b363SPhilipp Reisner long timeout; 17837be8da07SAndreas Gruenbacher int ret; 17847be8da07SAndreas Gruenbacher 17857be8da07SAndreas Gruenbacher if (!need_peer_seq(mdev)) 17867be8da07SAndreas Gruenbacher return 0; 17877be8da07SAndreas Gruenbacher 1788b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 1789b411b363SPhilipp Reisner for (;;) { 17907be8da07SAndreas Gruenbacher if (!seq_greater(peer_seq - 1, mdev->peer_seq)) { 17917be8da07SAndreas Gruenbacher mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq); 17927be8da07SAndreas Gruenbacher ret = 0; 1793b411b363SPhilipp Reisner break; 17947be8da07SAndreas Gruenbacher } 1795b411b363SPhilipp Reisner if (signal_pending(current)) { 1796b411b363SPhilipp Reisner ret = -ERESTARTSYS; 1797b411b363SPhilipp Reisner break; 1798b411b363SPhilipp Reisner } 17997be8da07SAndreas Gruenbacher prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE); 1800b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 180171b1c1ebSAndreas Gruenbacher timeout = mdev->tconn->net_conf->ping_timeo*HZ/10; 180271b1c1ebSAndreas Gruenbacher timeout = schedule_timeout(timeout); 1803b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 18047be8da07SAndreas Gruenbacher if (!timeout) { 1805b411b363SPhilipp Reisner ret = -ETIMEDOUT; 180671b1c1ebSAndreas Gruenbacher dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n"); 1807b411b363SPhilipp Reisner break; 1808b411b363SPhilipp Reisner } 1809b411b363SPhilipp Reisner } 1810b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 18117be8da07SAndreas Gruenbacher finish_wait(&mdev->seq_wait, &wait); 1812b411b363SPhilipp Reisner return ret; 1813b411b363SPhilipp Reisner } 1814b411b363SPhilipp Reisner 1815688593c5SLars Ellenberg /* see also bio_flags_to_wire() 1816688593c5SLars Ellenberg * DRBD_REQ_*, because we need to semantically map the flags to data packet 1817688593c5SLars Ellenberg * flags and back. We may replicate to other kernel versions. */ 1818688593c5SLars Ellenberg static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf) 181976d2e7ecSPhilipp Reisner { 182076d2e7ecSPhilipp Reisner return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) | 182176d2e7ecSPhilipp Reisner (dpf & DP_FUA ? REQ_FUA : 0) | 1822688593c5SLars Ellenberg (dpf & DP_FLUSH ? REQ_FLUSH : 0) | 182376d2e7ecSPhilipp Reisner (dpf & DP_DISCARD ? REQ_DISCARD : 0); 182476d2e7ecSPhilipp Reisner } 182576d2e7ecSPhilipp Reisner 18267be8da07SAndreas Gruenbacher static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector, 18277be8da07SAndreas Gruenbacher unsigned int size) 18287be8da07SAndreas Gruenbacher { 18297be8da07SAndreas Gruenbacher struct drbd_interval *i; 18307be8da07SAndreas Gruenbacher 18317be8da07SAndreas Gruenbacher repeat: 18327be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18337be8da07SAndreas Gruenbacher struct drbd_request *req; 18347be8da07SAndreas Gruenbacher struct bio_and_error m; 18357be8da07SAndreas Gruenbacher 18367be8da07SAndreas Gruenbacher if (!i->local) 18377be8da07SAndreas Gruenbacher continue; 18387be8da07SAndreas Gruenbacher req = container_of(i, struct drbd_request, i); 18397be8da07SAndreas Gruenbacher if (!(req->rq_state & RQ_POSTPONED)) 18407be8da07SAndreas Gruenbacher continue; 18417be8da07SAndreas Gruenbacher req->rq_state &= ~RQ_POSTPONED; 18427be8da07SAndreas Gruenbacher __req_mod(req, NEG_ACKED, &m); 18437be8da07SAndreas Gruenbacher spin_unlock_irq(&mdev->tconn->req_lock); 18447be8da07SAndreas Gruenbacher if (m.bio) 18457be8da07SAndreas Gruenbacher complete_master_bio(mdev, &m); 18467be8da07SAndreas Gruenbacher spin_lock_irq(&mdev->tconn->req_lock); 18477be8da07SAndreas Gruenbacher goto repeat; 18487be8da07SAndreas Gruenbacher } 18497be8da07SAndreas Gruenbacher } 18507be8da07SAndreas Gruenbacher 18517be8da07SAndreas Gruenbacher static int handle_write_conflicts(struct drbd_conf *mdev, 18527be8da07SAndreas Gruenbacher struct drbd_peer_request *peer_req) 18537be8da07SAndreas Gruenbacher { 18547be8da07SAndreas Gruenbacher struct drbd_tconn *tconn = mdev->tconn; 18557be8da07SAndreas Gruenbacher bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags); 18567be8da07SAndreas Gruenbacher sector_t sector = peer_req->i.sector; 18577be8da07SAndreas Gruenbacher const unsigned int size = peer_req->i.size; 18587be8da07SAndreas Gruenbacher struct drbd_interval *i; 18597be8da07SAndreas Gruenbacher bool equal; 18607be8da07SAndreas Gruenbacher int err; 18617be8da07SAndreas Gruenbacher 18627be8da07SAndreas Gruenbacher /* 18637be8da07SAndreas Gruenbacher * Inserting the peer request into the write_requests tree will prevent 18647be8da07SAndreas Gruenbacher * new conflicting local requests from being added. 18657be8da07SAndreas Gruenbacher */ 18667be8da07SAndreas Gruenbacher drbd_insert_interval(&mdev->write_requests, &peer_req->i); 18677be8da07SAndreas Gruenbacher 18687be8da07SAndreas Gruenbacher repeat: 18697be8da07SAndreas Gruenbacher drbd_for_each_overlap(i, &mdev->write_requests, sector, size) { 18707be8da07SAndreas Gruenbacher if (i == &peer_req->i) 18717be8da07SAndreas Gruenbacher continue; 18727be8da07SAndreas Gruenbacher 18737be8da07SAndreas Gruenbacher if (!i->local) { 18747be8da07SAndreas Gruenbacher /* 18757be8da07SAndreas Gruenbacher * Our peer has sent a conflicting remote request; this 18767be8da07SAndreas Gruenbacher * should not happen in a two-node setup. Wait for the 18777be8da07SAndreas Gruenbacher * earlier peer request to complete. 18787be8da07SAndreas Gruenbacher */ 18797be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, i); 18807be8da07SAndreas Gruenbacher if (err) 18817be8da07SAndreas Gruenbacher goto out; 18827be8da07SAndreas Gruenbacher goto repeat; 18837be8da07SAndreas Gruenbacher } 18847be8da07SAndreas Gruenbacher 18857be8da07SAndreas Gruenbacher equal = i->sector == sector && i->size == size; 18867be8da07SAndreas Gruenbacher if (resolve_conflicts) { 18877be8da07SAndreas Gruenbacher /* 18887be8da07SAndreas Gruenbacher * If the peer request is fully contained within the 18897be8da07SAndreas Gruenbacher * overlapping request, it can be discarded; otherwise, 18907be8da07SAndreas Gruenbacher * it will be retried once all overlapping requests 18917be8da07SAndreas Gruenbacher * have completed. 18927be8da07SAndreas Gruenbacher */ 18937be8da07SAndreas Gruenbacher bool discard = i->sector <= sector && i->sector + 18947be8da07SAndreas Gruenbacher (i->size >> 9) >= sector + (size >> 9); 18957be8da07SAndreas Gruenbacher 18967be8da07SAndreas Gruenbacher if (!equal) 18977be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 18987be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u, " 18997be8da07SAndreas Gruenbacher "assuming %s came first\n", 19007be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19017be8da07SAndreas Gruenbacher (unsigned long long)sector, size, 19027be8da07SAndreas Gruenbacher discard ? "local" : "remote"); 19037be8da07SAndreas Gruenbacher 19047be8da07SAndreas Gruenbacher inc_unacked(mdev); 19057be8da07SAndreas Gruenbacher peer_req->w.cb = discard ? e_send_discard_write : 19067be8da07SAndreas Gruenbacher e_send_retry_write; 19077be8da07SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->done_ee); 19087be8da07SAndreas Gruenbacher wake_asender(mdev->tconn); 19097be8da07SAndreas Gruenbacher 19107be8da07SAndreas Gruenbacher err = -ENOENT; 19117be8da07SAndreas Gruenbacher goto out; 19127be8da07SAndreas Gruenbacher } else { 19137be8da07SAndreas Gruenbacher struct drbd_request *req = 19147be8da07SAndreas Gruenbacher container_of(i, struct drbd_request, i); 19157be8da07SAndreas Gruenbacher 19167be8da07SAndreas Gruenbacher if (!equal) 19177be8da07SAndreas Gruenbacher dev_alert(DEV, "Concurrent writes detected: " 19187be8da07SAndreas Gruenbacher "local=%llus +%u, remote=%llus +%u\n", 19197be8da07SAndreas Gruenbacher (unsigned long long)i->sector, i->size, 19207be8da07SAndreas Gruenbacher (unsigned long long)sector, size); 19217be8da07SAndreas Gruenbacher 19227be8da07SAndreas Gruenbacher if (req->rq_state & RQ_LOCAL_PENDING || 19237be8da07SAndreas Gruenbacher !(req->rq_state & RQ_POSTPONED)) { 19247be8da07SAndreas Gruenbacher /* 19257be8da07SAndreas Gruenbacher * Wait for the node with the discard flag to 19267be8da07SAndreas Gruenbacher * decide if this request will be discarded or 19277be8da07SAndreas Gruenbacher * retried. Requests that are discarded will 19287be8da07SAndreas Gruenbacher * disappear from the write_requests tree. 19297be8da07SAndreas Gruenbacher * 19307be8da07SAndreas Gruenbacher * In addition, wait for the conflicting 19317be8da07SAndreas Gruenbacher * request to finish locally before submitting 19327be8da07SAndreas Gruenbacher * the conflicting peer request. 19337be8da07SAndreas Gruenbacher */ 19347be8da07SAndreas Gruenbacher err = drbd_wait_misc(mdev, &req->i); 19357be8da07SAndreas Gruenbacher if (err) { 19367be8da07SAndreas Gruenbacher _conn_request_state(mdev->tconn, 19377be8da07SAndreas Gruenbacher NS(conn, C_TIMEOUT), 19387be8da07SAndreas Gruenbacher CS_HARD); 19397be8da07SAndreas Gruenbacher fail_postponed_requests(mdev, sector, size); 19407be8da07SAndreas Gruenbacher goto out; 19417be8da07SAndreas Gruenbacher } 19427be8da07SAndreas Gruenbacher goto repeat; 19437be8da07SAndreas Gruenbacher } 19447be8da07SAndreas Gruenbacher /* 19457be8da07SAndreas Gruenbacher * Remember to restart the conflicting requests after 19467be8da07SAndreas Gruenbacher * the new peer request has completed. 19477be8da07SAndreas Gruenbacher */ 19487be8da07SAndreas Gruenbacher peer_req->flags |= EE_RESTART_REQUESTS; 19497be8da07SAndreas Gruenbacher } 19507be8da07SAndreas Gruenbacher } 19517be8da07SAndreas Gruenbacher err = 0; 19527be8da07SAndreas Gruenbacher 19537be8da07SAndreas Gruenbacher out: 19547be8da07SAndreas Gruenbacher if (err) 19557be8da07SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 19567be8da07SAndreas Gruenbacher return err; 19577be8da07SAndreas Gruenbacher } 19587be8da07SAndreas Gruenbacher 1959b411b363SPhilipp Reisner /* mirrored write */ 1960d8763023SAndreas Gruenbacher static int receive_Data(struct drbd_conf *mdev, enum drbd_packet cmd, 1961d8763023SAndreas Gruenbacher unsigned int data_size) 1962b411b363SPhilipp Reisner { 1963b411b363SPhilipp Reisner sector_t sector; 1964db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 1965e42325a5SPhilipp Reisner struct p_data *p = &mdev->tconn->data.rbuf.data; 19667be8da07SAndreas Gruenbacher u32 peer_seq = be32_to_cpu(p->seq_num); 1967b411b363SPhilipp Reisner int rw = WRITE; 1968b411b363SPhilipp Reisner u32 dp_flags; 19697be8da07SAndreas Gruenbacher int err; 19707be8da07SAndreas Gruenbacher 1971b411b363SPhilipp Reisner 1972b411b363SPhilipp Reisner if (!get_ldev(mdev)) { 19737be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 19742b2bf214SLars Ellenberg drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size); 1975b411b363SPhilipp Reisner atomic_inc(&mdev->current_epoch->epoch_size); 19767be8da07SAndreas Gruenbacher return drbd_drain_block(mdev, data_size) && err == 0; 1977b411b363SPhilipp Reisner } 1978b411b363SPhilipp Reisner 1979fcefa62eSAndreas Gruenbacher /* 1980fcefa62eSAndreas Gruenbacher * Corresponding put_ldev done either below (on various errors), or in 1981fcefa62eSAndreas Gruenbacher * drbd_peer_request_endio, if we successfully submit the data at the 1982fcefa62eSAndreas Gruenbacher * end of this function. 1983fcefa62eSAndreas Gruenbacher */ 1984b411b363SPhilipp Reisner 1985b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 1986db830c46SAndreas Gruenbacher peer_req = read_in_block(mdev, p->block_id, sector, data_size); 1987db830c46SAndreas Gruenbacher if (!peer_req) { 1988b411b363SPhilipp Reisner put_ldev(mdev); 198981e84650SAndreas Gruenbacher return false; 1990b411b363SPhilipp Reisner } 1991b411b363SPhilipp Reisner 1992db830c46SAndreas Gruenbacher peer_req->w.cb = e_end_block; 1993b411b363SPhilipp Reisner 1994688593c5SLars Ellenberg dp_flags = be32_to_cpu(p->dp_flags); 1995688593c5SLars Ellenberg rw |= wire_flags_to_bio(mdev, dp_flags); 1996688593c5SLars Ellenberg 1997688593c5SLars Ellenberg if (dp_flags & DP_MAY_SET_IN_SYNC) 1998db830c46SAndreas Gruenbacher peer_req->flags |= EE_MAY_SET_IN_SYNC; 1999688593c5SLars Ellenberg 2000b411b363SPhilipp Reisner spin_lock(&mdev->epoch_lock); 2001db830c46SAndreas Gruenbacher peer_req->epoch = mdev->current_epoch; 2002db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->epoch_size); 2003db830c46SAndreas Gruenbacher atomic_inc(&peer_req->epoch->active); 2004b411b363SPhilipp Reisner spin_unlock(&mdev->epoch_lock); 2005b411b363SPhilipp Reisner 20067be8da07SAndreas Gruenbacher if (mdev->tconn->net_conf->two_primaries) { 20077be8da07SAndreas Gruenbacher err = wait_for_and_update_peer_seq(mdev, peer_seq); 20087be8da07SAndreas Gruenbacher if (err) 2009b411b363SPhilipp Reisner goto out_interrupted; 201087eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 20117be8da07SAndreas Gruenbacher err = handle_write_conflicts(mdev, peer_req); 20127be8da07SAndreas Gruenbacher if (err) { 201387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 20147be8da07SAndreas Gruenbacher if (err == -ENOENT) { 2015b411b363SPhilipp Reisner put_ldev(mdev); 201681e84650SAndreas Gruenbacher return true; 2017b411b363SPhilipp Reisner } 2018b411b363SPhilipp Reisner goto out_interrupted; 2019b411b363SPhilipp Reisner } 20207be8da07SAndreas Gruenbacher } else 202187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2022db830c46SAndreas Gruenbacher list_add(&peer_req->w.list, &mdev->active_ee); 202387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2024b411b363SPhilipp Reisner 202589e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->wire_protocol) { 2026b411b363SPhilipp Reisner case DRBD_PROT_C: 2027b411b363SPhilipp Reisner inc_unacked(mdev); 2028b411b363SPhilipp Reisner /* corresponding dec_unacked() in e_end_block() 2029b411b363SPhilipp Reisner * respective _drbd_clear_done_ee */ 2030b411b363SPhilipp Reisner break; 2031b411b363SPhilipp Reisner case DRBD_PROT_B: 2032b411b363SPhilipp Reisner /* I really don't like it that the receiver thread 2033b411b363SPhilipp Reisner * sends on the msock, but anyways */ 2034db830c46SAndreas Gruenbacher drbd_send_ack(mdev, P_RECV_ACK, peer_req); 2035b411b363SPhilipp Reisner break; 2036b411b363SPhilipp Reisner case DRBD_PROT_A: 2037b411b363SPhilipp Reisner /* nothing to do */ 2038b411b363SPhilipp Reisner break; 2039b411b363SPhilipp Reisner } 2040b411b363SPhilipp Reisner 20416719fb03SLars Ellenberg if (mdev->state.pdsk < D_INCONSISTENT) { 2042b411b363SPhilipp Reisner /* In case we have the only disk of the cluster, */ 2043db830c46SAndreas Gruenbacher drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size); 2044db830c46SAndreas Gruenbacher peer_req->flags |= EE_CALL_AL_COMPLETE_IO; 2045db830c46SAndreas Gruenbacher peer_req->flags &= ~EE_MAY_SET_IN_SYNC; 2046db830c46SAndreas Gruenbacher drbd_al_begin_io(mdev, peer_req->i.sector); 2047b411b363SPhilipp Reisner } 2048b411b363SPhilipp Reisner 2049fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR) == 0) 205081e84650SAndreas Gruenbacher return true; 2051b411b363SPhilipp Reisner 205210f6d992SLars Ellenberg /* don't care for the reason here */ 205310f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 205487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2055db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 2056db830c46SAndreas Gruenbacher drbd_remove_epoch_entry_interval(mdev, peer_req); 205787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2058db830c46SAndreas Gruenbacher if (peer_req->flags & EE_CALL_AL_COMPLETE_IO) 2059db830c46SAndreas Gruenbacher drbd_al_complete_io(mdev, peer_req->i.sector); 206022cc37a9SLars Ellenberg 2061b411b363SPhilipp Reisner out_interrupted: 2062db830c46SAndreas Gruenbacher drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP); 2063b411b363SPhilipp Reisner put_ldev(mdev); 2064db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 206581e84650SAndreas Gruenbacher return false; 2066b411b363SPhilipp Reisner } 2067b411b363SPhilipp Reisner 20680f0601f4SLars Ellenberg /* We may throttle resync, if the lower device seems to be busy, 20690f0601f4SLars Ellenberg * and current sync rate is above c_min_rate. 20700f0601f4SLars Ellenberg * 20710f0601f4SLars Ellenberg * To decide whether or not the lower device is busy, we use a scheme similar 20720f0601f4SLars Ellenberg * to MD RAID is_mddev_idle(): if the partition stats reveal "significant" 20730f0601f4SLars Ellenberg * (more than 64 sectors) of activity we cannot account for with our own resync 20740f0601f4SLars Ellenberg * activity, it obviously is "busy". 20750f0601f4SLars Ellenberg * 20760f0601f4SLars Ellenberg * The current sync rate used here uses only the most recent two step marks, 20770f0601f4SLars Ellenberg * to have a short time average so we can react faster. 20780f0601f4SLars Ellenberg */ 2079e3555d85SPhilipp Reisner int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector) 20800f0601f4SLars Ellenberg { 20810f0601f4SLars Ellenberg struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk; 20820f0601f4SLars Ellenberg unsigned long db, dt, dbdt; 2083e3555d85SPhilipp Reisner struct lc_element *tmp; 20840f0601f4SLars Ellenberg int curr_events; 20850f0601f4SLars Ellenberg int throttle = 0; 20860f0601f4SLars Ellenberg 20870f0601f4SLars Ellenberg /* feature disabled? */ 2088f399002eSLars Ellenberg if (mdev->ldev->dc.c_min_rate == 0) 20890f0601f4SLars Ellenberg return 0; 20900f0601f4SLars Ellenberg 2091e3555d85SPhilipp Reisner spin_lock_irq(&mdev->al_lock); 2092e3555d85SPhilipp Reisner tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector)); 2093e3555d85SPhilipp Reisner if (tmp) { 2094e3555d85SPhilipp Reisner struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce); 2095e3555d85SPhilipp Reisner if (test_bit(BME_PRIORITY, &bm_ext->flags)) { 2096e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2097e3555d85SPhilipp Reisner return 0; 2098e3555d85SPhilipp Reisner } 2099e3555d85SPhilipp Reisner /* Do not slow down if app IO is already waiting for this extent */ 2100e3555d85SPhilipp Reisner } 2101e3555d85SPhilipp Reisner spin_unlock_irq(&mdev->al_lock); 2102e3555d85SPhilipp Reisner 21030f0601f4SLars Ellenberg curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + 21040f0601f4SLars Ellenberg (int)part_stat_read(&disk->part0, sectors[1]) - 21050f0601f4SLars Ellenberg atomic_read(&mdev->rs_sect_ev); 2106e3555d85SPhilipp Reisner 21070f0601f4SLars Ellenberg if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) { 21080f0601f4SLars Ellenberg unsigned long rs_left; 21090f0601f4SLars Ellenberg int i; 21100f0601f4SLars Ellenberg 21110f0601f4SLars Ellenberg mdev->rs_last_events = curr_events; 21120f0601f4SLars Ellenberg 21130f0601f4SLars Ellenberg /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP, 21140f0601f4SLars Ellenberg * approx. */ 21152649f080SLars Ellenberg i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS; 21162649f080SLars Ellenberg 21172649f080SLars Ellenberg if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T) 21182649f080SLars Ellenberg rs_left = mdev->ov_left; 21192649f080SLars Ellenberg else 21200f0601f4SLars Ellenberg rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed; 21210f0601f4SLars Ellenberg 21220f0601f4SLars Ellenberg dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ; 21230f0601f4SLars Ellenberg if (!dt) 21240f0601f4SLars Ellenberg dt++; 21250f0601f4SLars Ellenberg db = mdev->rs_mark_left[i] - rs_left; 21260f0601f4SLars Ellenberg dbdt = Bit2KB(db/dt); 21270f0601f4SLars Ellenberg 2128f399002eSLars Ellenberg if (dbdt > mdev->ldev->dc.c_min_rate) 21290f0601f4SLars Ellenberg throttle = 1; 21300f0601f4SLars Ellenberg } 21310f0601f4SLars Ellenberg return throttle; 21320f0601f4SLars Ellenberg } 21330f0601f4SLars Ellenberg 21340f0601f4SLars Ellenberg 2135d8763023SAndreas Gruenbacher static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packet cmd, 2136d8763023SAndreas Gruenbacher unsigned int digest_size) 2137b411b363SPhilipp Reisner { 2138b411b363SPhilipp Reisner sector_t sector; 2139b411b363SPhilipp Reisner const sector_t capacity = drbd_get_capacity(mdev->this_bdev); 2140db830c46SAndreas Gruenbacher struct drbd_peer_request *peer_req; 2141b411b363SPhilipp Reisner struct digest_info *di = NULL; 2142b18b37beSPhilipp Reisner int size, verb; 2143b411b363SPhilipp Reisner unsigned int fault_type; 2144e42325a5SPhilipp Reisner struct p_block_req *p = &mdev->tconn->data.rbuf.block_req; 2145b411b363SPhilipp Reisner 2146b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 2147b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 2148b411b363SPhilipp Reisner 2149c670a398SAndreas Gruenbacher if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) { 2150b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2151b411b363SPhilipp Reisner (unsigned long long)sector, size); 215281e84650SAndreas Gruenbacher return false; 2153b411b363SPhilipp Reisner } 2154b411b363SPhilipp Reisner if (sector + (size>>9) > capacity) { 2155b411b363SPhilipp Reisner dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__, 2156b411b363SPhilipp Reisner (unsigned long long)sector, size); 215781e84650SAndreas Gruenbacher return false; 2158b411b363SPhilipp Reisner } 2159b411b363SPhilipp Reisner 2160b411b363SPhilipp Reisner if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) { 2161b18b37beSPhilipp Reisner verb = 1; 2162b18b37beSPhilipp Reisner switch (cmd) { 2163b18b37beSPhilipp Reisner case P_DATA_REQUEST: 2164b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_DREPLY, p); 2165b18b37beSPhilipp Reisner break; 2166b18b37beSPhilipp Reisner case P_RS_DATA_REQUEST: 2167b18b37beSPhilipp Reisner case P_CSUM_RS_REQUEST: 2168b18b37beSPhilipp Reisner case P_OV_REQUEST: 2169b18b37beSPhilipp Reisner drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p); 2170b18b37beSPhilipp Reisner break; 2171b18b37beSPhilipp Reisner case P_OV_REPLY: 2172b18b37beSPhilipp Reisner verb = 0; 2173b18b37beSPhilipp Reisner dec_rs_pending(mdev); 2174b18b37beSPhilipp Reisner drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC); 2175b18b37beSPhilipp Reisner break; 2176b18b37beSPhilipp Reisner default: 2177b18b37beSPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 2178b18b37beSPhilipp Reisner cmdname(cmd)); 2179b18b37beSPhilipp Reisner } 2180b18b37beSPhilipp Reisner if (verb && __ratelimit(&drbd_ratelimit_state)) 2181b411b363SPhilipp Reisner dev_err(DEV, "Can not satisfy peer's read request, " 2182b411b363SPhilipp Reisner "no local data.\n"); 2183b18b37beSPhilipp Reisner 2184a821cc4aSLars Ellenberg /* drain possibly payload */ 2185a821cc4aSLars Ellenberg return drbd_drain_block(mdev, digest_size); 2186b411b363SPhilipp Reisner } 2187b411b363SPhilipp Reisner 2188b411b363SPhilipp Reisner /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD 2189b411b363SPhilipp Reisner * "criss-cross" setup, that might cause write-out on some other DRBD, 2190b411b363SPhilipp Reisner * which in turn might block on the other node at this very place. */ 2191db830c46SAndreas Gruenbacher peer_req = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO); 2192db830c46SAndreas Gruenbacher if (!peer_req) { 2193b411b363SPhilipp Reisner put_ldev(mdev); 219481e84650SAndreas Gruenbacher return false; 2195b411b363SPhilipp Reisner } 2196b411b363SPhilipp Reisner 219702918be2SPhilipp Reisner switch (cmd) { 2198b411b363SPhilipp Reisner case P_DATA_REQUEST: 2199db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_data_req; 2200b411b363SPhilipp Reisner fault_type = DRBD_FAULT_DT_RD; 220180a40e43SLars Ellenberg /* application IO, don't drbd_rs_begin_io */ 220280a40e43SLars Ellenberg goto submit; 220380a40e43SLars Ellenberg 2204b411b363SPhilipp Reisner case P_RS_DATA_REQUEST: 2205db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_rsdata_req; 2206b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 22075f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22085f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 2209b411b363SPhilipp Reisner break; 2210b411b363SPhilipp Reisner 2211b411b363SPhilipp Reisner case P_OV_REPLY: 2212b411b363SPhilipp Reisner case P_CSUM_RS_REQUEST: 2213b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2214b411b363SPhilipp Reisner di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO); 2215b411b363SPhilipp Reisner if (!di) 2216b411b363SPhilipp Reisner goto out_free_e; 2217b411b363SPhilipp Reisner 2218b411b363SPhilipp Reisner di->digest_size = digest_size; 2219b411b363SPhilipp Reisner di->digest = (((char *)di)+sizeof(struct digest_info)); 2220b411b363SPhilipp Reisner 2221db830c46SAndreas Gruenbacher peer_req->digest = di; 2222db830c46SAndreas Gruenbacher peer_req->flags |= EE_HAS_DIGEST; 2223c36c3cedSLars Ellenberg 2224de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, di->digest, digest_size) != digest_size) 2225b411b363SPhilipp Reisner goto out_free_e; 2226b411b363SPhilipp Reisner 222702918be2SPhilipp Reisner if (cmd == P_CSUM_RS_REQUEST) { 222831890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 2229db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_csum_rs_req; 22305f9915bbSLars Ellenberg /* used in the sector offset progress display */ 22315f9915bbSLars Ellenberg mdev->bm_resync_fo = BM_SECT_TO_BIT(sector); 223202918be2SPhilipp Reisner } else if (cmd == P_OV_REPLY) { 22332649f080SLars Ellenberg /* track progress, we may need to throttle */ 22342649f080SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_in); 2235db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_reply; 2236b411b363SPhilipp Reisner dec_rs_pending(mdev); 22370f0601f4SLars Ellenberg /* drbd_rs_begin_io done when we sent this request, 22380f0601f4SLars Ellenberg * but accounting still needs to be done. */ 22390f0601f4SLars Ellenberg goto submit_for_resync; 2240b411b363SPhilipp Reisner } 2241b411b363SPhilipp Reisner break; 2242b411b363SPhilipp Reisner 2243b411b363SPhilipp Reisner case P_OV_REQUEST: 2244b411b363SPhilipp Reisner if (mdev->ov_start_sector == ~(sector_t)0 && 224531890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90) { 2246de228bbaSLars Ellenberg unsigned long now = jiffies; 2247de228bbaSLars Ellenberg int i; 2248b411b363SPhilipp Reisner mdev->ov_start_sector = sector; 2249b411b363SPhilipp Reisner mdev->ov_position = sector; 225030b743a2SLars Ellenberg mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector); 225130b743a2SLars Ellenberg mdev->rs_total = mdev->ov_left; 2252de228bbaSLars Ellenberg for (i = 0; i < DRBD_SYNC_MARKS; i++) { 2253de228bbaSLars Ellenberg mdev->rs_mark_left[i] = mdev->ov_left; 2254de228bbaSLars Ellenberg mdev->rs_mark_time[i] = now; 2255de228bbaSLars Ellenberg } 2256b411b363SPhilipp Reisner dev_info(DEV, "Online Verify start sector: %llu\n", 2257b411b363SPhilipp Reisner (unsigned long long)sector); 2258b411b363SPhilipp Reisner } 2259db830c46SAndreas Gruenbacher peer_req->w.cb = w_e_end_ov_req; 2260b411b363SPhilipp Reisner fault_type = DRBD_FAULT_RS_RD; 2261b411b363SPhilipp Reisner break; 2262b411b363SPhilipp Reisner 2263b411b363SPhilipp Reisner default: 2264b411b363SPhilipp Reisner dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n", 226502918be2SPhilipp Reisner cmdname(cmd)); 2266b411b363SPhilipp Reisner fault_type = DRBD_FAULT_MAX; 226780a40e43SLars Ellenberg goto out_free_e; 2268b411b363SPhilipp Reisner } 2269b411b363SPhilipp Reisner 22700f0601f4SLars Ellenberg /* Throttle, drbd_rs_begin_io and submit should become asynchronous 22710f0601f4SLars Ellenberg * wrt the receiver, but it is not as straightforward as it may seem. 22720f0601f4SLars Ellenberg * Various places in the resync start and stop logic assume resync 22730f0601f4SLars Ellenberg * requests are processed in order, requeuing this on the worker thread 22740f0601f4SLars Ellenberg * introduces a bunch of new code for synchronization between threads. 22750f0601f4SLars Ellenberg * 22760f0601f4SLars Ellenberg * Unlimited throttling before drbd_rs_begin_io may stall the resync 22770f0601f4SLars Ellenberg * "forever", throttling after drbd_rs_begin_io will lock that extent 22780f0601f4SLars Ellenberg * for application writes for the same time. For now, just throttle 22790f0601f4SLars Ellenberg * here, where the rest of the code expects the receiver to sleep for 22800f0601f4SLars Ellenberg * a while, anyways. 22810f0601f4SLars Ellenberg */ 2282b411b363SPhilipp Reisner 22830f0601f4SLars Ellenberg /* Throttle before drbd_rs_begin_io, as that locks out application IO; 22840f0601f4SLars Ellenberg * this defers syncer requests for some time, before letting at least 22850f0601f4SLars Ellenberg * on request through. The resync controller on the receiving side 22860f0601f4SLars Ellenberg * will adapt to the incoming rate accordingly. 22870f0601f4SLars Ellenberg * 22880f0601f4SLars Ellenberg * We cannot throttle here if remote is Primary/SyncTarget: 22890f0601f4SLars Ellenberg * we would also throttle its application reads. 22900f0601f4SLars Ellenberg * In that case, throttling is done on the SyncTarget only. 22910f0601f4SLars Ellenberg */ 2292e3555d85SPhilipp Reisner if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector)) 2293e3555d85SPhilipp Reisner schedule_timeout_uninterruptible(HZ/10); 2294e3555d85SPhilipp Reisner if (drbd_rs_begin_io(mdev, sector)) 229580a40e43SLars Ellenberg goto out_free_e; 2296b411b363SPhilipp Reisner 22970f0601f4SLars Ellenberg submit_for_resync: 22980f0601f4SLars Ellenberg atomic_add(size >> 9, &mdev->rs_sect_ev); 22990f0601f4SLars Ellenberg 230080a40e43SLars Ellenberg submit: 2301b411b363SPhilipp Reisner inc_unacked(mdev); 230287eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2303db830c46SAndreas Gruenbacher list_add_tail(&peer_req->w.list, &mdev->read_ee); 230487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 2305b411b363SPhilipp Reisner 2306fbe29decSAndreas Gruenbacher if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0) 230781e84650SAndreas Gruenbacher return true; 2308b411b363SPhilipp Reisner 230910f6d992SLars Ellenberg /* don't care for the reason here */ 231010f6d992SLars Ellenberg dev_err(DEV, "submit failed, triggering re-connect\n"); 231187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 2312db830c46SAndreas Gruenbacher list_del(&peer_req->w.list); 231387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 231422cc37a9SLars Ellenberg /* no drbd_rs_complete_io(), we are dropping the connection anyways */ 231522cc37a9SLars Ellenberg 2316b411b363SPhilipp Reisner out_free_e: 2317b411b363SPhilipp Reisner put_ldev(mdev); 2318db830c46SAndreas Gruenbacher drbd_free_ee(mdev, peer_req); 231981e84650SAndreas Gruenbacher return false; 2320b411b363SPhilipp Reisner } 2321b411b363SPhilipp Reisner 2322b411b363SPhilipp Reisner static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local) 2323b411b363SPhilipp Reisner { 2324b411b363SPhilipp Reisner int self, peer, rv = -100; 2325b411b363SPhilipp Reisner unsigned long ch_self, ch_peer; 2326b411b363SPhilipp Reisner 2327b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & 1; 2328b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & 1; 2329b411b363SPhilipp Reisner 2330b411b363SPhilipp Reisner ch_peer = mdev->p_uuid[UI_SIZE]; 2331b411b363SPhilipp Reisner ch_self = mdev->comm_bm_set; 2332b411b363SPhilipp Reisner 233389e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_0p) { 2334b411b363SPhilipp Reisner case ASB_CONSENSUS: 2335b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2336b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2337b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2338b411b363SPhilipp Reisner break; 2339b411b363SPhilipp Reisner case ASB_DISCONNECT: 2340b411b363SPhilipp Reisner break; 2341b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2342b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2343b411b363SPhilipp Reisner rv = -1; 2344b411b363SPhilipp Reisner break; 2345b411b363SPhilipp Reisner } 2346b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2347b411b363SPhilipp Reisner rv = 1; 2348b411b363SPhilipp Reisner break; 2349b411b363SPhilipp Reisner } 2350b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2351b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2352b411b363SPhilipp Reisner if (self == 0 && peer == 1) { 2353b411b363SPhilipp Reisner rv = 1; 2354b411b363SPhilipp Reisner break; 2355b411b363SPhilipp Reisner } 2356b411b363SPhilipp Reisner if (self == 1 && peer == 0) { 2357b411b363SPhilipp Reisner rv = -1; 2358b411b363SPhilipp Reisner break; 2359b411b363SPhilipp Reisner } 2360b411b363SPhilipp Reisner /* Else fall through to one of the other strategies... */ 2361ad19bf6eSLars Ellenberg dev_warn(DEV, "Discard younger/older primary did not find a decision\n" 2362b411b363SPhilipp Reisner "Using discard-least-changes instead\n"); 2363b411b363SPhilipp Reisner case ASB_DISCARD_ZERO_CHG: 2364b411b363SPhilipp Reisner if (ch_peer == 0 && ch_self == 0) { 236525703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2366b411b363SPhilipp Reisner ? -1 : 1; 2367b411b363SPhilipp Reisner break; 2368b411b363SPhilipp Reisner } else { 2369b411b363SPhilipp Reisner if (ch_peer == 0) { rv = 1; break; } 2370b411b363SPhilipp Reisner if (ch_self == 0) { rv = -1; break; } 2371b411b363SPhilipp Reisner } 237289e58e75SPhilipp Reisner if (mdev->tconn->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG) 2373b411b363SPhilipp Reisner break; 2374b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2375b411b363SPhilipp Reisner if (ch_self < ch_peer) 2376b411b363SPhilipp Reisner rv = -1; 2377b411b363SPhilipp Reisner else if (ch_self > ch_peer) 2378b411b363SPhilipp Reisner rv = 1; 2379b411b363SPhilipp Reisner else /* ( ch_self == ch_peer ) */ 2380b411b363SPhilipp Reisner /* Well, then use something else. */ 238125703f83SPhilipp Reisner rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) 2382b411b363SPhilipp Reisner ? -1 : 1; 2383b411b363SPhilipp Reisner break; 2384b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2385b411b363SPhilipp Reisner rv = -1; 2386b411b363SPhilipp Reisner break; 2387b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2388b411b363SPhilipp Reisner rv = 1; 2389b411b363SPhilipp Reisner } 2390b411b363SPhilipp Reisner 2391b411b363SPhilipp Reisner return rv; 2392b411b363SPhilipp Reisner } 2393b411b363SPhilipp Reisner 2394b411b363SPhilipp Reisner static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local) 2395b411b363SPhilipp Reisner { 23966184ea21SAndreas Gruenbacher int hg, rv = -100; 2397b411b363SPhilipp Reisner 239889e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_1p) { 2399b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2400b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2401b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2402b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2403b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2404b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2405b411b363SPhilipp Reisner break; 2406b411b363SPhilipp Reisner case ASB_DISCONNECT: 2407b411b363SPhilipp Reisner break; 2408b411b363SPhilipp Reisner case ASB_CONSENSUS: 2409b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2410b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_SECONDARY) 2411b411b363SPhilipp Reisner rv = hg; 2412b411b363SPhilipp Reisner if (hg == 1 && mdev->state.role == R_PRIMARY) 2413b411b363SPhilipp Reisner rv = hg; 2414b411b363SPhilipp Reisner break; 2415b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2416b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2417b411b363SPhilipp Reisner break; 2418b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2419b411b363SPhilipp Reisner return mdev->state.role == R_PRIMARY ? 1 : -1; 2420b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2421b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2422b411b363SPhilipp Reisner if (hg == -1 && mdev->state.role == R_PRIMARY) { 2423bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2424bb437946SAndreas Gruenbacher 2425bb437946SAndreas Gruenbacher drbd_set_role(mdev, R_SECONDARY, 0); 2426b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2427b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2428b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2429bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2430bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2431b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2432b411b363SPhilipp Reisner } else { 2433b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2434b411b363SPhilipp Reisner rv = hg; 2435b411b363SPhilipp Reisner } 2436b411b363SPhilipp Reisner } else 2437b411b363SPhilipp Reisner rv = hg; 2438b411b363SPhilipp Reisner } 2439b411b363SPhilipp Reisner 2440b411b363SPhilipp Reisner return rv; 2441b411b363SPhilipp Reisner } 2442b411b363SPhilipp Reisner 2443b411b363SPhilipp Reisner static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local) 2444b411b363SPhilipp Reisner { 24456184ea21SAndreas Gruenbacher int hg, rv = -100; 2446b411b363SPhilipp Reisner 244789e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->after_sb_2p) { 2448b411b363SPhilipp Reisner case ASB_DISCARD_YOUNGER_PRI: 2449b411b363SPhilipp Reisner case ASB_DISCARD_OLDER_PRI: 2450b411b363SPhilipp Reisner case ASB_DISCARD_LEAST_CHG: 2451b411b363SPhilipp Reisner case ASB_DISCARD_LOCAL: 2452b411b363SPhilipp Reisner case ASB_DISCARD_REMOTE: 2453b411b363SPhilipp Reisner case ASB_CONSENSUS: 2454b411b363SPhilipp Reisner case ASB_DISCARD_SECONDARY: 2455b411b363SPhilipp Reisner dev_err(DEV, "Configuration error.\n"); 2456b411b363SPhilipp Reisner break; 2457b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2458b411b363SPhilipp Reisner rv = drbd_asb_recover_0p(mdev); 2459b411b363SPhilipp Reisner break; 2460b411b363SPhilipp Reisner case ASB_DISCONNECT: 2461b411b363SPhilipp Reisner break; 2462b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2463b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2464b411b363SPhilipp Reisner if (hg == -1) { 2465bb437946SAndreas Gruenbacher enum drbd_state_rv rv2; 2466bb437946SAndreas Gruenbacher 2467b411b363SPhilipp Reisner /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE, 2468b411b363SPhilipp Reisner * we might be here in C_WF_REPORT_PARAMS which is transient. 2469b411b363SPhilipp Reisner * we do not need to wait for the after state change work either. */ 2470bb437946SAndreas Gruenbacher rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY)); 2471bb437946SAndreas Gruenbacher if (rv2 != SS_SUCCESS) { 2472b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost-after-sb"); 2473b411b363SPhilipp Reisner } else { 2474b411b363SPhilipp Reisner dev_warn(DEV, "Successfully gave up primary role.\n"); 2475b411b363SPhilipp Reisner rv = hg; 2476b411b363SPhilipp Reisner } 2477b411b363SPhilipp Reisner } else 2478b411b363SPhilipp Reisner rv = hg; 2479b411b363SPhilipp Reisner } 2480b411b363SPhilipp Reisner 2481b411b363SPhilipp Reisner return rv; 2482b411b363SPhilipp Reisner } 2483b411b363SPhilipp Reisner 2484b411b363SPhilipp Reisner static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid, 2485b411b363SPhilipp Reisner u64 bits, u64 flags) 2486b411b363SPhilipp Reisner { 2487b411b363SPhilipp Reisner if (!uuid) { 2488b411b363SPhilipp Reisner dev_info(DEV, "%s uuid info vanished while I was looking!\n", text); 2489b411b363SPhilipp Reisner return; 2490b411b363SPhilipp Reisner } 2491b411b363SPhilipp Reisner dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n", 2492b411b363SPhilipp Reisner text, 2493b411b363SPhilipp Reisner (unsigned long long)uuid[UI_CURRENT], 2494b411b363SPhilipp Reisner (unsigned long long)uuid[UI_BITMAP], 2495b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_START], 2496b411b363SPhilipp Reisner (unsigned long long)uuid[UI_HISTORY_END], 2497b411b363SPhilipp Reisner (unsigned long long)bits, 2498b411b363SPhilipp Reisner (unsigned long long)flags); 2499b411b363SPhilipp Reisner } 2500b411b363SPhilipp Reisner 2501b411b363SPhilipp Reisner /* 2502b411b363SPhilipp Reisner 100 after split brain try auto recover 2503b411b363SPhilipp Reisner 2 C_SYNC_SOURCE set BitMap 2504b411b363SPhilipp Reisner 1 C_SYNC_SOURCE use BitMap 2505b411b363SPhilipp Reisner 0 no Sync 2506b411b363SPhilipp Reisner -1 C_SYNC_TARGET use BitMap 2507b411b363SPhilipp Reisner -2 C_SYNC_TARGET set BitMap 2508b411b363SPhilipp Reisner -100 after split brain, disconnect 2509b411b363SPhilipp Reisner -1000 unrelated data 25104a23f264SPhilipp Reisner -1091 requires proto 91 25114a23f264SPhilipp Reisner -1096 requires proto 96 2512b411b363SPhilipp Reisner */ 2513b411b363SPhilipp Reisner static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local) 2514b411b363SPhilipp Reisner { 2515b411b363SPhilipp Reisner u64 self, peer; 2516b411b363SPhilipp Reisner int i, j; 2517b411b363SPhilipp Reisner 2518b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2519b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2520b411b363SPhilipp Reisner 2521b411b363SPhilipp Reisner *rule_nr = 10; 2522b411b363SPhilipp Reisner if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED) 2523b411b363SPhilipp Reisner return 0; 2524b411b363SPhilipp Reisner 2525b411b363SPhilipp Reisner *rule_nr = 20; 2526b411b363SPhilipp Reisner if ((self == UUID_JUST_CREATED || self == (u64)0) && 2527b411b363SPhilipp Reisner peer != UUID_JUST_CREATED) 2528b411b363SPhilipp Reisner return -2; 2529b411b363SPhilipp Reisner 2530b411b363SPhilipp Reisner *rule_nr = 30; 2531b411b363SPhilipp Reisner if (self != UUID_JUST_CREATED && 2532b411b363SPhilipp Reisner (peer == UUID_JUST_CREATED || peer == (u64)0)) 2533b411b363SPhilipp Reisner return 2; 2534b411b363SPhilipp Reisner 2535b411b363SPhilipp Reisner if (self == peer) { 2536b411b363SPhilipp Reisner int rct, dc; /* roles at crash time */ 2537b411b363SPhilipp Reisner 2538b411b363SPhilipp Reisner if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) { 2539b411b363SPhilipp Reisner 254031890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25414a23f264SPhilipp Reisner return -1091; 2542b411b363SPhilipp Reisner 2543b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) && 2544b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) { 2545b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n"); 2546b411b363SPhilipp Reisner drbd_uuid_set_bm(mdev, 0UL); 2547b411b363SPhilipp Reisner 2548b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2549b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2550b411b363SPhilipp Reisner *rule_nr = 34; 2551b411b363SPhilipp Reisner } else { 2552b411b363SPhilipp Reisner dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n"); 2553b411b363SPhilipp Reisner *rule_nr = 36; 2554b411b363SPhilipp Reisner } 2555b411b363SPhilipp Reisner 2556b411b363SPhilipp Reisner return 1; 2557b411b363SPhilipp Reisner } 2558b411b363SPhilipp Reisner 2559b411b363SPhilipp Reisner if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) { 2560b411b363SPhilipp Reisner 256131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 25624a23f264SPhilipp Reisner return -1091; 2563b411b363SPhilipp Reisner 2564b411b363SPhilipp Reisner if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) && 2565b411b363SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) { 2566b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n"); 2567b411b363SPhilipp Reisner 2568b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START]; 2569b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP]; 2570b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = 0UL; 2571b411b363SPhilipp Reisner 2572b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2573b411b363SPhilipp Reisner *rule_nr = 35; 2574b411b363SPhilipp Reisner } else { 2575b411b363SPhilipp Reisner dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n"); 2576b411b363SPhilipp Reisner *rule_nr = 37; 2577b411b363SPhilipp Reisner } 2578b411b363SPhilipp Reisner 2579b411b363SPhilipp Reisner return -1; 2580b411b363SPhilipp Reisner } 2581b411b363SPhilipp Reisner 2582b411b363SPhilipp Reisner /* Common power [off|failure] */ 2583b411b363SPhilipp Reisner rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) + 2584b411b363SPhilipp Reisner (mdev->p_uuid[UI_FLAGS] & 2); 2585b411b363SPhilipp Reisner /* lowest bit is set when we were primary, 2586b411b363SPhilipp Reisner * next bit (weight 2) is set when peer was primary */ 2587b411b363SPhilipp Reisner *rule_nr = 40; 2588b411b363SPhilipp Reisner 2589b411b363SPhilipp Reisner switch (rct) { 2590b411b363SPhilipp Reisner case 0: /* !self_pri && !peer_pri */ return 0; 2591b411b363SPhilipp Reisner case 1: /* self_pri && !peer_pri */ return 1; 2592b411b363SPhilipp Reisner case 2: /* !self_pri && peer_pri */ return -1; 2593b411b363SPhilipp Reisner case 3: /* self_pri && peer_pri */ 259425703f83SPhilipp Reisner dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags); 2595b411b363SPhilipp Reisner return dc ? -1 : 1; 2596b411b363SPhilipp Reisner } 2597b411b363SPhilipp Reisner } 2598b411b363SPhilipp Reisner 2599b411b363SPhilipp Reisner *rule_nr = 50; 2600b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2601b411b363SPhilipp Reisner if (self == peer) 2602b411b363SPhilipp Reisner return -1; 2603b411b363SPhilipp Reisner 2604b411b363SPhilipp Reisner *rule_nr = 51; 2605b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1); 2606b411b363SPhilipp Reisner if (self == peer) { 260731890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26084a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == 26094a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) : 26104a23f264SPhilipp Reisner peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) { 2611b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2612b411b363SPhilipp Reisner resync as sync source modifications of the peer's UUIDs. */ 2613b411b363SPhilipp Reisner 261431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26154a23f264SPhilipp Reisner return -1091; 2616b411b363SPhilipp Reisner 2617b411b363SPhilipp Reisner mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START]; 2618b411b363SPhilipp Reisner mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1]; 26194a23f264SPhilipp Reisner 26204a23f264SPhilipp Reisner dev_info(DEV, "Did not got last syncUUID packet, corrected:\n"); 26214a23f264SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 26224a23f264SPhilipp Reisner 2623b411b363SPhilipp Reisner return -1; 2624b411b363SPhilipp Reisner } 2625b411b363SPhilipp Reisner } 2626b411b363SPhilipp Reisner 2627b411b363SPhilipp Reisner *rule_nr = 60; 2628b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1); 2629b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2630b411b363SPhilipp Reisner peer = mdev->p_uuid[i] & ~((u64)1); 2631b411b363SPhilipp Reisner if (self == peer) 2632b411b363SPhilipp Reisner return -2; 2633b411b363SPhilipp Reisner } 2634b411b363SPhilipp Reisner 2635b411b363SPhilipp Reisner *rule_nr = 70; 2636b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2637b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2638b411b363SPhilipp Reisner if (self == peer) 2639b411b363SPhilipp Reisner return 1; 2640b411b363SPhilipp Reisner 2641b411b363SPhilipp Reisner *rule_nr = 71; 2642b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1); 2643b411b363SPhilipp Reisner if (self == peer) { 264431890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 96 ? 26454a23f264SPhilipp Reisner (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == 26464a23f264SPhilipp Reisner (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) : 26474a23f264SPhilipp Reisner self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) { 2648b411b363SPhilipp Reisner /* The last P_SYNC_UUID did not get though. Undo the last start of 2649b411b363SPhilipp Reisner resync as sync source modifications of our UUIDs. */ 2650b411b363SPhilipp Reisner 265131890f4aSPhilipp Reisner if (mdev->tconn->agreed_pro_version < 91) 26524a23f264SPhilipp Reisner return -1091; 2653b411b363SPhilipp Reisner 2654b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]); 2655b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]); 2656b411b363SPhilipp Reisner 26574a23f264SPhilipp Reisner dev_info(DEV, "Last syncUUID did not get through, corrected:\n"); 2658b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, 2659b411b363SPhilipp Reisner mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0); 2660b411b363SPhilipp Reisner 2661b411b363SPhilipp Reisner return 1; 2662b411b363SPhilipp Reisner } 2663b411b363SPhilipp Reisner } 2664b411b363SPhilipp Reisner 2665b411b363SPhilipp Reisner 2666b411b363SPhilipp Reisner *rule_nr = 80; 2667d8c2a36bSPhilipp Reisner peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1); 2668b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2669b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2670b411b363SPhilipp Reisner if (self == peer) 2671b411b363SPhilipp Reisner return 2; 2672b411b363SPhilipp Reisner } 2673b411b363SPhilipp Reisner 2674b411b363SPhilipp Reisner *rule_nr = 90; 2675b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1); 2676b411b363SPhilipp Reisner peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1); 2677b411b363SPhilipp Reisner if (self == peer && self != ((u64)0)) 2678b411b363SPhilipp Reisner return 100; 2679b411b363SPhilipp Reisner 2680b411b363SPhilipp Reisner *rule_nr = 100; 2681b411b363SPhilipp Reisner for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) { 2682b411b363SPhilipp Reisner self = mdev->ldev->md.uuid[i] & ~((u64)1); 2683b411b363SPhilipp Reisner for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) { 2684b411b363SPhilipp Reisner peer = mdev->p_uuid[j] & ~((u64)1); 2685b411b363SPhilipp Reisner if (self == peer) 2686b411b363SPhilipp Reisner return -100; 2687b411b363SPhilipp Reisner } 2688b411b363SPhilipp Reisner } 2689b411b363SPhilipp Reisner 2690b411b363SPhilipp Reisner return -1000; 2691b411b363SPhilipp Reisner } 2692b411b363SPhilipp Reisner 2693b411b363SPhilipp Reisner /* drbd_sync_handshake() returns the new conn state on success, or 2694b411b363SPhilipp Reisner CONN_MASK (-1) on failure. 2695b411b363SPhilipp Reisner */ 2696b411b363SPhilipp Reisner static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role, 2697b411b363SPhilipp Reisner enum drbd_disk_state peer_disk) __must_hold(local) 2698b411b363SPhilipp Reisner { 2699b411b363SPhilipp Reisner int hg, rule_nr; 2700b411b363SPhilipp Reisner enum drbd_conns rv = C_MASK; 2701b411b363SPhilipp Reisner enum drbd_disk_state mydisk; 2702b411b363SPhilipp Reisner 2703b411b363SPhilipp Reisner mydisk = mdev->state.disk; 2704b411b363SPhilipp Reisner if (mydisk == D_NEGOTIATING) 2705b411b363SPhilipp Reisner mydisk = mdev->new_state_tmp.disk; 2706b411b363SPhilipp Reisner 2707b411b363SPhilipp Reisner dev_info(DEV, "drbd_sync_handshake:\n"); 2708b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0); 2709b411b363SPhilipp Reisner drbd_uuid_dump(mdev, "peer", mdev->p_uuid, 2710b411b363SPhilipp Reisner mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]); 2711b411b363SPhilipp Reisner 2712b411b363SPhilipp Reisner hg = drbd_uuid_compare(mdev, &rule_nr); 2713b411b363SPhilipp Reisner 2714b411b363SPhilipp Reisner dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr); 2715b411b363SPhilipp Reisner 2716b411b363SPhilipp Reisner if (hg == -1000) { 2717b411b363SPhilipp Reisner dev_alert(DEV, "Unrelated data, aborting!\n"); 2718b411b363SPhilipp Reisner return C_MASK; 2719b411b363SPhilipp Reisner } 27204a23f264SPhilipp Reisner if (hg < -1000) { 27214a23f264SPhilipp Reisner dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000); 2722b411b363SPhilipp Reisner return C_MASK; 2723b411b363SPhilipp Reisner } 2724b411b363SPhilipp Reisner 2725b411b363SPhilipp Reisner if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) || 2726b411b363SPhilipp Reisner (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) { 2727b411b363SPhilipp Reisner int f = (hg == -100) || abs(hg) == 2; 2728b411b363SPhilipp Reisner hg = mydisk > D_INCONSISTENT ? 1 : -1; 2729b411b363SPhilipp Reisner if (f) 2730b411b363SPhilipp Reisner hg = hg*2; 2731b411b363SPhilipp Reisner dev_info(DEV, "Becoming sync %s due to disk states.\n", 2732b411b363SPhilipp Reisner hg > 0 ? "source" : "target"); 2733b411b363SPhilipp Reisner } 2734b411b363SPhilipp Reisner 27353a11a487SAdam Gandelman if (abs(hg) == 100) 27363a11a487SAdam Gandelman drbd_khelper(mdev, "initial-split-brain"); 27373a11a487SAdam Gandelman 273889e58e75SPhilipp Reisner if (hg == 100 || (hg == -100 && mdev->tconn->net_conf->always_asbp)) { 2739b411b363SPhilipp Reisner int pcount = (mdev->state.role == R_PRIMARY) 2740b411b363SPhilipp Reisner + (peer_role == R_PRIMARY); 2741b411b363SPhilipp Reisner int forced = (hg == -100); 2742b411b363SPhilipp Reisner 2743b411b363SPhilipp Reisner switch (pcount) { 2744b411b363SPhilipp Reisner case 0: 2745b411b363SPhilipp Reisner hg = drbd_asb_recover_0p(mdev); 2746b411b363SPhilipp Reisner break; 2747b411b363SPhilipp Reisner case 1: 2748b411b363SPhilipp Reisner hg = drbd_asb_recover_1p(mdev); 2749b411b363SPhilipp Reisner break; 2750b411b363SPhilipp Reisner case 2: 2751b411b363SPhilipp Reisner hg = drbd_asb_recover_2p(mdev); 2752b411b363SPhilipp Reisner break; 2753b411b363SPhilipp Reisner } 2754b411b363SPhilipp Reisner if (abs(hg) < 100) { 2755b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, %d primaries, " 2756b411b363SPhilipp Reisner "automatically solved. Sync from %s node\n", 2757b411b363SPhilipp Reisner pcount, (hg < 0) ? "peer" : "this"); 2758b411b363SPhilipp Reisner if (forced) { 2759b411b363SPhilipp Reisner dev_warn(DEV, "Doing a full sync, since" 2760b411b363SPhilipp Reisner " UUIDs where ambiguous.\n"); 2761b411b363SPhilipp Reisner hg = hg*2; 2762b411b363SPhilipp Reisner } 2763b411b363SPhilipp Reisner } 2764b411b363SPhilipp Reisner } 2765b411b363SPhilipp Reisner 2766b411b363SPhilipp Reisner if (hg == -100) { 276789e58e75SPhilipp Reisner if (mdev->tconn->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1)) 2768b411b363SPhilipp Reisner hg = -1; 276989e58e75SPhilipp Reisner if (!mdev->tconn->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1)) 2770b411b363SPhilipp Reisner hg = 1; 2771b411b363SPhilipp Reisner 2772b411b363SPhilipp Reisner if (abs(hg) < 100) 2773b411b363SPhilipp Reisner dev_warn(DEV, "Split-Brain detected, manually solved. " 2774b411b363SPhilipp Reisner "Sync from %s node\n", 2775b411b363SPhilipp Reisner (hg < 0) ? "peer" : "this"); 2776b411b363SPhilipp Reisner } 2777b411b363SPhilipp Reisner 2778b411b363SPhilipp Reisner if (hg == -100) { 2779580b9767SLars Ellenberg /* FIXME this log message is not correct if we end up here 2780580b9767SLars Ellenberg * after an attempted attach on a diskless node. 2781580b9767SLars Ellenberg * We just refuse to attach -- well, we drop the "connection" 2782580b9767SLars Ellenberg * to that disk, in a way... */ 27833a11a487SAdam Gandelman dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n"); 2784b411b363SPhilipp Reisner drbd_khelper(mdev, "split-brain"); 2785b411b363SPhilipp Reisner return C_MASK; 2786b411b363SPhilipp Reisner } 2787b411b363SPhilipp Reisner 2788b411b363SPhilipp Reisner if (hg > 0 && mydisk <= D_INCONSISTENT) { 2789b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n"); 2790b411b363SPhilipp Reisner return C_MASK; 2791b411b363SPhilipp Reisner } 2792b411b363SPhilipp Reisner 2793b411b363SPhilipp Reisner if (hg < 0 && /* by intention we do not use mydisk here. */ 2794b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) { 279589e58e75SPhilipp Reisner switch (mdev->tconn->net_conf->rr_conflict) { 2796b411b363SPhilipp Reisner case ASB_CALL_HELPER: 2797b411b363SPhilipp Reisner drbd_khelper(mdev, "pri-lost"); 2798b411b363SPhilipp Reisner /* fall through */ 2799b411b363SPhilipp Reisner case ASB_DISCONNECT: 2800b411b363SPhilipp Reisner dev_err(DEV, "I shall become SyncTarget, but I am primary!\n"); 2801b411b363SPhilipp Reisner return C_MASK; 2802b411b363SPhilipp Reisner case ASB_VIOLENTLY: 2803b411b363SPhilipp Reisner dev_warn(DEV, "Becoming SyncTarget, violating the stable-data" 2804b411b363SPhilipp Reisner "assumption\n"); 2805b411b363SPhilipp Reisner } 2806b411b363SPhilipp Reisner } 2807b411b363SPhilipp Reisner 28088169e41bSPhilipp Reisner if (mdev->tconn->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) { 2809cf14c2e9SPhilipp Reisner if (hg == 0) 2810cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n"); 2811cf14c2e9SPhilipp Reisner else 2812cf14c2e9SPhilipp Reisner dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.", 2813cf14c2e9SPhilipp Reisner drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET), 2814cf14c2e9SPhilipp Reisner abs(hg) >= 2 ? "full" : "bit-map based"); 2815cf14c2e9SPhilipp Reisner return C_MASK; 2816cf14c2e9SPhilipp Reisner } 2817cf14c2e9SPhilipp Reisner 2818b411b363SPhilipp Reisner if (abs(hg) >= 2) { 2819b411b363SPhilipp Reisner dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n"); 282020ceb2b2SLars Ellenberg if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake", 282120ceb2b2SLars Ellenberg BM_LOCKED_SET_ALLOWED)) 2822b411b363SPhilipp Reisner return C_MASK; 2823b411b363SPhilipp Reisner } 2824b411b363SPhilipp Reisner 2825b411b363SPhilipp Reisner if (hg > 0) { /* become sync source. */ 2826b411b363SPhilipp Reisner rv = C_WF_BITMAP_S; 2827b411b363SPhilipp Reisner } else if (hg < 0) { /* become sync target */ 2828b411b363SPhilipp Reisner rv = C_WF_BITMAP_T; 2829b411b363SPhilipp Reisner } else { 2830b411b363SPhilipp Reisner rv = C_CONNECTED; 2831b411b363SPhilipp Reisner if (drbd_bm_total_weight(mdev)) { 2832b411b363SPhilipp Reisner dev_info(DEV, "No resync, but %lu bits in bitmap!\n", 2833b411b363SPhilipp Reisner drbd_bm_total_weight(mdev)); 2834b411b363SPhilipp Reisner } 2835b411b363SPhilipp Reisner } 2836b411b363SPhilipp Reisner 2837b411b363SPhilipp Reisner return rv; 2838b411b363SPhilipp Reisner } 2839b411b363SPhilipp Reisner 2840b411b363SPhilipp Reisner /* returns 1 if invalid */ 2841b411b363SPhilipp Reisner static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self) 2842b411b363SPhilipp Reisner { 2843b411b363SPhilipp Reisner /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */ 2844b411b363SPhilipp Reisner if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) || 2845b411b363SPhilipp Reisner (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL)) 2846b411b363SPhilipp Reisner return 0; 2847b411b363SPhilipp Reisner 2848b411b363SPhilipp Reisner /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */ 2849b411b363SPhilipp Reisner if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL || 2850b411b363SPhilipp Reisner self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL) 2851b411b363SPhilipp Reisner return 1; 2852b411b363SPhilipp Reisner 2853b411b363SPhilipp Reisner /* everything else is valid if they are equal on both sides. */ 2854b411b363SPhilipp Reisner if (peer == self) 2855b411b363SPhilipp Reisner return 0; 2856b411b363SPhilipp Reisner 2857b411b363SPhilipp Reisner /* everything es is invalid. */ 2858b411b363SPhilipp Reisner return 1; 2859b411b363SPhilipp Reisner } 2860b411b363SPhilipp Reisner 28617204624cSPhilipp Reisner static int receive_protocol(struct drbd_tconn *tconn, enum drbd_packet cmd, 2862d8763023SAndreas Gruenbacher unsigned int data_size) 2863b411b363SPhilipp Reisner { 28647204624cSPhilipp Reisner struct p_protocol *p = &tconn->data.rbuf.protocol; 2865b411b363SPhilipp Reisner int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p; 2866cf14c2e9SPhilipp Reisner int p_want_lose, p_two_primaries, cf; 2867b411b363SPhilipp Reisner char p_integrity_alg[SHARED_SECRET_MAX] = ""; 2868b411b363SPhilipp Reisner 2869b411b363SPhilipp Reisner p_proto = be32_to_cpu(p->protocol); 2870b411b363SPhilipp Reisner p_after_sb_0p = be32_to_cpu(p->after_sb_0p); 2871b411b363SPhilipp Reisner p_after_sb_1p = be32_to_cpu(p->after_sb_1p); 2872b411b363SPhilipp Reisner p_after_sb_2p = be32_to_cpu(p->after_sb_2p); 2873b411b363SPhilipp Reisner p_two_primaries = be32_to_cpu(p->two_primaries); 2874cf14c2e9SPhilipp Reisner cf = be32_to_cpu(p->conn_flags); 2875cf14c2e9SPhilipp Reisner p_want_lose = cf & CF_WANT_LOSE; 2876cf14c2e9SPhilipp Reisner 28777204624cSPhilipp Reisner clear_bit(CONN_DRY_RUN, &tconn->flags); 2878cf14c2e9SPhilipp Reisner 2879cf14c2e9SPhilipp Reisner if (cf & CF_DRY_RUN) 28807204624cSPhilipp Reisner set_bit(CONN_DRY_RUN, &tconn->flags); 2881b411b363SPhilipp Reisner 28827204624cSPhilipp Reisner if (p_proto != tconn->net_conf->wire_protocol) { 28837204624cSPhilipp Reisner conn_err(tconn, "incompatible communication protocols\n"); 2884b411b363SPhilipp Reisner goto disconnect; 2885b411b363SPhilipp Reisner } 2886b411b363SPhilipp Reisner 28877204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_0p, tconn->net_conf->after_sb_0p)) { 28887204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-0pri settings\n"); 2889b411b363SPhilipp Reisner goto disconnect; 2890b411b363SPhilipp Reisner } 2891b411b363SPhilipp Reisner 28927204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_1p, tconn->net_conf->after_sb_1p)) { 28937204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-1pri settings\n"); 2894b411b363SPhilipp Reisner goto disconnect; 2895b411b363SPhilipp Reisner } 2896b411b363SPhilipp Reisner 28977204624cSPhilipp Reisner if (cmp_after_sb(p_after_sb_2p, tconn->net_conf->after_sb_2p)) { 28987204624cSPhilipp Reisner conn_err(tconn, "incompatible after-sb-2pri settings\n"); 2899b411b363SPhilipp Reisner goto disconnect; 2900b411b363SPhilipp Reisner } 2901b411b363SPhilipp Reisner 29027204624cSPhilipp Reisner if (p_want_lose && tconn->net_conf->want_lose) { 29037204624cSPhilipp Reisner conn_err(tconn, "both sides have the 'want_lose' flag set\n"); 2904b411b363SPhilipp Reisner goto disconnect; 2905b411b363SPhilipp Reisner } 2906b411b363SPhilipp Reisner 29077204624cSPhilipp Reisner if (p_two_primaries != tconn->net_conf->two_primaries) { 29087204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the two-primaries options\n"); 2909b411b363SPhilipp Reisner goto disconnect; 2910b411b363SPhilipp Reisner } 2911b411b363SPhilipp Reisner 29127204624cSPhilipp Reisner if (tconn->agreed_pro_version >= 87) { 29137204624cSPhilipp Reisner unsigned char *my_alg = tconn->net_conf->integrity_alg; 2914b411b363SPhilipp Reisner 29157204624cSPhilipp Reisner if (drbd_recv(tconn, p_integrity_alg, data_size) != data_size) 291681e84650SAndreas Gruenbacher return false; 2917b411b363SPhilipp Reisner 2918b411b363SPhilipp Reisner p_integrity_alg[SHARED_SECRET_MAX-1] = 0; 2919b411b363SPhilipp Reisner if (strcmp(p_integrity_alg, my_alg)) { 29207204624cSPhilipp Reisner conn_err(tconn, "incompatible setting of the data-integrity-alg\n"); 2921b411b363SPhilipp Reisner goto disconnect; 2922b411b363SPhilipp Reisner } 29237204624cSPhilipp Reisner conn_info(tconn, "data-integrity-alg: %s\n", 2924b411b363SPhilipp Reisner my_alg[0] ? my_alg : (unsigned char *)"<not-used>"); 2925b411b363SPhilipp Reisner } 2926b411b363SPhilipp Reisner 292781e84650SAndreas Gruenbacher return true; 2928b411b363SPhilipp Reisner 2929b411b363SPhilipp Reisner disconnect: 29307204624cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 293181e84650SAndreas Gruenbacher return false; 2932b411b363SPhilipp Reisner } 2933b411b363SPhilipp Reisner 2934b411b363SPhilipp Reisner /* helper function 2935b411b363SPhilipp Reisner * input: alg name, feature name 2936b411b363SPhilipp Reisner * return: NULL (alg name was "") 2937b411b363SPhilipp Reisner * ERR_PTR(error) if something goes wrong 2938b411b363SPhilipp Reisner * or the crypto hash ptr, if it worked out ok. */ 2939b411b363SPhilipp Reisner struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev, 2940b411b363SPhilipp Reisner const char *alg, const char *name) 2941b411b363SPhilipp Reisner { 2942b411b363SPhilipp Reisner struct crypto_hash *tfm; 2943b411b363SPhilipp Reisner 2944b411b363SPhilipp Reisner if (!alg[0]) 2945b411b363SPhilipp Reisner return NULL; 2946b411b363SPhilipp Reisner 2947b411b363SPhilipp Reisner tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC); 2948b411b363SPhilipp Reisner if (IS_ERR(tfm)) { 2949b411b363SPhilipp Reisner dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n", 2950b411b363SPhilipp Reisner alg, name, PTR_ERR(tfm)); 2951b411b363SPhilipp Reisner return tfm; 2952b411b363SPhilipp Reisner } 2953b411b363SPhilipp Reisner if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) { 2954b411b363SPhilipp Reisner crypto_free_hash(tfm); 2955b411b363SPhilipp Reisner dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name); 2956b411b363SPhilipp Reisner return ERR_PTR(-EINVAL); 2957b411b363SPhilipp Reisner } 2958b411b363SPhilipp Reisner return tfm; 2959b411b363SPhilipp Reisner } 2960b411b363SPhilipp Reisner 2961d8763023SAndreas Gruenbacher static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packet cmd, 2962d8763023SAndreas Gruenbacher unsigned int packet_size) 2963b411b363SPhilipp Reisner { 296481e84650SAndreas Gruenbacher int ok = true; 2965e42325a5SPhilipp Reisner struct p_rs_param_95 *p = &mdev->tconn->data.rbuf.rs_param_95; 2966b411b363SPhilipp Reisner unsigned int header_size, data_size, exp_max_sz; 2967b411b363SPhilipp Reisner struct crypto_hash *verify_tfm = NULL; 2968b411b363SPhilipp Reisner struct crypto_hash *csums_tfm = NULL; 296931890f4aSPhilipp Reisner const int apv = mdev->tconn->agreed_pro_version; 2970778f271dSPhilipp Reisner int *rs_plan_s = NULL; 2971778f271dSPhilipp Reisner int fifo_size = 0; 2972b411b363SPhilipp Reisner 2973b411b363SPhilipp Reisner exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param) 2974b411b363SPhilipp Reisner : apv == 88 ? sizeof(struct p_rs_param) 2975b411b363SPhilipp Reisner + SHARED_SECRET_MAX 29768e26f9ccSPhilipp Reisner : apv <= 94 ? sizeof(struct p_rs_param_89) 29778e26f9ccSPhilipp Reisner : /* apv >= 95 */ sizeof(struct p_rs_param_95); 2978b411b363SPhilipp Reisner 297902918be2SPhilipp Reisner if (packet_size > exp_max_sz) { 2980b411b363SPhilipp Reisner dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n", 298102918be2SPhilipp Reisner packet_size, exp_max_sz); 298281e84650SAndreas Gruenbacher return false; 2983b411b363SPhilipp Reisner } 2984b411b363SPhilipp Reisner 2985b411b363SPhilipp Reisner if (apv <= 88) { 2986257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param) - sizeof(struct p_header); 298702918be2SPhilipp Reisner data_size = packet_size - header_size; 29888e26f9ccSPhilipp Reisner } else if (apv <= 94) { 2989257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header); 299002918be2SPhilipp Reisner data_size = packet_size - header_size; 2991b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 29928e26f9ccSPhilipp Reisner } else { 2993257d0af6SPhilipp Reisner header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header); 299402918be2SPhilipp Reisner data_size = packet_size - header_size; 2995b411b363SPhilipp Reisner D_ASSERT(data_size == 0); 2996b411b363SPhilipp Reisner } 2997b411b363SPhilipp Reisner 2998b411b363SPhilipp Reisner /* initialize verify_alg and csums_alg */ 2999b411b363SPhilipp Reisner memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX); 3000b411b363SPhilipp Reisner 3001de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, &p->head.payload, header_size) != header_size) 300281e84650SAndreas Gruenbacher return false; 3003b411b363SPhilipp Reisner 3004f399002eSLars Ellenberg if (get_ldev(mdev)) { 3005f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3006f399002eSLars Ellenberg put_ldev(mdev); 3007f399002eSLars Ellenberg } 3008b411b363SPhilipp Reisner 3009b411b363SPhilipp Reisner if (apv >= 88) { 3010b411b363SPhilipp Reisner if (apv == 88) { 3011b411b363SPhilipp Reisner if (data_size > SHARED_SECRET_MAX) { 3012b411b363SPhilipp Reisner dev_err(DEV, "verify-alg too long, " 3013b411b363SPhilipp Reisner "peer wants %u, accepting only %u byte\n", 3014b411b363SPhilipp Reisner data_size, SHARED_SECRET_MAX); 301581e84650SAndreas Gruenbacher return false; 3016b411b363SPhilipp Reisner } 3017b411b363SPhilipp Reisner 3018de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->verify_alg, data_size) != data_size) 301981e84650SAndreas Gruenbacher return false; 3020b411b363SPhilipp Reisner 3021b411b363SPhilipp Reisner /* we expect NUL terminated string */ 3022b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3023b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[data_size-1] == 0); 3024b411b363SPhilipp Reisner p->verify_alg[data_size-1] = 0; 3025b411b363SPhilipp Reisner 3026b411b363SPhilipp Reisner } else /* apv >= 89 */ { 3027b411b363SPhilipp Reisner /* we still expect NUL terminated strings */ 3028b411b363SPhilipp Reisner /* but just in case someone tries to be evil */ 3029b411b363SPhilipp Reisner D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0); 3030b411b363SPhilipp Reisner D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0); 3031b411b363SPhilipp Reisner p->verify_alg[SHARED_SECRET_MAX-1] = 0; 3032b411b363SPhilipp Reisner p->csums_alg[SHARED_SECRET_MAX-1] = 0; 3033b411b363SPhilipp Reisner } 3034b411b363SPhilipp Reisner 3035f399002eSLars Ellenberg if (strcmp(mdev->tconn->net_conf->verify_alg, p->verify_alg)) { 3036b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3037b411b363SPhilipp Reisner dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n", 3038f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg, p->verify_alg); 3039b411b363SPhilipp Reisner goto disconnect; 3040b411b363SPhilipp Reisner } 3041b411b363SPhilipp Reisner verify_tfm = drbd_crypto_alloc_digest_safe(mdev, 3042b411b363SPhilipp Reisner p->verify_alg, "verify-alg"); 3043b411b363SPhilipp Reisner if (IS_ERR(verify_tfm)) { 3044b411b363SPhilipp Reisner verify_tfm = NULL; 3045b411b363SPhilipp Reisner goto disconnect; 3046b411b363SPhilipp Reisner } 3047b411b363SPhilipp Reisner } 3048b411b363SPhilipp Reisner 3049f399002eSLars Ellenberg if (apv >= 89 && strcmp(mdev->tconn->net_conf->csums_alg, p->csums_alg)) { 3050b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) { 3051b411b363SPhilipp Reisner dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n", 3052f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg, p->csums_alg); 3053b411b363SPhilipp Reisner goto disconnect; 3054b411b363SPhilipp Reisner } 3055b411b363SPhilipp Reisner csums_tfm = drbd_crypto_alloc_digest_safe(mdev, 3056b411b363SPhilipp Reisner p->csums_alg, "csums-alg"); 3057b411b363SPhilipp Reisner if (IS_ERR(csums_tfm)) { 3058b411b363SPhilipp Reisner csums_tfm = NULL; 3059b411b363SPhilipp Reisner goto disconnect; 3060b411b363SPhilipp Reisner } 3061b411b363SPhilipp Reisner } 3062b411b363SPhilipp Reisner 3063f399002eSLars Ellenberg if (apv > 94 && get_ldev(mdev)) { 3064f399002eSLars Ellenberg mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate); 3065f399002eSLars Ellenberg mdev->ldev->dc.c_plan_ahead = be32_to_cpu(p->c_plan_ahead); 3066f399002eSLars Ellenberg mdev->ldev->dc.c_delay_target = be32_to_cpu(p->c_delay_target); 3067f399002eSLars Ellenberg mdev->ldev->dc.c_fill_target = be32_to_cpu(p->c_fill_target); 3068f399002eSLars Ellenberg mdev->ldev->dc.c_max_rate = be32_to_cpu(p->c_max_rate); 3069778f271dSPhilipp Reisner 3070f399002eSLars Ellenberg fifo_size = (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ; 3071778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) { 3072778f271dSPhilipp Reisner rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL); 3073778f271dSPhilipp Reisner if (!rs_plan_s) { 3074778f271dSPhilipp Reisner dev_err(DEV, "kmalloc of fifo_buffer failed"); 3075f399002eSLars Ellenberg put_ldev(mdev); 3076778f271dSPhilipp Reisner goto disconnect; 3077778f271dSPhilipp Reisner } 3078778f271dSPhilipp Reisner } 3079f399002eSLars Ellenberg put_ldev(mdev); 30808e26f9ccSPhilipp Reisner } 3081b411b363SPhilipp Reisner 3082b411b363SPhilipp Reisner spin_lock(&mdev->peer_seq_lock); 3083b411b363SPhilipp Reisner /* lock against drbd_nl_syncer_conf() */ 3084b411b363SPhilipp Reisner if (verify_tfm) { 3085f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->verify_alg, p->verify_alg); 3086f399002eSLars Ellenberg mdev->tconn->net_conf->verify_alg_len = strlen(p->verify_alg) + 1; 3087f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->verify_tfm); 3088f399002eSLars Ellenberg mdev->tconn->verify_tfm = verify_tfm; 3089b411b363SPhilipp Reisner dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg); 3090b411b363SPhilipp Reisner } 3091b411b363SPhilipp Reisner if (csums_tfm) { 3092f399002eSLars Ellenberg strcpy(mdev->tconn->net_conf->csums_alg, p->csums_alg); 3093f399002eSLars Ellenberg mdev->tconn->net_conf->csums_alg_len = strlen(p->csums_alg) + 1; 3094f399002eSLars Ellenberg crypto_free_hash(mdev->tconn->csums_tfm); 3095f399002eSLars Ellenberg mdev->tconn->csums_tfm = csums_tfm; 3096b411b363SPhilipp Reisner dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg); 3097b411b363SPhilipp Reisner } 3098778f271dSPhilipp Reisner if (fifo_size != mdev->rs_plan_s.size) { 3099778f271dSPhilipp Reisner kfree(mdev->rs_plan_s.values); 3100778f271dSPhilipp Reisner mdev->rs_plan_s.values = rs_plan_s; 3101778f271dSPhilipp Reisner mdev->rs_plan_s.size = fifo_size; 3102778f271dSPhilipp Reisner mdev->rs_planed = 0; 3103778f271dSPhilipp Reisner } 3104b411b363SPhilipp Reisner spin_unlock(&mdev->peer_seq_lock); 3105b411b363SPhilipp Reisner } 3106b411b363SPhilipp Reisner 3107b411b363SPhilipp Reisner return ok; 3108b411b363SPhilipp Reisner disconnect: 3109b411b363SPhilipp Reisner /* just for completeness: actually not needed, 3110b411b363SPhilipp Reisner * as this is not reached if csums_tfm was ok. */ 3111b411b363SPhilipp Reisner crypto_free_hash(csums_tfm); 3112b411b363SPhilipp Reisner /* but free the verify_tfm again, if csums_tfm did not work out */ 3113b411b363SPhilipp Reisner crypto_free_hash(verify_tfm); 311438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 311581e84650SAndreas Gruenbacher return false; 3116b411b363SPhilipp Reisner } 3117b411b363SPhilipp Reisner 3118b411b363SPhilipp Reisner /* warn if the arguments differ by more than 12.5% */ 3119b411b363SPhilipp Reisner static void warn_if_differ_considerably(struct drbd_conf *mdev, 3120b411b363SPhilipp Reisner const char *s, sector_t a, sector_t b) 3121b411b363SPhilipp Reisner { 3122b411b363SPhilipp Reisner sector_t d; 3123b411b363SPhilipp Reisner if (a == 0 || b == 0) 3124b411b363SPhilipp Reisner return; 3125b411b363SPhilipp Reisner d = (a > b) ? (a - b) : (b - a); 3126b411b363SPhilipp Reisner if (d > (a>>3) || d > (b>>3)) 3127b411b363SPhilipp Reisner dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s, 3128b411b363SPhilipp Reisner (unsigned long long)a, (unsigned long long)b); 3129b411b363SPhilipp Reisner } 3130b411b363SPhilipp Reisner 3131d8763023SAndreas Gruenbacher static int receive_sizes(struct drbd_conf *mdev, enum drbd_packet cmd, 3132d8763023SAndreas Gruenbacher unsigned int data_size) 3133b411b363SPhilipp Reisner { 3134e42325a5SPhilipp Reisner struct p_sizes *p = &mdev->tconn->data.rbuf.sizes; 3135b411b363SPhilipp Reisner enum determine_dev_size dd = unchanged; 3136b411b363SPhilipp Reisner sector_t p_size, p_usize, my_usize; 3137b411b363SPhilipp Reisner int ldsc = 0; /* local disk size changed */ 3138e89b591cSPhilipp Reisner enum dds_flags ddsf; 3139b411b363SPhilipp Reisner 3140b411b363SPhilipp Reisner p_size = be64_to_cpu(p->d_size); 3141b411b363SPhilipp Reisner p_usize = be64_to_cpu(p->u_size); 3142b411b363SPhilipp Reisner 3143b411b363SPhilipp Reisner /* just store the peer's disk size for now. 3144b411b363SPhilipp Reisner * we still need to figure out whether we accept that. */ 3145b411b363SPhilipp Reisner mdev->p_size = p_size; 3146b411b363SPhilipp Reisner 3147b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3148b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "lower level device sizes", 3149b411b363SPhilipp Reisner p_size, drbd_get_max_capacity(mdev->ldev)); 3150b411b363SPhilipp Reisner warn_if_differ_considerably(mdev, "user requested size", 3151b411b363SPhilipp Reisner p_usize, mdev->ldev->dc.disk_size); 3152b411b363SPhilipp Reisner 3153b411b363SPhilipp Reisner /* if this is the first connect, or an otherwise expected 3154b411b363SPhilipp Reisner * param exchange, choose the minimum */ 3155b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_REPORT_PARAMS) 3156b411b363SPhilipp Reisner p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size, 3157b411b363SPhilipp Reisner p_usize); 3158b411b363SPhilipp Reisner 3159b411b363SPhilipp Reisner my_usize = mdev->ldev->dc.disk_size; 3160b411b363SPhilipp Reisner 3161b411b363SPhilipp Reisner if (mdev->ldev->dc.disk_size != p_usize) { 3162b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = p_usize; 3163b411b363SPhilipp Reisner dev_info(DEV, "Peer sets u_size to %lu sectors\n", 3164b411b363SPhilipp Reisner (unsigned long)mdev->ldev->dc.disk_size); 3165b411b363SPhilipp Reisner } 3166b411b363SPhilipp Reisner 3167b411b363SPhilipp Reisner /* Never shrink a device with usable data during connect. 3168b411b363SPhilipp Reisner But allow online shrinking if we are connected. */ 3169a393db6fSPhilipp Reisner if (drbd_new_dev_size(mdev, mdev->ldev, 0) < 3170b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) && 3171b411b363SPhilipp Reisner mdev->state.disk >= D_OUTDATED && 3172b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED) { 3173b411b363SPhilipp Reisner dev_err(DEV, "The peer's disk size is too small!\n"); 317438fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 3175b411b363SPhilipp Reisner mdev->ldev->dc.disk_size = my_usize; 3176b411b363SPhilipp Reisner put_ldev(mdev); 317781e84650SAndreas Gruenbacher return false; 3178b411b363SPhilipp Reisner } 3179b411b363SPhilipp Reisner put_ldev(mdev); 3180b411b363SPhilipp Reisner } 3181b411b363SPhilipp Reisner 3182e89b591cSPhilipp Reisner ddsf = be16_to_cpu(p->dds_flags); 3183b411b363SPhilipp Reisner if (get_ldev(mdev)) { 318424c4830cSBart Van Assche dd = drbd_determine_dev_size(mdev, ddsf); 3185b411b363SPhilipp Reisner put_ldev(mdev); 3186b411b363SPhilipp Reisner if (dd == dev_size_error) 318781e84650SAndreas Gruenbacher return false; 3188b411b363SPhilipp Reisner drbd_md_sync(mdev); 3189b411b363SPhilipp Reisner } else { 3190b411b363SPhilipp Reisner /* I am diskless, need to accept the peer's size. */ 3191b411b363SPhilipp Reisner drbd_set_my_capacity(mdev, p_size); 3192b411b363SPhilipp Reisner } 3193b411b363SPhilipp Reisner 319499432fccSPhilipp Reisner mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size); 319599432fccSPhilipp Reisner drbd_reconsider_max_bio_size(mdev); 319699432fccSPhilipp Reisner 3197b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3198b411b363SPhilipp Reisner if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) { 3199b411b363SPhilipp Reisner mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev); 3200b411b363SPhilipp Reisner ldsc = 1; 3201b411b363SPhilipp Reisner } 3202b411b363SPhilipp Reisner 3203b411b363SPhilipp Reisner put_ldev(mdev); 3204b411b363SPhilipp Reisner } 3205b411b363SPhilipp Reisner 3206b411b363SPhilipp Reisner if (mdev->state.conn > C_WF_REPORT_PARAMS) { 3207b411b363SPhilipp Reisner if (be64_to_cpu(p->c_size) != 3208b411b363SPhilipp Reisner drbd_get_capacity(mdev->this_bdev) || ldsc) { 3209b411b363SPhilipp Reisner /* we have different sizes, probably peer 3210b411b363SPhilipp Reisner * needs to know my new size... */ 3211e89b591cSPhilipp Reisner drbd_send_sizes(mdev, 0, ddsf); 3212b411b363SPhilipp Reisner } 3213b411b363SPhilipp Reisner if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) || 3214b411b363SPhilipp Reisner (dd == grew && mdev->state.conn == C_CONNECTED)) { 3215b411b363SPhilipp Reisner if (mdev->state.pdsk >= D_INCONSISTENT && 3216e89b591cSPhilipp Reisner mdev->state.disk >= D_INCONSISTENT) { 3217e89b591cSPhilipp Reisner if (ddsf & DDSF_NO_RESYNC) 3218e89b591cSPhilipp Reisner dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n"); 3219b411b363SPhilipp Reisner else 3220e89b591cSPhilipp Reisner resync_after_online_grow(mdev); 3221e89b591cSPhilipp Reisner } else 3222b411b363SPhilipp Reisner set_bit(RESYNC_AFTER_NEG, &mdev->flags); 3223b411b363SPhilipp Reisner } 3224b411b363SPhilipp Reisner } 3225b411b363SPhilipp Reisner 322681e84650SAndreas Gruenbacher return true; 3227b411b363SPhilipp Reisner } 3228b411b363SPhilipp Reisner 3229d8763023SAndreas Gruenbacher static int receive_uuids(struct drbd_conf *mdev, enum drbd_packet cmd, 3230d8763023SAndreas Gruenbacher unsigned int data_size) 3231b411b363SPhilipp Reisner { 3232e42325a5SPhilipp Reisner struct p_uuids *p = &mdev->tconn->data.rbuf.uuids; 3233b411b363SPhilipp Reisner u64 *p_uuid; 323462b0da3aSLars Ellenberg int i, updated_uuids = 0; 3235b411b363SPhilipp Reisner 3236b411b363SPhilipp Reisner p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO); 3237b411b363SPhilipp Reisner 3238b411b363SPhilipp Reisner for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++) 3239b411b363SPhilipp Reisner p_uuid[i] = be64_to_cpu(p->uuid[i]); 3240b411b363SPhilipp Reisner 3241b411b363SPhilipp Reisner kfree(mdev->p_uuid); 3242b411b363SPhilipp Reisner mdev->p_uuid = p_uuid; 3243b411b363SPhilipp Reisner 3244b411b363SPhilipp Reisner if (mdev->state.conn < C_CONNECTED && 3245b411b363SPhilipp Reisner mdev->state.disk < D_INCONSISTENT && 3246b411b363SPhilipp Reisner mdev->state.role == R_PRIMARY && 3247b411b363SPhilipp Reisner (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) { 3248b411b363SPhilipp Reisner dev_err(DEV, "Can only connect to data with current UUID=%016llX\n", 3249b411b363SPhilipp Reisner (unsigned long long)mdev->ed_uuid); 325038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 325181e84650SAndreas Gruenbacher return false; 3252b411b363SPhilipp Reisner } 3253b411b363SPhilipp Reisner 3254b411b363SPhilipp Reisner if (get_ldev(mdev)) { 3255b411b363SPhilipp Reisner int skip_initial_sync = 3256b411b363SPhilipp Reisner mdev->state.conn == C_CONNECTED && 325731890f4aSPhilipp Reisner mdev->tconn->agreed_pro_version >= 90 && 3258b411b363SPhilipp Reisner mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && 3259b411b363SPhilipp Reisner (p_uuid[UI_FLAGS] & 8); 3260b411b363SPhilipp Reisner if (skip_initial_sync) { 3261b411b363SPhilipp Reisner dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n"); 3262b411b363SPhilipp Reisner drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write, 326320ceb2b2SLars Ellenberg "clear_n_write from receive_uuids", 326420ceb2b2SLars Ellenberg BM_LOCKED_TEST_ALLOWED); 3265b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]); 3266b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0); 3267b411b363SPhilipp Reisner _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE), 3268b411b363SPhilipp Reisner CS_VERBOSE, NULL); 3269b411b363SPhilipp Reisner drbd_md_sync(mdev); 327062b0da3aSLars Ellenberg updated_uuids = 1; 3271b411b363SPhilipp Reisner } 3272b411b363SPhilipp Reisner put_ldev(mdev); 327318a50fa2SPhilipp Reisner } else if (mdev->state.disk < D_INCONSISTENT && 327418a50fa2SPhilipp Reisner mdev->state.role == R_PRIMARY) { 327518a50fa2SPhilipp Reisner /* I am a diskless primary, the peer just created a new current UUID 327618a50fa2SPhilipp Reisner for me. */ 327762b0da3aSLars Ellenberg updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 3278b411b363SPhilipp Reisner } 3279b411b363SPhilipp Reisner 3280b411b363SPhilipp Reisner /* Before we test for the disk state, we should wait until an eventually 3281b411b363SPhilipp Reisner ongoing cluster wide state change is finished. That is important if 3282b411b363SPhilipp Reisner we are primary and are detaching from our disk. We need to see the 3283b411b363SPhilipp Reisner new disk state... */ 32848410da8fSPhilipp Reisner mutex_lock(mdev->state_mutex); 32858410da8fSPhilipp Reisner mutex_unlock(mdev->state_mutex); 3286b411b363SPhilipp Reisner if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT) 328762b0da3aSLars Ellenberg updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]); 328862b0da3aSLars Ellenberg 328962b0da3aSLars Ellenberg if (updated_uuids) 329062b0da3aSLars Ellenberg drbd_print_uuids(mdev, "receiver updated UUIDs to"); 3291b411b363SPhilipp Reisner 329281e84650SAndreas Gruenbacher return true; 3293b411b363SPhilipp Reisner } 3294b411b363SPhilipp Reisner 3295b411b363SPhilipp Reisner /** 3296b411b363SPhilipp Reisner * convert_state() - Converts the peer's view of the cluster state to our point of view 3297b411b363SPhilipp Reisner * @ps: The state as seen by the peer. 3298b411b363SPhilipp Reisner */ 3299b411b363SPhilipp Reisner static union drbd_state convert_state(union drbd_state ps) 3300b411b363SPhilipp Reisner { 3301b411b363SPhilipp Reisner union drbd_state ms; 3302b411b363SPhilipp Reisner 3303b411b363SPhilipp Reisner static enum drbd_conns c_tab[] = { 3304b411b363SPhilipp Reisner [C_CONNECTED] = C_CONNECTED, 3305b411b363SPhilipp Reisner 3306b411b363SPhilipp Reisner [C_STARTING_SYNC_S] = C_STARTING_SYNC_T, 3307b411b363SPhilipp Reisner [C_STARTING_SYNC_T] = C_STARTING_SYNC_S, 3308b411b363SPhilipp Reisner [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */ 3309b411b363SPhilipp Reisner [C_VERIFY_S] = C_VERIFY_T, 3310b411b363SPhilipp Reisner [C_MASK] = C_MASK, 3311b411b363SPhilipp Reisner }; 3312b411b363SPhilipp Reisner 3313b411b363SPhilipp Reisner ms.i = ps.i; 3314b411b363SPhilipp Reisner 3315b411b363SPhilipp Reisner ms.conn = c_tab[ps.conn]; 3316b411b363SPhilipp Reisner ms.peer = ps.role; 3317b411b363SPhilipp Reisner ms.role = ps.peer; 3318b411b363SPhilipp Reisner ms.pdsk = ps.disk; 3319b411b363SPhilipp Reisner ms.disk = ps.pdsk; 3320b411b363SPhilipp Reisner ms.peer_isp = (ps.aftr_isp | ps.user_isp); 3321b411b363SPhilipp Reisner 3322b411b363SPhilipp Reisner return ms; 3323b411b363SPhilipp Reisner } 3324b411b363SPhilipp Reisner 3325d8763023SAndreas Gruenbacher static int receive_req_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3326d8763023SAndreas Gruenbacher unsigned int data_size) 3327b411b363SPhilipp Reisner { 3328e42325a5SPhilipp Reisner struct p_req_state *p = &mdev->tconn->data.rbuf.req_state; 3329b411b363SPhilipp Reisner union drbd_state mask, val; 3330bf885f8aSAndreas Gruenbacher enum drbd_state_rv rv; 3331b411b363SPhilipp Reisner 3332b411b363SPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3333b411b363SPhilipp Reisner val.i = be32_to_cpu(p->val); 3334b411b363SPhilipp Reisner 333525703f83SPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) && 33368410da8fSPhilipp Reisner mutex_is_locked(mdev->state_mutex)) { 3337b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG); 333881e84650SAndreas Gruenbacher return true; 3339b411b363SPhilipp Reisner } 3340b411b363SPhilipp Reisner 3341b411b363SPhilipp Reisner mask = convert_state(mask); 3342b411b363SPhilipp Reisner val = convert_state(val); 3343b411b363SPhilipp Reisner 3344b411b363SPhilipp Reisner rv = drbd_change_state(mdev, CS_VERBOSE, mask, val); 3345b411b363SPhilipp Reisner drbd_send_sr_reply(mdev, rv); 3346047cd4a6SPhilipp Reisner 3347b411b363SPhilipp Reisner drbd_md_sync(mdev); 3348b411b363SPhilipp Reisner 334981e84650SAndreas Gruenbacher return true; 3350b411b363SPhilipp Reisner } 3351b411b363SPhilipp Reisner 3352dfafcc8aSPhilipp Reisner static int receive_req_conn_state(struct drbd_tconn *tconn, enum drbd_packet cmd, 3353dfafcc8aSPhilipp Reisner unsigned int data_size) 3354dfafcc8aSPhilipp Reisner { 3355dfafcc8aSPhilipp Reisner struct p_req_state *p = &tconn->data.rbuf.req_state; 3356dfafcc8aSPhilipp Reisner union drbd_state mask, val; 3357dfafcc8aSPhilipp Reisner enum drbd_state_rv rv; 3358dfafcc8aSPhilipp Reisner 3359dfafcc8aSPhilipp Reisner mask.i = be32_to_cpu(p->mask); 3360dfafcc8aSPhilipp Reisner val.i = be32_to_cpu(p->val); 3361dfafcc8aSPhilipp Reisner 3362dfafcc8aSPhilipp Reisner if (test_bit(DISCARD_CONCURRENT, &tconn->flags) && 3363dfafcc8aSPhilipp Reisner mutex_is_locked(&tconn->cstate_mutex)) { 3364dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG); 3365dfafcc8aSPhilipp Reisner return true; 3366dfafcc8aSPhilipp Reisner } 3367dfafcc8aSPhilipp Reisner 3368dfafcc8aSPhilipp Reisner mask = convert_state(mask); 3369dfafcc8aSPhilipp Reisner val = convert_state(val); 3370dfafcc8aSPhilipp Reisner 3371dfafcc8aSPhilipp Reisner rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY); 3372dfafcc8aSPhilipp Reisner conn_send_sr_reply(tconn, rv); 3373dfafcc8aSPhilipp Reisner 3374dfafcc8aSPhilipp Reisner return true; 3375dfafcc8aSPhilipp Reisner } 3376dfafcc8aSPhilipp Reisner 3377d8763023SAndreas Gruenbacher static int receive_state(struct drbd_conf *mdev, enum drbd_packet cmd, 3378d8763023SAndreas Gruenbacher unsigned int data_size) 3379b411b363SPhilipp Reisner { 3380e42325a5SPhilipp Reisner struct p_state *p = &mdev->tconn->data.rbuf.state; 33814ac4aadaSLars Ellenberg union drbd_state os, ns, peer_state; 3382b411b363SPhilipp Reisner enum drbd_disk_state real_peer_disk; 338365d922c3SPhilipp Reisner enum chg_state_flags cs_flags; 3384b411b363SPhilipp Reisner int rv; 3385b411b363SPhilipp Reisner 3386b411b363SPhilipp Reisner peer_state.i = be32_to_cpu(p->state); 3387b411b363SPhilipp Reisner 3388b411b363SPhilipp Reisner real_peer_disk = peer_state.disk; 3389b411b363SPhilipp Reisner if (peer_state.disk == D_NEGOTIATING) { 3390b411b363SPhilipp Reisner real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT; 3391b411b363SPhilipp Reisner dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk)); 3392b411b363SPhilipp Reisner } 3393b411b363SPhilipp Reisner 339487eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 3395b411b363SPhilipp Reisner retry: 33964ac4aadaSLars Ellenberg os = ns = mdev->state; 339787eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3398b411b363SPhilipp Reisner 3399e9ef7bb6SLars Ellenberg /* peer says his disk is uptodate, while we think it is inconsistent, 3400e9ef7bb6SLars Ellenberg * and this happens while we think we have a sync going on. */ 3401e9ef7bb6SLars Ellenberg if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE && 3402e9ef7bb6SLars Ellenberg os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) { 3403e9ef7bb6SLars Ellenberg /* If we are (becoming) SyncSource, but peer is still in sync 3404e9ef7bb6SLars Ellenberg * preparation, ignore its uptodate-ness to avoid flapping, it 3405e9ef7bb6SLars Ellenberg * will change to inconsistent once the peer reaches active 3406e9ef7bb6SLars Ellenberg * syncing states. 3407e9ef7bb6SLars Ellenberg * It may have changed syncer-paused flags, however, so we 3408e9ef7bb6SLars Ellenberg * cannot ignore this completely. */ 3409e9ef7bb6SLars Ellenberg if (peer_state.conn > C_CONNECTED && 3410e9ef7bb6SLars Ellenberg peer_state.conn < C_SYNC_SOURCE) 3411e9ef7bb6SLars Ellenberg real_peer_disk = D_INCONSISTENT; 3412e9ef7bb6SLars Ellenberg 3413e9ef7bb6SLars Ellenberg /* if peer_state changes to connected at the same time, 3414e9ef7bb6SLars Ellenberg * it explicitly notifies us that it finished resync. 3415e9ef7bb6SLars Ellenberg * Maybe we should finish it up, too? */ 3416e9ef7bb6SLars Ellenberg else if (os.conn >= C_SYNC_SOURCE && 3417e9ef7bb6SLars Ellenberg peer_state.conn == C_CONNECTED) { 3418e9ef7bb6SLars Ellenberg if (drbd_bm_total_weight(mdev) <= mdev->rs_failed) 3419e9ef7bb6SLars Ellenberg drbd_resync_finished(mdev); 342081e84650SAndreas Gruenbacher return true; 3421e9ef7bb6SLars Ellenberg } 3422e9ef7bb6SLars Ellenberg } 3423e9ef7bb6SLars Ellenberg 3424e9ef7bb6SLars Ellenberg /* peer says his disk is inconsistent, while we think it is uptodate, 3425e9ef7bb6SLars Ellenberg * and this happens while the peer still thinks we have a sync going on, 3426e9ef7bb6SLars Ellenberg * but we think we are already done with the sync. 3427e9ef7bb6SLars Ellenberg * We ignore this to avoid flapping pdsk. 3428e9ef7bb6SLars Ellenberg * This should not happen, if the peer is a recent version of drbd. */ 3429e9ef7bb6SLars Ellenberg if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT && 3430e9ef7bb6SLars Ellenberg os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE) 3431e9ef7bb6SLars Ellenberg real_peer_disk = D_UP_TO_DATE; 3432e9ef7bb6SLars Ellenberg 34334ac4aadaSLars Ellenberg if (ns.conn == C_WF_REPORT_PARAMS) 34344ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3435b411b363SPhilipp Reisner 343667531718SPhilipp Reisner if (peer_state.conn == C_AHEAD) 343767531718SPhilipp Reisner ns.conn = C_BEHIND; 343867531718SPhilipp Reisner 3439b411b363SPhilipp Reisner if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING && 3440b411b363SPhilipp Reisner get_ldev_if_state(mdev, D_NEGOTIATING)) { 3441b411b363SPhilipp Reisner int cr; /* consider resync */ 3442b411b363SPhilipp Reisner 3443b411b363SPhilipp Reisner /* if we established a new connection */ 34444ac4aadaSLars Ellenberg cr = (os.conn < C_CONNECTED); 3445b411b363SPhilipp Reisner /* if we had an established connection 3446b411b363SPhilipp Reisner * and one of the nodes newly attaches a disk */ 34474ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3448b411b363SPhilipp Reisner (peer_state.disk == D_NEGOTIATING || 34494ac4aadaSLars Ellenberg os.disk == D_NEGOTIATING)); 3450b411b363SPhilipp Reisner /* if we have both been inconsistent, and the peer has been 3451b411b363SPhilipp Reisner * forced to be UpToDate with --overwrite-data */ 3452b411b363SPhilipp Reisner cr |= test_bit(CONSIDER_RESYNC, &mdev->flags); 3453b411b363SPhilipp Reisner /* if we had been plain connected, and the admin requested to 3454b411b363SPhilipp Reisner * start a sync by "invalidate" or "invalidate-remote" */ 34554ac4aadaSLars Ellenberg cr |= (os.conn == C_CONNECTED && 3456b411b363SPhilipp Reisner (peer_state.conn >= C_STARTING_SYNC_S && 3457b411b363SPhilipp Reisner peer_state.conn <= C_WF_BITMAP_T)); 3458b411b363SPhilipp Reisner 3459b411b363SPhilipp Reisner if (cr) 34604ac4aadaSLars Ellenberg ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk); 3461b411b363SPhilipp Reisner 3462b411b363SPhilipp Reisner put_ldev(mdev); 34634ac4aadaSLars Ellenberg if (ns.conn == C_MASK) { 34644ac4aadaSLars Ellenberg ns.conn = C_CONNECTED; 3465b411b363SPhilipp Reisner if (mdev->state.disk == D_NEGOTIATING) { 346682f59cc6SLars Ellenberg drbd_force_state(mdev, NS(disk, D_FAILED)); 3467b411b363SPhilipp Reisner } else if (peer_state.disk == D_NEGOTIATING) { 3468b411b363SPhilipp Reisner dev_err(DEV, "Disk attach process on the peer node was aborted.\n"); 3469b411b363SPhilipp Reisner peer_state.disk = D_DISKLESS; 3470580b9767SLars Ellenberg real_peer_disk = D_DISKLESS; 3471b411b363SPhilipp Reisner } else { 34728169e41bSPhilipp Reisner if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags)) 347381e84650SAndreas Gruenbacher return false; 34744ac4aadaSLars Ellenberg D_ASSERT(os.conn == C_WF_REPORT_PARAMS); 347538fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 347681e84650SAndreas Gruenbacher return false; 3477b411b363SPhilipp Reisner } 3478b411b363SPhilipp Reisner } 3479b411b363SPhilipp Reisner } 3480b411b363SPhilipp Reisner 348187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 34824ac4aadaSLars Ellenberg if (mdev->state.i != os.i) 3483b411b363SPhilipp Reisner goto retry; 3484b411b363SPhilipp Reisner clear_bit(CONSIDER_RESYNC, &mdev->flags); 3485b411b363SPhilipp Reisner ns.peer = peer_state.role; 3486b411b363SPhilipp Reisner ns.pdsk = real_peer_disk; 3487b411b363SPhilipp Reisner ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp); 34884ac4aadaSLars Ellenberg if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING) 3489b411b363SPhilipp Reisner ns.disk = mdev->new_state_tmp.disk; 34904ac4aadaSLars Ellenberg cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD); 34914ac4aadaSLars Ellenberg if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED && 3492481c6f50SPhilipp Reisner test_bit(NEW_CUR_UUID, &mdev->flags)) { 34938554df1cSAndreas Gruenbacher /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this 3494481c6f50SPhilipp Reisner for temporal network outages! */ 349587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3496481c6f50SPhilipp Reisner dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n"); 34972f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 3498481c6f50SPhilipp Reisner drbd_uuid_new_current(mdev); 3499481c6f50SPhilipp Reisner clear_bit(NEW_CUR_UUID, &mdev->flags); 350038fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD); 350181e84650SAndreas Gruenbacher return false; 3502481c6f50SPhilipp Reisner } 350365d922c3SPhilipp Reisner rv = _drbd_set_state(mdev, ns, cs_flags, NULL); 3504b411b363SPhilipp Reisner ns = mdev->state; 350587eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 3506b411b363SPhilipp Reisner 3507b411b363SPhilipp Reisner if (rv < SS_SUCCESS) { 350838fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD); 350981e84650SAndreas Gruenbacher return false; 3510b411b363SPhilipp Reisner } 3511b411b363SPhilipp Reisner 35124ac4aadaSLars Ellenberg if (os.conn > C_WF_REPORT_PARAMS) { 35134ac4aadaSLars Ellenberg if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED && 3514b411b363SPhilipp Reisner peer_state.disk != D_NEGOTIATING ) { 3515b411b363SPhilipp Reisner /* we want resync, peer has not yet decided to sync... */ 3516b411b363SPhilipp Reisner /* Nowadays only used when forcing a node into primary role and 3517b411b363SPhilipp Reisner setting its disk to UpToDate with that */ 3518b411b363SPhilipp Reisner drbd_send_uuids(mdev); 3519b411b363SPhilipp Reisner drbd_send_state(mdev); 3520b411b363SPhilipp Reisner } 3521b411b363SPhilipp Reisner } 3522b411b363SPhilipp Reisner 352389e58e75SPhilipp Reisner mdev->tconn->net_conf->want_lose = 0; 3524b411b363SPhilipp Reisner 3525b411b363SPhilipp Reisner drbd_md_sync(mdev); /* update connected indicator, la_size, ... */ 3526b411b363SPhilipp Reisner 352781e84650SAndreas Gruenbacher return true; 3528b411b363SPhilipp Reisner } 3529b411b363SPhilipp Reisner 3530d8763023SAndreas Gruenbacher static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packet cmd, 3531d8763023SAndreas Gruenbacher unsigned int data_size) 3532b411b363SPhilipp Reisner { 3533e42325a5SPhilipp Reisner struct p_rs_uuid *p = &mdev->tconn->data.rbuf.rs_uuid; 3534b411b363SPhilipp Reisner 3535b411b363SPhilipp Reisner wait_event(mdev->misc_wait, 3536b411b363SPhilipp Reisner mdev->state.conn == C_WF_SYNC_UUID || 3537c4752ef1SPhilipp Reisner mdev->state.conn == C_BEHIND || 3538b411b363SPhilipp Reisner mdev->state.conn < C_CONNECTED || 3539b411b363SPhilipp Reisner mdev->state.disk < D_NEGOTIATING); 3540b411b363SPhilipp Reisner 3541b411b363SPhilipp Reisner /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */ 3542b411b363SPhilipp Reisner 3543b411b363SPhilipp Reisner /* Here the _drbd_uuid_ functions are right, current should 3544b411b363SPhilipp Reisner _not_ be rotated into the history */ 3545b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_NEGOTIATING)) { 3546b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid)); 3547b411b363SPhilipp Reisner _drbd_uuid_set(mdev, UI_BITMAP, 0UL); 3548b411b363SPhilipp Reisner 354962b0da3aSLars Ellenberg drbd_print_uuids(mdev, "updated sync uuid"); 3550b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_TARGET); 3551b411b363SPhilipp Reisner 3552b411b363SPhilipp Reisner put_ldev(mdev); 3553b411b363SPhilipp Reisner } else 3554b411b363SPhilipp Reisner dev_err(DEV, "Ignoring SyncUUID packet!\n"); 3555b411b363SPhilipp Reisner 355681e84650SAndreas Gruenbacher return true; 3557b411b363SPhilipp Reisner } 3558b411b363SPhilipp Reisner 35592c46407dSAndreas Gruenbacher /** 35602c46407dSAndreas Gruenbacher * receive_bitmap_plain 35612c46407dSAndreas Gruenbacher * 35622c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 35632c46407dSAndreas Gruenbacher * code upon failure. 35642c46407dSAndreas Gruenbacher */ 35652c46407dSAndreas Gruenbacher static int 356602918be2SPhilipp Reisner receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size, 3567b411b363SPhilipp Reisner unsigned long *buffer, struct bm_xfer_ctx *c) 3568b411b363SPhilipp Reisner { 3569b411b363SPhilipp Reisner unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset); 3570b411b363SPhilipp Reisner unsigned want = num_words * sizeof(long); 35712c46407dSAndreas Gruenbacher int err; 3572b411b363SPhilipp Reisner 357302918be2SPhilipp Reisner if (want != data_size) { 357402918be2SPhilipp Reisner dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size); 35752c46407dSAndreas Gruenbacher return -EIO; 3576b411b363SPhilipp Reisner } 3577b411b363SPhilipp Reisner if (want == 0) 35782c46407dSAndreas Gruenbacher return 0; 3579de0ff338SPhilipp Reisner err = drbd_recv(mdev->tconn, buffer, want); 35802c46407dSAndreas Gruenbacher if (err != want) { 35812c46407dSAndreas Gruenbacher if (err >= 0) 35822c46407dSAndreas Gruenbacher err = -EIO; 35832c46407dSAndreas Gruenbacher return err; 35842c46407dSAndreas Gruenbacher } 3585b411b363SPhilipp Reisner 3586b411b363SPhilipp Reisner drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer); 3587b411b363SPhilipp Reisner 3588b411b363SPhilipp Reisner c->word_offset += num_words; 3589b411b363SPhilipp Reisner c->bit_offset = c->word_offset * BITS_PER_LONG; 3590b411b363SPhilipp Reisner if (c->bit_offset > c->bm_bits) 3591b411b363SPhilipp Reisner c->bit_offset = c->bm_bits; 3592b411b363SPhilipp Reisner 35932c46407dSAndreas Gruenbacher return 1; 3594b411b363SPhilipp Reisner } 3595b411b363SPhilipp Reisner 35962c46407dSAndreas Gruenbacher /** 35972c46407dSAndreas Gruenbacher * recv_bm_rle_bits 35982c46407dSAndreas Gruenbacher * 35992c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36002c46407dSAndreas Gruenbacher * code upon failure. 36012c46407dSAndreas Gruenbacher */ 36022c46407dSAndreas Gruenbacher static int 3603b411b363SPhilipp Reisner recv_bm_rle_bits(struct drbd_conf *mdev, 3604b411b363SPhilipp Reisner struct p_compressed_bm *p, 3605c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3606c6d25cfeSPhilipp Reisner unsigned int len) 3607b411b363SPhilipp Reisner { 3608b411b363SPhilipp Reisner struct bitstream bs; 3609b411b363SPhilipp Reisner u64 look_ahead; 3610b411b363SPhilipp Reisner u64 rl; 3611b411b363SPhilipp Reisner u64 tmp; 3612b411b363SPhilipp Reisner unsigned long s = c->bit_offset; 3613b411b363SPhilipp Reisner unsigned long e; 3614b411b363SPhilipp Reisner int toggle = DCBP_get_start(p); 3615b411b363SPhilipp Reisner int have; 3616b411b363SPhilipp Reisner int bits; 3617b411b363SPhilipp Reisner 3618b411b363SPhilipp Reisner bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p)); 3619b411b363SPhilipp Reisner 3620b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &look_ahead, 64); 3621b411b363SPhilipp Reisner if (bits < 0) 36222c46407dSAndreas Gruenbacher return -EIO; 3623b411b363SPhilipp Reisner 3624b411b363SPhilipp Reisner for (have = bits; have > 0; s += rl, toggle = !toggle) { 3625b411b363SPhilipp Reisner bits = vli_decode_bits(&rl, look_ahead); 3626b411b363SPhilipp Reisner if (bits <= 0) 36272c46407dSAndreas Gruenbacher return -EIO; 3628b411b363SPhilipp Reisner 3629b411b363SPhilipp Reisner if (toggle) { 3630b411b363SPhilipp Reisner e = s + rl -1; 3631b411b363SPhilipp Reisner if (e >= c->bm_bits) { 3632b411b363SPhilipp Reisner dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e); 36332c46407dSAndreas Gruenbacher return -EIO; 3634b411b363SPhilipp Reisner } 3635b411b363SPhilipp Reisner _drbd_bm_set_bits(mdev, s, e); 3636b411b363SPhilipp Reisner } 3637b411b363SPhilipp Reisner 3638b411b363SPhilipp Reisner if (have < bits) { 3639b411b363SPhilipp Reisner dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n", 3640b411b363SPhilipp Reisner have, bits, look_ahead, 3641b411b363SPhilipp Reisner (unsigned int)(bs.cur.b - p->code), 3642b411b363SPhilipp Reisner (unsigned int)bs.buf_len); 36432c46407dSAndreas Gruenbacher return -EIO; 3644b411b363SPhilipp Reisner } 3645b411b363SPhilipp Reisner look_ahead >>= bits; 3646b411b363SPhilipp Reisner have -= bits; 3647b411b363SPhilipp Reisner 3648b411b363SPhilipp Reisner bits = bitstream_get_bits(&bs, &tmp, 64 - have); 3649b411b363SPhilipp Reisner if (bits < 0) 36502c46407dSAndreas Gruenbacher return -EIO; 3651b411b363SPhilipp Reisner look_ahead |= tmp << have; 3652b411b363SPhilipp Reisner have += bits; 3653b411b363SPhilipp Reisner } 3654b411b363SPhilipp Reisner 3655b411b363SPhilipp Reisner c->bit_offset = s; 3656b411b363SPhilipp Reisner bm_xfer_ctx_bit_to_word_offset(c); 3657b411b363SPhilipp Reisner 36582c46407dSAndreas Gruenbacher return (s != c->bm_bits); 3659b411b363SPhilipp Reisner } 3660b411b363SPhilipp Reisner 36612c46407dSAndreas Gruenbacher /** 36622c46407dSAndreas Gruenbacher * decode_bitmap_c 36632c46407dSAndreas Gruenbacher * 36642c46407dSAndreas Gruenbacher * Return 0 when done, 1 when another iteration is needed, and a negative error 36652c46407dSAndreas Gruenbacher * code upon failure. 36662c46407dSAndreas Gruenbacher */ 36672c46407dSAndreas Gruenbacher static int 3668b411b363SPhilipp Reisner decode_bitmap_c(struct drbd_conf *mdev, 3669b411b363SPhilipp Reisner struct p_compressed_bm *p, 3670c6d25cfeSPhilipp Reisner struct bm_xfer_ctx *c, 3671c6d25cfeSPhilipp Reisner unsigned int len) 3672b411b363SPhilipp Reisner { 3673b411b363SPhilipp Reisner if (DCBP_get_code(p) == RLE_VLI_Bits) 3674c6d25cfeSPhilipp Reisner return recv_bm_rle_bits(mdev, p, c, len); 3675b411b363SPhilipp Reisner 3676b411b363SPhilipp Reisner /* other variants had been implemented for evaluation, 3677b411b363SPhilipp Reisner * but have been dropped as this one turned out to be "best" 3678b411b363SPhilipp Reisner * during all our tests. */ 3679b411b363SPhilipp Reisner 3680b411b363SPhilipp Reisner dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding); 368138fa9988SPhilipp Reisner conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 36822c46407dSAndreas Gruenbacher return -EIO; 3683b411b363SPhilipp Reisner } 3684b411b363SPhilipp Reisner 3685b411b363SPhilipp Reisner void INFO_bm_xfer_stats(struct drbd_conf *mdev, 3686b411b363SPhilipp Reisner const char *direction, struct bm_xfer_ctx *c) 3687b411b363SPhilipp Reisner { 3688b411b363SPhilipp Reisner /* what would it take to transfer it "plaintext" */ 3689c012949aSPhilipp Reisner unsigned plain = sizeof(struct p_header) * 3690b411b363SPhilipp Reisner ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1) 3691b411b363SPhilipp Reisner + c->bm_words * sizeof(long); 3692b411b363SPhilipp Reisner unsigned total = c->bytes[0] + c->bytes[1]; 3693b411b363SPhilipp Reisner unsigned r; 3694b411b363SPhilipp Reisner 3695b411b363SPhilipp Reisner /* total can not be zero. but just in case: */ 3696b411b363SPhilipp Reisner if (total == 0) 3697b411b363SPhilipp Reisner return; 3698b411b363SPhilipp Reisner 3699b411b363SPhilipp Reisner /* don't report if not compressed */ 3700b411b363SPhilipp Reisner if (total >= plain) 3701b411b363SPhilipp Reisner return; 3702b411b363SPhilipp Reisner 3703b411b363SPhilipp Reisner /* total < plain. check for overflow, still */ 3704b411b363SPhilipp Reisner r = (total > UINT_MAX/1000) ? (total / (plain/1000)) 3705b411b363SPhilipp Reisner : (1000 * total / plain); 3706b411b363SPhilipp Reisner 3707b411b363SPhilipp Reisner if (r > 1000) 3708b411b363SPhilipp Reisner r = 1000; 3709b411b363SPhilipp Reisner 3710b411b363SPhilipp Reisner r = 1000 - r; 3711b411b363SPhilipp Reisner dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), " 3712b411b363SPhilipp Reisner "total %u; compression: %u.%u%%\n", 3713b411b363SPhilipp Reisner direction, 3714b411b363SPhilipp Reisner c->bytes[1], c->packets[1], 3715b411b363SPhilipp Reisner c->bytes[0], c->packets[0], 3716b411b363SPhilipp Reisner total, r/10, r % 10); 3717b411b363SPhilipp Reisner } 3718b411b363SPhilipp Reisner 3719b411b363SPhilipp Reisner /* Since we are processing the bitfield from lower addresses to higher, 3720b411b363SPhilipp Reisner it does not matter if the process it in 32 bit chunks or 64 bit 3721b411b363SPhilipp Reisner chunks as long as it is little endian. (Understand it as byte stream, 3722b411b363SPhilipp Reisner beginning with the lowest byte...) If we would use big endian 3723b411b363SPhilipp Reisner we would need to process it from the highest address to the lowest, 3724b411b363SPhilipp Reisner in order to be agnostic to the 32 vs 64 bits issue. 3725b411b363SPhilipp Reisner 3726b411b363SPhilipp Reisner returns 0 on failure, 1 if we successfully received it. */ 3727d8763023SAndreas Gruenbacher static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packet cmd, 3728d8763023SAndreas Gruenbacher unsigned int data_size) 3729b411b363SPhilipp Reisner { 3730b411b363SPhilipp Reisner struct bm_xfer_ctx c; 3731b411b363SPhilipp Reisner void *buffer; 37322c46407dSAndreas Gruenbacher int err; 373381e84650SAndreas Gruenbacher int ok = false; 3734257d0af6SPhilipp Reisner struct p_header *h = &mdev->tconn->data.rbuf.header; 373577351055SPhilipp Reisner struct packet_info pi; 3736b411b363SPhilipp Reisner 373720ceb2b2SLars Ellenberg drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED); 373820ceb2b2SLars Ellenberg /* you are supposed to send additional out-of-sync information 373920ceb2b2SLars Ellenberg * if you actually set bits during this phase */ 3740b411b363SPhilipp Reisner 3741b411b363SPhilipp Reisner /* maybe we should use some per thread scratch page, 3742b411b363SPhilipp Reisner * and allocate that during initial device creation? */ 3743b411b363SPhilipp Reisner buffer = (unsigned long *) __get_free_page(GFP_NOIO); 3744b411b363SPhilipp Reisner if (!buffer) { 3745b411b363SPhilipp Reisner dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__); 3746b411b363SPhilipp Reisner goto out; 3747b411b363SPhilipp Reisner } 3748b411b363SPhilipp Reisner 3749b411b363SPhilipp Reisner c = (struct bm_xfer_ctx) { 3750b411b363SPhilipp Reisner .bm_bits = drbd_bm_bits(mdev), 3751b411b363SPhilipp Reisner .bm_words = drbd_bm_words(mdev), 3752b411b363SPhilipp Reisner }; 3753b411b363SPhilipp Reisner 37542c46407dSAndreas Gruenbacher for(;;) { 375502918be2SPhilipp Reisner if (cmd == P_BITMAP) { 37562c46407dSAndreas Gruenbacher err = receive_bitmap_plain(mdev, data_size, buffer, &c); 375702918be2SPhilipp Reisner } else if (cmd == P_COMPRESSED_BITMAP) { 3758b411b363SPhilipp Reisner /* MAYBE: sanity check that we speak proto >= 90, 3759b411b363SPhilipp Reisner * and the feature is enabled! */ 3760b411b363SPhilipp Reisner struct p_compressed_bm *p; 3761b411b363SPhilipp Reisner 376202918be2SPhilipp Reisner if (data_size > BM_PACKET_PAYLOAD_BYTES) { 3763b411b363SPhilipp Reisner dev_err(DEV, "ReportCBitmap packet too large\n"); 3764b411b363SPhilipp Reisner goto out; 3765b411b363SPhilipp Reisner } 3766b411b363SPhilipp Reisner /* use the page buff */ 3767b411b363SPhilipp Reisner p = buffer; 3768b411b363SPhilipp Reisner memcpy(p, h, sizeof(*h)); 3769de0ff338SPhilipp Reisner if (drbd_recv(mdev->tconn, p->head.payload, data_size) != data_size) 3770b411b363SPhilipp Reisner goto out; 3771004352faSLars Ellenberg if (data_size <= (sizeof(*p) - sizeof(p->head))) { 3772004352faSLars Ellenberg dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size); 377378fcbdaeSAndreas Gruenbacher goto out; 3774b411b363SPhilipp Reisner } 3775c6d25cfeSPhilipp Reisner err = decode_bitmap_c(mdev, p, &c, data_size); 3776b411b363SPhilipp Reisner } else { 377702918be2SPhilipp Reisner dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd); 3778b411b363SPhilipp Reisner goto out; 3779b411b363SPhilipp Reisner } 3780b411b363SPhilipp Reisner 378102918be2SPhilipp Reisner c.packets[cmd == P_BITMAP]++; 3782257d0af6SPhilipp Reisner c.bytes[cmd == P_BITMAP] += sizeof(struct p_header) + data_size; 3783b411b363SPhilipp Reisner 37842c46407dSAndreas Gruenbacher if (err <= 0) { 37852c46407dSAndreas Gruenbacher if (err < 0) 37862c46407dSAndreas Gruenbacher goto out; 3787b411b363SPhilipp Reisner break; 37882c46407dSAndreas Gruenbacher } 37899ba7aa00SPhilipp Reisner if (!drbd_recv_header(mdev->tconn, &pi)) 3790b411b363SPhilipp Reisner goto out; 379177351055SPhilipp Reisner cmd = pi.cmd; 379277351055SPhilipp Reisner data_size = pi.size; 37932c46407dSAndreas Gruenbacher } 3794b411b363SPhilipp Reisner 3795b411b363SPhilipp Reisner INFO_bm_xfer_stats(mdev, "receive", &c); 3796b411b363SPhilipp Reisner 3797b411b363SPhilipp Reisner if (mdev->state.conn == C_WF_BITMAP_T) { 3798de1f8e4aSAndreas Gruenbacher enum drbd_state_rv rv; 3799de1f8e4aSAndreas Gruenbacher 3800b411b363SPhilipp Reisner ok = !drbd_send_bitmap(mdev); 3801b411b363SPhilipp Reisner if (!ok) 3802b411b363SPhilipp Reisner goto out; 3803b411b363SPhilipp Reisner /* Omit CS_ORDERED with this state transition to avoid deadlocks. */ 3804de1f8e4aSAndreas Gruenbacher rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE); 3805de1f8e4aSAndreas Gruenbacher D_ASSERT(rv == SS_SUCCESS); 3806b411b363SPhilipp Reisner } else if (mdev->state.conn != C_WF_BITMAP_S) { 3807b411b363SPhilipp Reisner /* admin may have requested C_DISCONNECTING, 3808b411b363SPhilipp Reisner * other threads may have noticed network errors */ 3809b411b363SPhilipp Reisner dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n", 3810b411b363SPhilipp Reisner drbd_conn_str(mdev->state.conn)); 3811b411b363SPhilipp Reisner } 3812b411b363SPhilipp Reisner 381381e84650SAndreas Gruenbacher ok = true; 3814b411b363SPhilipp Reisner out: 381520ceb2b2SLars Ellenberg drbd_bm_unlock(mdev); 3816b411b363SPhilipp Reisner if (ok && mdev->state.conn == C_WF_BITMAP_S) 3817b411b363SPhilipp Reisner drbd_start_resync(mdev, C_SYNC_SOURCE); 3818b411b363SPhilipp Reisner free_page((unsigned long) buffer); 3819b411b363SPhilipp Reisner return ok; 3820b411b363SPhilipp Reisner } 3821b411b363SPhilipp Reisner 38222de876efSPhilipp Reisner static int _tconn_receive_skip(struct drbd_tconn *tconn, unsigned int data_size) 3823b411b363SPhilipp Reisner { 3824b411b363SPhilipp Reisner /* TODO zero copy sink :) */ 3825b411b363SPhilipp Reisner static char sink[128]; 3826b411b363SPhilipp Reisner int size, want, r; 3827b411b363SPhilipp Reisner 382802918be2SPhilipp Reisner size = data_size; 3829b411b363SPhilipp Reisner while (size > 0) { 3830b411b363SPhilipp Reisner want = min_t(int, size, sizeof(sink)); 38312de876efSPhilipp Reisner r = drbd_recv(tconn, sink, want); 38322de876efSPhilipp Reisner if (r <= 0) 3833841ce241SAndreas Gruenbacher break; 3834b411b363SPhilipp Reisner size -= r; 3835b411b363SPhilipp Reisner } 3836b411b363SPhilipp Reisner return size == 0; 3837b411b363SPhilipp Reisner } 3838b411b363SPhilipp Reisner 38392de876efSPhilipp Reisner static int receive_skip(struct drbd_conf *mdev, enum drbd_packet cmd, 38402de876efSPhilipp Reisner unsigned int data_size) 38412de876efSPhilipp Reisner { 38422de876efSPhilipp Reisner dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n", 38432de876efSPhilipp Reisner cmd, data_size); 38442de876efSPhilipp Reisner 38452de876efSPhilipp Reisner return _tconn_receive_skip(mdev->tconn, data_size); 38462de876efSPhilipp Reisner } 38472de876efSPhilipp Reisner 38482de876efSPhilipp Reisner static int tconn_receive_skip(struct drbd_tconn *tconn, enum drbd_packet cmd, unsigned int data_size) 38492de876efSPhilipp Reisner { 38502de876efSPhilipp Reisner conn_warn(tconn, "skipping packet for non existing volume type %d, l: %d!\n", 38512de876efSPhilipp Reisner cmd, data_size); 38522de876efSPhilipp Reisner 38532de876efSPhilipp Reisner return _tconn_receive_skip(tconn, data_size); 38542de876efSPhilipp Reisner } 38552de876efSPhilipp Reisner 3856d8763023SAndreas Gruenbacher static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packet cmd, 3857d8763023SAndreas Gruenbacher unsigned int data_size) 3858b411b363SPhilipp Reisner { 3859b411b363SPhilipp Reisner /* Make sure we've acked all the TCP data associated 3860b411b363SPhilipp Reisner * with the data requests being unplugged */ 3861e42325a5SPhilipp Reisner drbd_tcp_quickack(mdev->tconn->data.socket); 3862b411b363SPhilipp Reisner 386381e84650SAndreas Gruenbacher return true; 3864b411b363SPhilipp Reisner } 3865b411b363SPhilipp Reisner 3866d8763023SAndreas Gruenbacher static int receive_out_of_sync(struct drbd_conf *mdev, enum drbd_packet cmd, 3867d8763023SAndreas Gruenbacher unsigned int data_size) 386873a01a18SPhilipp Reisner { 3869e42325a5SPhilipp Reisner struct p_block_desc *p = &mdev->tconn->data.rbuf.block_desc; 387073a01a18SPhilipp Reisner 3871f735e363SLars Ellenberg switch (mdev->state.conn) { 3872f735e363SLars Ellenberg case C_WF_SYNC_UUID: 3873f735e363SLars Ellenberg case C_WF_BITMAP_T: 3874f735e363SLars Ellenberg case C_BEHIND: 3875f735e363SLars Ellenberg break; 3876f735e363SLars Ellenberg default: 3877f735e363SLars Ellenberg dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n", 3878f735e363SLars Ellenberg drbd_conn_str(mdev->state.conn)); 3879f735e363SLars Ellenberg } 3880f735e363SLars Ellenberg 388173a01a18SPhilipp Reisner drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize)); 388273a01a18SPhilipp Reisner 388381e84650SAndreas Gruenbacher return true; 388473a01a18SPhilipp Reisner } 388573a01a18SPhilipp Reisner 388602918be2SPhilipp Reisner struct data_cmd { 388702918be2SPhilipp Reisner int expect_payload; 388802918be2SPhilipp Reisner size_t pkt_size; 3889a4fbda8eSPhilipp Reisner enum mdev_or_conn fa_type; /* first argument's type */ 3890d9ae84e7SPhilipp Reisner union { 3891d9ae84e7SPhilipp Reisner int (*mdev_fn)(struct drbd_conf *, enum drbd_packet cmd, 3892d9ae84e7SPhilipp Reisner unsigned int to_receive); 3893d9ae84e7SPhilipp Reisner int (*conn_fn)(struct drbd_tconn *, enum drbd_packet cmd, 3894d9ae84e7SPhilipp Reisner unsigned int to_receive); 3895d9ae84e7SPhilipp Reisner }; 3896b411b363SPhilipp Reisner }; 3897b411b363SPhilipp Reisner 389802918be2SPhilipp Reisner static struct data_cmd drbd_cmd_handler[] = { 3899d9ae84e7SPhilipp Reisner [P_DATA] = { 1, sizeof(struct p_data), MDEV, { receive_Data } }, 3900d9ae84e7SPhilipp Reisner [P_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_DataReply } }, 3901d9ae84e7SPhilipp Reisner [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), MDEV, { receive_RSDataReply } } , 3902d9ae84e7SPhilipp Reisner [P_BARRIER] = { 0, sizeof(struct p_barrier), MDEV, { receive_Barrier } } , 3903d9ae84e7SPhilipp Reisner [P_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3904d9ae84e7SPhilipp Reisner [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header), MDEV, { receive_bitmap } } , 3905d9ae84e7SPhilipp Reisner [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header), MDEV, { receive_UnplugRemote } }, 3906d9ae84e7SPhilipp Reisner [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3907d9ae84e7SPhilipp Reisner [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3908d9ae84e7SPhilipp Reisner [P_SYNC_PARAM] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 3909d9ae84e7SPhilipp Reisner [P_SYNC_PARAM89] = { 1, sizeof(struct p_header), MDEV, { receive_SyncParam } }, 39107204624cSPhilipp Reisner [P_PROTOCOL] = { 1, sizeof(struct p_protocol), CONN, { .conn_fn = receive_protocol } }, 3911d9ae84e7SPhilipp Reisner [P_UUIDS] = { 0, sizeof(struct p_uuids), MDEV, { receive_uuids } }, 3912d9ae84e7SPhilipp Reisner [P_SIZES] = { 0, sizeof(struct p_sizes), MDEV, { receive_sizes } }, 3913d9ae84e7SPhilipp Reisner [P_STATE] = { 0, sizeof(struct p_state), MDEV, { receive_state } }, 3914d9ae84e7SPhilipp Reisner [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), MDEV, { receive_req_state } }, 3915d9ae84e7SPhilipp Reisner [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), MDEV, { receive_sync_uuid } }, 3916d9ae84e7SPhilipp Reisner [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3917d9ae84e7SPhilipp Reisner [P_OV_REPLY] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3918d9ae84e7SPhilipp Reisner [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), MDEV, { receive_DataRequest } }, 3919d9ae84e7SPhilipp Reisner [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), MDEV, { receive_skip } }, 3920d9ae84e7SPhilipp Reisner [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), MDEV, { receive_out_of_sync } }, 3921dfafcc8aSPhilipp Reisner [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), CONN, { .conn_fn = receive_req_conn_state } }, 392202918be2SPhilipp Reisner }; 392302918be2SPhilipp Reisner 392402918be2SPhilipp Reisner /* All handler functions that expect a sub-header get that sub-heder in 3925e42325a5SPhilipp Reisner mdev->tconn->data.rbuf.header.head.payload. 392602918be2SPhilipp Reisner 3927e42325a5SPhilipp Reisner Usually in mdev->tconn->data.rbuf.header.head the callback can find the usual 392802918be2SPhilipp Reisner p_header, but they may not rely on that. Since there is also p_header95 ! 392902918be2SPhilipp Reisner */ 3930b411b363SPhilipp Reisner 3931eefc2f7dSPhilipp Reisner static void drbdd(struct drbd_tconn *tconn) 3932b411b363SPhilipp Reisner { 3933eefc2f7dSPhilipp Reisner struct p_header *header = &tconn->data.rbuf.header; 393477351055SPhilipp Reisner struct packet_info pi; 393502918be2SPhilipp Reisner size_t shs; /* sub header size */ 393602918be2SPhilipp Reisner int rv; 3937b411b363SPhilipp Reisner 3938eefc2f7dSPhilipp Reisner while (get_t_state(&tconn->receiver) == RUNNING) { 3939eefc2f7dSPhilipp Reisner drbd_thread_current_set_cpu(&tconn->receiver); 3940eefc2f7dSPhilipp Reisner if (!drbd_recv_header(tconn, &pi)) 394102918be2SPhilipp Reisner goto err_out; 394202918be2SPhilipp Reisner 39436e849ce8SAndreas Gruenbacher if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || 3944d9ae84e7SPhilipp Reisner !drbd_cmd_handler[pi.cmd].mdev_fn)) { 3945eefc2f7dSPhilipp Reisner conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size); 394602918be2SPhilipp Reisner goto err_out; 39470b33a916SLars Ellenberg } 3948b411b363SPhilipp Reisner 394977351055SPhilipp Reisner shs = drbd_cmd_handler[pi.cmd].pkt_size - sizeof(struct p_header); 395077351055SPhilipp Reisner if (pi.size - shs > 0 && !drbd_cmd_handler[pi.cmd].expect_payload) { 3951eefc2f7dSPhilipp Reisner conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size); 3952c13f7e1aSLars Ellenberg goto err_out; 3953c13f7e1aSLars Ellenberg } 3954c13f7e1aSLars Ellenberg 3955c13f7e1aSLars Ellenberg if (shs) { 3956eefc2f7dSPhilipp Reisner rv = drbd_recv(tconn, &header->payload, shs); 395702918be2SPhilipp Reisner if (unlikely(rv != shs)) { 39580ddc5549SLars Ellenberg if (!signal_pending(current)) 3959eefc2f7dSPhilipp Reisner conn_warn(tconn, "short read while reading sub header: rv=%d\n", rv); 396002918be2SPhilipp Reisner goto err_out; 3961b411b363SPhilipp Reisner } 396202918be2SPhilipp Reisner } 396302918be2SPhilipp Reisner 3964a4fbda8eSPhilipp Reisner if (drbd_cmd_handler[pi.cmd].fa_type == CONN) { 3965d9ae84e7SPhilipp Reisner rv = drbd_cmd_handler[pi.cmd].conn_fn(tconn, pi.cmd, pi.size - shs); 3966d9ae84e7SPhilipp Reisner } else { 3967d9ae84e7SPhilipp Reisner struct drbd_conf *mdev = vnr_to_mdev(tconn, pi.vnr); 39682de876efSPhilipp Reisner rv = mdev ? 3969d9ae84e7SPhilipp Reisner drbd_cmd_handler[pi.cmd].mdev_fn(mdev, pi.cmd, pi.size - shs) : 39702de876efSPhilipp Reisner tconn_receive_skip(tconn, pi.cmd, pi.size - shs); 3971d9ae84e7SPhilipp Reisner } 397202918be2SPhilipp Reisner 397302918be2SPhilipp Reisner if (unlikely(!rv)) { 3974eefc2f7dSPhilipp Reisner conn_err(tconn, "error receiving %s, l: %d!\n", 397577351055SPhilipp Reisner cmdname(pi.cmd), pi.size); 397602918be2SPhilipp Reisner goto err_out; 3977b411b363SPhilipp Reisner } 3978b411b363SPhilipp Reisner } 397902918be2SPhilipp Reisner 398002918be2SPhilipp Reisner if (0) { 398102918be2SPhilipp Reisner err_out: 3982bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD); 3983b411b363SPhilipp Reisner } 3984b411b363SPhilipp Reisner } 3985b411b363SPhilipp Reisner 39860e29d163SPhilipp Reisner void conn_flush_workqueue(struct drbd_tconn *tconn) 3987b411b363SPhilipp Reisner { 3988b411b363SPhilipp Reisner struct drbd_wq_barrier barr; 3989b411b363SPhilipp Reisner 3990b411b363SPhilipp Reisner barr.w.cb = w_prev_work_done; 39910e29d163SPhilipp Reisner barr.w.tconn = tconn; 3992b411b363SPhilipp Reisner init_completion(&barr.done); 39930e29d163SPhilipp Reisner drbd_queue_work(&tconn->data.work, &barr.w); 3994b411b363SPhilipp Reisner wait_for_completion(&barr.done); 3995b411b363SPhilipp Reisner } 3996b411b363SPhilipp Reisner 3997360cc740SPhilipp Reisner static void drbd_disconnect(struct drbd_tconn *tconn) 3998b411b363SPhilipp Reisner { 3999bbeb641cSPhilipp Reisner enum drbd_conns oc; 4000b411b363SPhilipp Reisner int rv = SS_UNKNOWN_ERROR; 4001b411b363SPhilipp Reisner 4002bbeb641cSPhilipp Reisner if (tconn->cstate == C_STANDALONE) 4003b411b363SPhilipp Reisner return; 4004b411b363SPhilipp Reisner 4005b411b363SPhilipp Reisner /* asender does not clean up anything. it must not interfere, either */ 4006360cc740SPhilipp Reisner drbd_thread_stop(&tconn->asender); 4007360cc740SPhilipp Reisner drbd_free_sock(tconn); 4008360cc740SPhilipp Reisner 4009360cc740SPhilipp Reisner idr_for_each(&tconn->volumes, drbd_disconnected, tconn); 4010360cc740SPhilipp Reisner 4011360cc740SPhilipp Reisner conn_info(tconn, "Connection closed\n"); 4012360cc740SPhilipp Reisner 4013360cc740SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4014bbeb641cSPhilipp Reisner oc = tconn->cstate; 4015bbeb641cSPhilipp Reisner if (oc >= C_UNCONNECTED) 4016bbeb641cSPhilipp Reisner rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE); 4017bbeb641cSPhilipp Reisner 4018360cc740SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 4019360cc740SPhilipp Reisner 4020bbeb641cSPhilipp Reisner if (oc == C_DISCONNECTING) { 4021360cc740SPhilipp Reisner wait_event(tconn->net_cnt_wait, atomic_read(&tconn->net_cnt) == 0); 4022360cc740SPhilipp Reisner 4023360cc740SPhilipp Reisner crypto_free_hash(tconn->cram_hmac_tfm); 4024360cc740SPhilipp Reisner tconn->cram_hmac_tfm = NULL; 4025360cc740SPhilipp Reisner 4026360cc740SPhilipp Reisner kfree(tconn->net_conf); 4027360cc740SPhilipp Reisner tconn->net_conf = NULL; 4028bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE); 4029360cc740SPhilipp Reisner } 4030360cc740SPhilipp Reisner } 4031360cc740SPhilipp Reisner 4032360cc740SPhilipp Reisner static int drbd_disconnected(int vnr, void *p, void *data) 4033360cc740SPhilipp Reisner { 4034360cc740SPhilipp Reisner struct drbd_conf *mdev = (struct drbd_conf *)p; 4035360cc740SPhilipp Reisner enum drbd_fencing_p fp; 4036360cc740SPhilipp Reisner unsigned int i; 4037b411b363SPhilipp Reisner 403885719573SPhilipp Reisner /* wait for current activity to cease. */ 403987eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4040b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->active_ee); 4041b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee); 4042b411b363SPhilipp Reisner _drbd_wait_ee_list_empty(mdev, &mdev->read_ee); 404387eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4044b411b363SPhilipp Reisner 4045b411b363SPhilipp Reisner /* We do not have data structures that would allow us to 4046b411b363SPhilipp Reisner * get the rs_pending_cnt down to 0 again. 4047b411b363SPhilipp Reisner * * On C_SYNC_TARGET we do not have any data structures describing 4048b411b363SPhilipp Reisner * the pending RSDataRequest's we have sent. 4049b411b363SPhilipp Reisner * * On C_SYNC_SOURCE there is no data structure that tracks 4050b411b363SPhilipp Reisner * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget. 4051b411b363SPhilipp Reisner * And no, it is not the sum of the reference counts in the 4052b411b363SPhilipp Reisner * resync_LRU. The resync_LRU tracks the whole operation including 4053b411b363SPhilipp Reisner * the disk-IO, while the rs_pending_cnt only tracks the blocks 4054b411b363SPhilipp Reisner * on the fly. */ 4055b411b363SPhilipp Reisner drbd_rs_cancel_all(mdev); 4056b411b363SPhilipp Reisner mdev->rs_total = 0; 4057b411b363SPhilipp Reisner mdev->rs_failed = 0; 4058b411b363SPhilipp Reisner atomic_set(&mdev->rs_pending_cnt, 0); 4059b411b363SPhilipp Reisner wake_up(&mdev->misc_wait); 4060b411b363SPhilipp Reisner 40617fde2be9SPhilipp Reisner del_timer(&mdev->request_timer); 40627fde2be9SPhilipp Reisner 4063b411b363SPhilipp Reisner del_timer_sync(&mdev->resync_timer); 4064b411b363SPhilipp Reisner resync_timer_fn((unsigned long)mdev); 4065b411b363SPhilipp Reisner 4066b411b363SPhilipp Reisner /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier, 4067b411b363SPhilipp Reisner * w_make_resync_request etc. which may still be on the worker queue 4068b411b363SPhilipp Reisner * to be "canceled" */ 4069a21e9298SPhilipp Reisner drbd_flush_workqueue(mdev); 4070b411b363SPhilipp Reisner 4071b411b363SPhilipp Reisner /* This also does reclaim_net_ee(). If we do this too early, we might 4072b411b363SPhilipp Reisner * miss some resync ee and pages.*/ 4073b411b363SPhilipp Reisner drbd_process_done_ee(mdev); 4074b411b363SPhilipp Reisner 4075b411b363SPhilipp Reisner kfree(mdev->p_uuid); 4076b411b363SPhilipp Reisner mdev->p_uuid = NULL; 4077b411b363SPhilipp Reisner 4078fb22c402SPhilipp Reisner if (!is_susp(mdev->state)) 40792f5cdd0bSPhilipp Reisner tl_clear(mdev->tconn); 4080b411b363SPhilipp Reisner 4081b411b363SPhilipp Reisner drbd_md_sync(mdev); 4082b411b363SPhilipp Reisner 4083b411b363SPhilipp Reisner fp = FP_DONT_CARE; 4084b411b363SPhilipp Reisner if (get_ldev(mdev)) { 4085b411b363SPhilipp Reisner fp = mdev->ldev->dc.fencing; 4086b411b363SPhilipp Reisner put_ldev(mdev); 4087b411b363SPhilipp Reisner } 4088b411b363SPhilipp Reisner 408987f7be4cSPhilipp Reisner if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN) 409087f7be4cSPhilipp Reisner drbd_try_outdate_peer_async(mdev); 4091b411b363SPhilipp Reisner 409220ceb2b2SLars Ellenberg /* serialize with bitmap writeout triggered by the state change, 409320ceb2b2SLars Ellenberg * if any. */ 409420ceb2b2SLars Ellenberg wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags)); 409520ceb2b2SLars Ellenberg 4096b411b363SPhilipp Reisner /* tcp_close and release of sendpage pages can be deferred. I don't 4097b411b363SPhilipp Reisner * want to use SO_LINGER, because apparently it can be deferred for 4098b411b363SPhilipp Reisner * more than 20 seconds (longest time I checked). 4099b411b363SPhilipp Reisner * 4100b411b363SPhilipp Reisner * Actually we don't care for exactly when the network stack does its 4101b411b363SPhilipp Reisner * put_page(), but release our reference on these pages right here. 4102b411b363SPhilipp Reisner */ 4103b411b363SPhilipp Reisner i = drbd_release_ee(mdev, &mdev->net_ee); 4104b411b363SPhilipp Reisner if (i) 4105b411b363SPhilipp Reisner dev_info(DEV, "net_ee not empty, killed %u entries\n", i); 4106435f0740SLars Ellenberg i = atomic_read(&mdev->pp_in_use_by_net); 4107435f0740SLars Ellenberg if (i) 4108435f0740SLars Ellenberg dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i); 4109b411b363SPhilipp Reisner i = atomic_read(&mdev->pp_in_use); 4110b411b363SPhilipp Reisner if (i) 411145bb912bSLars Ellenberg dev_info(DEV, "pp_in_use = %d, expected 0\n", i); 4112b411b363SPhilipp Reisner 4113b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->read_ee)); 4114b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->active_ee)); 4115b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->sync_ee)); 4116b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->done_ee)); 4117b411b363SPhilipp Reisner 4118b411b363SPhilipp Reisner /* ok, no more ee's on the fly, it is safe to reset the epoch_size */ 4119b411b363SPhilipp Reisner atomic_set(&mdev->current_epoch->epoch_size, 0); 4120b411b363SPhilipp Reisner D_ASSERT(list_empty(&mdev->current_epoch->list)); 4121360cc740SPhilipp Reisner 4122360cc740SPhilipp Reisner return 0; 4123b411b363SPhilipp Reisner } 4124b411b363SPhilipp Reisner 4125b411b363SPhilipp Reisner /* 4126b411b363SPhilipp Reisner * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version 4127b411b363SPhilipp Reisner * we can agree on is stored in agreed_pro_version. 4128b411b363SPhilipp Reisner * 4129b411b363SPhilipp Reisner * feature flags and the reserved array should be enough room for future 4130b411b363SPhilipp Reisner * enhancements of the handshake protocol, and possible plugins... 4131b411b363SPhilipp Reisner * 4132b411b363SPhilipp Reisner * for now, they are expected to be zero, but ignored. 4133b411b363SPhilipp Reisner */ 41348a22ccccSPhilipp Reisner static int drbd_send_handshake(struct drbd_tconn *tconn) 4135b411b363SPhilipp Reisner { 4136e6b3ea83SPhilipp Reisner /* ASSERT current == mdev->tconn->receiver ... */ 41378a22ccccSPhilipp Reisner struct p_handshake *p = &tconn->data.sbuf.handshake; 4138b411b363SPhilipp Reisner int ok; 4139b411b363SPhilipp Reisner 41408a22ccccSPhilipp Reisner if (mutex_lock_interruptible(&tconn->data.mutex)) { 41418a22ccccSPhilipp Reisner conn_err(tconn, "interrupted during initial handshake\n"); 4142b411b363SPhilipp Reisner return 0; /* interrupted. not ok. */ 4143b411b363SPhilipp Reisner } 4144b411b363SPhilipp Reisner 41458a22ccccSPhilipp Reisner if (tconn->data.socket == NULL) { 41468a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4147b411b363SPhilipp Reisner return 0; 4148b411b363SPhilipp Reisner } 4149b411b363SPhilipp Reisner 4150b411b363SPhilipp Reisner memset(p, 0, sizeof(*p)); 4151b411b363SPhilipp Reisner p->protocol_min = cpu_to_be32(PRO_VERSION_MIN); 4152b411b363SPhilipp Reisner p->protocol_max = cpu_to_be32(PRO_VERSION_MAX); 41538a22ccccSPhilipp Reisner ok = _conn_send_cmd(tconn, 0, tconn->data.socket, P_HAND_SHAKE, 4154c012949aSPhilipp Reisner &p->head, sizeof(*p), 0); 41558a22ccccSPhilipp Reisner mutex_unlock(&tconn->data.mutex); 4156b411b363SPhilipp Reisner return ok; 4157b411b363SPhilipp Reisner } 4158b411b363SPhilipp Reisner 4159b411b363SPhilipp Reisner /* 4160b411b363SPhilipp Reisner * return values: 4161b411b363SPhilipp Reisner * 1 yes, we have a valid connection 4162b411b363SPhilipp Reisner * 0 oops, did not work out, please try again 4163b411b363SPhilipp Reisner * -1 peer talks different language, 4164b411b363SPhilipp Reisner * no point in trying again, please go standalone. 4165b411b363SPhilipp Reisner */ 416665d11ed6SPhilipp Reisner static int drbd_do_handshake(struct drbd_tconn *tconn) 4167b411b363SPhilipp Reisner { 416865d11ed6SPhilipp Reisner /* ASSERT current == tconn->receiver ... */ 416965d11ed6SPhilipp Reisner struct p_handshake *p = &tconn->data.rbuf.handshake; 417002918be2SPhilipp Reisner const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80); 417177351055SPhilipp Reisner struct packet_info pi; 4172b411b363SPhilipp Reisner int rv; 4173b411b363SPhilipp Reisner 417465d11ed6SPhilipp Reisner rv = drbd_send_handshake(tconn); 4175b411b363SPhilipp Reisner if (!rv) 4176b411b363SPhilipp Reisner return 0; 4177b411b363SPhilipp Reisner 417865d11ed6SPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4179b411b363SPhilipp Reisner if (!rv) 4180b411b363SPhilipp Reisner return 0; 4181b411b363SPhilipp Reisner 418277351055SPhilipp Reisner if (pi.cmd != P_HAND_SHAKE) { 418365d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake packet, received: %s (0x%04x)\n", 418477351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4185b411b363SPhilipp Reisner return -1; 4186b411b363SPhilipp Reisner } 4187b411b363SPhilipp Reisner 418877351055SPhilipp Reisner if (pi.size != expect) { 418965d11ed6SPhilipp Reisner conn_err(tconn, "expected HandShake length: %u, received: %u\n", 419077351055SPhilipp Reisner expect, pi.size); 4191b411b363SPhilipp Reisner return -1; 4192b411b363SPhilipp Reisner } 4193b411b363SPhilipp Reisner 419465d11ed6SPhilipp Reisner rv = drbd_recv(tconn, &p->head.payload, expect); 4195b411b363SPhilipp Reisner 4196b411b363SPhilipp Reisner if (rv != expect) { 41970ddc5549SLars Ellenberg if (!signal_pending(current)) 419865d11ed6SPhilipp Reisner conn_warn(tconn, "short read receiving handshake packet: l=%u\n", rv); 4199b411b363SPhilipp Reisner return 0; 4200b411b363SPhilipp Reisner } 4201b411b363SPhilipp Reisner 4202b411b363SPhilipp Reisner p->protocol_min = be32_to_cpu(p->protocol_min); 4203b411b363SPhilipp Reisner p->protocol_max = be32_to_cpu(p->protocol_max); 4204b411b363SPhilipp Reisner if (p->protocol_max == 0) 4205b411b363SPhilipp Reisner p->protocol_max = p->protocol_min; 4206b411b363SPhilipp Reisner 4207b411b363SPhilipp Reisner if (PRO_VERSION_MAX < p->protocol_min || 4208b411b363SPhilipp Reisner PRO_VERSION_MIN > p->protocol_max) 4209b411b363SPhilipp Reisner goto incompat; 4210b411b363SPhilipp Reisner 421165d11ed6SPhilipp Reisner tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max); 4212b411b363SPhilipp Reisner 421365d11ed6SPhilipp Reisner conn_info(tconn, "Handshake successful: " 421465d11ed6SPhilipp Reisner "Agreed network protocol version %d\n", tconn->agreed_pro_version); 4215b411b363SPhilipp Reisner 4216b411b363SPhilipp Reisner return 1; 4217b411b363SPhilipp Reisner 4218b411b363SPhilipp Reisner incompat: 421965d11ed6SPhilipp Reisner conn_err(tconn, "incompatible DRBD dialects: " 4220b411b363SPhilipp Reisner "I support %d-%d, peer supports %d-%d\n", 4221b411b363SPhilipp Reisner PRO_VERSION_MIN, PRO_VERSION_MAX, 4222b411b363SPhilipp Reisner p->protocol_min, p->protocol_max); 4223b411b363SPhilipp Reisner return -1; 4224b411b363SPhilipp Reisner } 4225b411b363SPhilipp Reisner 4226b411b363SPhilipp Reisner #if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE) 422713e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4228b411b363SPhilipp Reisner { 4229b411b363SPhilipp Reisner dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n"); 4230b411b363SPhilipp Reisner dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n"); 4231b10d96cbSJohannes Thoma return -1; 4232b411b363SPhilipp Reisner } 4233b411b363SPhilipp Reisner #else 4234b411b363SPhilipp Reisner #define CHALLENGE_LEN 64 4235b10d96cbSJohannes Thoma 4236b10d96cbSJohannes Thoma /* Return value: 4237b10d96cbSJohannes Thoma 1 - auth succeeded, 4238b10d96cbSJohannes Thoma 0 - failed, try again (network error), 4239b10d96cbSJohannes Thoma -1 - auth failed, don't try again. 4240b10d96cbSJohannes Thoma */ 4241b10d96cbSJohannes Thoma 424213e6037dSPhilipp Reisner static int drbd_do_auth(struct drbd_tconn *tconn) 4243b411b363SPhilipp Reisner { 4244b411b363SPhilipp Reisner char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */ 4245b411b363SPhilipp Reisner struct scatterlist sg; 4246b411b363SPhilipp Reisner char *response = NULL; 4247b411b363SPhilipp Reisner char *right_response = NULL; 4248b411b363SPhilipp Reisner char *peers_ch = NULL; 424913e6037dSPhilipp Reisner unsigned int key_len = strlen(tconn->net_conf->shared_secret); 4250b411b363SPhilipp Reisner unsigned int resp_size; 4251b411b363SPhilipp Reisner struct hash_desc desc; 425277351055SPhilipp Reisner struct packet_info pi; 4253b411b363SPhilipp Reisner int rv; 4254b411b363SPhilipp Reisner 425513e6037dSPhilipp Reisner desc.tfm = tconn->cram_hmac_tfm; 4256b411b363SPhilipp Reisner desc.flags = 0; 4257b411b363SPhilipp Reisner 425813e6037dSPhilipp Reisner rv = crypto_hash_setkey(tconn->cram_hmac_tfm, 425913e6037dSPhilipp Reisner (u8 *)tconn->net_conf->shared_secret, key_len); 4260b411b363SPhilipp Reisner if (rv) { 426113e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv); 4262b10d96cbSJohannes Thoma rv = -1; 4263b411b363SPhilipp Reisner goto fail; 4264b411b363SPhilipp Reisner } 4265b411b363SPhilipp Reisner 4266b411b363SPhilipp Reisner get_random_bytes(my_challenge, CHALLENGE_LEN); 4267b411b363SPhilipp Reisner 4268ce9879cbSAndreas Gruenbacher rv = !conn_send_cmd2(tconn, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN); 4269b411b363SPhilipp Reisner if (!rv) 4270b411b363SPhilipp Reisner goto fail; 4271b411b363SPhilipp Reisner 427213e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4273b411b363SPhilipp Reisner if (!rv) 4274b411b363SPhilipp Reisner goto fail; 4275b411b363SPhilipp Reisner 427677351055SPhilipp Reisner if (pi.cmd != P_AUTH_CHALLENGE) { 427713e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n", 427877351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4279b411b363SPhilipp Reisner rv = 0; 4280b411b363SPhilipp Reisner goto fail; 4281b411b363SPhilipp Reisner } 4282b411b363SPhilipp Reisner 428377351055SPhilipp Reisner if (pi.size > CHALLENGE_LEN * 2) { 428413e6037dSPhilipp Reisner conn_err(tconn, "expected AuthChallenge payload too big.\n"); 4285b10d96cbSJohannes Thoma rv = -1; 4286b411b363SPhilipp Reisner goto fail; 4287b411b363SPhilipp Reisner } 4288b411b363SPhilipp Reisner 428977351055SPhilipp Reisner peers_ch = kmalloc(pi.size, GFP_NOIO); 4290b411b363SPhilipp Reisner if (peers_ch == NULL) { 429113e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of peers_ch failed\n"); 4292b10d96cbSJohannes Thoma rv = -1; 4293b411b363SPhilipp Reisner goto fail; 4294b411b363SPhilipp Reisner } 4295b411b363SPhilipp Reisner 429613e6037dSPhilipp Reisner rv = drbd_recv(tconn, peers_ch, pi.size); 4297b411b363SPhilipp Reisner 429877351055SPhilipp Reisner if (rv != pi.size) { 42990ddc5549SLars Ellenberg if (!signal_pending(current)) 430013e6037dSPhilipp Reisner conn_warn(tconn, "short read AuthChallenge: l=%u\n", rv); 4301b411b363SPhilipp Reisner rv = 0; 4302b411b363SPhilipp Reisner goto fail; 4303b411b363SPhilipp Reisner } 4304b411b363SPhilipp Reisner 430513e6037dSPhilipp Reisner resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm); 4306b411b363SPhilipp Reisner response = kmalloc(resp_size, GFP_NOIO); 4307b411b363SPhilipp Reisner if (response == NULL) { 430813e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of response failed\n"); 4309b10d96cbSJohannes Thoma rv = -1; 4310b411b363SPhilipp Reisner goto fail; 4311b411b363SPhilipp Reisner } 4312b411b363SPhilipp Reisner 4313b411b363SPhilipp Reisner sg_init_table(&sg, 1); 431477351055SPhilipp Reisner sg_set_buf(&sg, peers_ch, pi.size); 4315b411b363SPhilipp Reisner 4316b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, response); 4317b411b363SPhilipp Reisner if (rv) { 431813e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4319b10d96cbSJohannes Thoma rv = -1; 4320b411b363SPhilipp Reisner goto fail; 4321b411b363SPhilipp Reisner } 4322b411b363SPhilipp Reisner 4323ce9879cbSAndreas Gruenbacher rv = !conn_send_cmd2(tconn, P_AUTH_RESPONSE, response, resp_size); 4324b411b363SPhilipp Reisner if (!rv) 4325b411b363SPhilipp Reisner goto fail; 4326b411b363SPhilipp Reisner 432713e6037dSPhilipp Reisner rv = drbd_recv_header(tconn, &pi); 4328b411b363SPhilipp Reisner if (!rv) 4329b411b363SPhilipp Reisner goto fail; 4330b411b363SPhilipp Reisner 433177351055SPhilipp Reisner if (pi.cmd != P_AUTH_RESPONSE) { 433213e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n", 433377351055SPhilipp Reisner cmdname(pi.cmd), pi.cmd); 4334b411b363SPhilipp Reisner rv = 0; 4335b411b363SPhilipp Reisner goto fail; 4336b411b363SPhilipp Reisner } 4337b411b363SPhilipp Reisner 433877351055SPhilipp Reisner if (pi.size != resp_size) { 433913e6037dSPhilipp Reisner conn_err(tconn, "expected AuthResponse payload of wrong size\n"); 4340b411b363SPhilipp Reisner rv = 0; 4341b411b363SPhilipp Reisner goto fail; 4342b411b363SPhilipp Reisner } 4343b411b363SPhilipp Reisner 434413e6037dSPhilipp Reisner rv = drbd_recv(tconn, response , resp_size); 4345b411b363SPhilipp Reisner 4346b411b363SPhilipp Reisner if (rv != resp_size) { 43470ddc5549SLars Ellenberg if (!signal_pending(current)) 434813e6037dSPhilipp Reisner conn_warn(tconn, "short read receiving AuthResponse: l=%u\n", rv); 4349b411b363SPhilipp Reisner rv = 0; 4350b411b363SPhilipp Reisner goto fail; 4351b411b363SPhilipp Reisner } 4352b411b363SPhilipp Reisner 4353b411b363SPhilipp Reisner right_response = kmalloc(resp_size, GFP_NOIO); 43542d1ee87dSJulia Lawall if (right_response == NULL) { 435513e6037dSPhilipp Reisner conn_err(tconn, "kmalloc of right_response failed\n"); 4356b10d96cbSJohannes Thoma rv = -1; 4357b411b363SPhilipp Reisner goto fail; 4358b411b363SPhilipp Reisner } 4359b411b363SPhilipp Reisner 4360b411b363SPhilipp Reisner sg_set_buf(&sg, my_challenge, CHALLENGE_LEN); 4361b411b363SPhilipp Reisner 4362b411b363SPhilipp Reisner rv = crypto_hash_digest(&desc, &sg, sg.length, right_response); 4363b411b363SPhilipp Reisner if (rv) { 436413e6037dSPhilipp Reisner conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv); 4365b10d96cbSJohannes Thoma rv = -1; 4366b411b363SPhilipp Reisner goto fail; 4367b411b363SPhilipp Reisner } 4368b411b363SPhilipp Reisner 4369b411b363SPhilipp Reisner rv = !memcmp(response, right_response, resp_size); 4370b411b363SPhilipp Reisner 4371b411b363SPhilipp Reisner if (rv) 437213e6037dSPhilipp Reisner conn_info(tconn, "Peer authenticated using %d bytes of '%s' HMAC\n", 437313e6037dSPhilipp Reisner resp_size, tconn->net_conf->cram_hmac_alg); 4374b10d96cbSJohannes Thoma else 4375b10d96cbSJohannes Thoma rv = -1; 4376b411b363SPhilipp Reisner 4377b411b363SPhilipp Reisner fail: 4378b411b363SPhilipp Reisner kfree(peers_ch); 4379b411b363SPhilipp Reisner kfree(response); 4380b411b363SPhilipp Reisner kfree(right_response); 4381b411b363SPhilipp Reisner 4382b411b363SPhilipp Reisner return rv; 4383b411b363SPhilipp Reisner } 4384b411b363SPhilipp Reisner #endif 4385b411b363SPhilipp Reisner 4386b411b363SPhilipp Reisner int drbdd_init(struct drbd_thread *thi) 4387b411b363SPhilipp Reisner { 4388392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 4389b411b363SPhilipp Reisner int h; 4390b411b363SPhilipp Reisner 43914d641dd7SPhilipp Reisner conn_info(tconn, "receiver (re)started\n"); 4392b411b363SPhilipp Reisner 4393b411b363SPhilipp Reisner do { 43944d641dd7SPhilipp Reisner h = drbd_connect(tconn); 4395b411b363SPhilipp Reisner if (h == 0) { 43964d641dd7SPhilipp Reisner drbd_disconnect(tconn); 439720ee6390SPhilipp Reisner schedule_timeout_interruptible(HZ); 4398b411b363SPhilipp Reisner } 4399b411b363SPhilipp Reisner if (h == -1) { 44004d641dd7SPhilipp Reisner conn_warn(tconn, "Discarding network configuration.\n"); 4401bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4402b411b363SPhilipp Reisner } 4403b411b363SPhilipp Reisner } while (h == 0); 4404b411b363SPhilipp Reisner 4405b411b363SPhilipp Reisner if (h > 0) { 44064d641dd7SPhilipp Reisner if (get_net_conf(tconn)) { 44074d641dd7SPhilipp Reisner drbdd(tconn); 44084d641dd7SPhilipp Reisner put_net_conf(tconn); 4409b411b363SPhilipp Reisner } 4410b411b363SPhilipp Reisner } 4411b411b363SPhilipp Reisner 44124d641dd7SPhilipp Reisner drbd_disconnect(tconn); 4413b411b363SPhilipp Reisner 44144d641dd7SPhilipp Reisner conn_info(tconn, "receiver terminated\n"); 4415b411b363SPhilipp Reisner return 0; 4416b411b363SPhilipp Reisner } 4417b411b363SPhilipp Reisner 4418b411b363SPhilipp Reisner /* ********* acknowledge sender ******** */ 4419b411b363SPhilipp Reisner 4420e4f78edeSPhilipp Reisner static int got_conn_RqSReply(struct drbd_tconn *tconn, enum drbd_packet cmd) 4421b411b363SPhilipp Reisner { 4422e4f78edeSPhilipp Reisner struct p_req_state_reply *p = &tconn->meta.rbuf.req_state_reply; 4423b411b363SPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4424b411b363SPhilipp Reisner 4425fc3b10a4SPhilipp Reisner if (retcode >= SS_SUCCESS) { 4426fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags); 4427fc3b10a4SPhilipp Reisner } else { 4428fc3b10a4SPhilipp Reisner set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags); 4429fc3b10a4SPhilipp Reisner conn_err(tconn, "Requested state change failed by peer: %s (%d)\n", 4430fc3b10a4SPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4431fc3b10a4SPhilipp Reisner } 4432fc3b10a4SPhilipp Reisner wake_up(&tconn->ping_wait); 4433e4f78edeSPhilipp Reisner 4434e4f78edeSPhilipp Reisner return true; 4435fc3b10a4SPhilipp Reisner } 4436e4f78edeSPhilipp Reisner 4437e4f78edeSPhilipp Reisner static int got_RqSReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4438e4f78edeSPhilipp Reisner { 4439e4f78edeSPhilipp Reisner struct p_req_state_reply *p = &mdev->tconn->meta.rbuf.req_state_reply; 4440e4f78edeSPhilipp Reisner int retcode = be32_to_cpu(p->retcode); 4441e4f78edeSPhilipp Reisner 4442e4f78edeSPhilipp Reisner if (retcode >= SS_SUCCESS) { 4443e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_SUCCESS, &mdev->flags); 4444e4f78edeSPhilipp Reisner } else { 4445e4f78edeSPhilipp Reisner set_bit(CL_ST_CHG_FAIL, &mdev->flags); 4446e4f78edeSPhilipp Reisner dev_err(DEV, "Requested state change failed by peer: %s (%d)\n", 4447e4f78edeSPhilipp Reisner drbd_set_st_err_str(retcode), retcode); 4448e4f78edeSPhilipp Reisner } 4449e4f78edeSPhilipp Reisner wake_up(&mdev->state_wait); 4450e4f78edeSPhilipp Reisner 445181e84650SAndreas Gruenbacher return true; 4452b411b363SPhilipp Reisner } 4453b411b363SPhilipp Reisner 4454f19e4f8bSPhilipp Reisner static int got_Ping(struct drbd_tconn *tconn, enum drbd_packet cmd) 4455b411b363SPhilipp Reisner { 4456f19e4f8bSPhilipp Reisner return drbd_send_ping_ack(tconn); 4457b411b363SPhilipp Reisner 4458b411b363SPhilipp Reisner } 4459b411b363SPhilipp Reisner 4460f19e4f8bSPhilipp Reisner static int got_PingAck(struct drbd_tconn *tconn, enum drbd_packet cmd) 4461b411b363SPhilipp Reisner { 4462b411b363SPhilipp Reisner /* restore idle timeout */ 44632a67d8b9SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ; 44642a67d8b9SPhilipp Reisner if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags)) 44652a67d8b9SPhilipp Reisner wake_up(&tconn->ping_wait); 4466b411b363SPhilipp Reisner 446781e84650SAndreas Gruenbacher return true; 4468b411b363SPhilipp Reisner } 4469b411b363SPhilipp Reisner 4470d8763023SAndreas Gruenbacher static int got_IsInSync(struct drbd_conf *mdev, enum drbd_packet cmd) 4471b411b363SPhilipp Reisner { 4472257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4473b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4474b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4475b411b363SPhilipp Reisner 447631890f4aSPhilipp Reisner D_ASSERT(mdev->tconn->agreed_pro_version >= 89); 4477b411b363SPhilipp Reisner 4478b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4479b411b363SPhilipp Reisner 44801d53f09eSLars Ellenberg if (get_ldev(mdev)) { 4481b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4482b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4483b411b363SPhilipp Reisner /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */ 4484b411b363SPhilipp Reisner mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT); 44851d53f09eSLars Ellenberg put_ldev(mdev); 44861d53f09eSLars Ellenberg } 4487b411b363SPhilipp Reisner dec_rs_pending(mdev); 4488778f271dSPhilipp Reisner atomic_add(blksize >> 9, &mdev->rs_sect_in); 4489b411b363SPhilipp Reisner 449081e84650SAndreas Gruenbacher return true; 4491b411b363SPhilipp Reisner } 4492b411b363SPhilipp Reisner 4493bc9c5c41SAndreas Gruenbacher static int 4494bc9c5c41SAndreas Gruenbacher validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector, 4495bc9c5c41SAndreas Gruenbacher struct rb_root *root, const char *func, 4496bc9c5c41SAndreas Gruenbacher enum drbd_req_event what, bool missing_ok) 4497b411b363SPhilipp Reisner { 4498b411b363SPhilipp Reisner struct drbd_request *req; 4499b411b363SPhilipp Reisner struct bio_and_error m; 4500b411b363SPhilipp Reisner 450187eeee41SPhilipp Reisner spin_lock_irq(&mdev->tconn->req_lock); 4502bc9c5c41SAndreas Gruenbacher req = find_request(mdev, root, id, sector, missing_ok, func); 4503b411b363SPhilipp Reisner if (unlikely(!req)) { 450487eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 450581e84650SAndreas Gruenbacher return false; 4506b411b363SPhilipp Reisner } 4507b411b363SPhilipp Reisner __req_mod(req, what, &m); 450887eeee41SPhilipp Reisner spin_unlock_irq(&mdev->tconn->req_lock); 4509b411b363SPhilipp Reisner 4510b411b363SPhilipp Reisner if (m.bio) 4511b411b363SPhilipp Reisner complete_master_bio(mdev, &m); 451281e84650SAndreas Gruenbacher return true; 4513b411b363SPhilipp Reisner } 4514b411b363SPhilipp Reisner 4515d8763023SAndreas Gruenbacher static int got_BlockAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4516b411b363SPhilipp Reisner { 4517257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4518b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4519b411b363SPhilipp Reisner int blksize = be32_to_cpu(p->blksize); 4520b411b363SPhilipp Reisner enum drbd_req_event what; 4521b411b363SPhilipp Reisner 4522b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4523b411b363SPhilipp Reisner 4524579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4525b411b363SPhilipp Reisner drbd_set_in_sync(mdev, sector, blksize); 4526b411b363SPhilipp Reisner dec_rs_pending(mdev); 452781e84650SAndreas Gruenbacher return true; 4528b411b363SPhilipp Reisner } 4529257d0af6SPhilipp Reisner switch (cmd) { 4530b411b363SPhilipp Reisner case P_RS_WRITE_ACK: 453189e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45328554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER_AND_SIS; 4533b411b363SPhilipp Reisner break; 4534b411b363SPhilipp Reisner case P_WRITE_ACK: 453589e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45368554df1cSAndreas Gruenbacher what = WRITE_ACKED_BY_PEER; 4537b411b363SPhilipp Reisner break; 4538b411b363SPhilipp Reisner case P_RECV_ACK: 453989e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B); 45408554df1cSAndreas Gruenbacher what = RECV_ACKED_BY_PEER; 4541b411b363SPhilipp Reisner break; 45427be8da07SAndreas Gruenbacher case P_DISCARD_WRITE: 454389e58e75SPhilipp Reisner D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45447be8da07SAndreas Gruenbacher what = DISCARD_WRITE; 45457be8da07SAndreas Gruenbacher break; 45467be8da07SAndreas Gruenbacher case P_RETRY_WRITE: 45477be8da07SAndreas Gruenbacher D_ASSERT(mdev->tconn->net_conf->wire_protocol == DRBD_PROT_C); 45487be8da07SAndreas Gruenbacher what = POSTPONE_WRITE; 4549b411b363SPhilipp Reisner break; 4550b411b363SPhilipp Reisner default: 4551b411b363SPhilipp Reisner D_ASSERT(0); 455281e84650SAndreas Gruenbacher return false; 4553b411b363SPhilipp Reisner } 4554b411b363SPhilipp Reisner 4555b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4556bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 4557bc9c5c41SAndreas Gruenbacher what, false); 4558b411b363SPhilipp Reisner } 4559b411b363SPhilipp Reisner 4560d8763023SAndreas Gruenbacher static int got_NegAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4561b411b363SPhilipp Reisner { 4562257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4563b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 45642deb8336SPhilipp Reisner int size = be32_to_cpu(p->blksize); 456589e58e75SPhilipp Reisner bool missing_ok = mdev->tconn->net_conf->wire_protocol == DRBD_PROT_A || 456689e58e75SPhilipp Reisner mdev->tconn->net_conf->wire_protocol == DRBD_PROT_B; 4567c3afd8f5SAndreas Gruenbacher bool found; 4568b411b363SPhilipp Reisner 4569b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4570b411b363SPhilipp Reisner 4571579b57edSAndreas Gruenbacher if (p->block_id == ID_SYNCER) { 4572b411b363SPhilipp Reisner dec_rs_pending(mdev); 4573b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 457481e84650SAndreas Gruenbacher return true; 4575b411b363SPhilipp Reisner } 45762deb8336SPhilipp Reisner 4577c3afd8f5SAndreas Gruenbacher found = validate_req_change_req_state(mdev, p->block_id, sector, 4578bc9c5c41SAndreas Gruenbacher &mdev->write_requests, __func__, 45798554df1cSAndreas Gruenbacher NEG_ACKED, missing_ok); 4580c3afd8f5SAndreas Gruenbacher if (!found) { 45812deb8336SPhilipp Reisner /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs. 45822deb8336SPhilipp Reisner The master bio might already be completed, therefore the 4583c3afd8f5SAndreas Gruenbacher request is no longer in the collision hash. */ 45842deb8336SPhilipp Reisner /* In Protocol B we might already have got a P_RECV_ACK 45852deb8336SPhilipp Reisner but then get a P_NEG_ACK afterwards. */ 4586c3afd8f5SAndreas Gruenbacher if (!missing_ok) 45872deb8336SPhilipp Reisner return false; 4588c3afd8f5SAndreas Gruenbacher drbd_set_out_of_sync(mdev, sector, size); 45892deb8336SPhilipp Reisner } 45902deb8336SPhilipp Reisner return true; 4591b411b363SPhilipp Reisner } 4592b411b363SPhilipp Reisner 4593d8763023SAndreas Gruenbacher static int got_NegDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4594b411b363SPhilipp Reisner { 4595257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4596b411b363SPhilipp Reisner sector_t sector = be64_to_cpu(p->sector); 4597b411b363SPhilipp Reisner 4598b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 45997be8da07SAndreas Gruenbacher 4600b411b363SPhilipp Reisner dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n", 4601b411b363SPhilipp Reisner (unsigned long long)sector, be32_to_cpu(p->blksize)); 4602b411b363SPhilipp Reisner 4603b411b363SPhilipp Reisner return validate_req_change_req_state(mdev, p->block_id, sector, 4604bc9c5c41SAndreas Gruenbacher &mdev->read_requests, __func__, 46058554df1cSAndreas Gruenbacher NEG_ACKED, false); 4606b411b363SPhilipp Reisner } 4607b411b363SPhilipp Reisner 4608d8763023SAndreas Gruenbacher static int got_NegRSDReply(struct drbd_conf *mdev, enum drbd_packet cmd) 4609b411b363SPhilipp Reisner { 4610b411b363SPhilipp Reisner sector_t sector; 4611b411b363SPhilipp Reisner int size; 4612257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4613b411b363SPhilipp Reisner 4614b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4615b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4616b411b363SPhilipp Reisner 4617b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4618b411b363SPhilipp Reisner 4619b411b363SPhilipp Reisner dec_rs_pending(mdev); 4620b411b363SPhilipp Reisner 4621b411b363SPhilipp Reisner if (get_ldev_if_state(mdev, D_FAILED)) { 4622b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4623257d0af6SPhilipp Reisner switch (cmd) { 4624d612d309SPhilipp Reisner case P_NEG_RS_DREPLY: 4625b411b363SPhilipp Reisner drbd_rs_failed_io(mdev, sector, size); 4626d612d309SPhilipp Reisner case P_RS_CANCEL: 4627d612d309SPhilipp Reisner break; 4628d612d309SPhilipp Reisner default: 4629d612d309SPhilipp Reisner D_ASSERT(0); 4630d612d309SPhilipp Reisner put_ldev(mdev); 4631d612d309SPhilipp Reisner return false; 4632d612d309SPhilipp Reisner } 4633b411b363SPhilipp Reisner put_ldev(mdev); 4634b411b363SPhilipp Reisner } 4635b411b363SPhilipp Reisner 463681e84650SAndreas Gruenbacher return true; 4637b411b363SPhilipp Reisner } 4638b411b363SPhilipp Reisner 4639d8763023SAndreas Gruenbacher static int got_BarrierAck(struct drbd_conf *mdev, enum drbd_packet cmd) 4640b411b363SPhilipp Reisner { 4641257d0af6SPhilipp Reisner struct p_barrier_ack *p = &mdev->tconn->meta.rbuf.barrier_ack; 4642b411b363SPhilipp Reisner 46432f5cdd0bSPhilipp Reisner tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size)); 4644b411b363SPhilipp Reisner 4645c4752ef1SPhilipp Reisner if (mdev->state.conn == C_AHEAD && 4646c4752ef1SPhilipp Reisner atomic_read(&mdev->ap_in_flight) == 0 && 4647370a43e7SPhilipp Reisner !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) { 4648370a43e7SPhilipp Reisner mdev->start_resync_timer.expires = jiffies + HZ; 4649370a43e7SPhilipp Reisner add_timer(&mdev->start_resync_timer); 4650c4752ef1SPhilipp Reisner } 4651c4752ef1SPhilipp Reisner 465281e84650SAndreas Gruenbacher return true; 4653b411b363SPhilipp Reisner } 4654b411b363SPhilipp Reisner 4655d8763023SAndreas Gruenbacher static int got_OVResult(struct drbd_conf *mdev, enum drbd_packet cmd) 4656b411b363SPhilipp Reisner { 4657257d0af6SPhilipp Reisner struct p_block_ack *p = &mdev->tconn->meta.rbuf.block_ack; 4658b411b363SPhilipp Reisner struct drbd_work *w; 4659b411b363SPhilipp Reisner sector_t sector; 4660b411b363SPhilipp Reisner int size; 4661b411b363SPhilipp Reisner 4662b411b363SPhilipp Reisner sector = be64_to_cpu(p->sector); 4663b411b363SPhilipp Reisner size = be32_to_cpu(p->blksize); 4664b411b363SPhilipp Reisner 4665b411b363SPhilipp Reisner update_peer_seq(mdev, be32_to_cpu(p->seq_num)); 4666b411b363SPhilipp Reisner 4667b411b363SPhilipp Reisner if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC) 4668b411b363SPhilipp Reisner drbd_ov_oos_found(mdev, sector, size); 4669b411b363SPhilipp Reisner else 4670b411b363SPhilipp Reisner ov_oos_print(mdev); 4671b411b363SPhilipp Reisner 46721d53f09eSLars Ellenberg if (!get_ldev(mdev)) 467381e84650SAndreas Gruenbacher return true; 46741d53f09eSLars Ellenberg 4675b411b363SPhilipp Reisner drbd_rs_complete_io(mdev, sector); 4676b411b363SPhilipp Reisner dec_rs_pending(mdev); 4677b411b363SPhilipp Reisner 4678ea5442afSLars Ellenberg --mdev->ov_left; 4679ea5442afSLars Ellenberg 4680ea5442afSLars Ellenberg /* let's advance progress step marks only for every other megabyte */ 4681ea5442afSLars Ellenberg if ((mdev->ov_left & 0x200) == 0x200) 4682ea5442afSLars Ellenberg drbd_advance_rs_marks(mdev, mdev->ov_left); 4683ea5442afSLars Ellenberg 4684ea5442afSLars Ellenberg if (mdev->ov_left == 0) { 4685b411b363SPhilipp Reisner w = kmalloc(sizeof(*w), GFP_NOIO); 4686b411b363SPhilipp Reisner if (w) { 4687b411b363SPhilipp Reisner w->cb = w_ov_finished; 4688a21e9298SPhilipp Reisner w->mdev = mdev; 4689e42325a5SPhilipp Reisner drbd_queue_work_front(&mdev->tconn->data.work, w); 4690b411b363SPhilipp Reisner } else { 4691b411b363SPhilipp Reisner dev_err(DEV, "kmalloc(w) failed."); 4692b411b363SPhilipp Reisner ov_oos_print(mdev); 4693b411b363SPhilipp Reisner drbd_resync_finished(mdev); 4694b411b363SPhilipp Reisner } 4695b411b363SPhilipp Reisner } 46961d53f09eSLars Ellenberg put_ldev(mdev); 469781e84650SAndreas Gruenbacher return true; 4698b411b363SPhilipp Reisner } 4699b411b363SPhilipp Reisner 4700d8763023SAndreas Gruenbacher static int got_skip(struct drbd_conf *mdev, enum drbd_packet cmd) 47010ced55a3SPhilipp Reisner { 470281e84650SAndreas Gruenbacher return true; 47030ced55a3SPhilipp Reisner } 47040ced55a3SPhilipp Reisner 470532862ec7SPhilipp Reisner static int tconn_process_done_ee(struct drbd_tconn *tconn) 470632862ec7SPhilipp Reisner { 4707082a3439SPhilipp Reisner struct drbd_conf *mdev; 4708082a3439SPhilipp Reisner int i, not_empty = 0; 470932862ec7SPhilipp Reisner 471032862ec7SPhilipp Reisner do { 471132862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 471232862ec7SPhilipp Reisner flush_signals(current); 4713082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4714082a3439SPhilipp Reisner if (!drbd_process_done_ee(mdev)) 4715082a3439SPhilipp Reisner return 1; /* error */ 4716082a3439SPhilipp Reisner } 471732862ec7SPhilipp Reisner set_bit(SIGNAL_ASENDER, &tconn->flags); 4718082a3439SPhilipp Reisner 4719082a3439SPhilipp Reisner spin_lock_irq(&tconn->req_lock); 4720082a3439SPhilipp Reisner idr_for_each_entry(&tconn->volumes, mdev, i) { 4721082a3439SPhilipp Reisner not_empty = !list_empty(&mdev->done_ee); 4722082a3439SPhilipp Reisner if (not_empty) 4723082a3439SPhilipp Reisner break; 4724082a3439SPhilipp Reisner } 4725082a3439SPhilipp Reisner spin_unlock_irq(&tconn->req_lock); 472632862ec7SPhilipp Reisner } while (not_empty); 472732862ec7SPhilipp Reisner 472832862ec7SPhilipp Reisner return 0; 472932862ec7SPhilipp Reisner } 473032862ec7SPhilipp Reisner 47317201b972SAndreas Gruenbacher struct asender_cmd { 47327201b972SAndreas Gruenbacher size_t pkt_size; 4733a4fbda8eSPhilipp Reisner enum mdev_or_conn fa_type; /* first argument's type */ 4734a4fbda8eSPhilipp Reisner union { 4735a4fbda8eSPhilipp Reisner int (*mdev_fn)(struct drbd_conf *mdev, enum drbd_packet cmd); 4736a4fbda8eSPhilipp Reisner int (*conn_fn)(struct drbd_tconn *tconn, enum drbd_packet cmd); 4737a4fbda8eSPhilipp Reisner }; 47387201b972SAndreas Gruenbacher }; 47397201b972SAndreas Gruenbacher 47407201b972SAndreas Gruenbacher static struct asender_cmd asender_tbl[] = { 4741f19e4f8bSPhilipp Reisner [P_PING] = { sizeof(struct p_header), CONN, { .conn_fn = got_Ping } }, 4742f19e4f8bSPhilipp Reisner [P_PING_ACK] = { sizeof(struct p_header), CONN, { .conn_fn = got_PingAck } }, 4743a4fbda8eSPhilipp Reisner [P_RECV_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4744a4fbda8eSPhilipp Reisner [P_WRITE_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4745a4fbda8eSPhilipp Reisner [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4746a4fbda8eSPhilipp Reisner [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 4747a4fbda8eSPhilipp Reisner [P_NEG_ACK] = { sizeof(struct p_block_ack), MDEV, { got_NegAck } }, 4748a4fbda8eSPhilipp Reisner [P_NEG_DREPLY] = { sizeof(struct p_block_ack), MDEV, { got_NegDReply } }, 4749a4fbda8eSPhilipp Reisner [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), MDEV, { got_NegRSDReply } }, 4750a4fbda8eSPhilipp Reisner [P_OV_RESULT] = { sizeof(struct p_block_ack), MDEV, { got_OVResult } }, 4751a4fbda8eSPhilipp Reisner [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), MDEV, { got_BarrierAck } }, 4752a4fbda8eSPhilipp Reisner [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), MDEV, { got_RqSReply } }, 4753a4fbda8eSPhilipp Reisner [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), MDEV, { got_IsInSync } }, 4754a4fbda8eSPhilipp Reisner [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), MDEV, { got_skip } }, 4755a4fbda8eSPhilipp Reisner [P_RS_CANCEL] = { sizeof(struct p_block_ack), MDEV, { got_NegRSDReply } }, 4756e4f78edeSPhilipp Reisner [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), CONN, {.conn_fn = got_conn_RqSReply}}, 4757a4fbda8eSPhilipp Reisner [P_RETRY_WRITE] = { sizeof(struct p_block_ack), MDEV, { got_BlockAck } }, 47587201b972SAndreas Gruenbacher }; 47597201b972SAndreas Gruenbacher 4760b411b363SPhilipp Reisner int drbd_asender(struct drbd_thread *thi) 4761b411b363SPhilipp Reisner { 4762392c8801SPhilipp Reisner struct drbd_tconn *tconn = thi->tconn; 476332862ec7SPhilipp Reisner struct p_header *h = &tconn->meta.rbuf.header; 4764b411b363SPhilipp Reisner struct asender_cmd *cmd = NULL; 476577351055SPhilipp Reisner struct packet_info pi; 4766257d0af6SPhilipp Reisner int rv; 4767b411b363SPhilipp Reisner void *buf = h; 4768b411b363SPhilipp Reisner int received = 0; 4769257d0af6SPhilipp Reisner int expect = sizeof(struct p_header); 4770f36af18cSLars Ellenberg int ping_timeout_active = 0; 4771b411b363SPhilipp Reisner 4772b411b363SPhilipp Reisner current->policy = SCHED_RR; /* Make this a realtime task! */ 4773b411b363SPhilipp Reisner current->rt_priority = 2; /* more important than all other tasks */ 4774b411b363SPhilipp Reisner 4775e77a0a5cSAndreas Gruenbacher while (get_t_state(thi) == RUNNING) { 477680822284SPhilipp Reisner drbd_thread_current_set_cpu(thi); 477732862ec7SPhilipp Reisner if (test_and_clear_bit(SEND_PING, &tconn->flags)) { 47782a67d8b9SPhilipp Reisner if (!drbd_send_ping(tconn)) { 477932862ec7SPhilipp Reisner conn_err(tconn, "drbd_send_ping has failed\n"); 4780841ce241SAndreas Gruenbacher goto reconnect; 4781841ce241SAndreas Gruenbacher } 478232862ec7SPhilipp Reisner tconn->meta.socket->sk->sk_rcvtimeo = 478332862ec7SPhilipp Reisner tconn->net_conf->ping_timeo*HZ/10; 4784f36af18cSLars Ellenberg ping_timeout_active = 1; 4785b411b363SPhilipp Reisner } 4786b411b363SPhilipp Reisner 478732862ec7SPhilipp Reisner /* TODO: conditionally cork; it may hurt latency if we cork without 478832862ec7SPhilipp Reisner much to send */ 478932862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 479032862ec7SPhilipp Reisner drbd_tcp_cork(tconn->meta.socket); 4791082a3439SPhilipp Reisner if (tconn_process_done_ee(tconn)) { 4792082a3439SPhilipp Reisner conn_err(tconn, "tconn_process_done_ee() failed\n"); 4793b411b363SPhilipp Reisner goto reconnect; 4794082a3439SPhilipp Reisner } 4795b411b363SPhilipp Reisner /* but unconditionally uncork unless disabled */ 479632862ec7SPhilipp Reisner if (!tconn->net_conf->no_cork) 479732862ec7SPhilipp Reisner drbd_tcp_uncork(tconn->meta.socket); 4798b411b363SPhilipp Reisner 4799b411b363SPhilipp Reisner /* short circuit, recv_msg would return EINTR anyways. */ 4800b411b363SPhilipp Reisner if (signal_pending(current)) 4801b411b363SPhilipp Reisner continue; 4802b411b363SPhilipp Reisner 480332862ec7SPhilipp Reisner rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0); 480432862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4805b411b363SPhilipp Reisner 4806b411b363SPhilipp Reisner flush_signals(current); 4807b411b363SPhilipp Reisner 4808b411b363SPhilipp Reisner /* Note: 4809b411b363SPhilipp Reisner * -EINTR (on meta) we got a signal 4810b411b363SPhilipp Reisner * -EAGAIN (on meta) rcvtimeo expired 4811b411b363SPhilipp Reisner * -ECONNRESET other side closed the connection 4812b411b363SPhilipp Reisner * -ERESTARTSYS (on data) we got a signal 4813b411b363SPhilipp Reisner * rv < 0 other than above: unexpected error! 4814b411b363SPhilipp Reisner * rv == expected: full header or command 4815b411b363SPhilipp Reisner * rv < expected: "woken" by signal during receive 4816b411b363SPhilipp Reisner * rv == 0 : "connection shut down by peer" 4817b411b363SPhilipp Reisner */ 4818b411b363SPhilipp Reisner if (likely(rv > 0)) { 4819b411b363SPhilipp Reisner received += rv; 4820b411b363SPhilipp Reisner buf += rv; 4821b411b363SPhilipp Reisner } else if (rv == 0) { 482232862ec7SPhilipp Reisner conn_err(tconn, "meta connection shut down by peer.\n"); 4823b411b363SPhilipp Reisner goto reconnect; 4824b411b363SPhilipp Reisner } else if (rv == -EAGAIN) { 4825cb6518cbSLars Ellenberg /* If the data socket received something meanwhile, 4826cb6518cbSLars Ellenberg * that is good enough: peer is still alive. */ 482732862ec7SPhilipp Reisner if (time_after(tconn->last_received, 482832862ec7SPhilipp Reisner jiffies - tconn->meta.socket->sk->sk_rcvtimeo)) 4829cb6518cbSLars Ellenberg continue; 4830f36af18cSLars Ellenberg if (ping_timeout_active) { 483132862ec7SPhilipp Reisner conn_err(tconn, "PingAck did not arrive in time.\n"); 4832b411b363SPhilipp Reisner goto reconnect; 4833b411b363SPhilipp Reisner } 483432862ec7SPhilipp Reisner set_bit(SEND_PING, &tconn->flags); 4835b411b363SPhilipp Reisner continue; 4836b411b363SPhilipp Reisner } else if (rv == -EINTR) { 4837b411b363SPhilipp Reisner continue; 4838b411b363SPhilipp Reisner } else { 483932862ec7SPhilipp Reisner conn_err(tconn, "sock_recvmsg returned %d\n", rv); 4840b411b363SPhilipp Reisner goto reconnect; 4841b411b363SPhilipp Reisner } 4842b411b363SPhilipp Reisner 4843b411b363SPhilipp Reisner if (received == expect && cmd == NULL) { 484432862ec7SPhilipp Reisner if (!decode_header(tconn, h, &pi)) 4845b411b363SPhilipp Reisner goto reconnect; 48467201b972SAndreas Gruenbacher cmd = &asender_tbl[pi.cmd]; 48477201b972SAndreas Gruenbacher if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd) { 484832862ec7SPhilipp Reisner conn_err(tconn, "unknown command %d on meta (l: %d)\n", 484977351055SPhilipp Reisner pi.cmd, pi.size); 4850b411b363SPhilipp Reisner goto disconnect; 4851b411b363SPhilipp Reisner } 4852b411b363SPhilipp Reisner expect = cmd->pkt_size; 485377351055SPhilipp Reisner if (pi.size != expect - sizeof(struct p_header)) { 485432862ec7SPhilipp Reisner conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n", 485577351055SPhilipp Reisner pi.cmd, pi.size); 4856b411b363SPhilipp Reisner goto reconnect; 4857b411b363SPhilipp Reisner } 4858257d0af6SPhilipp Reisner } 4859b411b363SPhilipp Reisner if (received == expect) { 4860a4fbda8eSPhilipp Reisner bool rv; 4861a4fbda8eSPhilipp Reisner 4862a4fbda8eSPhilipp Reisner if (cmd->fa_type == CONN) { 4863a4fbda8eSPhilipp Reisner rv = cmd->conn_fn(tconn, pi.cmd); 4864a4fbda8eSPhilipp Reisner } else { 4865a4fbda8eSPhilipp Reisner struct drbd_conf *mdev = vnr_to_mdev(tconn, pi.vnr); 4866a4fbda8eSPhilipp Reisner rv = cmd->mdev_fn(mdev, pi.cmd); 4867a4fbda8eSPhilipp Reisner } 4868a4fbda8eSPhilipp Reisner 4869a4fbda8eSPhilipp Reisner if (!rv) 4870b411b363SPhilipp Reisner goto reconnect; 4871b411b363SPhilipp Reisner 4872a4fbda8eSPhilipp Reisner tconn->last_received = jiffies; 4873a4fbda8eSPhilipp Reisner 4874f36af18cSLars Ellenberg /* the idle_timeout (ping-int) 4875f36af18cSLars Ellenberg * has been restored in got_PingAck() */ 48767201b972SAndreas Gruenbacher if (cmd == &asender_tbl[P_PING_ACK]) 4877f36af18cSLars Ellenberg ping_timeout_active = 0; 4878f36af18cSLars Ellenberg 4879b411b363SPhilipp Reisner buf = h; 4880b411b363SPhilipp Reisner received = 0; 4881257d0af6SPhilipp Reisner expect = sizeof(struct p_header); 4882b411b363SPhilipp Reisner cmd = NULL; 4883b411b363SPhilipp Reisner } 4884b411b363SPhilipp Reisner } 4885b411b363SPhilipp Reisner 4886b411b363SPhilipp Reisner if (0) { 4887b411b363SPhilipp Reisner reconnect: 4888bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD); 4889b411b363SPhilipp Reisner } 4890b411b363SPhilipp Reisner if (0) { 4891b411b363SPhilipp Reisner disconnect: 4892bbeb641cSPhilipp Reisner conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD); 4893b411b363SPhilipp Reisner } 489432862ec7SPhilipp Reisner clear_bit(SIGNAL_ASENDER, &tconn->flags); 4895b411b363SPhilipp Reisner 489632862ec7SPhilipp Reisner conn_info(tconn, "asender terminated\n"); 4897b411b363SPhilipp Reisner 4898b411b363SPhilipp Reisner return 0; 4899b411b363SPhilipp Reisner } 4900