blob: 1c56af03c38b2f11dd9435ccda7898e378ce0b2b [file] [log] [blame]
Philipp Reisnerb411b362009-09-25 16:07:19 -07001/*
2 drbd_receiver.c
3
4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
5
6 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
7 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
8 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
9
10 drbd is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 drbd is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with drbd; see the file COPYING. If not, write to
22 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25
Philipp Reisnerb411b362009-09-25 16:07:19 -070026#include <linux/module.h>
27
28#include <asm/uaccess.h>
29#include <net/sock.h>
30
Philipp Reisnerb411b362009-09-25 16:07:19 -070031#include <linux/drbd.h>
32#include <linux/fs.h>
33#include <linux/file.h>
34#include <linux/in.h>
35#include <linux/mm.h>
36#include <linux/memcontrol.h>
37#include <linux/mm_inline.h>
38#include <linux/slab.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070039#include <linux/pkt_sched.h>
40#define __KERNEL_SYSCALLS__
41#include <linux/unistd.h>
42#include <linux/vmalloc.h>
43#include <linux/random.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070044#include <linux/string.h>
45#include <linux/scatterlist.h>
46#include "drbd_int.h"
Philipp Reisnerb411b362009-09-25 16:07:19 -070047#include "drbd_req.h"
48
49#include "drbd_vli.h"
50
Philipp Reisnerb411b362009-09-25 16:07:19 -070051enum finish_epoch {
52 FE_STILL_LIVE,
53 FE_DESTROYED,
54 FE_RECYCLED,
55};
56
57static int drbd_do_handshake(struct drbd_conf *mdev);
58static int drbd_do_auth(struct drbd_conf *mdev);
59
60static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event);
61static int e_end_block(struct drbd_conf *, struct drbd_work *, int);
62
Philipp Reisnerb411b362009-09-25 16:07:19 -070063
64#define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN)
65
Lars Ellenberg45bb9122010-05-14 17:10:48 +020066/*
67 * some helper functions to deal with single linked page lists,
68 * page->private being our "next" pointer.
69 */
70
71/* If at least n pages are linked at head, get n pages off.
72 * Otherwise, don't modify head, and return NULL.
73 * Locking is the responsibility of the caller.
74 */
75static struct page *page_chain_del(struct page **head, int n)
76{
77 struct page *page;
78 struct page *tmp;
79
80 BUG_ON(!n);
81 BUG_ON(!head);
82
83 page = *head;
Philipp Reisner23ce4222010-05-20 13:35:31 +020084
85 if (!page)
86 return NULL;
87
Lars Ellenberg45bb9122010-05-14 17:10:48 +020088 while (page) {
89 tmp = page_chain_next(page);
90 if (--n == 0)
91 break; /* found sufficient pages */
92 if (tmp == NULL)
93 /* insufficient pages, don't use any of them. */
94 return NULL;
95 page = tmp;
96 }
97
98 /* add end of list marker for the returned list */
99 set_page_private(page, 0);
100 /* actual return value, and adjustment of head */
101 page = *head;
102 *head = tmp;
103 return page;
104}
105
106/* may be used outside of locks to find the tail of a (usually short)
107 * "private" page chain, before adding it back to a global chain head
108 * with page_chain_add() under a spinlock. */
109static struct page *page_chain_tail(struct page *page, int *len)
110{
111 struct page *tmp;
112 int i = 1;
113 while ((tmp = page_chain_next(page)))
114 ++i, page = tmp;
115 if (len)
116 *len = i;
117 return page;
118}
119
120static int page_chain_free(struct page *page)
121{
122 struct page *tmp;
123 int i = 0;
124 page_chain_for_each_safe(page, tmp) {
125 put_page(page);
126 ++i;
127 }
128 return i;
129}
130
131static void page_chain_add(struct page **head,
132 struct page *chain_first, struct page *chain_last)
133{
134#if 1
135 struct page *tmp;
136 tmp = page_chain_tail(chain_first, NULL);
137 BUG_ON(tmp != chain_last);
138#endif
139
140 /* add chain to head */
141 set_page_private(chain_last, (unsigned long)*head);
142 *head = chain_first;
143}
144
145static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700146{
147 struct page *page = NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200148 struct page *tmp = NULL;
149 int i = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700150
151 /* Yes, testing drbd_pp_vacant outside the lock is racy.
152 * So what. It saves a spin_lock. */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200153 if (drbd_pp_vacant >= number) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700154 spin_lock(&drbd_pp_lock);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200155 page = page_chain_del(&drbd_pp_pool, number);
156 if (page)
157 drbd_pp_vacant -= number;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700158 spin_unlock(&drbd_pp_lock);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200159 if (page)
160 return page;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700161 }
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200162
Philipp Reisnerb411b362009-09-25 16:07:19 -0700163 /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD
164 * "criss-cross" setup, that might cause write-out on some other DRBD,
165 * which in turn might block on the other node at this very place. */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200166 for (i = 0; i < number; i++) {
167 tmp = alloc_page(GFP_TRY);
168 if (!tmp)
169 break;
170 set_page_private(tmp, (unsigned long)page);
171 page = tmp;
172 }
173
174 if (i == number)
175 return page;
176
177 /* Not enough pages immediately available this time.
178 * No need to jump around here, drbd_pp_alloc will retry this
179 * function "soon". */
180 if (page) {
181 tmp = page_chain_tail(page, NULL);
182 spin_lock(&drbd_pp_lock);
183 page_chain_add(&drbd_pp_pool, page, tmp);
184 drbd_pp_vacant += i;
185 spin_unlock(&drbd_pp_lock);
186 }
187 return NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700188}
189
Philipp Reisnerb411b362009-09-25 16:07:19 -0700190static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed)
191{
192 struct drbd_epoch_entry *e;
193 struct list_head *le, *tle;
194
195 /* The EEs are always appended to the end of the list. Since
196 they are sent in order over the wire, they have to finish
197 in order. As soon as we see the first not finished we can
198 stop to examine the list... */
199
200 list_for_each_safe(le, tle, &mdev->net_ee) {
201 e = list_entry(le, struct drbd_epoch_entry, w.list);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200202 if (drbd_ee_has_active_page(e))
Philipp Reisnerb411b362009-09-25 16:07:19 -0700203 break;
204 list_move(le, to_be_freed);
205 }
206}
207
208static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev)
209{
210 LIST_HEAD(reclaimed);
211 struct drbd_epoch_entry *e, *t;
212
Philipp Reisnerb411b362009-09-25 16:07:19 -0700213 spin_lock_irq(&mdev->req_lock);
214 reclaim_net_ee(mdev, &reclaimed);
215 spin_unlock_irq(&mdev->req_lock);
216
217 list_for_each_entry_safe(e, t, &reclaimed, w.list)
Lars Ellenberg435f0742010-09-06 12:30:25 +0200218 drbd_free_net_ee(mdev, e);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700219}
220
221/**
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200222 * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700223 * @mdev: DRBD device.
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200224 * @number: number of pages requested
225 * @retry: whether to retry, if not enough pages are available right now
Philipp Reisnerb411b362009-09-25 16:07:19 -0700226 *
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200227 * Tries to allocate number pages, first from our own page pool, then from
228 * the kernel, unless this allocation would exceed the max_buffers setting.
229 * Possibly retry until DRBD frees sufficient pages somewhere else.
230 *
231 * Returns a page chain linked via page->private.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700232 */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200233static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700234{
235 struct page *page = NULL;
236 DEFINE_WAIT(wait);
237
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200238 /* Yes, we may run up to @number over max_buffers. If we
239 * follow it strictly, the admin will get it wrong anyways. */
240 if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers)
241 page = drbd_pp_first_pages_or_try_alloc(mdev, number);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700242
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200243 while (page == NULL) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700244 prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE);
245
246 drbd_kick_lo_and_reclaim_net(mdev);
247
248 if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200249 page = drbd_pp_first_pages_or_try_alloc(mdev, number);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700250 if (page)
251 break;
252 }
253
254 if (!retry)
255 break;
256
257 if (signal_pending(current)) {
258 dev_warn(DEV, "drbd_pp_alloc interrupted!\n");
259 break;
260 }
261
262 schedule();
263 }
264 finish_wait(&drbd_pp_wait, &wait);
265
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200266 if (page)
267 atomic_add(number, &mdev->pp_in_use);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700268 return page;
269}
270
271/* Must not be used from irq, as that may deadlock: see drbd_pp_alloc.
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200272 * Is also used from inside an other spin_lock_irq(&mdev->req_lock);
273 * Either links the page chain back to the global pool,
274 * or returns all pages to the system. */
Lars Ellenberg435f0742010-09-06 12:30:25 +0200275static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700276{
Lars Ellenberg435f0742010-09-06 12:30:25 +0200277 atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700278 int i;
Lars Ellenberg435f0742010-09-06 12:30:25 +0200279
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200280 if (drbd_pp_vacant > (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE)*minor_count)
281 i = page_chain_free(page);
282 else {
283 struct page *tmp;
284 tmp = page_chain_tail(page, &i);
285 spin_lock(&drbd_pp_lock);
286 page_chain_add(&drbd_pp_pool, page, tmp);
287 drbd_pp_vacant += i;
288 spin_unlock(&drbd_pp_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700289 }
Lars Ellenberg435f0742010-09-06 12:30:25 +0200290 i = atomic_sub_return(i, a);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200291 if (i < 0)
Lars Ellenberg435f0742010-09-06 12:30:25 +0200292 dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n",
293 is_net ? "pp_in_use_by_net" : "pp_in_use", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700294 wake_up(&drbd_pp_wait);
295}
296
297/*
298You need to hold the req_lock:
299 _drbd_wait_ee_list_empty()
300
301You must not have the req_lock:
302 drbd_free_ee()
303 drbd_alloc_ee()
304 drbd_init_ee()
305 drbd_release_ee()
306 drbd_ee_fix_bhs()
307 drbd_process_done_ee()
308 drbd_clear_done_ee()
309 drbd_wait_ee_list_empty()
310*/
311
312struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev,
313 u64 id,
314 sector_t sector,
315 unsigned int data_size,
316 gfp_t gfp_mask) __must_hold(local)
317{
Philipp Reisnerb411b362009-09-25 16:07:19 -0700318 struct drbd_epoch_entry *e;
319 struct page *page;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200320 unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700321
322 if (FAULT_ACTIVE(mdev, DRBD_FAULT_AL_EE))
323 return NULL;
324
325 e = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM);
326 if (!e) {
327 if (!(gfp_mask & __GFP_NOWARN))
328 dev_err(DEV, "alloc_ee: Allocation of an EE failed\n");
329 return NULL;
330 }
331
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200332 page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT));
333 if (!page)
334 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700335
Philipp Reisnerb411b362009-09-25 16:07:19 -0700336 INIT_HLIST_NODE(&e->colision);
337 e->epoch = NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200338 e->mdev = mdev;
339 e->pages = page;
340 atomic_set(&e->pending_bios, 0);
341 e->size = data_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700342 e->flags = 0;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200343 e->sector = sector;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200344 e->block_id = id;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700345
Philipp Reisnerb411b362009-09-25 16:07:19 -0700346 return e;
347
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200348 fail:
Philipp Reisnerb411b362009-09-25 16:07:19 -0700349 mempool_free(e, drbd_ee_mempool);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700350 return NULL;
351}
352
Lars Ellenberg435f0742010-09-06 12:30:25 +0200353void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, int is_net)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700354{
Lars Ellenbergc36c3ce2010-08-11 20:42:55 +0200355 if (e->flags & EE_HAS_DIGEST)
356 kfree(e->digest);
Lars Ellenberg435f0742010-09-06 12:30:25 +0200357 drbd_pp_free(mdev, e->pages, is_net);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200358 D_ASSERT(atomic_read(&e->pending_bios) == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700359 D_ASSERT(hlist_unhashed(&e->colision));
360 mempool_free(e, drbd_ee_mempool);
361}
362
363int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list)
364{
365 LIST_HEAD(work_list);
366 struct drbd_epoch_entry *e, *t;
367 int count = 0;
Lars Ellenberg435f0742010-09-06 12:30:25 +0200368 int is_net = list == &mdev->net_ee;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700369
370 spin_lock_irq(&mdev->req_lock);
371 list_splice_init(list, &work_list);
372 spin_unlock_irq(&mdev->req_lock);
373
374 list_for_each_entry_safe(e, t, &work_list, w.list) {
Lars Ellenberg435f0742010-09-06 12:30:25 +0200375 drbd_free_some_ee(mdev, e, is_net);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700376 count++;
377 }
378 return count;
379}
380
381
382/*
383 * This function is called from _asender only_
384 * but see also comments in _req_mod(,barrier_acked)
385 * and receive_Barrier.
386 *
387 * Move entries from net_ee to done_ee, if ready.
388 * Grab done_ee, call all callbacks, free the entries.
389 * The callbacks typically send out ACKs.
390 */
391static int drbd_process_done_ee(struct drbd_conf *mdev)
392{
393 LIST_HEAD(work_list);
394 LIST_HEAD(reclaimed);
395 struct drbd_epoch_entry *e, *t;
396 int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS);
397
398 spin_lock_irq(&mdev->req_lock);
399 reclaim_net_ee(mdev, &reclaimed);
400 list_splice_init(&mdev->done_ee, &work_list);
401 spin_unlock_irq(&mdev->req_lock);
402
403 list_for_each_entry_safe(e, t, &reclaimed, w.list)
Lars Ellenberg435f0742010-09-06 12:30:25 +0200404 drbd_free_net_ee(mdev, e);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700405
406 /* possible callbacks here:
407 * e_end_block, and e_end_resync_block, e_send_discard_ack.
408 * all ignore the last argument.
409 */
410 list_for_each_entry_safe(e, t, &work_list, w.list) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700411 /* list_del not necessary, next/prev members not touched */
412 ok = e->w.cb(mdev, &e->w, !ok) && ok;
413 drbd_free_ee(mdev, e);
414 }
415 wake_up(&mdev->ee_wait);
416
417 return ok;
418}
419
420void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
421{
422 DEFINE_WAIT(wait);
423
424 /* avoids spin_lock/unlock
425 * and calling prepare_to_wait in the fast path */
426 while (!list_empty(head)) {
427 prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE);
428 spin_unlock_irq(&mdev->req_lock);
Jens Axboe7eaceac2011-03-10 08:52:07 +0100429 io_schedule();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700430 finish_wait(&mdev->ee_wait, &wait);
431 spin_lock_irq(&mdev->req_lock);
432 }
433}
434
435void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
436{
437 spin_lock_irq(&mdev->req_lock);
438 _drbd_wait_ee_list_empty(mdev, head);
439 spin_unlock_irq(&mdev->req_lock);
440}
441
442/* see also kernel_accept; which is only present since 2.6.18.
443 * also we want to log which part of it failed, exactly */
444static int drbd_accept(struct drbd_conf *mdev, const char **what,
445 struct socket *sock, struct socket **newsock)
446{
447 struct sock *sk = sock->sk;
448 int err = 0;
449
450 *what = "listen";
451 err = sock->ops->listen(sock, 5);
452 if (err < 0)
453 goto out;
454
455 *what = "sock_create_lite";
456 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
457 newsock);
458 if (err < 0)
459 goto out;
460
461 *what = "accept";
462 err = sock->ops->accept(sock, *newsock, 0);
463 if (err < 0) {
464 sock_release(*newsock);
465 *newsock = NULL;
466 goto out;
467 }
468 (*newsock)->ops = sock->ops;
469
470out:
471 return err;
472}
473
474static int drbd_recv_short(struct drbd_conf *mdev, struct socket *sock,
475 void *buf, size_t size, int flags)
476{
477 mm_segment_t oldfs;
478 struct kvec iov = {
479 .iov_base = buf,
480 .iov_len = size,
481 };
482 struct msghdr msg = {
483 .msg_iovlen = 1,
484 .msg_iov = (struct iovec *)&iov,
485 .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL)
486 };
487 int rv;
488
489 oldfs = get_fs();
490 set_fs(KERNEL_DS);
491 rv = sock_recvmsg(sock, &msg, size, msg.msg_flags);
492 set_fs(oldfs);
493
494 return rv;
495}
496
497static int drbd_recv(struct drbd_conf *mdev, void *buf, size_t size)
498{
499 mm_segment_t oldfs;
500 struct kvec iov = {
501 .iov_base = buf,
502 .iov_len = size,
503 };
504 struct msghdr msg = {
505 .msg_iovlen = 1,
506 .msg_iov = (struct iovec *)&iov,
507 .msg_flags = MSG_WAITALL | MSG_NOSIGNAL
508 };
509 int rv;
510
511 oldfs = get_fs();
512 set_fs(KERNEL_DS);
513
514 for (;;) {
515 rv = sock_recvmsg(mdev->data.socket, &msg, size, msg.msg_flags);
516 if (rv == size)
517 break;
518
519 /* Note:
520 * ECONNRESET other side closed the connection
521 * ERESTARTSYS (on sock) we got a signal
522 */
523
524 if (rv < 0) {
525 if (rv == -ECONNRESET)
526 dev_info(DEV, "sock was reset by peer\n");
527 else if (rv != -ERESTARTSYS)
528 dev_err(DEV, "sock_recvmsg returned %d\n", rv);
529 break;
530 } else if (rv == 0) {
531 dev_info(DEV, "sock was shut down by peer\n");
532 break;
533 } else {
534 /* signal came in, or peer/link went down,
535 * after we read a partial message
536 */
537 /* D_ASSERT(signal_pending(current)); */
538 break;
539 }
540 };
541
542 set_fs(oldfs);
543
544 if (rv != size)
545 drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE));
546
547 return rv;
548}
549
Lars Ellenberg5dbf1672010-05-25 16:18:01 +0200550/* quoting tcp(7):
551 * On individual connections, the socket buffer size must be set prior to the
552 * listen(2) or connect(2) calls in order to have it take effect.
553 * This is our wrapper to do so.
554 */
555static void drbd_setbufsize(struct socket *sock, unsigned int snd,
556 unsigned int rcv)
557{
558 /* open coded SO_SNDBUF, SO_RCVBUF */
559 if (snd) {
560 sock->sk->sk_sndbuf = snd;
561 sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
562 }
563 if (rcv) {
564 sock->sk->sk_rcvbuf = rcv;
565 sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
566 }
567}
568
Philipp Reisnerb411b362009-09-25 16:07:19 -0700569static struct socket *drbd_try_connect(struct drbd_conf *mdev)
570{
571 const char *what;
572 struct socket *sock;
573 struct sockaddr_in6 src_in6;
574 int err;
575 int disconnect_on_error = 1;
576
577 if (!get_net_conf(mdev))
578 return NULL;
579
580 what = "sock_create_kern";
581 err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family,
582 SOCK_STREAM, IPPROTO_TCP, &sock);
583 if (err < 0) {
584 sock = NULL;
585 goto out;
586 }
587
588 sock->sk->sk_rcvtimeo =
589 sock->sk->sk_sndtimeo = mdev->net_conf->try_connect_int*HZ;
Lars Ellenberg5dbf1672010-05-25 16:18:01 +0200590 drbd_setbufsize(sock, mdev->net_conf->sndbuf_size,
591 mdev->net_conf->rcvbuf_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700592
593 /* explicitly bind to the configured IP as source IP
594 * for the outgoing connections.
595 * This is needed for multihomed hosts and to be
596 * able to use lo: interfaces for drbd.
597 * Make sure to use 0 as port number, so linux selects
598 * a free one dynamically.
599 */
600 memcpy(&src_in6, mdev->net_conf->my_addr,
601 min_t(int, mdev->net_conf->my_addr_len, sizeof(src_in6)));
602 if (((struct sockaddr *)mdev->net_conf->my_addr)->sa_family == AF_INET6)
603 src_in6.sin6_port = 0;
604 else
605 ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */
606
607 what = "bind before connect";
608 err = sock->ops->bind(sock,
609 (struct sockaddr *) &src_in6,
610 mdev->net_conf->my_addr_len);
611 if (err < 0)
612 goto out;
613
614 /* connect may fail, peer not yet available.
615 * stay C_WF_CONNECTION, don't go Disconnecting! */
616 disconnect_on_error = 0;
617 what = "connect";
618 err = sock->ops->connect(sock,
619 (struct sockaddr *)mdev->net_conf->peer_addr,
620 mdev->net_conf->peer_addr_len, 0);
621
622out:
623 if (err < 0) {
624 if (sock) {
625 sock_release(sock);
626 sock = NULL;
627 }
628 switch (-err) {
629 /* timeout, busy, signal pending */
630 case ETIMEDOUT: case EAGAIN: case EINPROGRESS:
631 case EINTR: case ERESTARTSYS:
632 /* peer not (yet) available, network problem */
633 case ECONNREFUSED: case ENETUNREACH:
634 case EHOSTDOWN: case EHOSTUNREACH:
635 disconnect_on_error = 0;
636 break;
637 default:
638 dev_err(DEV, "%s failed, err = %d\n", what, err);
639 }
640 if (disconnect_on_error)
641 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
642 }
643 put_net_conf(mdev);
644 return sock;
645}
646
647static struct socket *drbd_wait_for_connect(struct drbd_conf *mdev)
648{
649 int timeo, err;
650 struct socket *s_estab = NULL, *s_listen;
651 const char *what;
652
653 if (!get_net_conf(mdev))
654 return NULL;
655
656 what = "sock_create_kern";
657 err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family,
658 SOCK_STREAM, IPPROTO_TCP, &s_listen);
659 if (err) {
660 s_listen = NULL;
661 goto out;
662 }
663
664 timeo = mdev->net_conf->try_connect_int * HZ;
665 timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */
666
667 s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */
668 s_listen->sk->sk_rcvtimeo = timeo;
669 s_listen->sk->sk_sndtimeo = timeo;
Lars Ellenberg5dbf1672010-05-25 16:18:01 +0200670 drbd_setbufsize(s_listen, mdev->net_conf->sndbuf_size,
671 mdev->net_conf->rcvbuf_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700672
673 what = "bind before listen";
674 err = s_listen->ops->bind(s_listen,
675 (struct sockaddr *) mdev->net_conf->my_addr,
676 mdev->net_conf->my_addr_len);
677 if (err < 0)
678 goto out;
679
680 err = drbd_accept(mdev, &what, s_listen, &s_estab);
681
682out:
683 if (s_listen)
684 sock_release(s_listen);
685 if (err < 0) {
686 if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) {
687 dev_err(DEV, "%s failed, err = %d\n", what, err);
688 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
689 }
690 }
691 put_net_conf(mdev);
692
693 return s_estab;
694}
695
696static int drbd_send_fp(struct drbd_conf *mdev,
697 struct socket *sock, enum drbd_packets cmd)
698{
Philipp Reisner02918be2010-08-20 14:35:10 +0200699 struct p_header80 *h = &mdev->data.sbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700700
701 return _drbd_send_cmd(mdev, sock, cmd, h, sizeof(*h), 0);
702}
703
704static enum drbd_packets drbd_recv_fp(struct drbd_conf *mdev, struct socket *sock)
705{
Philipp Reisner02918be2010-08-20 14:35:10 +0200706 struct p_header80 *h = &mdev->data.rbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700707 int rr;
708
709 rr = drbd_recv_short(mdev, sock, h, sizeof(*h), 0);
710
711 if (rr == sizeof(*h) && h->magic == BE_DRBD_MAGIC)
712 return be16_to_cpu(h->command);
713
714 return 0xffff;
715}
716
717/**
718 * drbd_socket_okay() - Free the socket if its connection is not okay
719 * @mdev: DRBD device.
720 * @sock: pointer to the pointer to the socket.
721 */
722static int drbd_socket_okay(struct drbd_conf *mdev, struct socket **sock)
723{
724 int rr;
725 char tb[4];
726
727 if (!*sock)
728 return FALSE;
729
730 rr = drbd_recv_short(mdev, *sock, tb, 4, MSG_DONTWAIT | MSG_PEEK);
731
732 if (rr > 0 || rr == -EAGAIN) {
733 return TRUE;
734 } else {
735 sock_release(*sock);
736 *sock = NULL;
737 return FALSE;
738 }
739}
740
741/*
742 * return values:
743 * 1 yes, we have a valid connection
744 * 0 oops, did not work out, please try again
745 * -1 peer talks different language,
746 * no point in trying again, please go standalone.
747 * -2 We do not have a network config...
748 */
749static int drbd_connect(struct drbd_conf *mdev)
750{
751 struct socket *s, *sock, *msock;
752 int try, h, ok;
753
754 D_ASSERT(!mdev->data.socket);
755
Philipp Reisnerb411b362009-09-25 16:07:19 -0700756 if (drbd_request_state(mdev, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS)
757 return -2;
758
759 clear_bit(DISCARD_CONCURRENT, &mdev->flags);
760
761 sock = NULL;
762 msock = NULL;
763
764 do {
765 for (try = 0;;) {
766 /* 3 tries, this should take less than a second! */
767 s = drbd_try_connect(mdev);
768 if (s || ++try >= 3)
769 break;
770 /* give the other side time to call bind() & listen() */
771 __set_current_state(TASK_INTERRUPTIBLE);
772 schedule_timeout(HZ / 10);
773 }
774
775 if (s) {
776 if (!sock) {
777 drbd_send_fp(mdev, s, P_HAND_SHAKE_S);
778 sock = s;
779 s = NULL;
780 } else if (!msock) {
781 drbd_send_fp(mdev, s, P_HAND_SHAKE_M);
782 msock = s;
783 s = NULL;
784 } else {
785 dev_err(DEV, "Logic error in drbd_connect()\n");
786 goto out_release_sockets;
787 }
788 }
789
790 if (sock && msock) {
791 __set_current_state(TASK_INTERRUPTIBLE);
792 schedule_timeout(HZ / 10);
793 ok = drbd_socket_okay(mdev, &sock);
794 ok = drbd_socket_okay(mdev, &msock) && ok;
795 if (ok)
796 break;
797 }
798
799retry:
800 s = drbd_wait_for_connect(mdev);
801 if (s) {
802 try = drbd_recv_fp(mdev, s);
803 drbd_socket_okay(mdev, &sock);
804 drbd_socket_okay(mdev, &msock);
805 switch (try) {
806 case P_HAND_SHAKE_S:
807 if (sock) {
808 dev_warn(DEV, "initial packet S crossed\n");
809 sock_release(sock);
810 }
811 sock = s;
812 break;
813 case P_HAND_SHAKE_M:
814 if (msock) {
815 dev_warn(DEV, "initial packet M crossed\n");
816 sock_release(msock);
817 }
818 msock = s;
819 set_bit(DISCARD_CONCURRENT, &mdev->flags);
820 break;
821 default:
822 dev_warn(DEV, "Error receiving initial packet\n");
823 sock_release(s);
824 if (random32() & 1)
825 goto retry;
826 }
827 }
828
829 if (mdev->state.conn <= C_DISCONNECTING)
830 goto out_release_sockets;
831 if (signal_pending(current)) {
832 flush_signals(current);
833 smp_rmb();
834 if (get_t_state(&mdev->receiver) == Exiting)
835 goto out_release_sockets;
836 }
837
838 if (sock && msock) {
839 ok = drbd_socket_okay(mdev, &sock);
840 ok = drbd_socket_okay(mdev, &msock) && ok;
841 if (ok)
842 break;
843 }
844 } while (1);
845
846 msock->sk->sk_reuse = 1; /* SO_REUSEADDR */
847 sock->sk->sk_reuse = 1; /* SO_REUSEADDR */
848
849 sock->sk->sk_allocation = GFP_NOIO;
850 msock->sk->sk_allocation = GFP_NOIO;
851
852 sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
853 msock->sk->sk_priority = TC_PRIO_INTERACTIVE;
854
Philipp Reisnerb411b362009-09-25 16:07:19 -0700855 /* NOT YET ...
856 * sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10;
857 * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
858 * first set it to the P_HAND_SHAKE timeout,
859 * which we set to 4x the configured ping_timeout. */
860 sock->sk->sk_sndtimeo =
861 sock->sk->sk_rcvtimeo = mdev->net_conf->ping_timeo*4*HZ/10;
862
863 msock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10;
864 msock->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ;
865
866 /* we don't want delays.
867 * we use TCP_CORK where apropriate, though */
868 drbd_tcp_nodelay(sock);
869 drbd_tcp_nodelay(msock);
870
871 mdev->data.socket = sock;
872 mdev->meta.socket = msock;
873 mdev->last_received = jiffies;
874
875 D_ASSERT(mdev->asender.task == NULL);
876
877 h = drbd_do_handshake(mdev);
878 if (h <= 0)
879 return h;
880
881 if (mdev->cram_hmac_tfm) {
882 /* drbd_request_state(mdev, NS(conn, WFAuth)); */
Johannes Thomab10d96c2010-01-07 16:02:50 +0100883 switch (drbd_do_auth(mdev)) {
884 case -1:
Philipp Reisnerb411b362009-09-25 16:07:19 -0700885 dev_err(DEV, "Authentication of peer failed\n");
886 return -1;
Johannes Thomab10d96c2010-01-07 16:02:50 +0100887 case 0:
888 dev_err(DEV, "Authentication of peer failed, trying again.\n");
889 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700890 }
891 }
892
893 if (drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS)
894 return 0;
895
896 sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10;
897 sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
898
899 atomic_set(&mdev->packet_seq, 0);
900 mdev->peer_seq = 0;
901
902 drbd_thread_start(&mdev->asender);
903
Philipp Reisnerd5373382010-08-23 15:18:33 +0200904 if (mdev->agreed_pro_version < 95 && get_ldev(mdev)) {
905 drbd_setup_queue_param(mdev, DRBD_MAX_SIZE_H80_PACKET);
906 put_ldev(mdev);
907 }
908
Philipp Reisner7e2455c2010-04-22 14:50:23 +0200909 if (!drbd_send_protocol(mdev))
910 return -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700911 drbd_send_sync_param(mdev, &mdev->sync_conf);
Philipp Reisnere89b5912010-03-24 17:11:33 +0100912 drbd_send_sizes(mdev, 0, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700913 drbd_send_uuids(mdev);
914 drbd_send_state(mdev);
915 clear_bit(USE_DEGR_WFC_T, &mdev->flags);
916 clear_bit(RESIZE_PENDING, &mdev->flags);
917
918 return 1;
919
920out_release_sockets:
921 if (sock)
922 sock_release(sock);
923 if (msock)
924 sock_release(msock);
925 return -1;
926}
927
Philipp Reisner02918be2010-08-20 14:35:10 +0200928static int drbd_recv_header(struct drbd_conf *mdev, enum drbd_packets *cmd, unsigned int *packet_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700929{
Philipp Reisner02918be2010-08-20 14:35:10 +0200930 union p_header *h = &mdev->data.rbuf.header;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700931 int r;
932
933 r = drbd_recv(mdev, h, sizeof(*h));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700934 if (unlikely(r != sizeof(*h))) {
935 dev_err(DEV, "short read expecting header on sock: r=%d\n", r);
936 return FALSE;
Philipp Reisner02918be2010-08-20 14:35:10 +0200937 }
938
939 if (likely(h->h80.magic == BE_DRBD_MAGIC)) {
940 *cmd = be16_to_cpu(h->h80.command);
941 *packet_size = be16_to_cpu(h->h80.length);
942 } else if (h->h95.magic == BE_DRBD_MAGIC_BIG) {
943 *cmd = be16_to_cpu(h->h95.command);
944 *packet_size = be32_to_cpu(h->h95.length);
945 } else {
Lars Ellenberg004352f2010-10-05 20:13:58 +0200946 dev_err(DEV, "magic?? on data m: 0x%08x c: %d l: %d\n",
947 be32_to_cpu(h->h80.magic),
948 be16_to_cpu(h->h80.command),
949 be16_to_cpu(h->h80.length));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700950 return FALSE;
951 }
952 mdev->last_received = jiffies;
953
954 return TRUE;
955}
956
Philipp Reisner2451fc32010-08-24 13:43:11 +0200957static void drbd_flush(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700958{
959 int rv;
960
961 if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) {
Dmitry Monakhovfbd9b092010-04-28 17:55:06 +0400962 rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL,
Christoph Hellwigdd3932e2010-09-16 20:51:46 +0200963 NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700964 if (rv) {
965 dev_err(DEV, "local disk flush failed with status %d\n", rv);
966 /* would rather check on EOPNOTSUPP, but that is not reliable.
967 * don't try again for ANY return value != 0
968 * if (rv == -EOPNOTSUPP) */
969 drbd_bump_write_ordering(mdev, WO_drain_io);
970 }
971 put_ldev(mdev);
972 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700973}
974
975/**
976 * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it.
977 * @mdev: DRBD device.
978 * @epoch: Epoch object.
979 * @ev: Epoch event.
980 */
981static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev,
982 struct drbd_epoch *epoch,
983 enum epoch_event ev)
984{
Philipp Reisner2451fc32010-08-24 13:43:11 +0200985 int epoch_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700986 struct drbd_epoch *next_epoch;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700987 enum finish_epoch rv = FE_STILL_LIVE;
988
989 spin_lock(&mdev->epoch_lock);
990 do {
991 next_epoch = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700992
993 epoch_size = atomic_read(&epoch->epoch_size);
994
995 switch (ev & ~EV_CLEANUP) {
996 case EV_PUT:
997 atomic_dec(&epoch->active);
998 break;
999 case EV_GOT_BARRIER_NR:
1000 set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001001 break;
1002 case EV_BECAME_LAST:
1003 /* nothing to do*/
1004 break;
1005 }
1006
Philipp Reisnerb411b362009-09-25 16:07:19 -07001007 if (epoch_size != 0 &&
1008 atomic_read(&epoch->active) == 0 &&
Philipp Reisner2451fc32010-08-24 13:43:11 +02001009 test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001010 if (!(ev & EV_CLEANUP)) {
1011 spin_unlock(&mdev->epoch_lock);
1012 drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size);
1013 spin_lock(&mdev->epoch_lock);
1014 }
1015 dec_unacked(mdev);
1016
1017 if (mdev->current_epoch != epoch) {
1018 next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list);
1019 list_del(&epoch->list);
1020 ev = EV_BECAME_LAST | (ev & EV_CLEANUP);
1021 mdev->epochs--;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001022 kfree(epoch);
1023
1024 if (rv == FE_STILL_LIVE)
1025 rv = FE_DESTROYED;
1026 } else {
1027 epoch->flags = 0;
1028 atomic_set(&epoch->epoch_size, 0);
Uwe Kleine-König698f9312010-07-02 20:41:51 +02001029 /* atomic_set(&epoch->active, 0); is already zero */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001030 if (rv == FE_STILL_LIVE)
1031 rv = FE_RECYCLED;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001032 wake_up(&mdev->ee_wait);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001033 }
1034 }
1035
1036 if (!next_epoch)
1037 break;
1038
1039 epoch = next_epoch;
1040 } while (1);
1041
1042 spin_unlock(&mdev->epoch_lock);
1043
Philipp Reisnerb411b362009-09-25 16:07:19 -07001044 return rv;
1045}
1046
1047/**
1048 * drbd_bump_write_ordering() - Fall back to an other write ordering method
1049 * @mdev: DRBD device.
1050 * @wo: Write ordering method to try.
1051 */
1052void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local)
1053{
1054 enum write_ordering_e pwo;
1055 static char *write_ordering_str[] = {
1056 [WO_none] = "none",
1057 [WO_drain_io] = "drain",
1058 [WO_bdev_flush] = "flush",
Philipp Reisnerb411b362009-09-25 16:07:19 -07001059 };
1060
1061 pwo = mdev->write_ordering;
1062 wo = min(pwo, wo);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001063 if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush)
1064 wo = WO_drain_io;
1065 if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain)
1066 wo = WO_none;
1067 mdev->write_ordering = wo;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001068 if (pwo != mdev->write_ordering || wo == WO_bdev_flush)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001069 dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]);
1070}
1071
1072/**
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001073 * drbd_submit_ee()
1074 * @mdev: DRBD device.
1075 * @e: epoch entry
1076 * @rw: flag field, see bio->bi_rw
1077 */
1078/* TODO allocate from our own bio_set. */
1079int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e,
1080 const unsigned rw, const int fault_type)
1081{
1082 struct bio *bios = NULL;
1083 struct bio *bio;
1084 struct page *page = e->pages;
1085 sector_t sector = e->sector;
1086 unsigned ds = e->size;
1087 unsigned n_bios = 0;
1088 unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT;
1089
1090 /* In most cases, we will only need one bio. But in case the lower
1091 * level restrictions happen to be different at this offset on this
1092 * side than those of the sending peer, we may need to submit the
1093 * request in more than one bio. */
1094next_bio:
1095 bio = bio_alloc(GFP_NOIO, nr_pages);
1096 if (!bio) {
1097 dev_err(DEV, "submit_ee: Allocation of a bio failed\n");
1098 goto fail;
1099 }
1100 /* > e->sector, unless this is the first bio */
1101 bio->bi_sector = sector;
1102 bio->bi_bdev = mdev->ldev->backing_bdev;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001103 bio->bi_rw = rw;
1104 bio->bi_private = e;
1105 bio->bi_end_io = drbd_endio_sec;
1106
1107 bio->bi_next = bios;
1108 bios = bio;
1109 ++n_bios;
1110
1111 page_chain_for_each(page) {
1112 unsigned len = min_t(unsigned, ds, PAGE_SIZE);
1113 if (!bio_add_page(bio, page, len, 0)) {
1114 /* a single page must always be possible! */
1115 BUG_ON(bio->bi_vcnt == 0);
1116 goto next_bio;
1117 }
1118 ds -= len;
1119 sector += len >> 9;
1120 --nr_pages;
1121 }
1122 D_ASSERT(page == NULL);
1123 D_ASSERT(ds == 0);
1124
1125 atomic_set(&e->pending_bios, n_bios);
1126 do {
1127 bio = bios;
1128 bios = bios->bi_next;
1129 bio->bi_next = NULL;
1130
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001131 drbd_generic_make_request(mdev, fault_type, bio);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001132 } while (bios);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001133 return 0;
1134
1135fail:
1136 while (bios) {
1137 bio = bios;
1138 bios = bios->bi_next;
1139 bio_put(bio);
1140 }
1141 return -ENOMEM;
1142}
1143
Philipp Reisner02918be2010-08-20 14:35:10 +02001144static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001145{
Philipp Reisner2451fc32010-08-24 13:43:11 +02001146 int rv;
Philipp Reisner02918be2010-08-20 14:35:10 +02001147 struct p_barrier *p = &mdev->data.rbuf.barrier;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001148 struct drbd_epoch *epoch;
1149
Philipp Reisnerb411b362009-09-25 16:07:19 -07001150 inc_unacked(mdev);
1151
Philipp Reisnerb411b362009-09-25 16:07:19 -07001152 mdev->current_epoch->barrier_nr = p->barrier;
1153 rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR);
1154
1155 /* P_BARRIER_ACK may imply that the corresponding extent is dropped from
1156 * the activity log, which means it would not be resynced in case the
1157 * R_PRIMARY crashes now.
1158 * Therefore we must send the barrier_ack after the barrier request was
1159 * completed. */
1160 switch (mdev->write_ordering) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001161 case WO_none:
1162 if (rv == FE_RECYCLED)
1163 return TRUE;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001164
1165 /* receiver context, in the writeout path of the other node.
1166 * avoid potential distributed deadlock */
1167 epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
1168 if (epoch)
1169 break;
1170 else
1171 dev_warn(DEV, "Allocation of an epoch failed, slowing down\n");
1172 /* Fall through */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001173
1174 case WO_bdev_flush:
1175 case WO_drain_io:
Philipp Reisnerb411b362009-09-25 16:07:19 -07001176 drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
Philipp Reisner2451fc32010-08-24 13:43:11 +02001177 drbd_flush(mdev);
1178
1179 if (atomic_read(&mdev->current_epoch->epoch_size)) {
1180 epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
1181 if (epoch)
1182 break;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001183 }
1184
Philipp Reisner2451fc32010-08-24 13:43:11 +02001185 epoch = mdev->current_epoch;
1186 wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0);
1187
1188 D_ASSERT(atomic_read(&epoch->active) == 0);
1189 D_ASSERT(epoch->flags == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001190
1191 return TRUE;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001192 default:
1193 dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering);
1194 return FALSE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001195 }
1196
1197 epoch->flags = 0;
1198 atomic_set(&epoch->epoch_size, 0);
1199 atomic_set(&epoch->active, 0);
1200
1201 spin_lock(&mdev->epoch_lock);
1202 if (atomic_read(&mdev->current_epoch->epoch_size)) {
1203 list_add(&epoch->list, &mdev->current_epoch->list);
1204 mdev->current_epoch = epoch;
1205 mdev->epochs++;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001206 } else {
1207 /* The current_epoch got recycled while we allocated this one... */
1208 kfree(epoch);
1209 }
1210 spin_unlock(&mdev->epoch_lock);
1211
1212 return TRUE;
1213}
1214
1215/* used from receive_RSDataReply (recv_resync_read)
1216 * and from receive_Data */
1217static struct drbd_epoch_entry *
1218read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __must_hold(local)
1219{
Lars Ellenberg66660322010-04-06 12:15:04 +02001220 const sector_t capacity = drbd_get_capacity(mdev->this_bdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001221 struct drbd_epoch_entry *e;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001222 struct page *page;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001223 int dgs, ds, rr;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001224 void *dig_in = mdev->int_dig_in;
1225 void *dig_vv = mdev->int_dig_vv;
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001226 unsigned long *data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001227
1228 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ?
1229 crypto_hash_digestsize(mdev->integrity_r_tfm) : 0;
1230
1231 if (dgs) {
1232 rr = drbd_recv(mdev, dig_in, dgs);
1233 if (rr != dgs) {
1234 dev_warn(DEV, "short read receiving data digest: read %d expected %d\n",
1235 rr, dgs);
1236 return NULL;
1237 }
1238 }
1239
1240 data_size -= dgs;
1241
1242 ERR_IF(data_size & 0x1ff) return NULL;
1243 ERR_IF(data_size > DRBD_MAX_SEGMENT_SIZE) return NULL;
1244
Lars Ellenberg66660322010-04-06 12:15:04 +02001245 /* even though we trust out peer,
1246 * we sometimes have to double check. */
1247 if (sector + (data_size>>9) > capacity) {
1248 dev_err(DEV, "capacity: %llus < sector: %llus + size: %u\n",
1249 (unsigned long long)capacity,
1250 (unsigned long long)sector, data_size);
1251 return NULL;
1252 }
1253
Philipp Reisnerb411b362009-09-25 16:07:19 -07001254 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
1255 * "criss-cross" setup, that might cause write-out on some other DRBD,
1256 * which in turn might block on the other node at this very place. */
1257 e = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO);
1258 if (!e)
1259 return NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001260
Philipp Reisnerb411b362009-09-25 16:07:19 -07001261 ds = data_size;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001262 page = e->pages;
1263 page_chain_for_each(page) {
1264 unsigned len = min_t(int, ds, PAGE_SIZE);
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001265 data = kmap(page);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001266 rr = drbd_recv(mdev, data, len);
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001267 if (FAULT_ACTIVE(mdev, DRBD_FAULT_RECEIVE)) {
1268 dev_err(DEV, "Fault injection: Corrupting data on receive\n");
1269 data[0] = data[0] ^ (unsigned long)-1;
1270 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001271 kunmap(page);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001272 if (rr != len) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001273 drbd_free_ee(mdev, e);
1274 dev_warn(DEV, "short read receiving data: read %d expected %d\n",
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001275 rr, len);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001276 return NULL;
1277 }
1278 ds -= rr;
1279 }
1280
1281 if (dgs) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001282 drbd_csum_ee(mdev, mdev->integrity_r_tfm, e, dig_vv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001283 if (memcmp(dig_in, dig_vv, dgs)) {
1284 dev_err(DEV, "Digest integrity check FAILED.\n");
1285 drbd_bcast_ee(mdev, "digest failed",
1286 dgs, dig_in, dig_vv, e);
1287 drbd_free_ee(mdev, e);
1288 return NULL;
1289 }
1290 }
1291 mdev->recv_cnt += data_size>>9;
1292 return e;
1293}
1294
1295/* drbd_drain_block() just takes a data block
1296 * out of the socket input buffer, and discards it.
1297 */
1298static int drbd_drain_block(struct drbd_conf *mdev, int data_size)
1299{
1300 struct page *page;
1301 int rr, rv = 1;
1302 void *data;
1303
Lars Ellenbergc3470cd2010-04-01 16:57:19 +02001304 if (!data_size)
1305 return TRUE;
1306
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001307 page = drbd_pp_alloc(mdev, 1, 1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001308
1309 data = kmap(page);
1310 while (data_size) {
1311 rr = drbd_recv(mdev, data, min_t(int, data_size, PAGE_SIZE));
1312 if (rr != min_t(int, data_size, PAGE_SIZE)) {
1313 rv = 0;
1314 dev_warn(DEV, "short read receiving data: read %d expected %d\n",
1315 rr, min_t(int, data_size, PAGE_SIZE));
1316 break;
1317 }
1318 data_size -= rr;
1319 }
1320 kunmap(page);
Lars Ellenberg435f0742010-09-06 12:30:25 +02001321 drbd_pp_free(mdev, page, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001322 return rv;
1323}
1324
1325static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req,
1326 sector_t sector, int data_size)
1327{
1328 struct bio_vec *bvec;
1329 struct bio *bio;
1330 int dgs, rr, i, expect;
1331 void *dig_in = mdev->int_dig_in;
1332 void *dig_vv = mdev->int_dig_vv;
1333
1334 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ?
1335 crypto_hash_digestsize(mdev->integrity_r_tfm) : 0;
1336
1337 if (dgs) {
1338 rr = drbd_recv(mdev, dig_in, dgs);
1339 if (rr != dgs) {
1340 dev_warn(DEV, "short read receiving data reply digest: read %d expected %d\n",
1341 rr, dgs);
1342 return 0;
1343 }
1344 }
1345
1346 data_size -= dgs;
1347
1348 /* optimistically update recv_cnt. if receiving fails below,
1349 * we disconnect anyways, and counters will be reset. */
1350 mdev->recv_cnt += data_size>>9;
1351
1352 bio = req->master_bio;
1353 D_ASSERT(sector == bio->bi_sector);
1354
1355 bio_for_each_segment(bvec, bio, i) {
1356 expect = min_t(int, data_size, bvec->bv_len);
1357 rr = drbd_recv(mdev,
1358 kmap(bvec->bv_page)+bvec->bv_offset,
1359 expect);
1360 kunmap(bvec->bv_page);
1361 if (rr != expect) {
1362 dev_warn(DEV, "short read receiving data reply: "
1363 "read %d expected %d\n",
1364 rr, expect);
1365 return 0;
1366 }
1367 data_size -= rr;
1368 }
1369
1370 if (dgs) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001371 drbd_csum_bio(mdev, mdev->integrity_r_tfm, bio, dig_vv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001372 if (memcmp(dig_in, dig_vv, dgs)) {
1373 dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n");
1374 return 0;
1375 }
1376 }
1377
1378 D_ASSERT(data_size == 0);
1379 return 1;
1380}
1381
1382/* e_end_resync_block() is called via
1383 * drbd_process_done_ee() by asender only */
1384static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused)
1385{
1386 struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w;
1387 sector_t sector = e->sector;
1388 int ok;
1389
1390 D_ASSERT(hlist_unhashed(&e->colision));
1391
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001392 if (likely((e->flags & EE_WAS_ERROR) == 0)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001393 drbd_set_in_sync(mdev, sector, e->size);
1394 ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, e);
1395 } else {
1396 /* Record failure to sync */
1397 drbd_rs_failed_io(mdev, sector, e->size);
1398
1399 ok = drbd_send_ack(mdev, P_NEG_ACK, e);
1400 }
1401 dec_unacked(mdev);
1402
1403 return ok;
1404}
1405
1406static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local)
1407{
1408 struct drbd_epoch_entry *e;
1409
1410 e = read_in_block(mdev, ID_SYNCER, sector, data_size);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001411 if (!e)
1412 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001413
1414 dec_rs_pending(mdev);
1415
Philipp Reisnerb411b362009-09-25 16:07:19 -07001416 inc_unacked(mdev);
1417 /* corresponding dec_unacked() in e_end_resync_block()
1418 * respective _drbd_clear_done_ee */
1419
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001420 e->w.cb = e_end_resync_block;
1421
Philipp Reisnerb411b362009-09-25 16:07:19 -07001422 spin_lock_irq(&mdev->req_lock);
1423 list_add(&e->w.list, &mdev->sync_ee);
1424 spin_unlock_irq(&mdev->req_lock);
1425
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001426 atomic_add(data_size >> 9, &mdev->rs_sect_ev);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001427 if (drbd_submit_ee(mdev, e, WRITE, DRBD_FAULT_RS_WR) == 0)
1428 return TRUE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001429
Lars Ellenberg22cc37a2010-09-14 20:40:41 +02001430 /* drbd_submit_ee currently fails for one reason only:
1431 * not being able to allocate enough bios.
1432 * Is dropping the connection going to help? */
1433 spin_lock_irq(&mdev->req_lock);
1434 list_del(&e->w.list);
1435 spin_unlock_irq(&mdev->req_lock);
1436
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001437 drbd_free_ee(mdev, e);
1438fail:
1439 put_ldev(mdev);
1440 return FALSE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001441}
1442
Philipp Reisner02918be2010-08-20 14:35:10 +02001443static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001444{
1445 struct drbd_request *req;
1446 sector_t sector;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001447 int ok;
Philipp Reisner02918be2010-08-20 14:35:10 +02001448 struct p_data *p = &mdev->data.rbuf.data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001449
1450 sector = be64_to_cpu(p->sector);
1451
1452 spin_lock_irq(&mdev->req_lock);
1453 req = _ar_id_to_req(mdev, p->block_id, sector);
1454 spin_unlock_irq(&mdev->req_lock);
1455 if (unlikely(!req)) {
1456 dev_err(DEV, "Got a corrupt block_id/sector pair(1).\n");
1457 return FALSE;
1458 }
1459
1460 /* hlist_del(&req->colision) is done in _req_may_be_done, to avoid
1461 * special casing it there for the various failure cases.
1462 * still no race with drbd_fail_pending_reads */
1463 ok = recv_dless_read(mdev, req, sector, data_size);
1464
1465 if (ok)
1466 req_mod(req, data_received);
1467 /* else: nothing. handled from drbd_disconnect...
1468 * I don't think we may complete this just yet
1469 * in case we are "on-disconnect: freeze" */
1470
1471 return ok;
1472}
1473
Philipp Reisner02918be2010-08-20 14:35:10 +02001474static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001475{
1476 sector_t sector;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001477 int ok;
Philipp Reisner02918be2010-08-20 14:35:10 +02001478 struct p_data *p = &mdev->data.rbuf.data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001479
1480 sector = be64_to_cpu(p->sector);
1481 D_ASSERT(p->block_id == ID_SYNCER);
1482
1483 if (get_ldev(mdev)) {
1484 /* data is submitted to disk within recv_resync_read.
1485 * corresponding put_ldev done below on error,
1486 * or in drbd_endio_write_sec. */
1487 ok = recv_resync_read(mdev, sector, data_size);
1488 } else {
1489 if (__ratelimit(&drbd_ratelimit_state))
1490 dev_err(DEV, "Can not write resync data to local disk.\n");
1491
1492 ok = drbd_drain_block(mdev, data_size);
1493
Lars Ellenberg2b2bf212010-10-06 11:46:55 +02001494 drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001495 }
1496
Philipp Reisner778f2712010-07-06 11:14:00 +02001497 atomic_add(data_size >> 9, &mdev->rs_sect_in);
1498
Philipp Reisnerb411b362009-09-25 16:07:19 -07001499 return ok;
1500}
1501
1502/* e_end_block() is called via drbd_process_done_ee().
1503 * this means this function only runs in the asender thread
1504 */
1505static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel)
1506{
1507 struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w;
1508 sector_t sector = e->sector;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001509 int ok = 1, pcmd;
1510
Philipp Reisnerb411b362009-09-25 16:07:19 -07001511 if (mdev->net_conf->wire_protocol == DRBD_PROT_C) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001512 if (likely((e->flags & EE_WAS_ERROR) == 0)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001513 pcmd = (mdev->state.conn >= C_SYNC_SOURCE &&
1514 mdev->state.conn <= C_PAUSED_SYNC_T &&
1515 e->flags & EE_MAY_SET_IN_SYNC) ?
1516 P_RS_WRITE_ACK : P_WRITE_ACK;
1517 ok &= drbd_send_ack(mdev, pcmd, e);
1518 if (pcmd == P_RS_WRITE_ACK)
1519 drbd_set_in_sync(mdev, sector, e->size);
1520 } else {
1521 ok = drbd_send_ack(mdev, P_NEG_ACK, e);
1522 /* we expect it to be marked out of sync anyways...
1523 * maybe assert this? */
1524 }
1525 dec_unacked(mdev);
1526 }
1527 /* we delete from the conflict detection hash _after_ we sent out the
1528 * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */
1529 if (mdev->net_conf->two_primaries) {
1530 spin_lock_irq(&mdev->req_lock);
1531 D_ASSERT(!hlist_unhashed(&e->colision));
1532 hlist_del_init(&e->colision);
1533 spin_unlock_irq(&mdev->req_lock);
1534 } else {
1535 D_ASSERT(hlist_unhashed(&e->colision));
1536 }
1537
1538 drbd_may_finish_epoch(mdev, e->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0));
1539
1540 return ok;
1541}
1542
1543static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused)
1544{
1545 struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w;
1546 int ok = 1;
1547
1548 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
1549 ok = drbd_send_ack(mdev, P_DISCARD_ACK, e);
1550
1551 spin_lock_irq(&mdev->req_lock);
1552 D_ASSERT(!hlist_unhashed(&e->colision));
1553 hlist_del_init(&e->colision);
1554 spin_unlock_irq(&mdev->req_lock);
1555
1556 dec_unacked(mdev);
1557
1558 return ok;
1559}
1560
1561/* Called from receive_Data.
1562 * Synchronize packets on sock with packets on msock.
1563 *
1564 * This is here so even when a P_DATA packet traveling via sock overtook an Ack
1565 * packet traveling on msock, they are still processed in the order they have
1566 * been sent.
1567 *
1568 * Note: we don't care for Ack packets overtaking P_DATA packets.
1569 *
1570 * In case packet_seq is larger than mdev->peer_seq number, there are
1571 * outstanding packets on the msock. We wait for them to arrive.
1572 * In case we are the logically next packet, we update mdev->peer_seq
1573 * ourselves. Correctly handles 32bit wrap around.
1574 *
1575 * Assume we have a 10 GBit connection, that is about 1<<30 byte per second,
1576 * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds
1577 * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have
1578 * 1<<9 == 512 seconds aka ages for the 32bit wrap around...
1579 *
1580 * returns 0 if we may process the packet,
1581 * -ERESTARTSYS if we were interrupted (by disconnect signal). */
1582static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq)
1583{
1584 DEFINE_WAIT(wait);
1585 unsigned int p_seq;
1586 long timeout;
1587 int ret = 0;
1588 spin_lock(&mdev->peer_seq_lock);
1589 for (;;) {
1590 prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE);
1591 if (seq_le(packet_seq, mdev->peer_seq+1))
1592 break;
1593 if (signal_pending(current)) {
1594 ret = -ERESTARTSYS;
1595 break;
1596 }
1597 p_seq = mdev->peer_seq;
1598 spin_unlock(&mdev->peer_seq_lock);
1599 timeout = schedule_timeout(30*HZ);
1600 spin_lock(&mdev->peer_seq_lock);
1601 if (timeout == 0 && p_seq == mdev->peer_seq) {
1602 ret = -ETIMEDOUT;
1603 dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n");
1604 break;
1605 }
1606 }
1607 finish_wait(&mdev->seq_wait, &wait);
1608 if (mdev->peer_seq+1 == packet_seq)
1609 mdev->peer_seq++;
1610 spin_unlock(&mdev->peer_seq_lock);
1611 return ret;
1612}
1613
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001614static unsigned long write_flags_to_bio(struct drbd_conf *mdev, u32 dpf)
1615{
1616 if (mdev->agreed_pro_version >= 95)
1617 return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) |
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001618 (dpf & DP_FUA ? REQ_FUA : 0) |
1619 (dpf & DP_FLUSH ? REQ_FUA : 0) |
1620 (dpf & DP_DISCARD ? REQ_DISCARD : 0);
1621 else
Jens Axboe721a9602011-03-09 11:56:30 +01001622 return dpf & DP_RW_SYNC ? REQ_SYNC : 0;
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001623}
1624
Philipp Reisnerb411b362009-09-25 16:07:19 -07001625/* mirrored write */
Philipp Reisner02918be2010-08-20 14:35:10 +02001626static int receive_Data(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001627{
1628 sector_t sector;
1629 struct drbd_epoch_entry *e;
Philipp Reisner02918be2010-08-20 14:35:10 +02001630 struct p_data *p = &mdev->data.rbuf.data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001631 int rw = WRITE;
1632 u32 dp_flags;
1633
Philipp Reisnerb411b362009-09-25 16:07:19 -07001634 if (!get_ldev(mdev)) {
1635 if (__ratelimit(&drbd_ratelimit_state))
1636 dev_err(DEV, "Can not write mirrored data block "
1637 "to local disk.\n");
1638 spin_lock(&mdev->peer_seq_lock);
1639 if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num))
1640 mdev->peer_seq++;
1641 spin_unlock(&mdev->peer_seq_lock);
1642
Lars Ellenberg2b2bf212010-10-06 11:46:55 +02001643 drbd_send_ack_dp(mdev, P_NEG_ACK, p, data_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001644 atomic_inc(&mdev->current_epoch->epoch_size);
1645 return drbd_drain_block(mdev, data_size);
1646 }
1647
1648 /* get_ldev(mdev) successful.
1649 * Corresponding put_ldev done either below (on various errors),
1650 * or in drbd_endio_write_sec, if we successfully submit the data at
1651 * the end of this function. */
1652
1653 sector = be64_to_cpu(p->sector);
1654 e = read_in_block(mdev, p->block_id, sector, data_size);
1655 if (!e) {
1656 put_ldev(mdev);
1657 return FALSE;
1658 }
1659
Philipp Reisnerb411b362009-09-25 16:07:19 -07001660 e->w.cb = e_end_block;
1661
1662 spin_lock(&mdev->epoch_lock);
1663 e->epoch = mdev->current_epoch;
1664 atomic_inc(&e->epoch->epoch_size);
1665 atomic_inc(&e->epoch->active);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001666 spin_unlock(&mdev->epoch_lock);
1667
1668 dp_flags = be32_to_cpu(p->dp_flags);
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001669 rw |= write_flags_to_bio(mdev, dp_flags);
1670
Philipp Reisnerb411b362009-09-25 16:07:19 -07001671 if (dp_flags & DP_MAY_SET_IN_SYNC)
1672 e->flags |= EE_MAY_SET_IN_SYNC;
1673
1674 /* I'm the receiver, I do hold a net_cnt reference. */
1675 if (!mdev->net_conf->two_primaries) {
1676 spin_lock_irq(&mdev->req_lock);
1677 } else {
1678 /* don't get the req_lock yet,
1679 * we may sleep in drbd_wait_peer_seq */
1680 const int size = e->size;
1681 const int discard = test_bit(DISCARD_CONCURRENT, &mdev->flags);
1682 DEFINE_WAIT(wait);
1683 struct drbd_request *i;
1684 struct hlist_node *n;
1685 struct hlist_head *slot;
1686 int first;
1687
1688 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
1689 BUG_ON(mdev->ee_hash == NULL);
1690 BUG_ON(mdev->tl_hash == NULL);
1691
1692 /* conflict detection and handling:
1693 * 1. wait on the sequence number,
1694 * in case this data packet overtook ACK packets.
1695 * 2. check our hash tables for conflicting requests.
1696 * we only need to walk the tl_hash, since an ee can not
1697 * have a conflict with an other ee: on the submitting
1698 * node, the corresponding req had already been conflicting,
1699 * and a conflicting req is never sent.
1700 *
1701 * Note: for two_primaries, we are protocol C,
1702 * so there cannot be any request that is DONE
1703 * but still on the transfer log.
1704 *
1705 * unconditionally add to the ee_hash.
1706 *
1707 * if no conflicting request is found:
1708 * submit.
1709 *
1710 * if any conflicting request is found
1711 * that has not yet been acked,
1712 * AND I have the "discard concurrent writes" flag:
1713 * queue (via done_ee) the P_DISCARD_ACK; OUT.
1714 *
1715 * if any conflicting request is found:
1716 * block the receiver, waiting on misc_wait
1717 * until no more conflicting requests are there,
1718 * or we get interrupted (disconnect).
1719 *
1720 * we do not just write after local io completion of those
1721 * requests, but only after req is done completely, i.e.
1722 * we wait for the P_DISCARD_ACK to arrive!
1723 *
1724 * then proceed normally, i.e. submit.
1725 */
1726 if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num)))
1727 goto out_interrupted;
1728
1729 spin_lock_irq(&mdev->req_lock);
1730
1731 hlist_add_head(&e->colision, ee_hash_slot(mdev, sector));
1732
1733#define OVERLAPS overlaps(i->sector, i->size, sector, size)
1734 slot = tl_hash_slot(mdev, sector);
1735 first = 1;
1736 for (;;) {
1737 int have_unacked = 0;
1738 int have_conflict = 0;
1739 prepare_to_wait(&mdev->misc_wait, &wait,
1740 TASK_INTERRUPTIBLE);
1741 hlist_for_each_entry(i, n, slot, colision) {
1742 if (OVERLAPS) {
1743 /* only ALERT on first iteration,
1744 * we may be woken up early... */
1745 if (first)
1746 dev_alert(DEV, "%s[%u] Concurrent local write detected!"
1747 " new: %llus +%u; pending: %llus +%u\n",
1748 current->comm, current->pid,
1749 (unsigned long long)sector, size,
1750 (unsigned long long)i->sector, i->size);
1751 if (i->rq_state & RQ_NET_PENDING)
1752 ++have_unacked;
1753 ++have_conflict;
1754 }
1755 }
1756#undef OVERLAPS
1757 if (!have_conflict)
1758 break;
1759
1760 /* Discard Ack only for the _first_ iteration */
1761 if (first && discard && have_unacked) {
1762 dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n",
1763 (unsigned long long)sector);
1764 inc_unacked(mdev);
1765 e->w.cb = e_send_discard_ack;
1766 list_add_tail(&e->w.list, &mdev->done_ee);
1767
1768 spin_unlock_irq(&mdev->req_lock);
1769
1770 /* we could probably send that P_DISCARD_ACK ourselves,
1771 * but I don't like the receiver using the msock */
1772
1773 put_ldev(mdev);
1774 wake_asender(mdev);
1775 finish_wait(&mdev->misc_wait, &wait);
1776 return TRUE;
1777 }
1778
1779 if (signal_pending(current)) {
1780 hlist_del_init(&e->colision);
1781
1782 spin_unlock_irq(&mdev->req_lock);
1783
1784 finish_wait(&mdev->misc_wait, &wait);
1785 goto out_interrupted;
1786 }
1787
1788 spin_unlock_irq(&mdev->req_lock);
1789 if (first) {
1790 first = 0;
1791 dev_alert(DEV, "Concurrent write! [W AFTERWARDS] "
1792 "sec=%llus\n", (unsigned long long)sector);
1793 } else if (discard) {
1794 /* we had none on the first iteration.
1795 * there must be none now. */
1796 D_ASSERT(have_unacked == 0);
1797 }
1798 schedule();
1799 spin_lock_irq(&mdev->req_lock);
1800 }
1801 finish_wait(&mdev->misc_wait, &wait);
1802 }
1803
1804 list_add(&e->w.list, &mdev->active_ee);
1805 spin_unlock_irq(&mdev->req_lock);
1806
1807 switch (mdev->net_conf->wire_protocol) {
1808 case DRBD_PROT_C:
1809 inc_unacked(mdev);
1810 /* corresponding dec_unacked() in e_end_block()
1811 * respective _drbd_clear_done_ee */
1812 break;
1813 case DRBD_PROT_B:
1814 /* I really don't like it that the receiver thread
1815 * sends on the msock, but anyways */
1816 drbd_send_ack(mdev, P_RECV_ACK, e);
1817 break;
1818 case DRBD_PROT_A:
1819 /* nothing to do */
1820 break;
1821 }
1822
Lars Ellenberg6719fb02010-10-18 23:04:07 +02001823 if (mdev->state.pdsk < D_INCONSISTENT) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001824 /* In case we have the only disk of the cluster, */
1825 drbd_set_out_of_sync(mdev, e->sector, e->size);
1826 e->flags |= EE_CALL_AL_COMPLETE_IO;
Lars Ellenberg6719fb02010-10-18 23:04:07 +02001827 e->flags &= ~EE_MAY_SET_IN_SYNC;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001828 drbd_al_begin_io(mdev, e->sector);
1829 }
1830
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001831 if (drbd_submit_ee(mdev, e, rw, DRBD_FAULT_DT_WR) == 0)
1832 return TRUE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001833
Lars Ellenberg22cc37a2010-09-14 20:40:41 +02001834 /* drbd_submit_ee currently fails for one reason only:
1835 * not being able to allocate enough bios.
1836 * Is dropping the connection going to help? */
1837 spin_lock_irq(&mdev->req_lock);
1838 list_del(&e->w.list);
1839 hlist_del_init(&e->colision);
1840 spin_unlock_irq(&mdev->req_lock);
1841 if (e->flags & EE_CALL_AL_COMPLETE_IO)
1842 drbd_al_complete_io(mdev, e->sector);
1843
Philipp Reisnerb411b362009-09-25 16:07:19 -07001844out_interrupted:
1845 /* yes, the epoch_size now is imbalanced.
1846 * but we drop the connection anyways, so we don't have a chance to
1847 * receive a barrier... atomic_inc(&mdev->epoch_size); */
1848 put_ldev(mdev);
1849 drbd_free_ee(mdev, e);
1850 return FALSE;
1851}
1852
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001853/* We may throttle resync, if the lower device seems to be busy,
1854 * and current sync rate is above c_min_rate.
1855 *
1856 * To decide whether or not the lower device is busy, we use a scheme similar
1857 * to MD RAID is_mddev_idle(): if the partition stats reveal "significant"
1858 * (more than 64 sectors) of activity we cannot account for with our own resync
1859 * activity, it obviously is "busy".
1860 *
1861 * The current sync rate used here uses only the most recent two step marks,
1862 * to have a short time average so we can react faster.
1863 */
1864int drbd_rs_should_slow_down(struct drbd_conf *mdev)
1865{
1866 struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk;
1867 unsigned long db, dt, dbdt;
1868 int curr_events;
1869 int throttle = 0;
1870
1871 /* feature disabled? */
1872 if (mdev->sync_conf.c_min_rate == 0)
1873 return 0;
1874
1875 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
1876 (int)part_stat_read(&disk->part0, sectors[1]) -
1877 atomic_read(&mdev->rs_sect_ev);
1878 if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) {
1879 unsigned long rs_left;
1880 int i;
1881
1882 mdev->rs_last_events = curr_events;
1883
1884 /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP,
1885 * approx. */
Lars Ellenberg2649f082010-11-05 10:05:47 +01001886 i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS;
1887
1888 if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)
1889 rs_left = mdev->ov_left;
1890 else
1891 rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed;
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001892
1893 dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ;
1894 if (!dt)
1895 dt++;
1896 db = mdev->rs_mark_left[i] - rs_left;
1897 dbdt = Bit2KB(db/dt);
1898
1899 if (dbdt > mdev->sync_conf.c_min_rate)
1900 throttle = 1;
1901 }
1902 return throttle;
1903}
1904
1905
Philipp Reisner02918be2010-08-20 14:35:10 +02001906static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int digest_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001907{
1908 sector_t sector;
1909 const sector_t capacity = drbd_get_capacity(mdev->this_bdev);
1910 struct drbd_epoch_entry *e;
1911 struct digest_info *di = NULL;
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02001912 int size, verb;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001913 unsigned int fault_type;
Philipp Reisner02918be2010-08-20 14:35:10 +02001914 struct p_block_req *p = &mdev->data.rbuf.block_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001915
1916 sector = be64_to_cpu(p->sector);
1917 size = be32_to_cpu(p->blksize);
1918
1919 if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) {
1920 dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
1921 (unsigned long long)sector, size);
1922 return FALSE;
1923 }
1924 if (sector + (size>>9) > capacity) {
1925 dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
1926 (unsigned long long)sector, size);
1927 return FALSE;
1928 }
1929
1930 if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) {
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02001931 verb = 1;
1932 switch (cmd) {
1933 case P_DATA_REQUEST:
1934 drbd_send_ack_rp(mdev, P_NEG_DREPLY, p);
1935 break;
1936 case P_RS_DATA_REQUEST:
1937 case P_CSUM_RS_REQUEST:
1938 case P_OV_REQUEST:
1939 drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p);
1940 break;
1941 case P_OV_REPLY:
1942 verb = 0;
1943 dec_rs_pending(mdev);
1944 drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC);
1945 break;
1946 default:
1947 dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n",
1948 cmdname(cmd));
1949 }
1950 if (verb && __ratelimit(&drbd_ratelimit_state))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001951 dev_err(DEV, "Can not satisfy peer's read request, "
1952 "no local data.\n");
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02001953
Lars Ellenberga821cc42010-09-06 12:31:37 +02001954 /* drain possibly payload */
1955 return drbd_drain_block(mdev, digest_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001956 }
1957
1958 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
1959 * "criss-cross" setup, that might cause write-out on some other DRBD,
1960 * which in turn might block on the other node at this very place. */
1961 e = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO);
1962 if (!e) {
1963 put_ldev(mdev);
1964 return FALSE;
1965 }
1966
Philipp Reisner02918be2010-08-20 14:35:10 +02001967 switch (cmd) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001968 case P_DATA_REQUEST:
1969 e->w.cb = w_e_end_data_req;
1970 fault_type = DRBD_FAULT_DT_RD;
Lars Ellenberg80a40e42010-08-11 23:28:00 +02001971 /* application IO, don't drbd_rs_begin_io */
1972 goto submit;
1973
Philipp Reisnerb411b362009-09-25 16:07:19 -07001974 case P_RS_DATA_REQUEST:
1975 e->w.cb = w_e_end_rsdata_req;
1976 fault_type = DRBD_FAULT_RS_RD;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001977 break;
1978
1979 case P_OV_REPLY:
1980 case P_CSUM_RS_REQUEST:
1981 fault_type = DRBD_FAULT_RS_RD;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001982 di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO);
1983 if (!di)
1984 goto out_free_e;
1985
1986 di->digest_size = digest_size;
1987 di->digest = (((char *)di)+sizeof(struct digest_info));
1988
Lars Ellenbergc36c3ce2010-08-11 20:42:55 +02001989 e->digest = di;
1990 e->flags |= EE_HAS_DIGEST;
1991
Philipp Reisnerb411b362009-09-25 16:07:19 -07001992 if (drbd_recv(mdev, di->digest, digest_size) != digest_size)
1993 goto out_free_e;
1994
Philipp Reisner02918be2010-08-20 14:35:10 +02001995 if (cmd == P_CSUM_RS_REQUEST) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001996 D_ASSERT(mdev->agreed_pro_version >= 89);
1997 e->w.cb = w_e_end_csum_rs_req;
Philipp Reisner02918be2010-08-20 14:35:10 +02001998 } else if (cmd == P_OV_REPLY) {
Lars Ellenberg2649f082010-11-05 10:05:47 +01001999 /* track progress, we may need to throttle */
2000 atomic_add(size >> 9, &mdev->rs_sect_in);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002001 e->w.cb = w_e_end_ov_reply;
2002 dec_rs_pending(mdev);
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002003 /* drbd_rs_begin_io done when we sent this request,
2004 * but accounting still needs to be done. */
2005 goto submit_for_resync;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002006 }
2007 break;
2008
2009 case P_OV_REQUEST:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002010 if (mdev->ov_start_sector == ~(sector_t)0 &&
2011 mdev->agreed_pro_version >= 90) {
Lars Ellenbergde228bb2010-11-05 09:43:15 +01002012 unsigned long now = jiffies;
2013 int i;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002014 mdev->ov_start_sector = sector;
2015 mdev->ov_position = sector;
Lars Ellenberg30b743a2010-11-05 09:39:06 +01002016 mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector);
2017 mdev->rs_total = mdev->ov_left;
Lars Ellenbergde228bb2010-11-05 09:43:15 +01002018 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
2019 mdev->rs_mark_left[i] = mdev->ov_left;
2020 mdev->rs_mark_time[i] = now;
2021 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002022 dev_info(DEV, "Online Verify start sector: %llu\n",
2023 (unsigned long long)sector);
2024 }
2025 e->w.cb = w_e_end_ov_req;
2026 fault_type = DRBD_FAULT_RS_RD;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002027 break;
2028
Philipp Reisnerb411b362009-09-25 16:07:19 -07002029 default:
2030 dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02002031 cmdname(cmd));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002032 fault_type = DRBD_FAULT_MAX;
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002033 goto out_free_e;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002034 }
2035
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002036 /* Throttle, drbd_rs_begin_io and submit should become asynchronous
2037 * wrt the receiver, but it is not as straightforward as it may seem.
2038 * Various places in the resync start and stop logic assume resync
2039 * requests are processed in order, requeuing this on the worker thread
2040 * introduces a bunch of new code for synchronization between threads.
2041 *
2042 * Unlimited throttling before drbd_rs_begin_io may stall the resync
2043 * "forever", throttling after drbd_rs_begin_io will lock that extent
2044 * for application writes for the same time. For now, just throttle
2045 * here, where the rest of the code expects the receiver to sleep for
2046 * a while, anyways.
2047 */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002048
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002049 /* Throttle before drbd_rs_begin_io, as that locks out application IO;
2050 * this defers syncer requests for some time, before letting at least
2051 * on request through. The resync controller on the receiving side
2052 * will adapt to the incoming rate accordingly.
2053 *
2054 * We cannot throttle here if remote is Primary/SyncTarget:
2055 * we would also throttle its application reads.
2056 * In that case, throttling is done on the SyncTarget only.
2057 */
2058 if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev))
2059 msleep(100);
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002060 if (drbd_rs_begin_io(mdev, e->sector))
2061 goto out_free_e;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002062
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002063submit_for_resync:
2064 atomic_add(size >> 9, &mdev->rs_sect_ev);
2065
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002066submit:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002067 inc_unacked(mdev);
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002068 spin_lock_irq(&mdev->req_lock);
2069 list_add_tail(&e->w.list, &mdev->read_ee);
2070 spin_unlock_irq(&mdev->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002071
Lars Ellenberg45bb9122010-05-14 17:10:48 +02002072 if (drbd_submit_ee(mdev, e, READ, fault_type) == 0)
2073 return TRUE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002074
Lars Ellenberg22cc37a2010-09-14 20:40:41 +02002075 /* drbd_submit_ee currently fails for one reason only:
2076 * not being able to allocate enough bios.
2077 * Is dropping the connection going to help? */
2078 spin_lock_irq(&mdev->req_lock);
2079 list_del(&e->w.list);
2080 spin_unlock_irq(&mdev->req_lock);
2081 /* no drbd_rs_complete_io(), we are dropping the connection anyways */
2082
Philipp Reisnerb411b362009-09-25 16:07:19 -07002083out_free_e:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002084 put_ldev(mdev);
2085 drbd_free_ee(mdev, e);
2086 return FALSE;
2087}
2088
2089static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local)
2090{
2091 int self, peer, rv = -100;
2092 unsigned long ch_self, ch_peer;
2093
2094 self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
2095 peer = mdev->p_uuid[UI_BITMAP] & 1;
2096
2097 ch_peer = mdev->p_uuid[UI_SIZE];
2098 ch_self = mdev->comm_bm_set;
2099
2100 switch (mdev->net_conf->after_sb_0p) {
2101 case ASB_CONSENSUS:
2102 case ASB_DISCARD_SECONDARY:
2103 case ASB_CALL_HELPER:
2104 dev_err(DEV, "Configuration error.\n");
2105 break;
2106 case ASB_DISCONNECT:
2107 break;
2108 case ASB_DISCARD_YOUNGER_PRI:
2109 if (self == 0 && peer == 1) {
2110 rv = -1;
2111 break;
2112 }
2113 if (self == 1 && peer == 0) {
2114 rv = 1;
2115 break;
2116 }
2117 /* Else fall through to one of the other strategies... */
2118 case ASB_DISCARD_OLDER_PRI:
2119 if (self == 0 && peer == 1) {
2120 rv = 1;
2121 break;
2122 }
2123 if (self == 1 && peer == 0) {
2124 rv = -1;
2125 break;
2126 }
2127 /* Else fall through to one of the other strategies... */
Lars Ellenbergad19bf62009-10-14 09:36:49 +02002128 dev_warn(DEV, "Discard younger/older primary did not find a decision\n"
Philipp Reisnerb411b362009-09-25 16:07:19 -07002129 "Using discard-least-changes instead\n");
2130 case ASB_DISCARD_ZERO_CHG:
2131 if (ch_peer == 0 && ch_self == 0) {
2132 rv = test_bit(DISCARD_CONCURRENT, &mdev->flags)
2133 ? -1 : 1;
2134 break;
2135 } else {
2136 if (ch_peer == 0) { rv = 1; break; }
2137 if (ch_self == 0) { rv = -1; break; }
2138 }
2139 if (mdev->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG)
2140 break;
2141 case ASB_DISCARD_LEAST_CHG:
2142 if (ch_self < ch_peer)
2143 rv = -1;
2144 else if (ch_self > ch_peer)
2145 rv = 1;
2146 else /* ( ch_self == ch_peer ) */
2147 /* Well, then use something else. */
2148 rv = test_bit(DISCARD_CONCURRENT, &mdev->flags)
2149 ? -1 : 1;
2150 break;
2151 case ASB_DISCARD_LOCAL:
2152 rv = -1;
2153 break;
2154 case ASB_DISCARD_REMOTE:
2155 rv = 1;
2156 }
2157
2158 return rv;
2159}
2160
2161static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local)
2162{
2163 int self, peer, hg, rv = -100;
2164
2165 self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
2166 peer = mdev->p_uuid[UI_BITMAP] & 1;
2167
2168 switch (mdev->net_conf->after_sb_1p) {
2169 case ASB_DISCARD_YOUNGER_PRI:
2170 case ASB_DISCARD_OLDER_PRI:
2171 case ASB_DISCARD_LEAST_CHG:
2172 case ASB_DISCARD_LOCAL:
2173 case ASB_DISCARD_REMOTE:
2174 dev_err(DEV, "Configuration error.\n");
2175 break;
2176 case ASB_DISCONNECT:
2177 break;
2178 case ASB_CONSENSUS:
2179 hg = drbd_asb_recover_0p(mdev);
2180 if (hg == -1 && mdev->state.role == R_SECONDARY)
2181 rv = hg;
2182 if (hg == 1 && mdev->state.role == R_PRIMARY)
2183 rv = hg;
2184 break;
2185 case ASB_VIOLENTLY:
2186 rv = drbd_asb_recover_0p(mdev);
2187 break;
2188 case ASB_DISCARD_SECONDARY:
2189 return mdev->state.role == R_PRIMARY ? 1 : -1;
2190 case ASB_CALL_HELPER:
2191 hg = drbd_asb_recover_0p(mdev);
2192 if (hg == -1 && mdev->state.role == R_PRIMARY) {
2193 self = drbd_set_role(mdev, R_SECONDARY, 0);
2194 /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
2195 * we might be here in C_WF_REPORT_PARAMS which is transient.
2196 * we do not need to wait for the after state change work either. */
2197 self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
2198 if (self != SS_SUCCESS) {
2199 drbd_khelper(mdev, "pri-lost-after-sb");
2200 } else {
2201 dev_warn(DEV, "Successfully gave up primary role.\n");
2202 rv = hg;
2203 }
2204 } else
2205 rv = hg;
2206 }
2207
2208 return rv;
2209}
2210
2211static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local)
2212{
2213 int self, peer, hg, rv = -100;
2214
2215 self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
2216 peer = mdev->p_uuid[UI_BITMAP] & 1;
2217
2218 switch (mdev->net_conf->after_sb_2p) {
2219 case ASB_DISCARD_YOUNGER_PRI:
2220 case ASB_DISCARD_OLDER_PRI:
2221 case ASB_DISCARD_LEAST_CHG:
2222 case ASB_DISCARD_LOCAL:
2223 case ASB_DISCARD_REMOTE:
2224 case ASB_CONSENSUS:
2225 case ASB_DISCARD_SECONDARY:
2226 dev_err(DEV, "Configuration error.\n");
2227 break;
2228 case ASB_VIOLENTLY:
2229 rv = drbd_asb_recover_0p(mdev);
2230 break;
2231 case ASB_DISCONNECT:
2232 break;
2233 case ASB_CALL_HELPER:
2234 hg = drbd_asb_recover_0p(mdev);
2235 if (hg == -1) {
2236 /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
2237 * we might be here in C_WF_REPORT_PARAMS which is transient.
2238 * we do not need to wait for the after state change work either. */
2239 self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
2240 if (self != SS_SUCCESS) {
2241 drbd_khelper(mdev, "pri-lost-after-sb");
2242 } else {
2243 dev_warn(DEV, "Successfully gave up primary role.\n");
2244 rv = hg;
2245 }
2246 } else
2247 rv = hg;
2248 }
2249
2250 return rv;
2251}
2252
2253static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid,
2254 u64 bits, u64 flags)
2255{
2256 if (!uuid) {
2257 dev_info(DEV, "%s uuid info vanished while I was looking!\n", text);
2258 return;
2259 }
2260 dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n",
2261 text,
2262 (unsigned long long)uuid[UI_CURRENT],
2263 (unsigned long long)uuid[UI_BITMAP],
2264 (unsigned long long)uuid[UI_HISTORY_START],
2265 (unsigned long long)uuid[UI_HISTORY_END],
2266 (unsigned long long)bits,
2267 (unsigned long long)flags);
2268}
2269
2270/*
2271 100 after split brain try auto recover
2272 2 C_SYNC_SOURCE set BitMap
2273 1 C_SYNC_SOURCE use BitMap
2274 0 no Sync
2275 -1 C_SYNC_TARGET use BitMap
2276 -2 C_SYNC_TARGET set BitMap
2277 -100 after split brain, disconnect
2278-1000 unrelated data
2279 */
2280static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local)
2281{
2282 u64 self, peer;
2283 int i, j;
2284
2285 self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
2286 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
2287
2288 *rule_nr = 10;
2289 if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED)
2290 return 0;
2291
2292 *rule_nr = 20;
2293 if ((self == UUID_JUST_CREATED || self == (u64)0) &&
2294 peer != UUID_JUST_CREATED)
2295 return -2;
2296
2297 *rule_nr = 30;
2298 if (self != UUID_JUST_CREATED &&
2299 (peer == UUID_JUST_CREATED || peer == (u64)0))
2300 return 2;
2301
2302 if (self == peer) {
2303 int rct, dc; /* roles at crash time */
2304
2305 if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) {
2306
2307 if (mdev->agreed_pro_version < 91)
2308 return -1001;
2309
2310 if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) &&
2311 (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) {
2312 dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n");
2313 drbd_uuid_set_bm(mdev, 0UL);
2314
2315 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
2316 mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
2317 *rule_nr = 34;
2318 } else {
2319 dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n");
2320 *rule_nr = 36;
2321 }
2322
2323 return 1;
2324 }
2325
2326 if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) {
2327
2328 if (mdev->agreed_pro_version < 91)
2329 return -1001;
2330
2331 if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) &&
2332 (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) {
2333 dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n");
2334
2335 mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START];
2336 mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP];
2337 mdev->p_uuid[UI_BITMAP] = 0UL;
2338
2339 drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
2340 *rule_nr = 35;
2341 } else {
2342 dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n");
2343 *rule_nr = 37;
2344 }
2345
2346 return -1;
2347 }
2348
2349 /* Common power [off|failure] */
2350 rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) +
2351 (mdev->p_uuid[UI_FLAGS] & 2);
2352 /* lowest bit is set when we were primary,
2353 * next bit (weight 2) is set when peer was primary */
2354 *rule_nr = 40;
2355
2356 switch (rct) {
2357 case 0: /* !self_pri && !peer_pri */ return 0;
2358 case 1: /* self_pri && !peer_pri */ return 1;
2359 case 2: /* !self_pri && peer_pri */ return -1;
2360 case 3: /* self_pri && peer_pri */
2361 dc = test_bit(DISCARD_CONCURRENT, &mdev->flags);
2362 return dc ? -1 : 1;
2363 }
2364 }
2365
2366 *rule_nr = 50;
2367 peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
2368 if (self == peer)
2369 return -1;
2370
2371 *rule_nr = 51;
2372 peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1);
2373 if (self == peer) {
2374 self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
2375 peer = mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1);
2376 if (self == peer) {
2377 /* The last P_SYNC_UUID did not get though. Undo the last start of
2378 resync as sync source modifications of the peer's UUIDs. */
2379
2380 if (mdev->agreed_pro_version < 91)
2381 return -1001;
2382
2383 mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START];
2384 mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1];
2385 return -1;
2386 }
2387 }
2388
2389 *rule_nr = 60;
2390 self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
2391 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2392 peer = mdev->p_uuid[i] & ~((u64)1);
2393 if (self == peer)
2394 return -2;
2395 }
2396
2397 *rule_nr = 70;
2398 self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
2399 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
2400 if (self == peer)
2401 return 1;
2402
2403 *rule_nr = 71;
2404 self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
2405 if (self == peer) {
2406 self = mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1);
2407 peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1);
2408 if (self == peer) {
2409 /* The last P_SYNC_UUID did not get though. Undo the last start of
2410 resync as sync source modifications of our UUIDs. */
2411
2412 if (mdev->agreed_pro_version < 91)
2413 return -1001;
2414
2415 _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]);
2416 _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]);
2417
2418 dev_info(DEV, "Undid last start of resync:\n");
2419
2420 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
2421 mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
2422
2423 return 1;
2424 }
2425 }
2426
2427
2428 *rule_nr = 80;
Philipp Reisnerd8c2a362009-11-18 15:52:51 +01002429 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002430 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2431 self = mdev->ldev->md.uuid[i] & ~((u64)1);
2432 if (self == peer)
2433 return 2;
2434 }
2435
2436 *rule_nr = 90;
2437 self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
2438 peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
2439 if (self == peer && self != ((u64)0))
2440 return 100;
2441
2442 *rule_nr = 100;
2443 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2444 self = mdev->ldev->md.uuid[i] & ~((u64)1);
2445 for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) {
2446 peer = mdev->p_uuid[j] & ~((u64)1);
2447 if (self == peer)
2448 return -100;
2449 }
2450 }
2451
2452 return -1000;
2453}
2454
2455/* drbd_sync_handshake() returns the new conn state on success, or
2456 CONN_MASK (-1) on failure.
2457 */
2458static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role,
2459 enum drbd_disk_state peer_disk) __must_hold(local)
2460{
2461 int hg, rule_nr;
2462 enum drbd_conns rv = C_MASK;
2463 enum drbd_disk_state mydisk;
2464
2465 mydisk = mdev->state.disk;
2466 if (mydisk == D_NEGOTIATING)
2467 mydisk = mdev->new_state_tmp.disk;
2468
2469 dev_info(DEV, "drbd_sync_handshake:\n");
2470 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0);
2471 drbd_uuid_dump(mdev, "peer", mdev->p_uuid,
2472 mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
2473
2474 hg = drbd_uuid_compare(mdev, &rule_nr);
2475
2476 dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr);
2477
2478 if (hg == -1000) {
2479 dev_alert(DEV, "Unrelated data, aborting!\n");
2480 return C_MASK;
2481 }
2482 if (hg == -1001) {
2483 dev_alert(DEV, "To resolve this both sides have to support at least protocol\n");
2484 return C_MASK;
2485 }
2486
2487 if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) ||
2488 (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) {
2489 int f = (hg == -100) || abs(hg) == 2;
2490 hg = mydisk > D_INCONSISTENT ? 1 : -1;
2491 if (f)
2492 hg = hg*2;
2493 dev_info(DEV, "Becoming sync %s due to disk states.\n",
2494 hg > 0 ? "source" : "target");
2495 }
2496
Adam Gandelman3a11a482010-04-08 16:48:23 -07002497 if (abs(hg) == 100)
2498 drbd_khelper(mdev, "initial-split-brain");
2499
Philipp Reisnerb411b362009-09-25 16:07:19 -07002500 if (hg == 100 || (hg == -100 && mdev->net_conf->always_asbp)) {
2501 int pcount = (mdev->state.role == R_PRIMARY)
2502 + (peer_role == R_PRIMARY);
2503 int forced = (hg == -100);
2504
2505 switch (pcount) {
2506 case 0:
2507 hg = drbd_asb_recover_0p(mdev);
2508 break;
2509 case 1:
2510 hg = drbd_asb_recover_1p(mdev);
2511 break;
2512 case 2:
2513 hg = drbd_asb_recover_2p(mdev);
2514 break;
2515 }
2516 if (abs(hg) < 100) {
2517 dev_warn(DEV, "Split-Brain detected, %d primaries, "
2518 "automatically solved. Sync from %s node\n",
2519 pcount, (hg < 0) ? "peer" : "this");
2520 if (forced) {
2521 dev_warn(DEV, "Doing a full sync, since"
2522 " UUIDs where ambiguous.\n");
2523 hg = hg*2;
2524 }
2525 }
2526 }
2527
2528 if (hg == -100) {
2529 if (mdev->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1))
2530 hg = -1;
2531 if (!mdev->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1))
2532 hg = 1;
2533
2534 if (abs(hg) < 100)
2535 dev_warn(DEV, "Split-Brain detected, manually solved. "
2536 "Sync from %s node\n",
2537 (hg < 0) ? "peer" : "this");
2538 }
2539
2540 if (hg == -100) {
Lars Ellenberg580b9762010-02-26 23:15:23 +01002541 /* FIXME this log message is not correct if we end up here
2542 * after an attempted attach on a diskless node.
2543 * We just refuse to attach -- well, we drop the "connection"
2544 * to that disk, in a way... */
Adam Gandelman3a11a482010-04-08 16:48:23 -07002545 dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07002546 drbd_khelper(mdev, "split-brain");
2547 return C_MASK;
2548 }
2549
2550 if (hg > 0 && mydisk <= D_INCONSISTENT) {
2551 dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n");
2552 return C_MASK;
2553 }
2554
2555 if (hg < 0 && /* by intention we do not use mydisk here. */
2556 mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) {
2557 switch (mdev->net_conf->rr_conflict) {
2558 case ASB_CALL_HELPER:
2559 drbd_khelper(mdev, "pri-lost");
2560 /* fall through */
2561 case ASB_DISCONNECT:
2562 dev_err(DEV, "I shall become SyncTarget, but I am primary!\n");
2563 return C_MASK;
2564 case ASB_VIOLENTLY:
2565 dev_warn(DEV, "Becoming SyncTarget, violating the stable-data"
2566 "assumption\n");
2567 }
2568 }
2569
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002570 if (mdev->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) {
2571 if (hg == 0)
2572 dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n");
2573 else
2574 dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.",
2575 drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET),
2576 abs(hg) >= 2 ? "full" : "bit-map based");
2577 return C_MASK;
2578 }
2579
Philipp Reisnerb411b362009-09-25 16:07:19 -07002580 if (abs(hg) >= 2) {
2581 dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n");
2582 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake"))
2583 return C_MASK;
2584 }
2585
2586 if (hg > 0) { /* become sync source. */
2587 rv = C_WF_BITMAP_S;
2588 } else if (hg < 0) { /* become sync target */
2589 rv = C_WF_BITMAP_T;
2590 } else {
2591 rv = C_CONNECTED;
2592 if (drbd_bm_total_weight(mdev)) {
2593 dev_info(DEV, "No resync, but %lu bits in bitmap!\n",
2594 drbd_bm_total_weight(mdev));
2595 }
2596 }
2597
2598 return rv;
2599}
2600
2601/* returns 1 if invalid */
2602static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self)
2603{
2604 /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */
2605 if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) ||
2606 (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL))
2607 return 0;
2608
2609 /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */
2610 if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL ||
2611 self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL)
2612 return 1;
2613
2614 /* everything else is valid if they are equal on both sides. */
2615 if (peer == self)
2616 return 0;
2617
2618 /* everything es is invalid. */
2619 return 1;
2620}
2621
Philipp Reisner02918be2010-08-20 14:35:10 +02002622static int receive_protocol(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002623{
Philipp Reisner02918be2010-08-20 14:35:10 +02002624 struct p_protocol *p = &mdev->data.rbuf.protocol;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002625 int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p;
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002626 int p_want_lose, p_two_primaries, cf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002627 char p_integrity_alg[SHARED_SECRET_MAX] = "";
2628
Philipp Reisnerb411b362009-09-25 16:07:19 -07002629 p_proto = be32_to_cpu(p->protocol);
2630 p_after_sb_0p = be32_to_cpu(p->after_sb_0p);
2631 p_after_sb_1p = be32_to_cpu(p->after_sb_1p);
2632 p_after_sb_2p = be32_to_cpu(p->after_sb_2p);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002633 p_two_primaries = be32_to_cpu(p->two_primaries);
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002634 cf = be32_to_cpu(p->conn_flags);
2635 p_want_lose = cf & CF_WANT_LOSE;
2636
2637 clear_bit(CONN_DRY_RUN, &mdev->flags);
2638
2639 if (cf & CF_DRY_RUN)
2640 set_bit(CONN_DRY_RUN, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002641
2642 if (p_proto != mdev->net_conf->wire_protocol) {
2643 dev_err(DEV, "incompatible communication protocols\n");
2644 goto disconnect;
2645 }
2646
2647 if (cmp_after_sb(p_after_sb_0p, mdev->net_conf->after_sb_0p)) {
2648 dev_err(DEV, "incompatible after-sb-0pri settings\n");
2649 goto disconnect;
2650 }
2651
2652 if (cmp_after_sb(p_after_sb_1p, mdev->net_conf->after_sb_1p)) {
2653 dev_err(DEV, "incompatible after-sb-1pri settings\n");
2654 goto disconnect;
2655 }
2656
2657 if (cmp_after_sb(p_after_sb_2p, mdev->net_conf->after_sb_2p)) {
2658 dev_err(DEV, "incompatible after-sb-2pri settings\n");
2659 goto disconnect;
2660 }
2661
2662 if (p_want_lose && mdev->net_conf->want_lose) {
2663 dev_err(DEV, "both sides have the 'want_lose' flag set\n");
2664 goto disconnect;
2665 }
2666
2667 if (p_two_primaries != mdev->net_conf->two_primaries) {
2668 dev_err(DEV, "incompatible setting of the two-primaries options\n");
2669 goto disconnect;
2670 }
2671
2672 if (mdev->agreed_pro_version >= 87) {
2673 unsigned char *my_alg = mdev->net_conf->integrity_alg;
2674
2675 if (drbd_recv(mdev, p_integrity_alg, data_size) != data_size)
2676 return FALSE;
2677
2678 p_integrity_alg[SHARED_SECRET_MAX-1] = 0;
2679 if (strcmp(p_integrity_alg, my_alg)) {
2680 dev_err(DEV, "incompatible setting of the data-integrity-alg\n");
2681 goto disconnect;
2682 }
2683 dev_info(DEV, "data-integrity-alg: %s\n",
2684 my_alg[0] ? my_alg : (unsigned char *)"<not-used>");
2685 }
2686
2687 return TRUE;
2688
2689disconnect:
2690 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
2691 return FALSE;
2692}
2693
2694/* helper function
2695 * input: alg name, feature name
2696 * return: NULL (alg name was "")
2697 * ERR_PTR(error) if something goes wrong
2698 * or the crypto hash ptr, if it worked out ok. */
2699struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev,
2700 const char *alg, const char *name)
2701{
2702 struct crypto_hash *tfm;
2703
2704 if (!alg[0])
2705 return NULL;
2706
2707 tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC);
2708 if (IS_ERR(tfm)) {
2709 dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n",
2710 alg, name, PTR_ERR(tfm));
2711 return tfm;
2712 }
2713 if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) {
2714 crypto_free_hash(tfm);
2715 dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name);
2716 return ERR_PTR(-EINVAL);
2717 }
2718 return tfm;
2719}
2720
Philipp Reisner02918be2010-08-20 14:35:10 +02002721static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int packet_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002722{
2723 int ok = TRUE;
Philipp Reisner02918be2010-08-20 14:35:10 +02002724 struct p_rs_param_95 *p = &mdev->data.rbuf.rs_param_95;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002725 unsigned int header_size, data_size, exp_max_sz;
2726 struct crypto_hash *verify_tfm = NULL;
2727 struct crypto_hash *csums_tfm = NULL;
2728 const int apv = mdev->agreed_pro_version;
Philipp Reisner778f2712010-07-06 11:14:00 +02002729 int *rs_plan_s = NULL;
2730 int fifo_size = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002731
2732 exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param)
2733 : apv == 88 ? sizeof(struct p_rs_param)
2734 + SHARED_SECRET_MAX
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002735 : apv <= 94 ? sizeof(struct p_rs_param_89)
2736 : /* apv >= 95 */ sizeof(struct p_rs_param_95);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002737
Philipp Reisner02918be2010-08-20 14:35:10 +02002738 if (packet_size > exp_max_sz) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002739 dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02002740 packet_size, exp_max_sz);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002741 return FALSE;
2742 }
2743
2744 if (apv <= 88) {
Philipp Reisner02918be2010-08-20 14:35:10 +02002745 header_size = sizeof(struct p_rs_param) - sizeof(struct p_header80);
2746 data_size = packet_size - header_size;
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002747 } else if (apv <= 94) {
Philipp Reisner02918be2010-08-20 14:35:10 +02002748 header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header80);
2749 data_size = packet_size - header_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002750 D_ASSERT(data_size == 0);
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002751 } else {
Philipp Reisner02918be2010-08-20 14:35:10 +02002752 header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header80);
2753 data_size = packet_size - header_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002754 D_ASSERT(data_size == 0);
2755 }
2756
2757 /* initialize verify_alg and csums_alg */
2758 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
2759
Philipp Reisner02918be2010-08-20 14:35:10 +02002760 if (drbd_recv(mdev, &p->head.payload, header_size) != header_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002761 return FALSE;
2762
2763 mdev->sync_conf.rate = be32_to_cpu(p->rate);
2764
2765 if (apv >= 88) {
2766 if (apv == 88) {
2767 if (data_size > SHARED_SECRET_MAX) {
2768 dev_err(DEV, "verify-alg too long, "
2769 "peer wants %u, accepting only %u byte\n",
2770 data_size, SHARED_SECRET_MAX);
2771 return FALSE;
2772 }
2773
2774 if (drbd_recv(mdev, p->verify_alg, data_size) != data_size)
2775 return FALSE;
2776
2777 /* we expect NUL terminated string */
2778 /* but just in case someone tries to be evil */
2779 D_ASSERT(p->verify_alg[data_size-1] == 0);
2780 p->verify_alg[data_size-1] = 0;
2781
2782 } else /* apv >= 89 */ {
2783 /* we still expect NUL terminated strings */
2784 /* but just in case someone tries to be evil */
2785 D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0);
2786 D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0);
2787 p->verify_alg[SHARED_SECRET_MAX-1] = 0;
2788 p->csums_alg[SHARED_SECRET_MAX-1] = 0;
2789 }
2790
2791 if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) {
2792 if (mdev->state.conn == C_WF_REPORT_PARAMS) {
2793 dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n",
2794 mdev->sync_conf.verify_alg, p->verify_alg);
2795 goto disconnect;
2796 }
2797 verify_tfm = drbd_crypto_alloc_digest_safe(mdev,
2798 p->verify_alg, "verify-alg");
2799 if (IS_ERR(verify_tfm)) {
2800 verify_tfm = NULL;
2801 goto disconnect;
2802 }
2803 }
2804
2805 if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) {
2806 if (mdev->state.conn == C_WF_REPORT_PARAMS) {
2807 dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n",
2808 mdev->sync_conf.csums_alg, p->csums_alg);
2809 goto disconnect;
2810 }
2811 csums_tfm = drbd_crypto_alloc_digest_safe(mdev,
2812 p->csums_alg, "csums-alg");
2813 if (IS_ERR(csums_tfm)) {
2814 csums_tfm = NULL;
2815 goto disconnect;
2816 }
2817 }
2818
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002819 if (apv > 94) {
2820 mdev->sync_conf.rate = be32_to_cpu(p->rate);
2821 mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead);
2822 mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target);
2823 mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target);
2824 mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate);
Philipp Reisner778f2712010-07-06 11:14:00 +02002825
2826 fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ;
2827 if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
2828 rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
2829 if (!rs_plan_s) {
2830 dev_err(DEV, "kmalloc of fifo_buffer failed");
2831 goto disconnect;
2832 }
2833 }
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002834 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002835
2836 spin_lock(&mdev->peer_seq_lock);
2837 /* lock against drbd_nl_syncer_conf() */
2838 if (verify_tfm) {
2839 strcpy(mdev->sync_conf.verify_alg, p->verify_alg);
2840 mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1;
2841 crypto_free_hash(mdev->verify_tfm);
2842 mdev->verify_tfm = verify_tfm;
2843 dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg);
2844 }
2845 if (csums_tfm) {
2846 strcpy(mdev->sync_conf.csums_alg, p->csums_alg);
2847 mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1;
2848 crypto_free_hash(mdev->csums_tfm);
2849 mdev->csums_tfm = csums_tfm;
2850 dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg);
2851 }
Philipp Reisner778f2712010-07-06 11:14:00 +02002852 if (fifo_size != mdev->rs_plan_s.size) {
2853 kfree(mdev->rs_plan_s.values);
2854 mdev->rs_plan_s.values = rs_plan_s;
2855 mdev->rs_plan_s.size = fifo_size;
2856 mdev->rs_planed = 0;
2857 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002858 spin_unlock(&mdev->peer_seq_lock);
2859 }
2860
2861 return ok;
2862disconnect:
2863 /* just for completeness: actually not needed,
2864 * as this is not reached if csums_tfm was ok. */
2865 crypto_free_hash(csums_tfm);
2866 /* but free the verify_tfm again, if csums_tfm did not work out */
2867 crypto_free_hash(verify_tfm);
2868 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
2869 return FALSE;
2870}
2871
2872static void drbd_setup_order_type(struct drbd_conf *mdev, int peer)
2873{
2874 /* sorry, we currently have no working implementation
2875 * of distributed TCQ */
2876}
2877
2878/* warn if the arguments differ by more than 12.5% */
2879static void warn_if_differ_considerably(struct drbd_conf *mdev,
2880 const char *s, sector_t a, sector_t b)
2881{
2882 sector_t d;
2883 if (a == 0 || b == 0)
2884 return;
2885 d = (a > b) ? (a - b) : (b - a);
2886 if (d > (a>>3) || d > (b>>3))
2887 dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s,
2888 (unsigned long long)a, (unsigned long long)b);
2889}
2890
Philipp Reisner02918be2010-08-20 14:35:10 +02002891static int receive_sizes(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002892{
Philipp Reisner02918be2010-08-20 14:35:10 +02002893 struct p_sizes *p = &mdev->data.rbuf.sizes;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002894 enum determine_dev_size dd = unchanged;
2895 unsigned int max_seg_s;
2896 sector_t p_size, p_usize, my_usize;
2897 int ldsc = 0; /* local disk size changed */
Philipp Reisnere89b5912010-03-24 17:11:33 +01002898 enum dds_flags ddsf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002899
Philipp Reisnerb411b362009-09-25 16:07:19 -07002900 p_size = be64_to_cpu(p->d_size);
2901 p_usize = be64_to_cpu(p->u_size);
2902
2903 if (p_size == 0 && mdev->state.disk == D_DISKLESS) {
2904 dev_err(DEV, "some backing storage is needed\n");
2905 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
2906 return FALSE;
2907 }
2908
2909 /* just store the peer's disk size for now.
2910 * we still need to figure out whether we accept that. */
2911 mdev->p_size = p_size;
2912
Philipp Reisnerb411b362009-09-25 16:07:19 -07002913 if (get_ldev(mdev)) {
2914 warn_if_differ_considerably(mdev, "lower level device sizes",
2915 p_size, drbd_get_max_capacity(mdev->ldev));
2916 warn_if_differ_considerably(mdev, "user requested size",
2917 p_usize, mdev->ldev->dc.disk_size);
2918
2919 /* if this is the first connect, or an otherwise expected
2920 * param exchange, choose the minimum */
2921 if (mdev->state.conn == C_WF_REPORT_PARAMS)
2922 p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size,
2923 p_usize);
2924
2925 my_usize = mdev->ldev->dc.disk_size;
2926
2927 if (mdev->ldev->dc.disk_size != p_usize) {
2928 mdev->ldev->dc.disk_size = p_usize;
2929 dev_info(DEV, "Peer sets u_size to %lu sectors\n",
2930 (unsigned long)mdev->ldev->dc.disk_size);
2931 }
2932
2933 /* Never shrink a device with usable data during connect.
2934 But allow online shrinking if we are connected. */
Philipp Reisnera393db62009-12-22 13:35:52 +01002935 if (drbd_new_dev_size(mdev, mdev->ldev, 0) <
Philipp Reisnerb411b362009-09-25 16:07:19 -07002936 drbd_get_capacity(mdev->this_bdev) &&
2937 mdev->state.disk >= D_OUTDATED &&
2938 mdev->state.conn < C_CONNECTED) {
2939 dev_err(DEV, "The peer's disk size is too small!\n");
2940 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
2941 mdev->ldev->dc.disk_size = my_usize;
2942 put_ldev(mdev);
2943 return FALSE;
2944 }
2945 put_ldev(mdev);
2946 }
2947#undef min_not_zero
2948
Philipp Reisnere89b5912010-03-24 17:11:33 +01002949 ddsf = be16_to_cpu(p->dds_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002950 if (get_ldev(mdev)) {
Philipp Reisnere89b5912010-03-24 17:11:33 +01002951 dd = drbd_determin_dev_size(mdev, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002952 put_ldev(mdev);
2953 if (dd == dev_size_error)
2954 return FALSE;
2955 drbd_md_sync(mdev);
2956 } else {
2957 /* I am diskless, need to accept the peer's size. */
2958 drbd_set_my_capacity(mdev, p_size);
2959 }
2960
Philipp Reisnerb411b362009-09-25 16:07:19 -07002961 if (get_ldev(mdev)) {
2962 if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) {
2963 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
2964 ldsc = 1;
2965 }
2966
Lars Ellenberga1c88d02010-05-14 19:16:41 +02002967 if (mdev->agreed_pro_version < 94)
2968 max_seg_s = be32_to_cpu(p->max_segment_size);
Lars Ellenberg8979d9c2010-09-14 15:56:29 +02002969 else if (mdev->agreed_pro_version == 94)
2970 max_seg_s = DRBD_MAX_SIZE_H80_PACKET;
Lars Ellenberga1c88d02010-05-14 19:16:41 +02002971 else /* drbd 8.3.8 onwards */
2972 max_seg_s = DRBD_MAX_SEGMENT_SIZE;
2973
Philipp Reisnerb411b362009-09-25 16:07:19 -07002974 if (max_seg_s != queue_max_segment_size(mdev->rq_queue))
2975 drbd_setup_queue_param(mdev, max_seg_s);
2976
Philipp Reisnere89b5912010-03-24 17:11:33 +01002977 drbd_setup_order_type(mdev, be16_to_cpu(p->queue_order_type));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002978 put_ldev(mdev);
2979 }
2980
2981 if (mdev->state.conn > C_WF_REPORT_PARAMS) {
2982 if (be64_to_cpu(p->c_size) !=
2983 drbd_get_capacity(mdev->this_bdev) || ldsc) {
2984 /* we have different sizes, probably peer
2985 * needs to know my new size... */
Philipp Reisnere89b5912010-03-24 17:11:33 +01002986 drbd_send_sizes(mdev, 0, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002987 }
2988 if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) ||
2989 (dd == grew && mdev->state.conn == C_CONNECTED)) {
2990 if (mdev->state.pdsk >= D_INCONSISTENT &&
Philipp Reisnere89b5912010-03-24 17:11:33 +01002991 mdev->state.disk >= D_INCONSISTENT) {
2992 if (ddsf & DDSF_NO_RESYNC)
2993 dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n");
2994 else
2995 resync_after_online_grow(mdev);
2996 } else
Philipp Reisnerb411b362009-09-25 16:07:19 -07002997 set_bit(RESYNC_AFTER_NEG, &mdev->flags);
2998 }
2999 }
3000
3001 return TRUE;
3002}
3003
Philipp Reisner02918be2010-08-20 14:35:10 +02003004static int receive_uuids(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003005{
Philipp Reisner02918be2010-08-20 14:35:10 +02003006 struct p_uuids *p = &mdev->data.rbuf.uuids;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003007 u64 *p_uuid;
3008 int i;
3009
Philipp Reisnerb411b362009-09-25 16:07:19 -07003010 p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO);
3011
3012 for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++)
3013 p_uuid[i] = be64_to_cpu(p->uuid[i]);
3014
3015 kfree(mdev->p_uuid);
3016 mdev->p_uuid = p_uuid;
3017
3018 if (mdev->state.conn < C_CONNECTED &&
3019 mdev->state.disk < D_INCONSISTENT &&
3020 mdev->state.role == R_PRIMARY &&
3021 (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
3022 dev_err(DEV, "Can only connect to data with current UUID=%016llX\n",
3023 (unsigned long long)mdev->ed_uuid);
3024 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3025 return FALSE;
3026 }
3027
3028 if (get_ldev(mdev)) {
3029 int skip_initial_sync =
3030 mdev->state.conn == C_CONNECTED &&
3031 mdev->agreed_pro_version >= 90 &&
3032 mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED &&
3033 (p_uuid[UI_FLAGS] & 8);
3034 if (skip_initial_sync) {
3035 dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n");
3036 drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
3037 "clear_n_write from receive_uuids");
3038 _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]);
3039 _drbd_uuid_set(mdev, UI_BITMAP, 0);
3040 _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
3041 CS_VERBOSE, NULL);
3042 drbd_md_sync(mdev);
3043 }
3044 put_ldev(mdev);
Philipp Reisner18a50fa2010-06-21 14:14:15 +02003045 } else if (mdev->state.disk < D_INCONSISTENT &&
3046 mdev->state.role == R_PRIMARY) {
3047 /* I am a diskless primary, the peer just created a new current UUID
3048 for me. */
3049 drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003050 }
3051
3052 /* Before we test for the disk state, we should wait until an eventually
3053 ongoing cluster wide state change is finished. That is important if
3054 we are primary and are detaching from our disk. We need to see the
3055 new disk state... */
3056 wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags));
3057 if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT)
3058 drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
3059
3060 return TRUE;
3061}
3062
3063/**
3064 * convert_state() - Converts the peer's view of the cluster state to our point of view
3065 * @ps: The state as seen by the peer.
3066 */
3067static union drbd_state convert_state(union drbd_state ps)
3068{
3069 union drbd_state ms;
3070
3071 static enum drbd_conns c_tab[] = {
3072 [C_CONNECTED] = C_CONNECTED,
3073
3074 [C_STARTING_SYNC_S] = C_STARTING_SYNC_T,
3075 [C_STARTING_SYNC_T] = C_STARTING_SYNC_S,
3076 [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */
3077 [C_VERIFY_S] = C_VERIFY_T,
3078 [C_MASK] = C_MASK,
3079 };
3080
3081 ms.i = ps.i;
3082
3083 ms.conn = c_tab[ps.conn];
3084 ms.peer = ps.role;
3085 ms.role = ps.peer;
3086 ms.pdsk = ps.disk;
3087 ms.disk = ps.pdsk;
3088 ms.peer_isp = (ps.aftr_isp | ps.user_isp);
3089
3090 return ms;
3091}
3092
Philipp Reisner02918be2010-08-20 14:35:10 +02003093static int receive_req_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003094{
Philipp Reisner02918be2010-08-20 14:35:10 +02003095 struct p_req_state *p = &mdev->data.rbuf.req_state;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003096 union drbd_state mask, val;
3097 int rv;
3098
Philipp Reisnerb411b362009-09-25 16:07:19 -07003099 mask.i = be32_to_cpu(p->mask);
3100 val.i = be32_to_cpu(p->val);
3101
3102 if (test_bit(DISCARD_CONCURRENT, &mdev->flags) &&
3103 test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) {
3104 drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG);
3105 return TRUE;
3106 }
3107
3108 mask = convert_state(mask);
3109 val = convert_state(val);
3110
3111 rv = drbd_change_state(mdev, CS_VERBOSE, mask, val);
3112
3113 drbd_send_sr_reply(mdev, rv);
3114 drbd_md_sync(mdev);
3115
3116 return TRUE;
3117}
3118
Philipp Reisner02918be2010-08-20 14:35:10 +02003119static int receive_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003120{
Philipp Reisner02918be2010-08-20 14:35:10 +02003121 struct p_state *p = &mdev->data.rbuf.state;
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003122 union drbd_state os, ns, peer_state;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003123 enum drbd_disk_state real_peer_disk;
Philipp Reisner65d922c2010-06-16 16:18:09 +02003124 enum chg_state_flags cs_flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003125 int rv;
3126
Philipp Reisnerb411b362009-09-25 16:07:19 -07003127 peer_state.i = be32_to_cpu(p->state);
3128
3129 real_peer_disk = peer_state.disk;
3130 if (peer_state.disk == D_NEGOTIATING) {
3131 real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT;
3132 dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk));
3133 }
3134
3135 spin_lock_irq(&mdev->req_lock);
3136 retry:
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003137 os = ns = mdev->state;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003138 spin_unlock_irq(&mdev->req_lock);
3139
Lars Ellenberge9ef7bb2010-10-07 15:55:39 +02003140 /* peer says his disk is uptodate, while we think it is inconsistent,
3141 * and this happens while we think we have a sync going on. */
3142 if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE &&
3143 os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) {
3144 /* If we are (becoming) SyncSource, but peer is still in sync
3145 * preparation, ignore its uptodate-ness to avoid flapping, it
3146 * will change to inconsistent once the peer reaches active
3147 * syncing states.
3148 * It may have changed syncer-paused flags, however, so we
3149 * cannot ignore this completely. */
3150 if (peer_state.conn > C_CONNECTED &&
3151 peer_state.conn < C_SYNC_SOURCE)
3152 real_peer_disk = D_INCONSISTENT;
3153
3154 /* if peer_state changes to connected at the same time,
3155 * it explicitly notifies us that it finished resync.
3156 * Maybe we should finish it up, too? */
3157 else if (os.conn >= C_SYNC_SOURCE &&
3158 peer_state.conn == C_CONNECTED) {
3159 if (drbd_bm_total_weight(mdev) <= mdev->rs_failed)
3160 drbd_resync_finished(mdev);
3161 return TRUE;
3162 }
3163 }
3164
3165 /* peer says his disk is inconsistent, while we think it is uptodate,
3166 * and this happens while the peer still thinks we have a sync going on,
3167 * but we think we are already done with the sync.
3168 * We ignore this to avoid flapping pdsk.
3169 * This should not happen, if the peer is a recent version of drbd. */
3170 if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT &&
3171 os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE)
3172 real_peer_disk = D_UP_TO_DATE;
3173
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003174 if (ns.conn == C_WF_REPORT_PARAMS)
3175 ns.conn = C_CONNECTED;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003176
3177 if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING &&
3178 get_ldev_if_state(mdev, D_NEGOTIATING)) {
3179 int cr; /* consider resync */
3180
3181 /* if we established a new connection */
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003182 cr = (os.conn < C_CONNECTED);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003183 /* if we had an established connection
3184 * and one of the nodes newly attaches a disk */
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003185 cr |= (os.conn == C_CONNECTED &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07003186 (peer_state.disk == D_NEGOTIATING ||
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003187 os.disk == D_NEGOTIATING));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003188 /* if we have both been inconsistent, and the peer has been
3189 * forced to be UpToDate with --overwrite-data */
3190 cr |= test_bit(CONSIDER_RESYNC, &mdev->flags);
3191 /* if we had been plain connected, and the admin requested to
3192 * start a sync by "invalidate" or "invalidate-remote" */
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003193 cr |= (os.conn == C_CONNECTED &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07003194 (peer_state.conn >= C_STARTING_SYNC_S &&
3195 peer_state.conn <= C_WF_BITMAP_T));
3196
3197 if (cr)
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003198 ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003199
3200 put_ldev(mdev);
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003201 if (ns.conn == C_MASK) {
3202 ns.conn = C_CONNECTED;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003203 if (mdev->state.disk == D_NEGOTIATING) {
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02003204 drbd_force_state(mdev, NS(disk, D_FAILED));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003205 } else if (peer_state.disk == D_NEGOTIATING) {
3206 dev_err(DEV, "Disk attach process on the peer node was aborted.\n");
3207 peer_state.disk = D_DISKLESS;
Lars Ellenberg580b9762010-02-26 23:15:23 +01003208 real_peer_disk = D_DISKLESS;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003209 } else {
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01003210 if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags))
3211 return FALSE;
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003212 D_ASSERT(os.conn == C_WF_REPORT_PARAMS);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003213 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3214 return FALSE;
3215 }
3216 }
3217 }
3218
3219 spin_lock_irq(&mdev->req_lock);
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003220 if (mdev->state.i != os.i)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003221 goto retry;
3222 clear_bit(CONSIDER_RESYNC, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003223 ns.peer = peer_state.role;
3224 ns.pdsk = real_peer_disk;
3225 ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp);
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003226 if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003227 ns.disk = mdev->new_state_tmp.disk;
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003228 cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD);
3229 if (ns.pdsk == D_CONSISTENT && is_susp(ns) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED &&
Philipp Reisner481c6f52010-06-22 14:03:27 +02003230 test_bit(NEW_CUR_UUID, &mdev->flags)) {
3231 /* Do not allow tl_restart(resend) for a rebooted peer. We can only allow this
3232 for temporal network outages! */
3233 spin_unlock_irq(&mdev->req_lock);
3234 dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n");
3235 tl_clear(mdev);
3236 drbd_uuid_new_current(mdev);
3237 clear_bit(NEW_CUR_UUID, &mdev->flags);
3238 drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0));
3239 return FALSE;
3240 }
Philipp Reisner65d922c2010-06-16 16:18:09 +02003241 rv = _drbd_set_state(mdev, ns, cs_flags, NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003242 ns = mdev->state;
3243 spin_unlock_irq(&mdev->req_lock);
3244
3245 if (rv < SS_SUCCESS) {
3246 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3247 return FALSE;
3248 }
3249
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003250 if (os.conn > C_WF_REPORT_PARAMS) {
3251 if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07003252 peer_state.disk != D_NEGOTIATING ) {
3253 /* we want resync, peer has not yet decided to sync... */
3254 /* Nowadays only used when forcing a node into primary role and
3255 setting its disk to UpToDate with that */
3256 drbd_send_uuids(mdev);
3257 drbd_send_state(mdev);
3258 }
3259 }
3260
3261 mdev->net_conf->want_lose = 0;
3262
3263 drbd_md_sync(mdev); /* update connected indicator, la_size, ... */
3264
3265 return TRUE;
3266}
3267
Philipp Reisner02918be2010-08-20 14:35:10 +02003268static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003269{
Philipp Reisner02918be2010-08-20 14:35:10 +02003270 struct p_rs_uuid *p = &mdev->data.rbuf.rs_uuid;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003271
3272 wait_event(mdev->misc_wait,
3273 mdev->state.conn == C_WF_SYNC_UUID ||
3274 mdev->state.conn < C_CONNECTED ||
3275 mdev->state.disk < D_NEGOTIATING);
3276
3277 /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */
3278
Philipp Reisnerb411b362009-09-25 16:07:19 -07003279 /* Here the _drbd_uuid_ functions are right, current should
3280 _not_ be rotated into the history */
3281 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
3282 _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid));
3283 _drbd_uuid_set(mdev, UI_BITMAP, 0UL);
3284
3285 drbd_start_resync(mdev, C_SYNC_TARGET);
3286
3287 put_ldev(mdev);
3288 } else
3289 dev_err(DEV, "Ignoring SyncUUID packet!\n");
3290
3291 return TRUE;
3292}
3293
3294enum receive_bitmap_ret { OK, DONE, FAILED };
3295
3296static enum receive_bitmap_ret
Philipp Reisner02918be2010-08-20 14:35:10 +02003297receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size,
3298 unsigned long *buffer, struct bm_xfer_ctx *c)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003299{
3300 unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset);
3301 unsigned want = num_words * sizeof(long);
3302
Philipp Reisner02918be2010-08-20 14:35:10 +02003303 if (want != data_size) {
3304 dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003305 return FAILED;
3306 }
3307 if (want == 0)
3308 return DONE;
3309 if (drbd_recv(mdev, buffer, want) != want)
3310 return FAILED;
3311
3312 drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer);
3313
3314 c->word_offset += num_words;
3315 c->bit_offset = c->word_offset * BITS_PER_LONG;
3316 if (c->bit_offset > c->bm_bits)
3317 c->bit_offset = c->bm_bits;
3318
3319 return OK;
3320}
3321
3322static enum receive_bitmap_ret
3323recv_bm_rle_bits(struct drbd_conf *mdev,
3324 struct p_compressed_bm *p,
3325 struct bm_xfer_ctx *c)
3326{
3327 struct bitstream bs;
3328 u64 look_ahead;
3329 u64 rl;
3330 u64 tmp;
3331 unsigned long s = c->bit_offset;
3332 unsigned long e;
Lars Ellenberg004352f2010-10-05 20:13:58 +02003333 int len = be16_to_cpu(p->head.length) - (sizeof(*p) - sizeof(p->head));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003334 int toggle = DCBP_get_start(p);
3335 int have;
3336 int bits;
3337
3338 bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p));
3339
3340 bits = bitstream_get_bits(&bs, &look_ahead, 64);
3341 if (bits < 0)
3342 return FAILED;
3343
3344 for (have = bits; have > 0; s += rl, toggle = !toggle) {
3345 bits = vli_decode_bits(&rl, look_ahead);
3346 if (bits <= 0)
3347 return FAILED;
3348
3349 if (toggle) {
3350 e = s + rl -1;
3351 if (e >= c->bm_bits) {
3352 dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e);
3353 return FAILED;
3354 }
3355 _drbd_bm_set_bits(mdev, s, e);
3356 }
3357
3358 if (have < bits) {
3359 dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n",
3360 have, bits, look_ahead,
3361 (unsigned int)(bs.cur.b - p->code),
3362 (unsigned int)bs.buf_len);
3363 return FAILED;
3364 }
3365 look_ahead >>= bits;
3366 have -= bits;
3367
3368 bits = bitstream_get_bits(&bs, &tmp, 64 - have);
3369 if (bits < 0)
3370 return FAILED;
3371 look_ahead |= tmp << have;
3372 have += bits;
3373 }
3374
3375 c->bit_offset = s;
3376 bm_xfer_ctx_bit_to_word_offset(c);
3377
3378 return (s == c->bm_bits) ? DONE : OK;
3379}
3380
3381static enum receive_bitmap_ret
3382decode_bitmap_c(struct drbd_conf *mdev,
3383 struct p_compressed_bm *p,
3384 struct bm_xfer_ctx *c)
3385{
3386 if (DCBP_get_code(p) == RLE_VLI_Bits)
3387 return recv_bm_rle_bits(mdev, p, c);
3388
3389 /* other variants had been implemented for evaluation,
3390 * but have been dropped as this one turned out to be "best"
3391 * during all our tests. */
3392
3393 dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding);
3394 drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
3395 return FAILED;
3396}
3397
3398void INFO_bm_xfer_stats(struct drbd_conf *mdev,
3399 const char *direction, struct bm_xfer_ctx *c)
3400{
3401 /* what would it take to transfer it "plaintext" */
Philipp Reisner0b70a132010-08-20 13:36:10 +02003402 unsigned plain = sizeof(struct p_header80) *
Philipp Reisnerb411b362009-09-25 16:07:19 -07003403 ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1)
3404 + c->bm_words * sizeof(long);
3405 unsigned total = c->bytes[0] + c->bytes[1];
3406 unsigned r;
3407
3408 /* total can not be zero. but just in case: */
3409 if (total == 0)
3410 return;
3411
3412 /* don't report if not compressed */
3413 if (total >= plain)
3414 return;
3415
3416 /* total < plain. check for overflow, still */
3417 r = (total > UINT_MAX/1000) ? (total / (plain/1000))
3418 : (1000 * total / plain);
3419
3420 if (r > 1000)
3421 r = 1000;
3422
3423 r = 1000 - r;
3424 dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), "
3425 "total %u; compression: %u.%u%%\n",
3426 direction,
3427 c->bytes[1], c->packets[1],
3428 c->bytes[0], c->packets[0],
3429 total, r/10, r % 10);
3430}
3431
3432/* Since we are processing the bitfield from lower addresses to higher,
3433 it does not matter if the process it in 32 bit chunks or 64 bit
3434 chunks as long as it is little endian. (Understand it as byte stream,
3435 beginning with the lowest byte...) If we would use big endian
3436 we would need to process it from the highest address to the lowest,
3437 in order to be agnostic to the 32 vs 64 bits issue.
3438
3439 returns 0 on failure, 1 if we successfully received it. */
Philipp Reisner02918be2010-08-20 14:35:10 +02003440static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003441{
3442 struct bm_xfer_ctx c;
3443 void *buffer;
3444 enum receive_bitmap_ret ret;
3445 int ok = FALSE;
Philipp Reisner02918be2010-08-20 14:35:10 +02003446 struct p_header80 *h = &mdev->data.rbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003447
3448 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
3449
3450 drbd_bm_lock(mdev, "receive bitmap");
3451
3452 /* maybe we should use some per thread scratch page,
3453 * and allocate that during initial device creation? */
3454 buffer = (unsigned long *) __get_free_page(GFP_NOIO);
3455 if (!buffer) {
3456 dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__);
3457 goto out;
3458 }
3459
3460 c = (struct bm_xfer_ctx) {
3461 .bm_bits = drbd_bm_bits(mdev),
3462 .bm_words = drbd_bm_words(mdev),
3463 };
3464
3465 do {
Philipp Reisner02918be2010-08-20 14:35:10 +02003466 if (cmd == P_BITMAP) {
3467 ret = receive_bitmap_plain(mdev, data_size, buffer, &c);
3468 } else if (cmd == P_COMPRESSED_BITMAP) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003469 /* MAYBE: sanity check that we speak proto >= 90,
3470 * and the feature is enabled! */
3471 struct p_compressed_bm *p;
3472
Philipp Reisner02918be2010-08-20 14:35:10 +02003473 if (data_size > BM_PACKET_PAYLOAD_BYTES) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003474 dev_err(DEV, "ReportCBitmap packet too large\n");
3475 goto out;
3476 }
3477 /* use the page buff */
3478 p = buffer;
3479 memcpy(p, h, sizeof(*h));
Philipp Reisner02918be2010-08-20 14:35:10 +02003480 if (drbd_recv(mdev, p->head.payload, data_size) != data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003481 goto out;
Lars Ellenberg004352f2010-10-05 20:13:58 +02003482 if (data_size <= (sizeof(*p) - sizeof(p->head))) {
3483 dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", data_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003484 return FAILED;
3485 }
3486 ret = decode_bitmap_c(mdev, p, &c);
3487 } else {
Philipp Reisner02918be2010-08-20 14:35:10 +02003488 dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003489 goto out;
3490 }
3491
Philipp Reisner02918be2010-08-20 14:35:10 +02003492 c.packets[cmd == P_BITMAP]++;
3493 c.bytes[cmd == P_BITMAP] += sizeof(struct p_header80) + data_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003494
3495 if (ret != OK)
3496 break;
3497
Philipp Reisner02918be2010-08-20 14:35:10 +02003498 if (!drbd_recv_header(mdev, &cmd, &data_size))
Philipp Reisnerb411b362009-09-25 16:07:19 -07003499 goto out;
3500 } while (ret == OK);
3501 if (ret == FAILED)
3502 goto out;
3503
3504 INFO_bm_xfer_stats(mdev, "receive", &c);
3505
3506 if (mdev->state.conn == C_WF_BITMAP_T) {
3507 ok = !drbd_send_bitmap(mdev);
3508 if (!ok)
3509 goto out;
3510 /* Omit CS_ORDERED with this state transition to avoid deadlocks. */
3511 ok = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
3512 D_ASSERT(ok == SS_SUCCESS);
3513 } else if (mdev->state.conn != C_WF_BITMAP_S) {
3514 /* admin may have requested C_DISCONNECTING,
3515 * other threads may have noticed network errors */
3516 dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n",
3517 drbd_conn_str(mdev->state.conn));
3518 }
3519
3520 ok = TRUE;
3521 out:
3522 drbd_bm_unlock(mdev);
3523 if (ok && mdev->state.conn == C_WF_BITMAP_S)
3524 drbd_start_resync(mdev, C_SYNC_SOURCE);
3525 free_page((unsigned long) buffer);
3526 return ok;
3527}
3528
Philipp Reisner02918be2010-08-20 14:35:10 +02003529static int receive_skip(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003530{
3531 /* TODO zero copy sink :) */
3532 static char sink[128];
3533 int size, want, r;
3534
Philipp Reisner02918be2010-08-20 14:35:10 +02003535 dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n",
3536 cmd, data_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003537
Philipp Reisner02918be2010-08-20 14:35:10 +02003538 size = data_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003539 while (size > 0) {
3540 want = min_t(int, size, sizeof(sink));
3541 r = drbd_recv(mdev, sink, want);
3542 ERR_IF(r <= 0) break;
3543 size -= r;
3544 }
3545 return size == 0;
3546}
3547
Philipp Reisner02918be2010-08-20 14:35:10 +02003548static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003549{
Philipp Reisnerb411b362009-09-25 16:07:19 -07003550 /* Make sure we've acked all the TCP data associated
3551 * with the data requests being unplugged */
3552 drbd_tcp_quickack(mdev->data.socket);
3553
3554 return TRUE;
3555}
3556
Philipp Reisner02918be2010-08-20 14:35:10 +02003557typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packets cmd, unsigned int to_receive);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003558
Philipp Reisner02918be2010-08-20 14:35:10 +02003559struct data_cmd {
3560 int expect_payload;
3561 size_t pkt_size;
3562 drbd_cmd_handler_f function;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003563};
3564
Philipp Reisner02918be2010-08-20 14:35:10 +02003565static struct data_cmd drbd_cmd_handler[] = {
3566 [P_DATA] = { 1, sizeof(struct p_data), receive_Data },
3567 [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply },
3568 [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } ,
3569 [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } ,
3570 [P_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } ,
3571 [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } ,
3572 [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header80), receive_UnplugRemote },
3573 [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
3574 [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
3575 [P_SYNC_PARAM] = { 1, sizeof(struct p_header80), receive_SyncParam },
3576 [P_SYNC_PARAM89] = { 1, sizeof(struct p_header80), receive_SyncParam },
3577 [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol },
3578 [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids },
3579 [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes },
3580 [P_STATE] = { 0, sizeof(struct p_state), receive_state },
3581 [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state },
3582 [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid },
3583 [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
3584 [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest },
3585 [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest },
3586 [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip },
3587 /* anything missing from this table is in
3588 * the asender_tbl, see get_asender_cmd */
3589 [P_MAX_CMD] = { 0, 0, NULL },
3590};
3591
3592/* All handler functions that expect a sub-header get that sub-heder in
3593 mdev->data.rbuf.header.head.payload.
3594
3595 Usually in mdev->data.rbuf.header.head the callback can find the usual
3596 p_header, but they may not rely on that. Since there is also p_header95 !
3597 */
Philipp Reisnerb411b362009-09-25 16:07:19 -07003598
3599static void drbdd(struct drbd_conf *mdev)
3600{
Philipp Reisner02918be2010-08-20 14:35:10 +02003601 union p_header *header = &mdev->data.rbuf.header;
3602 unsigned int packet_size;
3603 enum drbd_packets cmd;
3604 size_t shs; /* sub header size */
3605 int rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003606
3607 while (get_t_state(&mdev->receiver) == Running) {
3608 drbd_thread_current_set_cpu(mdev);
Philipp Reisner02918be2010-08-20 14:35:10 +02003609 if (!drbd_recv_header(mdev, &cmd, &packet_size))
3610 goto err_out;
3611
3612 if (unlikely(cmd >= P_MAX_CMD || !drbd_cmd_handler[cmd].function)) {
3613 dev_err(DEV, "unknown packet type %d, l: %d!\n", cmd, packet_size);
3614 goto err_out;
Lars Ellenberg0b33a912009-11-16 15:58:04 +01003615 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003616
Philipp Reisner02918be2010-08-20 14:35:10 +02003617 shs = drbd_cmd_handler[cmd].pkt_size - sizeof(union p_header);
Philipp Reisner02918be2010-08-20 14:35:10 +02003618 if (packet_size - shs > 0 && !drbd_cmd_handler[cmd].expect_payload) {
3619 dev_err(DEV, "No payload expected %s l:%d\n", cmdname(cmd), packet_size);
3620 goto err_out;
3621 }
3622
Lars Ellenbergc13f7e12010-10-29 23:32:01 +02003623 if (shs) {
3624 rv = drbd_recv(mdev, &header->h80.payload, shs);
3625 if (unlikely(rv != shs)) {
3626 dev_err(DEV, "short read while reading sub header: rv=%d\n", rv);
3627 goto err_out;
3628 }
3629 }
3630
Philipp Reisner02918be2010-08-20 14:35:10 +02003631 rv = drbd_cmd_handler[cmd].function(mdev, cmd, packet_size - shs);
3632
3633 if (unlikely(!rv)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003634 dev_err(DEV, "error receiving %s, l: %d!\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02003635 cmdname(cmd), packet_size);
3636 goto err_out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003637 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003638 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003639
Philipp Reisner02918be2010-08-20 14:35:10 +02003640 if (0) {
3641 err_out:
3642 drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003643 }
Lars Ellenberg856c50c2010-10-14 13:37:40 +02003644 /* If we leave here, we probably want to update at least the
3645 * "Connected" indicator on stable storage. Do so explicitly here. */
3646 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003647}
3648
3649void drbd_flush_workqueue(struct drbd_conf *mdev)
3650{
3651 struct drbd_wq_barrier barr;
3652
3653 barr.w.cb = w_prev_work_done;
3654 init_completion(&barr.done);
3655 drbd_queue_work(&mdev->data.work, &barr.w);
3656 wait_for_completion(&barr.done);
3657}
3658
Philipp Reisnerf70b35112010-06-24 14:34:40 +02003659void drbd_free_tl_hash(struct drbd_conf *mdev)
3660{
3661 struct hlist_head *h;
3662
3663 spin_lock_irq(&mdev->req_lock);
3664
3665 if (!mdev->tl_hash || mdev->state.conn != C_STANDALONE) {
3666 spin_unlock_irq(&mdev->req_lock);
3667 return;
3668 }
3669 /* paranoia code */
3670 for (h = mdev->ee_hash; h < mdev->ee_hash + mdev->ee_hash_s; h++)
3671 if (h->first)
3672 dev_err(DEV, "ASSERT FAILED ee_hash[%u].first == %p, expected NULL\n",
3673 (int)(h - mdev->ee_hash), h->first);
3674 kfree(mdev->ee_hash);
3675 mdev->ee_hash = NULL;
3676 mdev->ee_hash_s = 0;
3677
3678 /* paranoia code */
3679 for (h = mdev->tl_hash; h < mdev->tl_hash + mdev->tl_hash_s; h++)
3680 if (h->first)
3681 dev_err(DEV, "ASSERT FAILED tl_hash[%u] == %p, expected NULL\n",
3682 (int)(h - mdev->tl_hash), h->first);
3683 kfree(mdev->tl_hash);
3684 mdev->tl_hash = NULL;
3685 mdev->tl_hash_s = 0;
3686 spin_unlock_irq(&mdev->req_lock);
3687}
3688
Philipp Reisnerb411b362009-09-25 16:07:19 -07003689static void drbd_disconnect(struct drbd_conf *mdev)
3690{
3691 enum drbd_fencing_p fp;
3692 union drbd_state os, ns;
3693 int rv = SS_UNKNOWN_ERROR;
3694 unsigned int i;
3695
3696 if (mdev->state.conn == C_STANDALONE)
3697 return;
3698 if (mdev->state.conn >= C_WF_CONNECTION)
3699 dev_err(DEV, "ASSERT FAILED cstate = %s, expected < WFConnection\n",
3700 drbd_conn_str(mdev->state.conn));
3701
3702 /* asender does not clean up anything. it must not interfere, either */
3703 drbd_thread_stop(&mdev->asender);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003704 drbd_free_sock(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003705
Philipp Reisner85719572010-07-21 10:20:17 +02003706 /* wait for current activity to cease. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07003707 spin_lock_irq(&mdev->req_lock);
3708 _drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
3709 _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee);
3710 _drbd_wait_ee_list_empty(mdev, &mdev->read_ee);
3711 spin_unlock_irq(&mdev->req_lock);
3712
3713 /* We do not have data structures that would allow us to
3714 * get the rs_pending_cnt down to 0 again.
3715 * * On C_SYNC_TARGET we do not have any data structures describing
3716 * the pending RSDataRequest's we have sent.
3717 * * On C_SYNC_SOURCE there is no data structure that tracks
3718 * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget.
3719 * And no, it is not the sum of the reference counts in the
3720 * resync_LRU. The resync_LRU tracks the whole operation including
3721 * the disk-IO, while the rs_pending_cnt only tracks the blocks
3722 * on the fly. */
3723 drbd_rs_cancel_all(mdev);
3724 mdev->rs_total = 0;
3725 mdev->rs_failed = 0;
3726 atomic_set(&mdev->rs_pending_cnt, 0);
3727 wake_up(&mdev->misc_wait);
3728
3729 /* make sure syncer is stopped and w_resume_next_sg queued */
3730 del_timer_sync(&mdev->resync_timer);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003731 resync_timer_fn((unsigned long)mdev);
3732
Philipp Reisnerb411b362009-09-25 16:07:19 -07003733 /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier,
3734 * w_make_resync_request etc. which may still be on the worker queue
3735 * to be "canceled" */
3736 drbd_flush_workqueue(mdev);
3737
3738 /* This also does reclaim_net_ee(). If we do this too early, we might
3739 * miss some resync ee and pages.*/
3740 drbd_process_done_ee(mdev);
3741
3742 kfree(mdev->p_uuid);
3743 mdev->p_uuid = NULL;
3744
Philipp Reisnerfb22c402010-09-08 23:20:21 +02003745 if (!is_susp(mdev->state))
Philipp Reisnerb411b362009-09-25 16:07:19 -07003746 tl_clear(mdev);
3747
Philipp Reisnerb411b362009-09-25 16:07:19 -07003748 dev_info(DEV, "Connection closed\n");
3749
3750 drbd_md_sync(mdev);
3751
3752 fp = FP_DONT_CARE;
3753 if (get_ldev(mdev)) {
3754 fp = mdev->ldev->dc.fencing;
3755 put_ldev(mdev);
3756 }
3757
Philipp Reisner87f7be42010-06-11 13:56:33 +02003758 if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN)
3759 drbd_try_outdate_peer_async(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003760
3761 spin_lock_irq(&mdev->req_lock);
3762 os = mdev->state;
3763 if (os.conn >= C_UNCONNECTED) {
3764 /* Do not restart in case we are C_DISCONNECTING */
3765 ns = os;
3766 ns.conn = C_UNCONNECTED;
3767 rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
3768 }
3769 spin_unlock_irq(&mdev->req_lock);
3770
3771 if (os.conn == C_DISCONNECTING) {
Philipp Reisner84dfb9f2010-06-23 11:20:05 +02003772 wait_event(mdev->net_cnt_wait, atomic_read(&mdev->net_cnt) == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003773
Philipp Reisnerfb22c402010-09-08 23:20:21 +02003774 if (!is_susp(mdev->state)) {
Philipp Reisnerf70b35112010-06-24 14:34:40 +02003775 /* we must not free the tl_hash
3776 * while application io is still on the fly */
3777 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
3778 drbd_free_tl_hash(mdev);
3779 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003780
3781 crypto_free_hash(mdev->cram_hmac_tfm);
3782 mdev->cram_hmac_tfm = NULL;
3783
3784 kfree(mdev->net_conf);
3785 mdev->net_conf = NULL;
3786 drbd_request_state(mdev, NS(conn, C_STANDALONE));
3787 }
3788
3789 /* tcp_close and release of sendpage pages can be deferred. I don't
3790 * want to use SO_LINGER, because apparently it can be deferred for
3791 * more than 20 seconds (longest time I checked).
3792 *
3793 * Actually we don't care for exactly when the network stack does its
3794 * put_page(), but release our reference on these pages right here.
3795 */
3796 i = drbd_release_ee(mdev, &mdev->net_ee);
3797 if (i)
3798 dev_info(DEV, "net_ee not empty, killed %u entries\n", i);
Lars Ellenberg435f0742010-09-06 12:30:25 +02003799 i = atomic_read(&mdev->pp_in_use_by_net);
3800 if (i)
3801 dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003802 i = atomic_read(&mdev->pp_in_use);
3803 if (i)
Lars Ellenberg45bb9122010-05-14 17:10:48 +02003804 dev_info(DEV, "pp_in_use = %d, expected 0\n", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003805
3806 D_ASSERT(list_empty(&mdev->read_ee));
3807 D_ASSERT(list_empty(&mdev->active_ee));
3808 D_ASSERT(list_empty(&mdev->sync_ee));
3809 D_ASSERT(list_empty(&mdev->done_ee));
3810
3811 /* ok, no more ee's on the fly, it is safe to reset the epoch_size */
3812 atomic_set(&mdev->current_epoch->epoch_size, 0);
3813 D_ASSERT(list_empty(&mdev->current_epoch->list));
3814}
3815
3816/*
3817 * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version
3818 * we can agree on is stored in agreed_pro_version.
3819 *
3820 * feature flags and the reserved array should be enough room for future
3821 * enhancements of the handshake protocol, and possible plugins...
3822 *
3823 * for now, they are expected to be zero, but ignored.
3824 */
3825static int drbd_send_handshake(struct drbd_conf *mdev)
3826{
3827 /* ASSERT current == mdev->receiver ... */
3828 struct p_handshake *p = &mdev->data.sbuf.handshake;
3829 int ok;
3830
3831 if (mutex_lock_interruptible(&mdev->data.mutex)) {
3832 dev_err(DEV, "interrupted during initial handshake\n");
3833 return 0; /* interrupted. not ok. */
3834 }
3835
3836 if (mdev->data.socket == NULL) {
3837 mutex_unlock(&mdev->data.mutex);
3838 return 0;
3839 }
3840
3841 memset(p, 0, sizeof(*p));
3842 p->protocol_min = cpu_to_be32(PRO_VERSION_MIN);
3843 p->protocol_max = cpu_to_be32(PRO_VERSION_MAX);
3844 ok = _drbd_send_cmd( mdev, mdev->data.socket, P_HAND_SHAKE,
Philipp Reisner0b70a132010-08-20 13:36:10 +02003845 (struct p_header80 *)p, sizeof(*p), 0 );
Philipp Reisnerb411b362009-09-25 16:07:19 -07003846 mutex_unlock(&mdev->data.mutex);
3847 return ok;
3848}
3849
3850/*
3851 * return values:
3852 * 1 yes, we have a valid connection
3853 * 0 oops, did not work out, please try again
3854 * -1 peer talks different language,
3855 * no point in trying again, please go standalone.
3856 */
3857static int drbd_do_handshake(struct drbd_conf *mdev)
3858{
3859 /* ASSERT current == mdev->receiver ... */
3860 struct p_handshake *p = &mdev->data.rbuf.handshake;
Philipp Reisner02918be2010-08-20 14:35:10 +02003861 const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80);
3862 unsigned int length;
3863 enum drbd_packets cmd;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003864 int rv;
3865
3866 rv = drbd_send_handshake(mdev);
3867 if (!rv)
3868 return 0;
3869
Philipp Reisner02918be2010-08-20 14:35:10 +02003870 rv = drbd_recv_header(mdev, &cmd, &length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003871 if (!rv)
3872 return 0;
3873
Philipp Reisner02918be2010-08-20 14:35:10 +02003874 if (cmd != P_HAND_SHAKE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003875 dev_err(DEV, "expected HandShake packet, received: %s (0x%04x)\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02003876 cmdname(cmd), cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003877 return -1;
3878 }
3879
Philipp Reisner02918be2010-08-20 14:35:10 +02003880 if (length != expect) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003881 dev_err(DEV, "expected HandShake length: %u, received: %u\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02003882 expect, length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003883 return -1;
3884 }
3885
3886 rv = drbd_recv(mdev, &p->head.payload, expect);
3887
3888 if (rv != expect) {
3889 dev_err(DEV, "short read receiving handshake packet: l=%u\n", rv);
3890 return 0;
3891 }
3892
Philipp Reisnerb411b362009-09-25 16:07:19 -07003893 p->protocol_min = be32_to_cpu(p->protocol_min);
3894 p->protocol_max = be32_to_cpu(p->protocol_max);
3895 if (p->protocol_max == 0)
3896 p->protocol_max = p->protocol_min;
3897
3898 if (PRO_VERSION_MAX < p->protocol_min ||
3899 PRO_VERSION_MIN > p->protocol_max)
3900 goto incompat;
3901
3902 mdev->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max);
3903
3904 dev_info(DEV, "Handshake successful: "
3905 "Agreed network protocol version %d\n", mdev->agreed_pro_version);
3906
3907 return 1;
3908
3909 incompat:
3910 dev_err(DEV, "incompatible DRBD dialects: "
3911 "I support %d-%d, peer supports %d-%d\n",
3912 PRO_VERSION_MIN, PRO_VERSION_MAX,
3913 p->protocol_min, p->protocol_max);
3914 return -1;
3915}
3916
3917#if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE)
3918static int drbd_do_auth(struct drbd_conf *mdev)
3919{
3920 dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n");
3921 dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01003922 return -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003923}
3924#else
3925#define CHALLENGE_LEN 64
Johannes Thomab10d96c2010-01-07 16:02:50 +01003926
3927/* Return value:
3928 1 - auth succeeded,
3929 0 - failed, try again (network error),
3930 -1 - auth failed, don't try again.
3931*/
3932
Philipp Reisnerb411b362009-09-25 16:07:19 -07003933static int drbd_do_auth(struct drbd_conf *mdev)
3934{
3935 char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */
3936 struct scatterlist sg;
3937 char *response = NULL;
3938 char *right_response = NULL;
3939 char *peers_ch = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003940 unsigned int key_len = strlen(mdev->net_conf->shared_secret);
3941 unsigned int resp_size;
3942 struct hash_desc desc;
Philipp Reisner02918be2010-08-20 14:35:10 +02003943 enum drbd_packets cmd;
3944 unsigned int length;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003945 int rv;
3946
3947 desc.tfm = mdev->cram_hmac_tfm;
3948 desc.flags = 0;
3949
3950 rv = crypto_hash_setkey(mdev->cram_hmac_tfm,
3951 (u8 *)mdev->net_conf->shared_secret, key_len);
3952 if (rv) {
3953 dev_err(DEV, "crypto_hash_setkey() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01003954 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003955 goto fail;
3956 }
3957
3958 get_random_bytes(my_challenge, CHALLENGE_LEN);
3959
3960 rv = drbd_send_cmd2(mdev, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN);
3961 if (!rv)
3962 goto fail;
3963
Philipp Reisner02918be2010-08-20 14:35:10 +02003964 rv = drbd_recv_header(mdev, &cmd, &length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003965 if (!rv)
3966 goto fail;
3967
Philipp Reisner02918be2010-08-20 14:35:10 +02003968 if (cmd != P_AUTH_CHALLENGE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003969 dev_err(DEV, "expected AuthChallenge packet, received: %s (0x%04x)\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02003970 cmdname(cmd), cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003971 rv = 0;
3972 goto fail;
3973 }
3974
Philipp Reisner02918be2010-08-20 14:35:10 +02003975 if (length > CHALLENGE_LEN * 2) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003976 dev_err(DEV, "expected AuthChallenge payload too big.\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01003977 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003978 goto fail;
3979 }
3980
Philipp Reisner02918be2010-08-20 14:35:10 +02003981 peers_ch = kmalloc(length, GFP_NOIO);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003982 if (peers_ch == NULL) {
3983 dev_err(DEV, "kmalloc of peers_ch failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01003984 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003985 goto fail;
3986 }
3987
Philipp Reisner02918be2010-08-20 14:35:10 +02003988 rv = drbd_recv(mdev, peers_ch, length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003989
Philipp Reisner02918be2010-08-20 14:35:10 +02003990 if (rv != length) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003991 dev_err(DEV, "short read AuthChallenge: l=%u\n", rv);
3992 rv = 0;
3993 goto fail;
3994 }
3995
3996 resp_size = crypto_hash_digestsize(mdev->cram_hmac_tfm);
3997 response = kmalloc(resp_size, GFP_NOIO);
3998 if (response == NULL) {
3999 dev_err(DEV, "kmalloc of response failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004000 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004001 goto fail;
4002 }
4003
4004 sg_init_table(&sg, 1);
Philipp Reisner02918be2010-08-20 14:35:10 +02004005 sg_set_buf(&sg, peers_ch, length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004006
4007 rv = crypto_hash_digest(&desc, &sg, sg.length, response);
4008 if (rv) {
4009 dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004010 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004011 goto fail;
4012 }
4013
4014 rv = drbd_send_cmd2(mdev, P_AUTH_RESPONSE, response, resp_size);
4015 if (!rv)
4016 goto fail;
4017
Philipp Reisner02918be2010-08-20 14:35:10 +02004018 rv = drbd_recv_header(mdev, &cmd, &length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004019 if (!rv)
4020 goto fail;
4021
Philipp Reisner02918be2010-08-20 14:35:10 +02004022 if (cmd != P_AUTH_RESPONSE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004023 dev_err(DEV, "expected AuthResponse packet, received: %s (0x%04x)\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02004024 cmdname(cmd), cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004025 rv = 0;
4026 goto fail;
4027 }
4028
Philipp Reisner02918be2010-08-20 14:35:10 +02004029 if (length != resp_size) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004030 dev_err(DEV, "expected AuthResponse payload of wrong size\n");
4031 rv = 0;
4032 goto fail;
4033 }
4034
4035 rv = drbd_recv(mdev, response , resp_size);
4036
4037 if (rv != resp_size) {
4038 dev_err(DEV, "short read receiving AuthResponse: l=%u\n", rv);
4039 rv = 0;
4040 goto fail;
4041 }
4042
4043 right_response = kmalloc(resp_size, GFP_NOIO);
Julia Lawall2d1ee872009-12-27 22:27:11 +01004044 if (right_response == NULL) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004045 dev_err(DEV, "kmalloc of right_response failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004046 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004047 goto fail;
4048 }
4049
4050 sg_set_buf(&sg, my_challenge, CHALLENGE_LEN);
4051
4052 rv = crypto_hash_digest(&desc, &sg, sg.length, right_response);
4053 if (rv) {
4054 dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004055 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004056 goto fail;
4057 }
4058
4059 rv = !memcmp(response, right_response, resp_size);
4060
4061 if (rv)
4062 dev_info(DEV, "Peer authenticated using %d bytes of '%s' HMAC\n",
4063 resp_size, mdev->net_conf->cram_hmac_alg);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004064 else
4065 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004066
4067 fail:
4068 kfree(peers_ch);
4069 kfree(response);
4070 kfree(right_response);
4071
4072 return rv;
4073}
4074#endif
4075
4076int drbdd_init(struct drbd_thread *thi)
4077{
4078 struct drbd_conf *mdev = thi->mdev;
4079 unsigned int minor = mdev_to_minor(mdev);
4080 int h;
4081
4082 sprintf(current->comm, "drbd%d_receiver", minor);
4083
4084 dev_info(DEV, "receiver (re)started\n");
4085
4086 do {
4087 h = drbd_connect(mdev);
4088 if (h == 0) {
4089 drbd_disconnect(mdev);
4090 __set_current_state(TASK_INTERRUPTIBLE);
4091 schedule_timeout(HZ);
4092 }
4093 if (h == -1) {
4094 dev_warn(DEV, "Discarding network configuration.\n");
4095 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
4096 }
4097 } while (h == 0);
4098
4099 if (h > 0) {
4100 if (get_net_conf(mdev)) {
4101 drbdd(mdev);
4102 put_net_conf(mdev);
4103 }
4104 }
4105
4106 drbd_disconnect(mdev);
4107
4108 dev_info(DEV, "receiver terminated\n");
4109 return 0;
4110}
4111
4112/* ********* acknowledge sender ******** */
4113
Philipp Reisner0b70a132010-08-20 13:36:10 +02004114static int got_RqSReply(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004115{
4116 struct p_req_state_reply *p = (struct p_req_state_reply *)h;
4117
4118 int retcode = be32_to_cpu(p->retcode);
4119
4120 if (retcode >= SS_SUCCESS) {
4121 set_bit(CL_ST_CHG_SUCCESS, &mdev->flags);
4122 } else {
4123 set_bit(CL_ST_CHG_FAIL, &mdev->flags);
4124 dev_err(DEV, "Requested state change failed by peer: %s (%d)\n",
4125 drbd_set_st_err_str(retcode), retcode);
4126 }
4127 wake_up(&mdev->state_wait);
4128
4129 return TRUE;
4130}
4131
Philipp Reisner0b70a132010-08-20 13:36:10 +02004132static int got_Ping(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004133{
4134 return drbd_send_ping_ack(mdev);
4135
4136}
4137
Philipp Reisner0b70a132010-08-20 13:36:10 +02004138static int got_PingAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004139{
4140 /* restore idle timeout */
4141 mdev->meta.socket->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ;
Philipp Reisner309d1602010-03-02 15:03:44 +01004142 if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags))
4143 wake_up(&mdev->misc_wait);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004144
4145 return TRUE;
4146}
4147
Philipp Reisner0b70a132010-08-20 13:36:10 +02004148static int got_IsInSync(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004149{
4150 struct p_block_ack *p = (struct p_block_ack *)h;
4151 sector_t sector = be64_to_cpu(p->sector);
4152 int blksize = be32_to_cpu(p->blksize);
4153
4154 D_ASSERT(mdev->agreed_pro_version >= 89);
4155
4156 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4157
Lars Ellenberg1d53f092010-09-05 01:13:24 +02004158 if (get_ldev(mdev)) {
4159 drbd_rs_complete_io(mdev, sector);
4160 drbd_set_in_sync(mdev, sector, blksize);
4161 /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */
4162 mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT);
4163 put_ldev(mdev);
4164 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004165 dec_rs_pending(mdev);
Philipp Reisner778f2712010-07-06 11:14:00 +02004166 atomic_add(blksize >> 9, &mdev->rs_sect_in);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004167
4168 return TRUE;
4169}
4170
4171/* when we receive the ACK for a write request,
4172 * verify that we actually know about it */
4173static struct drbd_request *_ack_id_to_req(struct drbd_conf *mdev,
4174 u64 id, sector_t sector)
4175{
4176 struct hlist_head *slot = tl_hash_slot(mdev, sector);
4177 struct hlist_node *n;
4178 struct drbd_request *req;
4179
4180 hlist_for_each_entry(req, n, slot, colision) {
4181 if ((unsigned long)req == (unsigned long)id) {
4182 if (req->sector != sector) {
4183 dev_err(DEV, "_ack_id_to_req: found req %p but it has "
4184 "wrong sector (%llus versus %llus)\n", req,
4185 (unsigned long long)req->sector,
4186 (unsigned long long)sector);
4187 break;
4188 }
4189 return req;
4190 }
4191 }
4192 dev_err(DEV, "_ack_id_to_req: failed to find req %p, sector %llus in list\n",
4193 (void *)(unsigned long)id, (unsigned long long)sector);
4194 return NULL;
4195}
4196
4197typedef struct drbd_request *(req_validator_fn)
4198 (struct drbd_conf *mdev, u64 id, sector_t sector);
4199
4200static int validate_req_change_req_state(struct drbd_conf *mdev,
4201 u64 id, sector_t sector, req_validator_fn validator,
4202 const char *func, enum drbd_req_event what)
4203{
4204 struct drbd_request *req;
4205 struct bio_and_error m;
4206
4207 spin_lock_irq(&mdev->req_lock);
4208 req = validator(mdev, id, sector);
4209 if (unlikely(!req)) {
4210 spin_unlock_irq(&mdev->req_lock);
4211 dev_err(DEV, "%s: got a corrupt block_id/sector pair\n", func);
4212 return FALSE;
4213 }
4214 __req_mod(req, what, &m);
4215 spin_unlock_irq(&mdev->req_lock);
4216
4217 if (m.bio)
4218 complete_master_bio(mdev, &m);
4219 return TRUE;
4220}
4221
Philipp Reisner0b70a132010-08-20 13:36:10 +02004222static int got_BlockAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004223{
4224 struct p_block_ack *p = (struct p_block_ack *)h;
4225 sector_t sector = be64_to_cpu(p->sector);
4226 int blksize = be32_to_cpu(p->blksize);
4227 enum drbd_req_event what;
4228
4229 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4230
4231 if (is_syncer_block_id(p->block_id)) {
4232 drbd_set_in_sync(mdev, sector, blksize);
4233 dec_rs_pending(mdev);
4234 return TRUE;
4235 }
4236 switch (be16_to_cpu(h->command)) {
4237 case P_RS_WRITE_ACK:
4238 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
4239 what = write_acked_by_peer_and_sis;
4240 break;
4241 case P_WRITE_ACK:
4242 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
4243 what = write_acked_by_peer;
4244 break;
4245 case P_RECV_ACK:
4246 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_B);
4247 what = recv_acked_by_peer;
4248 break;
4249 case P_DISCARD_ACK:
4250 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
4251 what = conflict_discarded_by_peer;
4252 break;
4253 default:
4254 D_ASSERT(0);
4255 return FALSE;
4256 }
4257
4258 return validate_req_change_req_state(mdev, p->block_id, sector,
4259 _ack_id_to_req, __func__ , what);
4260}
4261
Philipp Reisner0b70a132010-08-20 13:36:10 +02004262static int got_NegAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004263{
4264 struct p_block_ack *p = (struct p_block_ack *)h;
4265 sector_t sector = be64_to_cpu(p->sector);
4266
4267 if (__ratelimit(&drbd_ratelimit_state))
4268 dev_warn(DEV, "Got NegAck packet. Peer is in troubles?\n");
4269
4270 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4271
4272 if (is_syncer_block_id(p->block_id)) {
4273 int size = be32_to_cpu(p->blksize);
4274 dec_rs_pending(mdev);
4275 drbd_rs_failed_io(mdev, sector, size);
4276 return TRUE;
4277 }
4278 return validate_req_change_req_state(mdev, p->block_id, sector,
4279 _ack_id_to_req, __func__ , neg_acked);
4280}
4281
Philipp Reisner0b70a132010-08-20 13:36:10 +02004282static int got_NegDReply(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004283{
4284 struct p_block_ack *p = (struct p_block_ack *)h;
4285 sector_t sector = be64_to_cpu(p->sector);
4286
4287 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4288 dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n",
4289 (unsigned long long)sector, be32_to_cpu(p->blksize));
4290
4291 return validate_req_change_req_state(mdev, p->block_id, sector,
4292 _ar_id_to_req, __func__ , neg_acked);
4293}
4294
Philipp Reisner0b70a132010-08-20 13:36:10 +02004295static int got_NegRSDReply(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004296{
4297 sector_t sector;
4298 int size;
4299 struct p_block_ack *p = (struct p_block_ack *)h;
4300
4301 sector = be64_to_cpu(p->sector);
4302 size = be32_to_cpu(p->blksize);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004303
4304 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4305
4306 dec_rs_pending(mdev);
4307
4308 if (get_ldev_if_state(mdev, D_FAILED)) {
4309 drbd_rs_complete_io(mdev, sector);
4310 drbd_rs_failed_io(mdev, sector, size);
4311 put_ldev(mdev);
4312 }
4313
4314 return TRUE;
4315}
4316
Philipp Reisner0b70a132010-08-20 13:36:10 +02004317static int got_BarrierAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004318{
4319 struct p_barrier_ack *p = (struct p_barrier_ack *)h;
4320
4321 tl_release(mdev, p->barrier, be32_to_cpu(p->set_size));
4322
4323 return TRUE;
4324}
4325
Philipp Reisner0b70a132010-08-20 13:36:10 +02004326static int got_OVResult(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004327{
4328 struct p_block_ack *p = (struct p_block_ack *)h;
4329 struct drbd_work *w;
4330 sector_t sector;
4331 int size;
4332
4333 sector = be64_to_cpu(p->sector);
4334 size = be32_to_cpu(p->blksize);
4335
4336 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4337
4338 if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC)
4339 drbd_ov_oos_found(mdev, sector, size);
4340 else
4341 ov_oos_print(mdev);
4342
Lars Ellenberg1d53f092010-09-05 01:13:24 +02004343 if (!get_ldev(mdev))
4344 return TRUE;
4345
Philipp Reisnerb411b362009-09-25 16:07:19 -07004346 drbd_rs_complete_io(mdev, sector);
4347 dec_rs_pending(mdev);
4348
Lars Ellenbergea5442a2010-11-05 09:48:01 +01004349 --mdev->ov_left;
4350
4351 /* let's advance progress step marks only for every other megabyte */
4352 if ((mdev->ov_left & 0x200) == 0x200)
4353 drbd_advance_rs_marks(mdev, mdev->ov_left);
4354
4355 if (mdev->ov_left == 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004356 w = kmalloc(sizeof(*w), GFP_NOIO);
4357 if (w) {
4358 w->cb = w_ov_finished;
4359 drbd_queue_work_front(&mdev->data.work, w);
4360 } else {
4361 dev_err(DEV, "kmalloc(w) failed.");
4362 ov_oos_print(mdev);
4363 drbd_resync_finished(mdev);
4364 }
4365 }
Lars Ellenberg1d53f092010-09-05 01:13:24 +02004366 put_ldev(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004367 return TRUE;
4368}
4369
Philipp Reisner02918be2010-08-20 14:35:10 +02004370static int got_skip(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisner0ced55a2010-04-30 15:26:20 +02004371{
Philipp Reisner0ced55a2010-04-30 15:26:20 +02004372 return TRUE;
4373}
4374
Philipp Reisnerb411b362009-09-25 16:07:19 -07004375struct asender_cmd {
4376 size_t pkt_size;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004377 int (*process)(struct drbd_conf *mdev, struct p_header80 *h);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004378};
4379
4380static struct asender_cmd *get_asender_cmd(int cmd)
4381{
4382 static struct asender_cmd asender_tbl[] = {
4383 /* anything missing from this table is in
4384 * the drbd_cmd_handler (drbd_default_handler) table,
4385 * see the beginning of drbdd() */
Philipp Reisner0b70a132010-08-20 13:36:10 +02004386 [P_PING] = { sizeof(struct p_header80), got_Ping },
4387 [P_PING_ACK] = { sizeof(struct p_header80), got_PingAck },
Philipp Reisnerb411b362009-09-25 16:07:19 -07004388 [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4389 [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4390 [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4391 [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4392 [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck },
4393 [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply },
4394 [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply},
4395 [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult },
4396 [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck },
4397 [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply },
4398 [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync },
Philipp Reisner02918be2010-08-20 14:35:10 +02004399 [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip },
Philipp Reisnerb411b362009-09-25 16:07:19 -07004400 [P_MAX_CMD] = { 0, NULL },
4401 };
4402 if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL)
4403 return NULL;
4404 return &asender_tbl[cmd];
4405}
4406
4407int drbd_asender(struct drbd_thread *thi)
4408{
4409 struct drbd_conf *mdev = thi->mdev;
Philipp Reisner02918be2010-08-20 14:35:10 +02004410 struct p_header80 *h = &mdev->meta.rbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004411 struct asender_cmd *cmd = NULL;
4412
4413 int rv, len;
4414 void *buf = h;
4415 int received = 0;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004416 int expect = sizeof(struct p_header80);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004417 int empty;
4418
4419 sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev));
4420
4421 current->policy = SCHED_RR; /* Make this a realtime task! */
4422 current->rt_priority = 2; /* more important than all other tasks */
4423
4424 while (get_t_state(thi) == Running) {
4425 drbd_thread_current_set_cpu(mdev);
4426 if (test_and_clear_bit(SEND_PING, &mdev->flags)) {
4427 ERR_IF(!drbd_send_ping(mdev)) goto reconnect;
4428 mdev->meta.socket->sk->sk_rcvtimeo =
4429 mdev->net_conf->ping_timeo*HZ/10;
4430 }
4431
4432 /* conditionally cork;
4433 * it may hurt latency if we cork without much to send */
4434 if (!mdev->net_conf->no_cork &&
4435 3 < atomic_read(&mdev->unacked_cnt))
4436 drbd_tcp_cork(mdev->meta.socket);
4437 while (1) {
4438 clear_bit(SIGNAL_ASENDER, &mdev->flags);
4439 flush_signals(current);
Lars Ellenberg0f8488e2010-10-13 18:19:23 +02004440 if (!drbd_process_done_ee(mdev))
Philipp Reisnerb411b362009-09-25 16:07:19 -07004441 goto reconnect;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004442 /* to avoid race with newly queued ACKs */
4443 set_bit(SIGNAL_ASENDER, &mdev->flags);
4444 spin_lock_irq(&mdev->req_lock);
4445 empty = list_empty(&mdev->done_ee);
4446 spin_unlock_irq(&mdev->req_lock);
4447 /* new ack may have been queued right here,
4448 * but then there is also a signal pending,
4449 * and we start over... */
4450 if (empty)
4451 break;
4452 }
4453 /* but unconditionally uncork unless disabled */
4454 if (!mdev->net_conf->no_cork)
4455 drbd_tcp_uncork(mdev->meta.socket);
4456
4457 /* short circuit, recv_msg would return EINTR anyways. */
4458 if (signal_pending(current))
4459 continue;
4460
4461 rv = drbd_recv_short(mdev, mdev->meta.socket,
4462 buf, expect-received, 0);
4463 clear_bit(SIGNAL_ASENDER, &mdev->flags);
4464
4465 flush_signals(current);
4466
4467 /* Note:
4468 * -EINTR (on meta) we got a signal
4469 * -EAGAIN (on meta) rcvtimeo expired
4470 * -ECONNRESET other side closed the connection
4471 * -ERESTARTSYS (on data) we got a signal
4472 * rv < 0 other than above: unexpected error!
4473 * rv == expected: full header or command
4474 * rv < expected: "woken" by signal during receive
4475 * rv == 0 : "connection shut down by peer"
4476 */
4477 if (likely(rv > 0)) {
4478 received += rv;
4479 buf += rv;
4480 } else if (rv == 0) {
4481 dev_err(DEV, "meta connection shut down by peer.\n");
4482 goto reconnect;
4483 } else if (rv == -EAGAIN) {
4484 if (mdev->meta.socket->sk->sk_rcvtimeo ==
4485 mdev->net_conf->ping_timeo*HZ/10) {
4486 dev_err(DEV, "PingAck did not arrive in time.\n");
4487 goto reconnect;
4488 }
4489 set_bit(SEND_PING, &mdev->flags);
4490 continue;
4491 } else if (rv == -EINTR) {
4492 continue;
4493 } else {
4494 dev_err(DEV, "sock_recvmsg returned %d\n", rv);
4495 goto reconnect;
4496 }
4497
4498 if (received == expect && cmd == NULL) {
4499 if (unlikely(h->magic != BE_DRBD_MAGIC)) {
Lars Ellenberg004352f2010-10-05 20:13:58 +02004500 dev_err(DEV, "magic?? on meta m: 0x%08x c: %d l: %d\n",
4501 be32_to_cpu(h->magic),
4502 be16_to_cpu(h->command),
4503 be16_to_cpu(h->length));
Philipp Reisnerb411b362009-09-25 16:07:19 -07004504 goto reconnect;
4505 }
4506 cmd = get_asender_cmd(be16_to_cpu(h->command));
4507 len = be16_to_cpu(h->length);
4508 if (unlikely(cmd == NULL)) {
Lars Ellenberg004352f2010-10-05 20:13:58 +02004509 dev_err(DEV, "unknown command?? on meta m: 0x%08x c: %d l: %d\n",
4510 be32_to_cpu(h->magic),
4511 be16_to_cpu(h->command),
4512 be16_to_cpu(h->length));
Philipp Reisnerb411b362009-09-25 16:07:19 -07004513 goto disconnect;
4514 }
4515 expect = cmd->pkt_size;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004516 ERR_IF(len != expect-sizeof(struct p_header80))
Philipp Reisnerb411b362009-09-25 16:07:19 -07004517 goto reconnect;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004518 }
4519 if (received == expect) {
4520 D_ASSERT(cmd != NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004521 if (!cmd->process(mdev, h))
4522 goto reconnect;
4523
4524 buf = h;
4525 received = 0;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004526 expect = sizeof(struct p_header80);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004527 cmd = NULL;
4528 }
4529 }
4530
4531 if (0) {
4532reconnect:
4533 drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE));
Lars Ellenberg856c50c2010-10-14 13:37:40 +02004534 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004535 }
4536 if (0) {
4537disconnect:
4538 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
Lars Ellenberg856c50c2010-10-14 13:37:40 +02004539 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004540 }
4541 clear_bit(SIGNAL_ASENDER, &mdev->flags);
4542
4543 D_ASSERT(mdev->state.conn < C_CONNECTED);
4544 dev_info(DEV, "asender terminated\n");
4545
4546 return 0;
4547}