blob: 2c3edf0ac5ca5d93ee3634d5e7ebc7a289202977 [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>
39#include <linux/smp_lock.h>
40#include <linux/pkt_sched.h>
41#define __KERNEL_SYSCALLS__
42#include <linux/unistd.h>
43#include <linux/vmalloc.h>
44#include <linux/random.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070045#include <linux/string.h>
46#include <linux/scatterlist.h>
47#include "drbd_int.h"
Philipp Reisnerb411b362009-09-25 16:07:19 -070048#include "drbd_req.h"
49
50#include "drbd_vli.h"
51
52struct flush_work {
53 struct drbd_work w;
54 struct drbd_epoch *epoch;
55};
56
57enum finish_epoch {
58 FE_STILL_LIVE,
59 FE_DESTROYED,
60 FE_RECYCLED,
61};
62
63static int drbd_do_handshake(struct drbd_conf *mdev);
64static int drbd_do_auth(struct drbd_conf *mdev);
65
66static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event);
67static int e_end_block(struct drbd_conf *, struct drbd_work *, int);
68
69static struct drbd_epoch *previous_epoch(struct drbd_conf *mdev, struct drbd_epoch *epoch)
70{
71 struct drbd_epoch *prev;
72 spin_lock(&mdev->epoch_lock);
73 prev = list_entry(epoch->list.prev, struct drbd_epoch, list);
74 if (prev == epoch || prev == mdev->current_epoch)
75 prev = NULL;
76 spin_unlock(&mdev->epoch_lock);
77 return prev;
78}
79
80#define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN)
81
Lars Ellenberg45bb9122010-05-14 17:10:48 +020082/*
83 * some helper functions to deal with single linked page lists,
84 * page->private being our "next" pointer.
85 */
86
87/* If at least n pages are linked at head, get n pages off.
88 * Otherwise, don't modify head, and return NULL.
89 * Locking is the responsibility of the caller.
90 */
91static struct page *page_chain_del(struct page **head, int n)
92{
93 struct page *page;
94 struct page *tmp;
95
96 BUG_ON(!n);
97 BUG_ON(!head);
98
99 page = *head;
Philipp Reisner23ce4222010-05-20 13:35:31 +0200100
101 if (!page)
102 return NULL;
103
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200104 while (page) {
105 tmp = page_chain_next(page);
106 if (--n == 0)
107 break; /* found sufficient pages */
108 if (tmp == NULL)
109 /* insufficient pages, don't use any of them. */
110 return NULL;
111 page = tmp;
112 }
113
114 /* add end of list marker for the returned list */
115 set_page_private(page, 0);
116 /* actual return value, and adjustment of head */
117 page = *head;
118 *head = tmp;
119 return page;
120}
121
122/* may be used outside of locks to find the tail of a (usually short)
123 * "private" page chain, before adding it back to a global chain head
124 * with page_chain_add() under a spinlock. */
125static struct page *page_chain_tail(struct page *page, int *len)
126{
127 struct page *tmp;
128 int i = 1;
129 while ((tmp = page_chain_next(page)))
130 ++i, page = tmp;
131 if (len)
132 *len = i;
133 return page;
134}
135
136static int page_chain_free(struct page *page)
137{
138 struct page *tmp;
139 int i = 0;
140 page_chain_for_each_safe(page, tmp) {
141 put_page(page);
142 ++i;
143 }
144 return i;
145}
146
147static void page_chain_add(struct page **head,
148 struct page *chain_first, struct page *chain_last)
149{
150#if 1
151 struct page *tmp;
152 tmp = page_chain_tail(chain_first, NULL);
153 BUG_ON(tmp != chain_last);
154#endif
155
156 /* add chain to head */
157 set_page_private(chain_last, (unsigned long)*head);
158 *head = chain_first;
159}
160
161static struct page *drbd_pp_first_pages_or_try_alloc(struct drbd_conf *mdev, int number)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700162{
163 struct page *page = NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200164 struct page *tmp = NULL;
165 int i = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700166
167 /* Yes, testing drbd_pp_vacant outside the lock is racy.
168 * So what. It saves a spin_lock. */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200169 if (drbd_pp_vacant >= number) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700170 spin_lock(&drbd_pp_lock);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200171 page = page_chain_del(&drbd_pp_pool, number);
172 if (page)
173 drbd_pp_vacant -= number;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700174 spin_unlock(&drbd_pp_lock);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200175 if (page)
176 return page;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700177 }
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200178
Philipp Reisnerb411b362009-09-25 16:07:19 -0700179 /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD
180 * "criss-cross" setup, that might cause write-out on some other DRBD,
181 * which in turn might block on the other node at this very place. */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200182 for (i = 0; i < number; i++) {
183 tmp = alloc_page(GFP_TRY);
184 if (!tmp)
185 break;
186 set_page_private(tmp, (unsigned long)page);
187 page = tmp;
188 }
189
190 if (i == number)
191 return page;
192
193 /* Not enough pages immediately available this time.
194 * No need to jump around here, drbd_pp_alloc will retry this
195 * function "soon". */
196 if (page) {
197 tmp = page_chain_tail(page, NULL);
198 spin_lock(&drbd_pp_lock);
199 page_chain_add(&drbd_pp_pool, page, tmp);
200 drbd_pp_vacant += i;
201 spin_unlock(&drbd_pp_lock);
202 }
203 return NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700204}
205
206/* kick lower level device, if we have more than (arbitrary number)
207 * reference counts on it, which typically are locally submitted io
208 * requests. don't use unacked_cnt, so we speed up proto A and B, too. */
209static void maybe_kick_lo(struct drbd_conf *mdev)
210{
211 if (atomic_read(&mdev->local_cnt) >= mdev->net_conf->unplug_watermark)
212 drbd_kick_lo(mdev);
213}
214
215static void reclaim_net_ee(struct drbd_conf *mdev, struct list_head *to_be_freed)
216{
217 struct drbd_epoch_entry *e;
218 struct list_head *le, *tle;
219
220 /* The EEs are always appended to the end of the list. Since
221 they are sent in order over the wire, they have to finish
222 in order. As soon as we see the first not finished we can
223 stop to examine the list... */
224
225 list_for_each_safe(le, tle, &mdev->net_ee) {
226 e = list_entry(le, struct drbd_epoch_entry, w.list);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200227 if (drbd_ee_has_active_page(e))
Philipp Reisnerb411b362009-09-25 16:07:19 -0700228 break;
229 list_move(le, to_be_freed);
230 }
231}
232
233static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev)
234{
235 LIST_HEAD(reclaimed);
236 struct drbd_epoch_entry *e, *t;
237
238 maybe_kick_lo(mdev);
239 spin_lock_irq(&mdev->req_lock);
240 reclaim_net_ee(mdev, &reclaimed);
241 spin_unlock_irq(&mdev->req_lock);
242
243 list_for_each_entry_safe(e, t, &reclaimed, w.list)
Lars Ellenberg435f0742010-09-06 12:30:25 +0200244 drbd_free_net_ee(mdev, e);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700245}
246
247/**
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200248 * drbd_pp_alloc() - Returns @number pages, retries forever (or until signalled)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700249 * @mdev: DRBD device.
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200250 * @number: number of pages requested
251 * @retry: whether to retry, if not enough pages are available right now
Philipp Reisnerb411b362009-09-25 16:07:19 -0700252 *
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200253 * Tries to allocate number pages, first from our own page pool, then from
254 * the kernel, unless this allocation would exceed the max_buffers setting.
255 * Possibly retry until DRBD frees sufficient pages somewhere else.
256 *
257 * Returns a page chain linked via page->private.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700258 */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200259static struct page *drbd_pp_alloc(struct drbd_conf *mdev, unsigned number, bool retry)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700260{
261 struct page *page = NULL;
262 DEFINE_WAIT(wait);
263
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200264 /* Yes, we may run up to @number over max_buffers. If we
265 * follow it strictly, the admin will get it wrong anyways. */
266 if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers)
267 page = drbd_pp_first_pages_or_try_alloc(mdev, number);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700268
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200269 while (page == NULL) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700270 prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE);
271
272 drbd_kick_lo_and_reclaim_net(mdev);
273
274 if (atomic_read(&mdev->pp_in_use) < mdev->net_conf->max_buffers) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200275 page = drbd_pp_first_pages_or_try_alloc(mdev, number);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700276 if (page)
277 break;
278 }
279
280 if (!retry)
281 break;
282
283 if (signal_pending(current)) {
284 dev_warn(DEV, "drbd_pp_alloc interrupted!\n");
285 break;
286 }
287
288 schedule();
289 }
290 finish_wait(&drbd_pp_wait, &wait);
291
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200292 if (page)
293 atomic_add(number, &mdev->pp_in_use);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700294 return page;
295}
296
297/* Must not be used from irq, as that may deadlock: see drbd_pp_alloc.
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200298 * Is also used from inside an other spin_lock_irq(&mdev->req_lock);
299 * Either links the page chain back to the global pool,
300 * or returns all pages to the system. */
Lars Ellenberg435f0742010-09-06 12:30:25 +0200301static void drbd_pp_free(struct drbd_conf *mdev, struct page *page, int is_net)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700302{
Lars Ellenberg435f0742010-09-06 12:30:25 +0200303 atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700304 int i;
Lars Ellenberg435f0742010-09-06 12:30:25 +0200305
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200306 if (drbd_pp_vacant > (DRBD_MAX_SEGMENT_SIZE/PAGE_SIZE)*minor_count)
307 i = page_chain_free(page);
308 else {
309 struct page *tmp;
310 tmp = page_chain_tail(page, &i);
311 spin_lock(&drbd_pp_lock);
312 page_chain_add(&drbd_pp_pool, page, tmp);
313 drbd_pp_vacant += i;
314 spin_unlock(&drbd_pp_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700315 }
Lars Ellenberg435f0742010-09-06 12:30:25 +0200316 i = atomic_sub_return(i, a);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200317 if (i < 0)
Lars Ellenberg435f0742010-09-06 12:30:25 +0200318 dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n",
319 is_net ? "pp_in_use_by_net" : "pp_in_use", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700320 wake_up(&drbd_pp_wait);
321}
322
323/*
324You need to hold the req_lock:
325 _drbd_wait_ee_list_empty()
326
327You must not have the req_lock:
328 drbd_free_ee()
329 drbd_alloc_ee()
330 drbd_init_ee()
331 drbd_release_ee()
332 drbd_ee_fix_bhs()
333 drbd_process_done_ee()
334 drbd_clear_done_ee()
335 drbd_wait_ee_list_empty()
336*/
337
338struct drbd_epoch_entry *drbd_alloc_ee(struct drbd_conf *mdev,
339 u64 id,
340 sector_t sector,
341 unsigned int data_size,
342 gfp_t gfp_mask) __must_hold(local)
343{
Philipp Reisnerb411b362009-09-25 16:07:19 -0700344 struct drbd_epoch_entry *e;
345 struct page *page;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200346 unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700347
348 if (FAULT_ACTIVE(mdev, DRBD_FAULT_AL_EE))
349 return NULL;
350
351 e = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM);
352 if (!e) {
353 if (!(gfp_mask & __GFP_NOWARN))
354 dev_err(DEV, "alloc_ee: Allocation of an EE failed\n");
355 return NULL;
356 }
357
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200358 page = drbd_pp_alloc(mdev, nr_pages, (gfp_mask & __GFP_WAIT));
359 if (!page)
360 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700361
Philipp Reisnerb411b362009-09-25 16:07:19 -0700362 INIT_HLIST_NODE(&e->colision);
363 e->epoch = NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200364 e->mdev = mdev;
365 e->pages = page;
366 atomic_set(&e->pending_bios, 0);
367 e->size = data_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700368 e->flags = 0;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200369 e->sector = sector;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200370 e->block_id = id;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700371
Philipp Reisnerb411b362009-09-25 16:07:19 -0700372 return e;
373
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200374 fail:
Philipp Reisnerb411b362009-09-25 16:07:19 -0700375 mempool_free(e, drbd_ee_mempool);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700376 return NULL;
377}
378
Lars Ellenberg435f0742010-09-06 12:30:25 +0200379void drbd_free_some_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, int is_net)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700380{
Lars Ellenbergc36c3ce2010-08-11 20:42:55 +0200381 if (e->flags & EE_HAS_DIGEST)
382 kfree(e->digest);
Lars Ellenberg435f0742010-09-06 12:30:25 +0200383 drbd_pp_free(mdev, e->pages, is_net);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200384 D_ASSERT(atomic_read(&e->pending_bios) == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700385 D_ASSERT(hlist_unhashed(&e->colision));
386 mempool_free(e, drbd_ee_mempool);
387}
388
389int drbd_release_ee(struct drbd_conf *mdev, struct list_head *list)
390{
391 LIST_HEAD(work_list);
392 struct drbd_epoch_entry *e, *t;
393 int count = 0;
Lars Ellenberg435f0742010-09-06 12:30:25 +0200394 int is_net = list == &mdev->net_ee;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700395
396 spin_lock_irq(&mdev->req_lock);
397 list_splice_init(list, &work_list);
398 spin_unlock_irq(&mdev->req_lock);
399
400 list_for_each_entry_safe(e, t, &work_list, w.list) {
Lars Ellenberg435f0742010-09-06 12:30:25 +0200401 drbd_free_some_ee(mdev, e, is_net);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700402 count++;
403 }
404 return count;
405}
406
407
408/*
409 * This function is called from _asender only_
410 * but see also comments in _req_mod(,barrier_acked)
411 * and receive_Barrier.
412 *
413 * Move entries from net_ee to done_ee, if ready.
414 * Grab done_ee, call all callbacks, free the entries.
415 * The callbacks typically send out ACKs.
416 */
417static int drbd_process_done_ee(struct drbd_conf *mdev)
418{
419 LIST_HEAD(work_list);
420 LIST_HEAD(reclaimed);
421 struct drbd_epoch_entry *e, *t;
422 int ok = (mdev->state.conn >= C_WF_REPORT_PARAMS);
423
424 spin_lock_irq(&mdev->req_lock);
425 reclaim_net_ee(mdev, &reclaimed);
426 list_splice_init(&mdev->done_ee, &work_list);
427 spin_unlock_irq(&mdev->req_lock);
428
429 list_for_each_entry_safe(e, t, &reclaimed, w.list)
Lars Ellenberg435f0742010-09-06 12:30:25 +0200430 drbd_free_net_ee(mdev, e);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700431
432 /* possible callbacks here:
433 * e_end_block, and e_end_resync_block, e_send_discard_ack.
434 * all ignore the last argument.
435 */
436 list_for_each_entry_safe(e, t, &work_list, w.list) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700437 /* list_del not necessary, next/prev members not touched */
438 ok = e->w.cb(mdev, &e->w, !ok) && ok;
439 drbd_free_ee(mdev, e);
440 }
441 wake_up(&mdev->ee_wait);
442
443 return ok;
444}
445
446void _drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
447{
448 DEFINE_WAIT(wait);
449
450 /* avoids spin_lock/unlock
451 * and calling prepare_to_wait in the fast path */
452 while (!list_empty(head)) {
453 prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE);
454 spin_unlock_irq(&mdev->req_lock);
455 drbd_kick_lo(mdev);
456 schedule();
457 finish_wait(&mdev->ee_wait, &wait);
458 spin_lock_irq(&mdev->req_lock);
459 }
460}
461
462void drbd_wait_ee_list_empty(struct drbd_conf *mdev, struct list_head *head)
463{
464 spin_lock_irq(&mdev->req_lock);
465 _drbd_wait_ee_list_empty(mdev, head);
466 spin_unlock_irq(&mdev->req_lock);
467}
468
469/* see also kernel_accept; which is only present since 2.6.18.
470 * also we want to log which part of it failed, exactly */
471static int drbd_accept(struct drbd_conf *mdev, const char **what,
472 struct socket *sock, struct socket **newsock)
473{
474 struct sock *sk = sock->sk;
475 int err = 0;
476
477 *what = "listen";
478 err = sock->ops->listen(sock, 5);
479 if (err < 0)
480 goto out;
481
482 *what = "sock_create_lite";
483 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
484 newsock);
485 if (err < 0)
486 goto out;
487
488 *what = "accept";
489 err = sock->ops->accept(sock, *newsock, 0);
490 if (err < 0) {
491 sock_release(*newsock);
492 *newsock = NULL;
493 goto out;
494 }
495 (*newsock)->ops = sock->ops;
496
497out:
498 return err;
499}
500
501static int drbd_recv_short(struct drbd_conf *mdev, struct socket *sock,
502 void *buf, size_t size, int flags)
503{
504 mm_segment_t oldfs;
505 struct kvec iov = {
506 .iov_base = buf,
507 .iov_len = size,
508 };
509 struct msghdr msg = {
510 .msg_iovlen = 1,
511 .msg_iov = (struct iovec *)&iov,
512 .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL)
513 };
514 int rv;
515
516 oldfs = get_fs();
517 set_fs(KERNEL_DS);
518 rv = sock_recvmsg(sock, &msg, size, msg.msg_flags);
519 set_fs(oldfs);
520
521 return rv;
522}
523
524static int drbd_recv(struct drbd_conf *mdev, void *buf, size_t size)
525{
526 mm_segment_t oldfs;
527 struct kvec iov = {
528 .iov_base = buf,
529 .iov_len = size,
530 };
531 struct msghdr msg = {
532 .msg_iovlen = 1,
533 .msg_iov = (struct iovec *)&iov,
534 .msg_flags = MSG_WAITALL | MSG_NOSIGNAL
535 };
536 int rv;
537
538 oldfs = get_fs();
539 set_fs(KERNEL_DS);
540
541 for (;;) {
542 rv = sock_recvmsg(mdev->data.socket, &msg, size, msg.msg_flags);
543 if (rv == size)
544 break;
545
546 /* Note:
547 * ECONNRESET other side closed the connection
548 * ERESTARTSYS (on sock) we got a signal
549 */
550
551 if (rv < 0) {
552 if (rv == -ECONNRESET)
553 dev_info(DEV, "sock was reset by peer\n");
554 else if (rv != -ERESTARTSYS)
555 dev_err(DEV, "sock_recvmsg returned %d\n", rv);
556 break;
557 } else if (rv == 0) {
558 dev_info(DEV, "sock was shut down by peer\n");
559 break;
560 } else {
561 /* signal came in, or peer/link went down,
562 * after we read a partial message
563 */
564 /* D_ASSERT(signal_pending(current)); */
565 break;
566 }
567 };
568
569 set_fs(oldfs);
570
571 if (rv != size)
572 drbd_force_state(mdev, NS(conn, C_BROKEN_PIPE));
573
574 return rv;
575}
576
Lars Ellenberg5dbf1672010-05-25 16:18:01 +0200577/* quoting tcp(7):
578 * On individual connections, the socket buffer size must be set prior to the
579 * listen(2) or connect(2) calls in order to have it take effect.
580 * This is our wrapper to do so.
581 */
582static void drbd_setbufsize(struct socket *sock, unsigned int snd,
583 unsigned int rcv)
584{
585 /* open coded SO_SNDBUF, SO_RCVBUF */
586 if (snd) {
587 sock->sk->sk_sndbuf = snd;
588 sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
589 }
590 if (rcv) {
591 sock->sk->sk_rcvbuf = rcv;
592 sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
593 }
594}
595
Philipp Reisnerb411b362009-09-25 16:07:19 -0700596static struct socket *drbd_try_connect(struct drbd_conf *mdev)
597{
598 const char *what;
599 struct socket *sock;
600 struct sockaddr_in6 src_in6;
601 int err;
602 int disconnect_on_error = 1;
603
604 if (!get_net_conf(mdev))
605 return NULL;
606
607 what = "sock_create_kern";
608 err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family,
609 SOCK_STREAM, IPPROTO_TCP, &sock);
610 if (err < 0) {
611 sock = NULL;
612 goto out;
613 }
614
615 sock->sk->sk_rcvtimeo =
616 sock->sk->sk_sndtimeo = mdev->net_conf->try_connect_int*HZ;
Lars Ellenberg5dbf1672010-05-25 16:18:01 +0200617 drbd_setbufsize(sock, mdev->net_conf->sndbuf_size,
618 mdev->net_conf->rcvbuf_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700619
620 /* explicitly bind to the configured IP as source IP
621 * for the outgoing connections.
622 * This is needed for multihomed hosts and to be
623 * able to use lo: interfaces for drbd.
624 * Make sure to use 0 as port number, so linux selects
625 * a free one dynamically.
626 */
627 memcpy(&src_in6, mdev->net_conf->my_addr,
628 min_t(int, mdev->net_conf->my_addr_len, sizeof(src_in6)));
629 if (((struct sockaddr *)mdev->net_conf->my_addr)->sa_family == AF_INET6)
630 src_in6.sin6_port = 0;
631 else
632 ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */
633
634 what = "bind before connect";
635 err = sock->ops->bind(sock,
636 (struct sockaddr *) &src_in6,
637 mdev->net_conf->my_addr_len);
638 if (err < 0)
639 goto out;
640
641 /* connect may fail, peer not yet available.
642 * stay C_WF_CONNECTION, don't go Disconnecting! */
643 disconnect_on_error = 0;
644 what = "connect";
645 err = sock->ops->connect(sock,
646 (struct sockaddr *)mdev->net_conf->peer_addr,
647 mdev->net_conf->peer_addr_len, 0);
648
649out:
650 if (err < 0) {
651 if (sock) {
652 sock_release(sock);
653 sock = NULL;
654 }
655 switch (-err) {
656 /* timeout, busy, signal pending */
657 case ETIMEDOUT: case EAGAIN: case EINPROGRESS:
658 case EINTR: case ERESTARTSYS:
659 /* peer not (yet) available, network problem */
660 case ECONNREFUSED: case ENETUNREACH:
661 case EHOSTDOWN: case EHOSTUNREACH:
662 disconnect_on_error = 0;
663 break;
664 default:
665 dev_err(DEV, "%s failed, err = %d\n", what, err);
666 }
667 if (disconnect_on_error)
668 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
669 }
670 put_net_conf(mdev);
671 return sock;
672}
673
674static struct socket *drbd_wait_for_connect(struct drbd_conf *mdev)
675{
676 int timeo, err;
677 struct socket *s_estab = NULL, *s_listen;
678 const char *what;
679
680 if (!get_net_conf(mdev))
681 return NULL;
682
683 what = "sock_create_kern";
684 err = sock_create_kern(((struct sockaddr *)mdev->net_conf->my_addr)->sa_family,
685 SOCK_STREAM, IPPROTO_TCP, &s_listen);
686 if (err) {
687 s_listen = NULL;
688 goto out;
689 }
690
691 timeo = mdev->net_conf->try_connect_int * HZ;
692 timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */
693
694 s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */
695 s_listen->sk->sk_rcvtimeo = timeo;
696 s_listen->sk->sk_sndtimeo = timeo;
Lars Ellenberg5dbf1672010-05-25 16:18:01 +0200697 drbd_setbufsize(s_listen, mdev->net_conf->sndbuf_size,
698 mdev->net_conf->rcvbuf_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700699
700 what = "bind before listen";
701 err = s_listen->ops->bind(s_listen,
702 (struct sockaddr *) mdev->net_conf->my_addr,
703 mdev->net_conf->my_addr_len);
704 if (err < 0)
705 goto out;
706
707 err = drbd_accept(mdev, &what, s_listen, &s_estab);
708
709out:
710 if (s_listen)
711 sock_release(s_listen);
712 if (err < 0) {
713 if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) {
714 dev_err(DEV, "%s failed, err = %d\n", what, err);
715 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
716 }
717 }
718 put_net_conf(mdev);
719
720 return s_estab;
721}
722
723static int drbd_send_fp(struct drbd_conf *mdev,
724 struct socket *sock, enum drbd_packets cmd)
725{
Philipp Reisner02918be2010-08-20 14:35:10 +0200726 struct p_header80 *h = &mdev->data.sbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700727
728 return _drbd_send_cmd(mdev, sock, cmd, h, sizeof(*h), 0);
729}
730
731static enum drbd_packets drbd_recv_fp(struct drbd_conf *mdev, struct socket *sock)
732{
Philipp Reisner02918be2010-08-20 14:35:10 +0200733 struct p_header80 *h = &mdev->data.rbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700734 int rr;
735
736 rr = drbd_recv_short(mdev, sock, h, sizeof(*h), 0);
737
738 if (rr == sizeof(*h) && h->magic == BE_DRBD_MAGIC)
739 return be16_to_cpu(h->command);
740
741 return 0xffff;
742}
743
744/**
745 * drbd_socket_okay() - Free the socket if its connection is not okay
746 * @mdev: DRBD device.
747 * @sock: pointer to the pointer to the socket.
748 */
749static int drbd_socket_okay(struct drbd_conf *mdev, struct socket **sock)
750{
751 int rr;
752 char tb[4];
753
754 if (!*sock)
755 return FALSE;
756
757 rr = drbd_recv_short(mdev, *sock, tb, 4, MSG_DONTWAIT | MSG_PEEK);
758
759 if (rr > 0 || rr == -EAGAIN) {
760 return TRUE;
761 } else {
762 sock_release(*sock);
763 *sock = NULL;
764 return FALSE;
765 }
766}
767
768/*
769 * return values:
770 * 1 yes, we have a valid connection
771 * 0 oops, did not work out, please try again
772 * -1 peer talks different language,
773 * no point in trying again, please go standalone.
774 * -2 We do not have a network config...
775 */
776static int drbd_connect(struct drbd_conf *mdev)
777{
778 struct socket *s, *sock, *msock;
779 int try, h, ok;
780
781 D_ASSERT(!mdev->data.socket);
782
Philipp Reisnerb411b362009-09-25 16:07:19 -0700783 if (drbd_request_state(mdev, NS(conn, C_WF_CONNECTION)) < SS_SUCCESS)
784 return -2;
785
786 clear_bit(DISCARD_CONCURRENT, &mdev->flags);
787
788 sock = NULL;
789 msock = NULL;
790
791 do {
792 for (try = 0;;) {
793 /* 3 tries, this should take less than a second! */
794 s = drbd_try_connect(mdev);
795 if (s || ++try >= 3)
796 break;
797 /* give the other side time to call bind() & listen() */
798 __set_current_state(TASK_INTERRUPTIBLE);
799 schedule_timeout(HZ / 10);
800 }
801
802 if (s) {
803 if (!sock) {
804 drbd_send_fp(mdev, s, P_HAND_SHAKE_S);
805 sock = s;
806 s = NULL;
807 } else if (!msock) {
808 drbd_send_fp(mdev, s, P_HAND_SHAKE_M);
809 msock = s;
810 s = NULL;
811 } else {
812 dev_err(DEV, "Logic error in drbd_connect()\n");
813 goto out_release_sockets;
814 }
815 }
816
817 if (sock && msock) {
818 __set_current_state(TASK_INTERRUPTIBLE);
819 schedule_timeout(HZ / 10);
820 ok = drbd_socket_okay(mdev, &sock);
821 ok = drbd_socket_okay(mdev, &msock) && ok;
822 if (ok)
823 break;
824 }
825
826retry:
827 s = drbd_wait_for_connect(mdev);
828 if (s) {
829 try = drbd_recv_fp(mdev, s);
830 drbd_socket_okay(mdev, &sock);
831 drbd_socket_okay(mdev, &msock);
832 switch (try) {
833 case P_HAND_SHAKE_S:
834 if (sock) {
835 dev_warn(DEV, "initial packet S crossed\n");
836 sock_release(sock);
837 }
838 sock = s;
839 break;
840 case P_HAND_SHAKE_M:
841 if (msock) {
842 dev_warn(DEV, "initial packet M crossed\n");
843 sock_release(msock);
844 }
845 msock = s;
846 set_bit(DISCARD_CONCURRENT, &mdev->flags);
847 break;
848 default:
849 dev_warn(DEV, "Error receiving initial packet\n");
850 sock_release(s);
851 if (random32() & 1)
852 goto retry;
853 }
854 }
855
856 if (mdev->state.conn <= C_DISCONNECTING)
857 goto out_release_sockets;
858 if (signal_pending(current)) {
859 flush_signals(current);
860 smp_rmb();
861 if (get_t_state(&mdev->receiver) == Exiting)
862 goto out_release_sockets;
863 }
864
865 if (sock && msock) {
866 ok = drbd_socket_okay(mdev, &sock);
867 ok = drbd_socket_okay(mdev, &msock) && ok;
868 if (ok)
869 break;
870 }
871 } while (1);
872
873 msock->sk->sk_reuse = 1; /* SO_REUSEADDR */
874 sock->sk->sk_reuse = 1; /* SO_REUSEADDR */
875
876 sock->sk->sk_allocation = GFP_NOIO;
877 msock->sk->sk_allocation = GFP_NOIO;
878
879 sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
880 msock->sk->sk_priority = TC_PRIO_INTERACTIVE;
881
Philipp Reisnerb411b362009-09-25 16:07:19 -0700882 /* NOT YET ...
883 * sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10;
884 * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
885 * first set it to the P_HAND_SHAKE timeout,
886 * which we set to 4x the configured ping_timeout. */
887 sock->sk->sk_sndtimeo =
888 sock->sk->sk_rcvtimeo = mdev->net_conf->ping_timeo*4*HZ/10;
889
890 msock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10;
891 msock->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ;
892
893 /* we don't want delays.
894 * we use TCP_CORK where apropriate, though */
895 drbd_tcp_nodelay(sock);
896 drbd_tcp_nodelay(msock);
897
898 mdev->data.socket = sock;
899 mdev->meta.socket = msock;
900 mdev->last_received = jiffies;
901
902 D_ASSERT(mdev->asender.task == NULL);
903
904 h = drbd_do_handshake(mdev);
905 if (h <= 0)
906 return h;
907
908 if (mdev->cram_hmac_tfm) {
909 /* drbd_request_state(mdev, NS(conn, WFAuth)); */
Johannes Thomab10d96c2010-01-07 16:02:50 +0100910 switch (drbd_do_auth(mdev)) {
911 case -1:
Philipp Reisnerb411b362009-09-25 16:07:19 -0700912 dev_err(DEV, "Authentication of peer failed\n");
913 return -1;
Johannes Thomab10d96c2010-01-07 16:02:50 +0100914 case 0:
915 dev_err(DEV, "Authentication of peer failed, trying again.\n");
916 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700917 }
918 }
919
920 if (drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS)) < SS_SUCCESS)
921 return 0;
922
923 sock->sk->sk_sndtimeo = mdev->net_conf->timeout*HZ/10;
924 sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
925
926 atomic_set(&mdev->packet_seq, 0);
927 mdev->peer_seq = 0;
928
929 drbd_thread_start(&mdev->asender);
930
Philipp Reisnerd5373382010-08-23 15:18:33 +0200931 if (mdev->agreed_pro_version < 95 && get_ldev(mdev)) {
932 drbd_setup_queue_param(mdev, DRBD_MAX_SIZE_H80_PACKET);
933 put_ldev(mdev);
934 }
935
Philipp Reisner7e2455c2010-04-22 14:50:23 +0200936 if (!drbd_send_protocol(mdev))
937 return -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700938 drbd_send_sync_param(mdev, &mdev->sync_conf);
Philipp Reisnere89b5912010-03-24 17:11:33 +0100939 drbd_send_sizes(mdev, 0, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700940 drbd_send_uuids(mdev);
941 drbd_send_state(mdev);
942 clear_bit(USE_DEGR_WFC_T, &mdev->flags);
943 clear_bit(RESIZE_PENDING, &mdev->flags);
944
945 return 1;
946
947out_release_sockets:
948 if (sock)
949 sock_release(sock);
950 if (msock)
951 sock_release(msock);
952 return -1;
953}
954
Philipp Reisner02918be2010-08-20 14:35:10 +0200955static int drbd_recv_header(struct drbd_conf *mdev, enum drbd_packets *cmd, unsigned int *packet_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700956{
Philipp Reisner02918be2010-08-20 14:35:10 +0200957 union p_header *h = &mdev->data.rbuf.header;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700958 int r;
959
960 r = drbd_recv(mdev, h, sizeof(*h));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700961 if (unlikely(r != sizeof(*h))) {
962 dev_err(DEV, "short read expecting header on sock: r=%d\n", r);
963 return FALSE;
Philipp Reisner02918be2010-08-20 14:35:10 +0200964 }
965
966 if (likely(h->h80.magic == BE_DRBD_MAGIC)) {
967 *cmd = be16_to_cpu(h->h80.command);
968 *packet_size = be16_to_cpu(h->h80.length);
969 } else if (h->h95.magic == BE_DRBD_MAGIC_BIG) {
970 *cmd = be16_to_cpu(h->h95.command);
971 *packet_size = be32_to_cpu(h->h95.length);
972 } else {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700973 dev_err(DEV, "magic?? on data m: 0x%lx c: %d l: %d\n",
Philipp Reisner02918be2010-08-20 14:35:10 +0200974 (long)be32_to_cpu(h->h80.magic),
975 h->h80.command, h->h80.length);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700976 return FALSE;
977 }
978 mdev->last_received = jiffies;
979
980 return TRUE;
981}
982
983static enum finish_epoch drbd_flush_after_epoch(struct drbd_conf *mdev, struct drbd_epoch *epoch)
984{
985 int rv;
986
987 if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) {
Dmitry Monakhovfbd9b092010-04-28 17:55:06 +0400988 rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL,
989 NULL, BLKDEV_IFL_WAIT);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700990 if (rv) {
991 dev_err(DEV, "local disk flush failed with status %d\n", rv);
992 /* would rather check on EOPNOTSUPP, but that is not reliable.
993 * don't try again for ANY return value != 0
994 * if (rv == -EOPNOTSUPP) */
995 drbd_bump_write_ordering(mdev, WO_drain_io);
996 }
997 put_ldev(mdev);
998 }
999
1000 return drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE);
1001}
1002
1003static int w_flush(struct drbd_conf *mdev, struct drbd_work *w, int cancel)
1004{
1005 struct flush_work *fw = (struct flush_work *)w;
1006 struct drbd_epoch *epoch = fw->epoch;
1007
1008 kfree(w);
1009
1010 if (!test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags))
1011 drbd_flush_after_epoch(mdev, epoch);
1012
1013 drbd_may_finish_epoch(mdev, epoch, EV_PUT |
1014 (mdev->state.conn < C_CONNECTED ? EV_CLEANUP : 0));
1015
1016 return 1;
1017}
1018
1019/**
1020 * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it.
1021 * @mdev: DRBD device.
1022 * @epoch: Epoch object.
1023 * @ev: Epoch event.
1024 */
1025static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev,
1026 struct drbd_epoch *epoch,
1027 enum epoch_event ev)
1028{
1029 int finish, epoch_size;
1030 struct drbd_epoch *next_epoch;
1031 int schedule_flush = 0;
1032 enum finish_epoch rv = FE_STILL_LIVE;
1033
1034 spin_lock(&mdev->epoch_lock);
1035 do {
1036 next_epoch = NULL;
1037 finish = 0;
1038
1039 epoch_size = atomic_read(&epoch->epoch_size);
1040
1041 switch (ev & ~EV_CLEANUP) {
1042 case EV_PUT:
1043 atomic_dec(&epoch->active);
1044 break;
1045 case EV_GOT_BARRIER_NR:
1046 set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags);
1047
1048 /* Special case: If we just switched from WO_bio_barrier to
1049 WO_bdev_flush we should not finish the current epoch */
1050 if (test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags) && epoch_size == 1 &&
1051 mdev->write_ordering != WO_bio_barrier &&
1052 epoch == mdev->current_epoch)
1053 clear_bit(DE_CONTAINS_A_BARRIER, &epoch->flags);
1054 break;
1055 case EV_BARRIER_DONE:
1056 set_bit(DE_BARRIER_IN_NEXT_EPOCH_DONE, &epoch->flags);
1057 break;
1058 case EV_BECAME_LAST:
1059 /* nothing to do*/
1060 break;
1061 }
1062
Philipp Reisnerb411b362009-09-25 16:07:19 -07001063 if (epoch_size != 0 &&
1064 atomic_read(&epoch->active) == 0 &&
1065 test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) &&
1066 epoch->list.prev == &mdev->current_epoch->list &&
1067 !test_bit(DE_IS_FINISHING, &epoch->flags)) {
1068 /* Nearly all conditions are met to finish that epoch... */
1069 if (test_bit(DE_BARRIER_IN_NEXT_EPOCH_DONE, &epoch->flags) ||
1070 mdev->write_ordering == WO_none ||
1071 (epoch_size == 1 && test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags)) ||
1072 ev & EV_CLEANUP) {
1073 finish = 1;
1074 set_bit(DE_IS_FINISHING, &epoch->flags);
1075 } else if (!test_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags) &&
1076 mdev->write_ordering == WO_bio_barrier) {
1077 atomic_inc(&epoch->active);
1078 schedule_flush = 1;
1079 }
1080 }
1081 if (finish) {
1082 if (!(ev & EV_CLEANUP)) {
1083 spin_unlock(&mdev->epoch_lock);
1084 drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size);
1085 spin_lock(&mdev->epoch_lock);
1086 }
1087 dec_unacked(mdev);
1088
1089 if (mdev->current_epoch != epoch) {
1090 next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list);
1091 list_del(&epoch->list);
1092 ev = EV_BECAME_LAST | (ev & EV_CLEANUP);
1093 mdev->epochs--;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001094 kfree(epoch);
1095
1096 if (rv == FE_STILL_LIVE)
1097 rv = FE_DESTROYED;
1098 } else {
1099 epoch->flags = 0;
1100 atomic_set(&epoch->epoch_size, 0);
Uwe Kleine-König698f9312010-07-02 20:41:51 +02001101 /* atomic_set(&epoch->active, 0); is already zero */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001102 if (rv == FE_STILL_LIVE)
1103 rv = FE_RECYCLED;
1104 }
1105 }
1106
1107 if (!next_epoch)
1108 break;
1109
1110 epoch = next_epoch;
1111 } while (1);
1112
1113 spin_unlock(&mdev->epoch_lock);
1114
1115 if (schedule_flush) {
1116 struct flush_work *fw;
1117 fw = kmalloc(sizeof(*fw), GFP_ATOMIC);
1118 if (fw) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001119 fw->w.cb = w_flush;
1120 fw->epoch = epoch;
1121 drbd_queue_work(&mdev->data.work, &fw->w);
1122 } else {
1123 dev_warn(DEV, "Could not kmalloc a flush_work obj\n");
1124 set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags);
1125 /* That is not a recursion, only one level */
1126 drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE);
1127 drbd_may_finish_epoch(mdev, epoch, EV_PUT);
1128 }
1129 }
1130
1131 return rv;
1132}
1133
1134/**
1135 * drbd_bump_write_ordering() - Fall back to an other write ordering method
1136 * @mdev: DRBD device.
1137 * @wo: Write ordering method to try.
1138 */
1139void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local)
1140{
1141 enum write_ordering_e pwo;
1142 static char *write_ordering_str[] = {
1143 [WO_none] = "none",
1144 [WO_drain_io] = "drain",
1145 [WO_bdev_flush] = "flush",
1146 [WO_bio_barrier] = "barrier",
1147 };
1148
1149 pwo = mdev->write_ordering;
1150 wo = min(pwo, wo);
1151 if (wo == WO_bio_barrier && mdev->ldev->dc.no_disk_barrier)
1152 wo = WO_bdev_flush;
1153 if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush)
1154 wo = WO_drain_io;
1155 if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain)
1156 wo = WO_none;
1157 mdev->write_ordering = wo;
1158 if (pwo != mdev->write_ordering || wo == WO_bio_barrier)
1159 dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]);
1160}
1161
1162/**
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001163 * drbd_submit_ee()
1164 * @mdev: DRBD device.
1165 * @e: epoch entry
1166 * @rw: flag field, see bio->bi_rw
1167 */
1168/* TODO allocate from our own bio_set. */
1169int drbd_submit_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e,
1170 const unsigned rw, const int fault_type)
1171{
1172 struct bio *bios = NULL;
1173 struct bio *bio;
1174 struct page *page = e->pages;
1175 sector_t sector = e->sector;
1176 unsigned ds = e->size;
1177 unsigned n_bios = 0;
1178 unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT;
1179
1180 /* In most cases, we will only need one bio. But in case the lower
1181 * level restrictions happen to be different at this offset on this
1182 * side than those of the sending peer, we may need to submit the
1183 * request in more than one bio. */
1184next_bio:
1185 bio = bio_alloc(GFP_NOIO, nr_pages);
1186 if (!bio) {
1187 dev_err(DEV, "submit_ee: Allocation of a bio failed\n");
1188 goto fail;
1189 }
1190 /* > e->sector, unless this is the first bio */
1191 bio->bi_sector = sector;
1192 bio->bi_bdev = mdev->ldev->backing_bdev;
1193 /* we special case some flags in the multi-bio case, see below
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001194 * (REQ_UNPLUG, REQ_HARDBARRIER) */
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001195 bio->bi_rw = rw;
1196 bio->bi_private = e;
1197 bio->bi_end_io = drbd_endio_sec;
1198
1199 bio->bi_next = bios;
1200 bios = bio;
1201 ++n_bios;
1202
1203 page_chain_for_each(page) {
1204 unsigned len = min_t(unsigned, ds, PAGE_SIZE);
1205 if (!bio_add_page(bio, page, len, 0)) {
1206 /* a single page must always be possible! */
1207 BUG_ON(bio->bi_vcnt == 0);
1208 goto next_bio;
1209 }
1210 ds -= len;
1211 sector += len >> 9;
1212 --nr_pages;
1213 }
1214 D_ASSERT(page == NULL);
1215 D_ASSERT(ds == 0);
1216
1217 atomic_set(&e->pending_bios, n_bios);
1218 do {
1219 bio = bios;
1220 bios = bios->bi_next;
1221 bio->bi_next = NULL;
1222
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001223 /* strip off REQ_UNPLUG unless it is the last bio */
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001224 if (bios)
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001225 bio->bi_rw &= ~REQ_UNPLUG;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001226
1227 drbd_generic_make_request(mdev, fault_type, bio);
1228
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001229 /* strip off REQ_HARDBARRIER,
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001230 * unless it is the first or last bio */
1231 if (bios && bios->bi_next)
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001232 bios->bi_rw &= ~REQ_HARDBARRIER;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001233 } while (bios);
1234 maybe_kick_lo(mdev);
1235 return 0;
1236
1237fail:
1238 while (bios) {
1239 bio = bios;
1240 bios = bios->bi_next;
1241 bio_put(bio);
1242 }
1243 return -ENOMEM;
1244}
1245
1246/**
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001247 * w_e_reissue() - Worker callback; Resubmit a bio, without REQ_HARDBARRIER set
Philipp Reisnerb411b362009-09-25 16:07:19 -07001248 * @mdev: DRBD device.
1249 * @w: work object.
1250 * @cancel: The connection will be closed anyways (unused in this callback)
1251 */
1252int w_e_reissue(struct drbd_conf *mdev, struct drbd_work *w, int cancel) __releases(local)
1253{
1254 struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001255 /* We leave DE_CONTAINS_A_BARRIER and EE_IS_BARRIER in place,
1256 (and DE_BARRIER_IN_NEXT_EPOCH_ISSUED in the previous Epoch)
1257 so that we can finish that epoch in drbd_may_finish_epoch().
1258 That is necessary if we already have a long chain of Epochs, before
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001259 we realize that REQ_HARDBARRIER is actually not supported */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001260
1261 /* As long as the -ENOTSUPP on the barrier is reported immediately
1262 that will never trigger. If it is reported late, we will just
1263 print that warning and continue correctly for all future requests
1264 with WO_bdev_flush */
1265 if (previous_epoch(mdev, e->epoch))
1266 dev_warn(DEV, "Write ordering was not enforced (one time event)\n");
1267
Philipp Reisnerb411b362009-09-25 16:07:19 -07001268 /* we still have a local reference,
1269 * get_ldev was done in receive_Data. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001270
1271 e->w.cb = e_end_block;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001272 if (drbd_submit_ee(mdev, e, WRITE, DRBD_FAULT_DT_WR) != 0) {
1273 /* drbd_submit_ee fails for one reason only:
1274 * if was not able to allocate sufficient bios.
1275 * requeue, try again later. */
1276 e->w.cb = w_e_reissue;
1277 drbd_queue_work(&mdev->data.work, &e->w);
1278 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001279 return 1;
1280}
1281
Philipp Reisner02918be2010-08-20 14:35:10 +02001282static int receive_Barrier(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001283{
1284 int rv, issue_flush;
Philipp Reisner02918be2010-08-20 14:35:10 +02001285 struct p_barrier *p = &mdev->data.rbuf.barrier;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001286 struct drbd_epoch *epoch;
1287
Philipp Reisnerb411b362009-09-25 16:07:19 -07001288 inc_unacked(mdev);
1289
1290 if (mdev->net_conf->wire_protocol != DRBD_PROT_C)
1291 drbd_kick_lo(mdev);
1292
1293 mdev->current_epoch->barrier_nr = p->barrier;
1294 rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR);
1295
1296 /* P_BARRIER_ACK may imply that the corresponding extent is dropped from
1297 * the activity log, which means it would not be resynced in case the
1298 * R_PRIMARY crashes now.
1299 * Therefore we must send the barrier_ack after the barrier request was
1300 * completed. */
1301 switch (mdev->write_ordering) {
1302 case WO_bio_barrier:
1303 case WO_none:
1304 if (rv == FE_RECYCLED)
1305 return TRUE;
1306 break;
1307
1308 case WO_bdev_flush:
1309 case WO_drain_io:
Philipp Reisner367a8d72009-12-29 15:56:01 +01001310 if (rv == FE_STILL_LIVE) {
1311 set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &mdev->current_epoch->flags);
1312 drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
1313 rv = drbd_flush_after_epoch(mdev, mdev->current_epoch);
1314 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001315 if (rv == FE_RECYCLED)
1316 return TRUE;
1317
1318 /* The asender will send all the ACKs and barrier ACKs out, since
1319 all EEs moved from the active_ee to the done_ee. We need to
1320 provide a new epoch object for the EEs that come in soon */
1321 break;
1322 }
1323
1324 /* receiver context, in the writeout path of the other node.
1325 * avoid potential distributed deadlock */
1326 epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
1327 if (!epoch) {
1328 dev_warn(DEV, "Allocation of an epoch failed, slowing down\n");
Dan Carpenterd3db7b42010-01-23 15:45:22 +03001329 issue_flush = !test_and_set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &mdev->current_epoch->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001330 drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
1331 if (issue_flush) {
1332 rv = drbd_flush_after_epoch(mdev, mdev->current_epoch);
1333 if (rv == FE_RECYCLED)
1334 return TRUE;
1335 }
1336
1337 drbd_wait_ee_list_empty(mdev, &mdev->done_ee);
1338
1339 return TRUE;
1340 }
1341
1342 epoch->flags = 0;
1343 atomic_set(&epoch->epoch_size, 0);
1344 atomic_set(&epoch->active, 0);
1345
1346 spin_lock(&mdev->epoch_lock);
1347 if (atomic_read(&mdev->current_epoch->epoch_size)) {
1348 list_add(&epoch->list, &mdev->current_epoch->list);
1349 mdev->current_epoch = epoch;
1350 mdev->epochs++;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001351 } else {
1352 /* The current_epoch got recycled while we allocated this one... */
1353 kfree(epoch);
1354 }
1355 spin_unlock(&mdev->epoch_lock);
1356
1357 return TRUE;
1358}
1359
1360/* used from receive_RSDataReply (recv_resync_read)
1361 * and from receive_Data */
1362static struct drbd_epoch_entry *
1363read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector, int data_size) __must_hold(local)
1364{
Lars Ellenberg66660322010-04-06 12:15:04 +02001365 const sector_t capacity = drbd_get_capacity(mdev->this_bdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001366 struct drbd_epoch_entry *e;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001367 struct page *page;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001368 int dgs, ds, rr;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001369 void *dig_in = mdev->int_dig_in;
1370 void *dig_vv = mdev->int_dig_vv;
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001371 unsigned long *data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001372
1373 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ?
1374 crypto_hash_digestsize(mdev->integrity_r_tfm) : 0;
1375
1376 if (dgs) {
1377 rr = drbd_recv(mdev, dig_in, dgs);
1378 if (rr != dgs) {
1379 dev_warn(DEV, "short read receiving data digest: read %d expected %d\n",
1380 rr, dgs);
1381 return NULL;
1382 }
1383 }
1384
1385 data_size -= dgs;
1386
1387 ERR_IF(data_size & 0x1ff) return NULL;
1388 ERR_IF(data_size > DRBD_MAX_SEGMENT_SIZE) return NULL;
1389
Lars Ellenberg66660322010-04-06 12:15:04 +02001390 /* even though we trust out peer,
1391 * we sometimes have to double check. */
1392 if (sector + (data_size>>9) > capacity) {
1393 dev_err(DEV, "capacity: %llus < sector: %llus + size: %u\n",
1394 (unsigned long long)capacity,
1395 (unsigned long long)sector, data_size);
1396 return NULL;
1397 }
1398
Philipp Reisnerb411b362009-09-25 16:07:19 -07001399 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
1400 * "criss-cross" setup, that might cause write-out on some other DRBD,
1401 * which in turn might block on the other node at this very place. */
1402 e = drbd_alloc_ee(mdev, id, sector, data_size, GFP_NOIO);
1403 if (!e)
1404 return NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001405
Philipp Reisnerb411b362009-09-25 16:07:19 -07001406 ds = data_size;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001407 page = e->pages;
1408 page_chain_for_each(page) {
1409 unsigned len = min_t(int, ds, PAGE_SIZE);
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001410 data = kmap(page);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001411 rr = drbd_recv(mdev, data, len);
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001412 if (FAULT_ACTIVE(mdev, DRBD_FAULT_RECEIVE)) {
1413 dev_err(DEV, "Fault injection: Corrupting data on receive\n");
1414 data[0] = data[0] ^ (unsigned long)-1;
1415 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001416 kunmap(page);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001417 if (rr != len) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001418 drbd_free_ee(mdev, e);
1419 dev_warn(DEV, "short read receiving data: read %d expected %d\n",
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001420 rr, len);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001421 return NULL;
1422 }
1423 ds -= rr;
1424 }
1425
1426 if (dgs) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001427 drbd_csum_ee(mdev, mdev->integrity_r_tfm, e, dig_vv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001428 if (memcmp(dig_in, dig_vv, dgs)) {
1429 dev_err(DEV, "Digest integrity check FAILED.\n");
1430 drbd_bcast_ee(mdev, "digest failed",
1431 dgs, dig_in, dig_vv, e);
1432 drbd_free_ee(mdev, e);
1433 return NULL;
1434 }
1435 }
1436 mdev->recv_cnt += data_size>>9;
1437 return e;
1438}
1439
1440/* drbd_drain_block() just takes a data block
1441 * out of the socket input buffer, and discards it.
1442 */
1443static int drbd_drain_block(struct drbd_conf *mdev, int data_size)
1444{
1445 struct page *page;
1446 int rr, rv = 1;
1447 void *data;
1448
Lars Ellenbergc3470cd2010-04-01 16:57:19 +02001449 if (!data_size)
1450 return TRUE;
1451
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001452 page = drbd_pp_alloc(mdev, 1, 1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001453
1454 data = kmap(page);
1455 while (data_size) {
1456 rr = drbd_recv(mdev, data, min_t(int, data_size, PAGE_SIZE));
1457 if (rr != min_t(int, data_size, PAGE_SIZE)) {
1458 rv = 0;
1459 dev_warn(DEV, "short read receiving data: read %d expected %d\n",
1460 rr, min_t(int, data_size, PAGE_SIZE));
1461 break;
1462 }
1463 data_size -= rr;
1464 }
1465 kunmap(page);
Lars Ellenberg435f0742010-09-06 12:30:25 +02001466 drbd_pp_free(mdev, page, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001467 return rv;
1468}
1469
1470static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req,
1471 sector_t sector, int data_size)
1472{
1473 struct bio_vec *bvec;
1474 struct bio *bio;
1475 int dgs, rr, i, expect;
1476 void *dig_in = mdev->int_dig_in;
1477 void *dig_vv = mdev->int_dig_vv;
1478
1479 dgs = (mdev->agreed_pro_version >= 87 && mdev->integrity_r_tfm) ?
1480 crypto_hash_digestsize(mdev->integrity_r_tfm) : 0;
1481
1482 if (dgs) {
1483 rr = drbd_recv(mdev, dig_in, dgs);
1484 if (rr != dgs) {
1485 dev_warn(DEV, "short read receiving data reply digest: read %d expected %d\n",
1486 rr, dgs);
1487 return 0;
1488 }
1489 }
1490
1491 data_size -= dgs;
1492
1493 /* optimistically update recv_cnt. if receiving fails below,
1494 * we disconnect anyways, and counters will be reset. */
1495 mdev->recv_cnt += data_size>>9;
1496
1497 bio = req->master_bio;
1498 D_ASSERT(sector == bio->bi_sector);
1499
1500 bio_for_each_segment(bvec, bio, i) {
1501 expect = min_t(int, data_size, bvec->bv_len);
1502 rr = drbd_recv(mdev,
1503 kmap(bvec->bv_page)+bvec->bv_offset,
1504 expect);
1505 kunmap(bvec->bv_page);
1506 if (rr != expect) {
1507 dev_warn(DEV, "short read receiving data reply: "
1508 "read %d expected %d\n",
1509 rr, expect);
1510 return 0;
1511 }
1512 data_size -= rr;
1513 }
1514
1515 if (dgs) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001516 drbd_csum_bio(mdev, mdev->integrity_r_tfm, bio, dig_vv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001517 if (memcmp(dig_in, dig_vv, dgs)) {
1518 dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n");
1519 return 0;
1520 }
1521 }
1522
1523 D_ASSERT(data_size == 0);
1524 return 1;
1525}
1526
1527/* e_end_resync_block() is called via
1528 * drbd_process_done_ee() by asender only */
1529static int e_end_resync_block(struct drbd_conf *mdev, struct drbd_work *w, int unused)
1530{
1531 struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w;
1532 sector_t sector = e->sector;
1533 int ok;
1534
1535 D_ASSERT(hlist_unhashed(&e->colision));
1536
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001537 if (likely((e->flags & EE_WAS_ERROR) == 0)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001538 drbd_set_in_sync(mdev, sector, e->size);
1539 ok = drbd_send_ack(mdev, P_RS_WRITE_ACK, e);
1540 } else {
1541 /* Record failure to sync */
1542 drbd_rs_failed_io(mdev, sector, e->size);
1543
1544 ok = drbd_send_ack(mdev, P_NEG_ACK, e);
1545 }
1546 dec_unacked(mdev);
1547
1548 return ok;
1549}
1550
1551static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local)
1552{
1553 struct drbd_epoch_entry *e;
1554
1555 e = read_in_block(mdev, ID_SYNCER, sector, data_size);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001556 if (!e)
1557 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001558
1559 dec_rs_pending(mdev);
1560
Philipp Reisnerb411b362009-09-25 16:07:19 -07001561 inc_unacked(mdev);
1562 /* corresponding dec_unacked() in e_end_resync_block()
1563 * respective _drbd_clear_done_ee */
1564
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001565 e->w.cb = e_end_resync_block;
1566
Philipp Reisnerb411b362009-09-25 16:07:19 -07001567 spin_lock_irq(&mdev->req_lock);
1568 list_add(&e->w.list, &mdev->sync_ee);
1569 spin_unlock_irq(&mdev->req_lock);
1570
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001571 atomic_add(data_size >> 9, &mdev->rs_sect_ev);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001572 if (drbd_submit_ee(mdev, e, WRITE, DRBD_FAULT_RS_WR) == 0)
1573 return TRUE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001574
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001575 drbd_free_ee(mdev, e);
1576fail:
1577 put_ldev(mdev);
1578 return FALSE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001579}
1580
Philipp Reisner02918be2010-08-20 14:35:10 +02001581static int receive_DataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001582{
1583 struct drbd_request *req;
1584 sector_t sector;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001585 int ok;
Philipp Reisner02918be2010-08-20 14:35:10 +02001586 struct p_data *p = &mdev->data.rbuf.data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001587
1588 sector = be64_to_cpu(p->sector);
1589
1590 spin_lock_irq(&mdev->req_lock);
1591 req = _ar_id_to_req(mdev, p->block_id, sector);
1592 spin_unlock_irq(&mdev->req_lock);
1593 if (unlikely(!req)) {
1594 dev_err(DEV, "Got a corrupt block_id/sector pair(1).\n");
1595 return FALSE;
1596 }
1597
1598 /* hlist_del(&req->colision) is done in _req_may_be_done, to avoid
1599 * special casing it there for the various failure cases.
1600 * still no race with drbd_fail_pending_reads */
1601 ok = recv_dless_read(mdev, req, sector, data_size);
1602
1603 if (ok)
1604 req_mod(req, data_received);
1605 /* else: nothing. handled from drbd_disconnect...
1606 * I don't think we may complete this just yet
1607 * in case we are "on-disconnect: freeze" */
1608
1609 return ok;
1610}
1611
Philipp Reisner02918be2010-08-20 14:35:10 +02001612static int receive_RSDataReply(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001613{
1614 sector_t sector;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001615 int ok;
Philipp Reisner02918be2010-08-20 14:35:10 +02001616 struct p_data *p = &mdev->data.rbuf.data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001617
1618 sector = be64_to_cpu(p->sector);
1619 D_ASSERT(p->block_id == ID_SYNCER);
1620
1621 if (get_ldev(mdev)) {
1622 /* data is submitted to disk within recv_resync_read.
1623 * corresponding put_ldev done below on error,
1624 * or in drbd_endio_write_sec. */
1625 ok = recv_resync_read(mdev, sector, data_size);
1626 } else {
1627 if (__ratelimit(&drbd_ratelimit_state))
1628 dev_err(DEV, "Can not write resync data to local disk.\n");
1629
1630 ok = drbd_drain_block(mdev, data_size);
1631
1632 drbd_send_ack_dp(mdev, P_NEG_ACK, p);
1633 }
1634
Philipp Reisner778f2712010-07-06 11:14:00 +02001635 atomic_add(data_size >> 9, &mdev->rs_sect_in);
1636
Philipp Reisnerb411b362009-09-25 16:07:19 -07001637 return ok;
1638}
1639
1640/* e_end_block() is called via drbd_process_done_ee().
1641 * this means this function only runs in the asender thread
1642 */
1643static int e_end_block(struct drbd_conf *mdev, struct drbd_work *w, int cancel)
1644{
1645 struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w;
1646 sector_t sector = e->sector;
1647 struct drbd_epoch *epoch;
1648 int ok = 1, pcmd;
1649
1650 if (e->flags & EE_IS_BARRIER) {
1651 epoch = previous_epoch(mdev, e->epoch);
1652 if (epoch)
1653 drbd_may_finish_epoch(mdev, epoch, EV_BARRIER_DONE + (cancel ? EV_CLEANUP : 0));
1654 }
1655
1656 if (mdev->net_conf->wire_protocol == DRBD_PROT_C) {
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001657 if (likely((e->flags & EE_WAS_ERROR) == 0)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001658 pcmd = (mdev->state.conn >= C_SYNC_SOURCE &&
1659 mdev->state.conn <= C_PAUSED_SYNC_T &&
1660 e->flags & EE_MAY_SET_IN_SYNC) ?
1661 P_RS_WRITE_ACK : P_WRITE_ACK;
1662 ok &= drbd_send_ack(mdev, pcmd, e);
1663 if (pcmd == P_RS_WRITE_ACK)
1664 drbd_set_in_sync(mdev, sector, e->size);
1665 } else {
1666 ok = drbd_send_ack(mdev, P_NEG_ACK, e);
1667 /* we expect it to be marked out of sync anyways...
1668 * maybe assert this? */
1669 }
1670 dec_unacked(mdev);
1671 }
1672 /* we delete from the conflict detection hash _after_ we sent out the
1673 * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */
1674 if (mdev->net_conf->two_primaries) {
1675 spin_lock_irq(&mdev->req_lock);
1676 D_ASSERT(!hlist_unhashed(&e->colision));
1677 hlist_del_init(&e->colision);
1678 spin_unlock_irq(&mdev->req_lock);
1679 } else {
1680 D_ASSERT(hlist_unhashed(&e->colision));
1681 }
1682
1683 drbd_may_finish_epoch(mdev, e->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0));
1684
1685 return ok;
1686}
1687
1688static int e_send_discard_ack(struct drbd_conf *mdev, struct drbd_work *w, int unused)
1689{
1690 struct drbd_epoch_entry *e = (struct drbd_epoch_entry *)w;
1691 int ok = 1;
1692
1693 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
1694 ok = drbd_send_ack(mdev, P_DISCARD_ACK, e);
1695
1696 spin_lock_irq(&mdev->req_lock);
1697 D_ASSERT(!hlist_unhashed(&e->colision));
1698 hlist_del_init(&e->colision);
1699 spin_unlock_irq(&mdev->req_lock);
1700
1701 dec_unacked(mdev);
1702
1703 return ok;
1704}
1705
1706/* Called from receive_Data.
1707 * Synchronize packets on sock with packets on msock.
1708 *
1709 * This is here so even when a P_DATA packet traveling via sock overtook an Ack
1710 * packet traveling on msock, they are still processed in the order they have
1711 * been sent.
1712 *
1713 * Note: we don't care for Ack packets overtaking P_DATA packets.
1714 *
1715 * In case packet_seq is larger than mdev->peer_seq number, there are
1716 * outstanding packets on the msock. We wait for them to arrive.
1717 * In case we are the logically next packet, we update mdev->peer_seq
1718 * ourselves. Correctly handles 32bit wrap around.
1719 *
1720 * Assume we have a 10 GBit connection, that is about 1<<30 byte per second,
1721 * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds
1722 * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have
1723 * 1<<9 == 512 seconds aka ages for the 32bit wrap around...
1724 *
1725 * returns 0 if we may process the packet,
1726 * -ERESTARTSYS if we were interrupted (by disconnect signal). */
1727static int drbd_wait_peer_seq(struct drbd_conf *mdev, const u32 packet_seq)
1728{
1729 DEFINE_WAIT(wait);
1730 unsigned int p_seq;
1731 long timeout;
1732 int ret = 0;
1733 spin_lock(&mdev->peer_seq_lock);
1734 for (;;) {
1735 prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE);
1736 if (seq_le(packet_seq, mdev->peer_seq+1))
1737 break;
1738 if (signal_pending(current)) {
1739 ret = -ERESTARTSYS;
1740 break;
1741 }
1742 p_seq = mdev->peer_seq;
1743 spin_unlock(&mdev->peer_seq_lock);
1744 timeout = schedule_timeout(30*HZ);
1745 spin_lock(&mdev->peer_seq_lock);
1746 if (timeout == 0 && p_seq == mdev->peer_seq) {
1747 ret = -ETIMEDOUT;
1748 dev_err(DEV, "ASSERT FAILED waited 30 seconds for sequence update, forcing reconnect\n");
1749 break;
1750 }
1751 }
1752 finish_wait(&mdev->seq_wait, &wait);
1753 if (mdev->peer_seq+1 == packet_seq)
1754 mdev->peer_seq++;
1755 spin_unlock(&mdev->peer_seq_lock);
1756 return ret;
1757}
1758
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001759static unsigned long write_flags_to_bio(struct drbd_conf *mdev, u32 dpf)
1760{
1761 if (mdev->agreed_pro_version >= 95)
1762 return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) |
1763 (dpf & DP_UNPLUG ? REQ_UNPLUG : 0) |
1764 (dpf & DP_FUA ? REQ_FUA : 0) |
1765 (dpf & DP_FLUSH ? REQ_FUA : 0) |
1766 (dpf & DP_DISCARD ? REQ_DISCARD : 0);
1767 else
1768 return dpf & DP_RW_SYNC ? (REQ_SYNC | REQ_UNPLUG) : 0;
1769}
1770
Philipp Reisnerb411b362009-09-25 16:07:19 -07001771/* mirrored write */
Philipp Reisner02918be2010-08-20 14:35:10 +02001772static int receive_Data(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001773{
1774 sector_t sector;
1775 struct drbd_epoch_entry *e;
Philipp Reisner02918be2010-08-20 14:35:10 +02001776 struct p_data *p = &mdev->data.rbuf.data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001777 int rw = WRITE;
1778 u32 dp_flags;
1779
Philipp Reisnerb411b362009-09-25 16:07:19 -07001780 if (!get_ldev(mdev)) {
1781 if (__ratelimit(&drbd_ratelimit_state))
1782 dev_err(DEV, "Can not write mirrored data block "
1783 "to local disk.\n");
1784 spin_lock(&mdev->peer_seq_lock);
1785 if (mdev->peer_seq+1 == be32_to_cpu(p->seq_num))
1786 mdev->peer_seq++;
1787 spin_unlock(&mdev->peer_seq_lock);
1788
1789 drbd_send_ack_dp(mdev, P_NEG_ACK, p);
1790 atomic_inc(&mdev->current_epoch->epoch_size);
1791 return drbd_drain_block(mdev, data_size);
1792 }
1793
1794 /* get_ldev(mdev) successful.
1795 * Corresponding put_ldev done either below (on various errors),
1796 * or in drbd_endio_write_sec, if we successfully submit the data at
1797 * the end of this function. */
1798
1799 sector = be64_to_cpu(p->sector);
1800 e = read_in_block(mdev, p->block_id, sector, data_size);
1801 if (!e) {
1802 put_ldev(mdev);
1803 return FALSE;
1804 }
1805
Philipp Reisnerb411b362009-09-25 16:07:19 -07001806 e->w.cb = e_end_block;
1807
1808 spin_lock(&mdev->epoch_lock);
1809 e->epoch = mdev->current_epoch;
1810 atomic_inc(&e->epoch->epoch_size);
1811 atomic_inc(&e->epoch->active);
1812
1813 if (mdev->write_ordering == WO_bio_barrier && atomic_read(&e->epoch->epoch_size) == 1) {
1814 struct drbd_epoch *epoch;
1815 /* Issue a barrier if we start a new epoch, and the previous epoch
1816 was not a epoch containing a single request which already was
1817 a Barrier. */
1818 epoch = list_entry(e->epoch->list.prev, struct drbd_epoch, list);
1819 if (epoch == e->epoch) {
1820 set_bit(DE_CONTAINS_A_BARRIER, &e->epoch->flags);
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001821 rw |= REQ_HARDBARRIER;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001822 e->flags |= EE_IS_BARRIER;
1823 } else {
1824 if (atomic_read(&epoch->epoch_size) > 1 ||
1825 !test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags)) {
1826 set_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001827 set_bit(DE_CONTAINS_A_BARRIER, &e->epoch->flags);
Christoph Hellwig7b6d91d2010-08-07 18:20:39 +02001828 rw |= REQ_HARDBARRIER;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001829 e->flags |= EE_IS_BARRIER;
1830 }
1831 }
1832 }
1833 spin_unlock(&mdev->epoch_lock);
1834
1835 dp_flags = be32_to_cpu(p->dp_flags);
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001836 rw |= write_flags_to_bio(mdev, dp_flags);
1837
Philipp Reisnerb411b362009-09-25 16:07:19 -07001838 if (dp_flags & DP_MAY_SET_IN_SYNC)
1839 e->flags |= EE_MAY_SET_IN_SYNC;
1840
1841 /* I'm the receiver, I do hold a net_cnt reference. */
1842 if (!mdev->net_conf->two_primaries) {
1843 spin_lock_irq(&mdev->req_lock);
1844 } else {
1845 /* don't get the req_lock yet,
1846 * we may sleep in drbd_wait_peer_seq */
1847 const int size = e->size;
1848 const int discard = test_bit(DISCARD_CONCURRENT, &mdev->flags);
1849 DEFINE_WAIT(wait);
1850 struct drbd_request *i;
1851 struct hlist_node *n;
1852 struct hlist_head *slot;
1853 int first;
1854
1855 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
1856 BUG_ON(mdev->ee_hash == NULL);
1857 BUG_ON(mdev->tl_hash == NULL);
1858
1859 /* conflict detection and handling:
1860 * 1. wait on the sequence number,
1861 * in case this data packet overtook ACK packets.
1862 * 2. check our hash tables for conflicting requests.
1863 * we only need to walk the tl_hash, since an ee can not
1864 * have a conflict with an other ee: on the submitting
1865 * node, the corresponding req had already been conflicting,
1866 * and a conflicting req is never sent.
1867 *
1868 * Note: for two_primaries, we are protocol C,
1869 * so there cannot be any request that is DONE
1870 * but still on the transfer log.
1871 *
1872 * unconditionally add to the ee_hash.
1873 *
1874 * if no conflicting request is found:
1875 * submit.
1876 *
1877 * if any conflicting request is found
1878 * that has not yet been acked,
1879 * AND I have the "discard concurrent writes" flag:
1880 * queue (via done_ee) the P_DISCARD_ACK; OUT.
1881 *
1882 * if any conflicting request is found:
1883 * block the receiver, waiting on misc_wait
1884 * until no more conflicting requests are there,
1885 * or we get interrupted (disconnect).
1886 *
1887 * we do not just write after local io completion of those
1888 * requests, but only after req is done completely, i.e.
1889 * we wait for the P_DISCARD_ACK to arrive!
1890 *
1891 * then proceed normally, i.e. submit.
1892 */
1893 if (drbd_wait_peer_seq(mdev, be32_to_cpu(p->seq_num)))
1894 goto out_interrupted;
1895
1896 spin_lock_irq(&mdev->req_lock);
1897
1898 hlist_add_head(&e->colision, ee_hash_slot(mdev, sector));
1899
1900#define OVERLAPS overlaps(i->sector, i->size, sector, size)
1901 slot = tl_hash_slot(mdev, sector);
1902 first = 1;
1903 for (;;) {
1904 int have_unacked = 0;
1905 int have_conflict = 0;
1906 prepare_to_wait(&mdev->misc_wait, &wait,
1907 TASK_INTERRUPTIBLE);
1908 hlist_for_each_entry(i, n, slot, colision) {
1909 if (OVERLAPS) {
1910 /* only ALERT on first iteration,
1911 * we may be woken up early... */
1912 if (first)
1913 dev_alert(DEV, "%s[%u] Concurrent local write detected!"
1914 " new: %llus +%u; pending: %llus +%u\n",
1915 current->comm, current->pid,
1916 (unsigned long long)sector, size,
1917 (unsigned long long)i->sector, i->size);
1918 if (i->rq_state & RQ_NET_PENDING)
1919 ++have_unacked;
1920 ++have_conflict;
1921 }
1922 }
1923#undef OVERLAPS
1924 if (!have_conflict)
1925 break;
1926
1927 /* Discard Ack only for the _first_ iteration */
1928 if (first && discard && have_unacked) {
1929 dev_alert(DEV, "Concurrent write! [DISCARD BY FLAG] sec=%llus\n",
1930 (unsigned long long)sector);
1931 inc_unacked(mdev);
1932 e->w.cb = e_send_discard_ack;
1933 list_add_tail(&e->w.list, &mdev->done_ee);
1934
1935 spin_unlock_irq(&mdev->req_lock);
1936
1937 /* we could probably send that P_DISCARD_ACK ourselves,
1938 * but I don't like the receiver using the msock */
1939
1940 put_ldev(mdev);
1941 wake_asender(mdev);
1942 finish_wait(&mdev->misc_wait, &wait);
1943 return TRUE;
1944 }
1945
1946 if (signal_pending(current)) {
1947 hlist_del_init(&e->colision);
1948
1949 spin_unlock_irq(&mdev->req_lock);
1950
1951 finish_wait(&mdev->misc_wait, &wait);
1952 goto out_interrupted;
1953 }
1954
1955 spin_unlock_irq(&mdev->req_lock);
1956 if (first) {
1957 first = 0;
1958 dev_alert(DEV, "Concurrent write! [W AFTERWARDS] "
1959 "sec=%llus\n", (unsigned long long)sector);
1960 } else if (discard) {
1961 /* we had none on the first iteration.
1962 * there must be none now. */
1963 D_ASSERT(have_unacked == 0);
1964 }
1965 schedule();
1966 spin_lock_irq(&mdev->req_lock);
1967 }
1968 finish_wait(&mdev->misc_wait, &wait);
1969 }
1970
1971 list_add(&e->w.list, &mdev->active_ee);
1972 spin_unlock_irq(&mdev->req_lock);
1973
1974 switch (mdev->net_conf->wire_protocol) {
1975 case DRBD_PROT_C:
1976 inc_unacked(mdev);
1977 /* corresponding dec_unacked() in e_end_block()
1978 * respective _drbd_clear_done_ee */
1979 break;
1980 case DRBD_PROT_B:
1981 /* I really don't like it that the receiver thread
1982 * sends on the msock, but anyways */
1983 drbd_send_ack(mdev, P_RECV_ACK, e);
1984 break;
1985 case DRBD_PROT_A:
1986 /* nothing to do */
1987 break;
1988 }
1989
1990 if (mdev->state.pdsk == D_DISKLESS) {
1991 /* In case we have the only disk of the cluster, */
1992 drbd_set_out_of_sync(mdev, e->sector, e->size);
1993 e->flags |= EE_CALL_AL_COMPLETE_IO;
1994 drbd_al_begin_io(mdev, e->sector);
1995 }
1996
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001997 if (drbd_submit_ee(mdev, e, rw, DRBD_FAULT_DT_WR) == 0)
1998 return TRUE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001999
2000out_interrupted:
2001 /* yes, the epoch_size now is imbalanced.
2002 * but we drop the connection anyways, so we don't have a chance to
2003 * receive a barrier... atomic_inc(&mdev->epoch_size); */
2004 put_ldev(mdev);
2005 drbd_free_ee(mdev, e);
2006 return FALSE;
2007}
2008
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002009/* We may throttle resync, if the lower device seems to be busy,
2010 * and current sync rate is above c_min_rate.
2011 *
2012 * To decide whether or not the lower device is busy, we use a scheme similar
2013 * to MD RAID is_mddev_idle(): if the partition stats reveal "significant"
2014 * (more than 64 sectors) of activity we cannot account for with our own resync
2015 * activity, it obviously is "busy".
2016 *
2017 * The current sync rate used here uses only the most recent two step marks,
2018 * to have a short time average so we can react faster.
2019 */
2020int drbd_rs_should_slow_down(struct drbd_conf *mdev)
2021{
2022 struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk;
2023 unsigned long db, dt, dbdt;
2024 int curr_events;
2025 int throttle = 0;
2026
2027 /* feature disabled? */
2028 if (mdev->sync_conf.c_min_rate == 0)
2029 return 0;
2030
2031 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
2032 (int)part_stat_read(&disk->part0, sectors[1]) -
2033 atomic_read(&mdev->rs_sect_ev);
2034 if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) {
2035 unsigned long rs_left;
2036 int i;
2037
2038 mdev->rs_last_events = curr_events;
2039
2040 /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP,
2041 * approx. */
2042 i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-2) % DRBD_SYNC_MARKS;
2043 rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed;
2044
2045 dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ;
2046 if (!dt)
2047 dt++;
2048 db = mdev->rs_mark_left[i] - rs_left;
2049 dbdt = Bit2KB(db/dt);
2050
2051 if (dbdt > mdev->sync_conf.c_min_rate)
2052 throttle = 1;
2053 }
2054 return throttle;
2055}
2056
2057
Philipp Reisner02918be2010-08-20 14:35:10 +02002058static int receive_DataRequest(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int digest_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002059{
2060 sector_t sector;
2061 const sector_t capacity = drbd_get_capacity(mdev->this_bdev);
2062 struct drbd_epoch_entry *e;
2063 struct digest_info *di = NULL;
Philipp Reisner02918be2010-08-20 14:35:10 +02002064 int size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002065 unsigned int fault_type;
Philipp Reisner02918be2010-08-20 14:35:10 +02002066 struct p_block_req *p = &mdev->data.rbuf.block_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002067
2068 sector = be64_to_cpu(p->sector);
2069 size = be32_to_cpu(p->blksize);
2070
2071 if (size <= 0 || (size & 0x1ff) != 0 || size > DRBD_MAX_SEGMENT_SIZE) {
2072 dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
2073 (unsigned long long)sector, size);
2074 return FALSE;
2075 }
2076 if (sector + (size>>9) > capacity) {
2077 dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
2078 (unsigned long long)sector, size);
2079 return FALSE;
2080 }
2081
2082 if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) {
2083 if (__ratelimit(&drbd_ratelimit_state))
2084 dev_err(DEV, "Can not satisfy peer's read request, "
2085 "no local data.\n");
Philipp Reisner02918be2010-08-20 14:35:10 +02002086 drbd_send_ack_rp(mdev, cmd == P_DATA_REQUEST ? P_NEG_DREPLY :
Philipp Reisnerb411b362009-09-25 16:07:19 -07002087 P_NEG_RS_DREPLY , p);
Philipp Reisner02918be2010-08-20 14:35:10 +02002088 return TRUE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002089 }
2090
2091 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
2092 * "criss-cross" setup, that might cause write-out on some other DRBD,
2093 * which in turn might block on the other node at this very place. */
2094 e = drbd_alloc_ee(mdev, p->block_id, sector, size, GFP_NOIO);
2095 if (!e) {
2096 put_ldev(mdev);
2097 return FALSE;
2098 }
2099
Philipp Reisner02918be2010-08-20 14:35:10 +02002100 switch (cmd) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002101 case P_DATA_REQUEST:
2102 e->w.cb = w_e_end_data_req;
2103 fault_type = DRBD_FAULT_DT_RD;
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002104 /* application IO, don't drbd_rs_begin_io */
2105 goto submit;
2106
Philipp Reisnerb411b362009-09-25 16:07:19 -07002107 case P_RS_DATA_REQUEST:
2108 e->w.cb = w_e_end_rsdata_req;
2109 fault_type = DRBD_FAULT_RS_RD;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002110 break;
2111
2112 case P_OV_REPLY:
2113 case P_CSUM_RS_REQUEST:
2114 fault_type = DRBD_FAULT_RS_RD;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002115 di = kmalloc(sizeof(*di) + digest_size, GFP_NOIO);
2116 if (!di)
2117 goto out_free_e;
2118
2119 di->digest_size = digest_size;
2120 di->digest = (((char *)di)+sizeof(struct digest_info));
2121
Lars Ellenbergc36c3ce2010-08-11 20:42:55 +02002122 e->digest = di;
2123 e->flags |= EE_HAS_DIGEST;
2124
Philipp Reisnerb411b362009-09-25 16:07:19 -07002125 if (drbd_recv(mdev, di->digest, digest_size) != digest_size)
2126 goto out_free_e;
2127
Philipp Reisner02918be2010-08-20 14:35:10 +02002128 if (cmd == P_CSUM_RS_REQUEST) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002129 D_ASSERT(mdev->agreed_pro_version >= 89);
2130 e->w.cb = w_e_end_csum_rs_req;
Philipp Reisner02918be2010-08-20 14:35:10 +02002131 } else if (cmd == P_OV_REPLY) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002132 e->w.cb = w_e_end_ov_reply;
2133 dec_rs_pending(mdev);
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002134 /* drbd_rs_begin_io done when we sent this request,
2135 * but accounting still needs to be done. */
2136 goto submit_for_resync;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002137 }
2138 break;
2139
2140 case P_OV_REQUEST:
2141 if (mdev->state.conn >= C_CONNECTED &&
2142 mdev->state.conn != C_VERIFY_T)
2143 dev_warn(DEV, "ASSERT FAILED: got P_OV_REQUEST while being %s\n",
2144 drbd_conn_str(mdev->state.conn));
2145 if (mdev->ov_start_sector == ~(sector_t)0 &&
2146 mdev->agreed_pro_version >= 90) {
2147 mdev->ov_start_sector = sector;
2148 mdev->ov_position = sector;
2149 mdev->ov_left = mdev->rs_total - BM_SECT_TO_BIT(sector);
2150 dev_info(DEV, "Online Verify start sector: %llu\n",
2151 (unsigned long long)sector);
2152 }
2153 e->w.cb = w_e_end_ov_req;
2154 fault_type = DRBD_FAULT_RS_RD;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002155 break;
2156
Philipp Reisnerb411b362009-09-25 16:07:19 -07002157 default:
2158 dev_err(DEV, "unexpected command (%s) in receive_DataRequest\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02002159 cmdname(cmd));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002160 fault_type = DRBD_FAULT_MAX;
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002161 goto out_free_e;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002162 }
2163
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002164 /* Throttle, drbd_rs_begin_io and submit should become asynchronous
2165 * wrt the receiver, but it is not as straightforward as it may seem.
2166 * Various places in the resync start and stop logic assume resync
2167 * requests are processed in order, requeuing this on the worker thread
2168 * introduces a bunch of new code for synchronization between threads.
2169 *
2170 * Unlimited throttling before drbd_rs_begin_io may stall the resync
2171 * "forever", throttling after drbd_rs_begin_io will lock that extent
2172 * for application writes for the same time. For now, just throttle
2173 * here, where the rest of the code expects the receiver to sleep for
2174 * a while, anyways.
2175 */
2176
2177 /* Throttle before drbd_rs_begin_io, as that locks out application IO;
2178 * this defers syncer requests for some time, before letting at least
2179 * on request through. The resync controller on the receiving side
2180 * will adapt to the incoming rate accordingly.
2181 *
2182 * We cannot throttle here if remote is Primary/SyncTarget:
2183 * we would also throttle its application reads.
2184 * In that case, throttling is done on the SyncTarget only.
2185 */
2186 if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev))
2187 msleep(100);
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002188 if (drbd_rs_begin_io(mdev, e->sector))
2189 goto out_free_e;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002190
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002191submit_for_resync:
2192 atomic_add(size >> 9, &mdev->rs_sect_ev);
2193
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002194submit:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002195 inc_unacked(mdev);
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002196 spin_lock_irq(&mdev->req_lock);
2197 list_add_tail(&e->w.list, &mdev->read_ee);
2198 spin_unlock_irq(&mdev->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002199
Lars Ellenberg45bb9122010-05-14 17:10:48 +02002200 if (drbd_submit_ee(mdev, e, READ, fault_type) == 0)
2201 return TRUE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002202
2203out_free_e:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002204 put_ldev(mdev);
2205 drbd_free_ee(mdev, e);
2206 return FALSE;
2207}
2208
2209static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local)
2210{
2211 int self, peer, rv = -100;
2212 unsigned long ch_self, ch_peer;
2213
2214 self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
2215 peer = mdev->p_uuid[UI_BITMAP] & 1;
2216
2217 ch_peer = mdev->p_uuid[UI_SIZE];
2218 ch_self = mdev->comm_bm_set;
2219
2220 switch (mdev->net_conf->after_sb_0p) {
2221 case ASB_CONSENSUS:
2222 case ASB_DISCARD_SECONDARY:
2223 case ASB_CALL_HELPER:
2224 dev_err(DEV, "Configuration error.\n");
2225 break;
2226 case ASB_DISCONNECT:
2227 break;
2228 case ASB_DISCARD_YOUNGER_PRI:
2229 if (self == 0 && peer == 1) {
2230 rv = -1;
2231 break;
2232 }
2233 if (self == 1 && peer == 0) {
2234 rv = 1;
2235 break;
2236 }
2237 /* Else fall through to one of the other strategies... */
2238 case ASB_DISCARD_OLDER_PRI:
2239 if (self == 0 && peer == 1) {
2240 rv = 1;
2241 break;
2242 }
2243 if (self == 1 && peer == 0) {
2244 rv = -1;
2245 break;
2246 }
2247 /* Else fall through to one of the other strategies... */
Lars Ellenbergad19bf62009-10-14 09:36:49 +02002248 dev_warn(DEV, "Discard younger/older primary did not find a decision\n"
Philipp Reisnerb411b362009-09-25 16:07:19 -07002249 "Using discard-least-changes instead\n");
2250 case ASB_DISCARD_ZERO_CHG:
2251 if (ch_peer == 0 && ch_self == 0) {
2252 rv = test_bit(DISCARD_CONCURRENT, &mdev->flags)
2253 ? -1 : 1;
2254 break;
2255 } else {
2256 if (ch_peer == 0) { rv = 1; break; }
2257 if (ch_self == 0) { rv = -1; break; }
2258 }
2259 if (mdev->net_conf->after_sb_0p == ASB_DISCARD_ZERO_CHG)
2260 break;
2261 case ASB_DISCARD_LEAST_CHG:
2262 if (ch_self < ch_peer)
2263 rv = -1;
2264 else if (ch_self > ch_peer)
2265 rv = 1;
2266 else /* ( ch_self == ch_peer ) */
2267 /* Well, then use something else. */
2268 rv = test_bit(DISCARD_CONCURRENT, &mdev->flags)
2269 ? -1 : 1;
2270 break;
2271 case ASB_DISCARD_LOCAL:
2272 rv = -1;
2273 break;
2274 case ASB_DISCARD_REMOTE:
2275 rv = 1;
2276 }
2277
2278 return rv;
2279}
2280
2281static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local)
2282{
2283 int self, peer, hg, rv = -100;
2284
2285 self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
2286 peer = mdev->p_uuid[UI_BITMAP] & 1;
2287
2288 switch (mdev->net_conf->after_sb_1p) {
2289 case ASB_DISCARD_YOUNGER_PRI:
2290 case ASB_DISCARD_OLDER_PRI:
2291 case ASB_DISCARD_LEAST_CHG:
2292 case ASB_DISCARD_LOCAL:
2293 case ASB_DISCARD_REMOTE:
2294 dev_err(DEV, "Configuration error.\n");
2295 break;
2296 case ASB_DISCONNECT:
2297 break;
2298 case ASB_CONSENSUS:
2299 hg = drbd_asb_recover_0p(mdev);
2300 if (hg == -1 && mdev->state.role == R_SECONDARY)
2301 rv = hg;
2302 if (hg == 1 && mdev->state.role == R_PRIMARY)
2303 rv = hg;
2304 break;
2305 case ASB_VIOLENTLY:
2306 rv = drbd_asb_recover_0p(mdev);
2307 break;
2308 case ASB_DISCARD_SECONDARY:
2309 return mdev->state.role == R_PRIMARY ? 1 : -1;
2310 case ASB_CALL_HELPER:
2311 hg = drbd_asb_recover_0p(mdev);
2312 if (hg == -1 && mdev->state.role == R_PRIMARY) {
2313 self = drbd_set_role(mdev, R_SECONDARY, 0);
2314 /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
2315 * we might be here in C_WF_REPORT_PARAMS which is transient.
2316 * we do not need to wait for the after state change work either. */
2317 self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
2318 if (self != SS_SUCCESS) {
2319 drbd_khelper(mdev, "pri-lost-after-sb");
2320 } else {
2321 dev_warn(DEV, "Successfully gave up primary role.\n");
2322 rv = hg;
2323 }
2324 } else
2325 rv = hg;
2326 }
2327
2328 return rv;
2329}
2330
2331static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local)
2332{
2333 int self, peer, hg, rv = -100;
2334
2335 self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
2336 peer = mdev->p_uuid[UI_BITMAP] & 1;
2337
2338 switch (mdev->net_conf->after_sb_2p) {
2339 case ASB_DISCARD_YOUNGER_PRI:
2340 case ASB_DISCARD_OLDER_PRI:
2341 case ASB_DISCARD_LEAST_CHG:
2342 case ASB_DISCARD_LOCAL:
2343 case ASB_DISCARD_REMOTE:
2344 case ASB_CONSENSUS:
2345 case ASB_DISCARD_SECONDARY:
2346 dev_err(DEV, "Configuration error.\n");
2347 break;
2348 case ASB_VIOLENTLY:
2349 rv = drbd_asb_recover_0p(mdev);
2350 break;
2351 case ASB_DISCONNECT:
2352 break;
2353 case ASB_CALL_HELPER:
2354 hg = drbd_asb_recover_0p(mdev);
2355 if (hg == -1) {
2356 /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
2357 * we might be here in C_WF_REPORT_PARAMS which is transient.
2358 * we do not need to wait for the after state change work either. */
2359 self = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
2360 if (self != SS_SUCCESS) {
2361 drbd_khelper(mdev, "pri-lost-after-sb");
2362 } else {
2363 dev_warn(DEV, "Successfully gave up primary role.\n");
2364 rv = hg;
2365 }
2366 } else
2367 rv = hg;
2368 }
2369
2370 return rv;
2371}
2372
2373static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid,
2374 u64 bits, u64 flags)
2375{
2376 if (!uuid) {
2377 dev_info(DEV, "%s uuid info vanished while I was looking!\n", text);
2378 return;
2379 }
2380 dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n",
2381 text,
2382 (unsigned long long)uuid[UI_CURRENT],
2383 (unsigned long long)uuid[UI_BITMAP],
2384 (unsigned long long)uuid[UI_HISTORY_START],
2385 (unsigned long long)uuid[UI_HISTORY_END],
2386 (unsigned long long)bits,
2387 (unsigned long long)flags);
2388}
2389
2390/*
2391 100 after split brain try auto recover
2392 2 C_SYNC_SOURCE set BitMap
2393 1 C_SYNC_SOURCE use BitMap
2394 0 no Sync
2395 -1 C_SYNC_TARGET use BitMap
2396 -2 C_SYNC_TARGET set BitMap
2397 -100 after split brain, disconnect
2398-1000 unrelated data
2399 */
2400static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local)
2401{
2402 u64 self, peer;
2403 int i, j;
2404
2405 self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
2406 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
2407
2408 *rule_nr = 10;
2409 if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED)
2410 return 0;
2411
2412 *rule_nr = 20;
2413 if ((self == UUID_JUST_CREATED || self == (u64)0) &&
2414 peer != UUID_JUST_CREATED)
2415 return -2;
2416
2417 *rule_nr = 30;
2418 if (self != UUID_JUST_CREATED &&
2419 (peer == UUID_JUST_CREATED || peer == (u64)0))
2420 return 2;
2421
2422 if (self == peer) {
2423 int rct, dc; /* roles at crash time */
2424
2425 if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) {
2426
2427 if (mdev->agreed_pro_version < 91)
2428 return -1001;
2429
2430 if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) &&
2431 (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) {
2432 dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n");
2433 drbd_uuid_set_bm(mdev, 0UL);
2434
2435 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
2436 mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
2437 *rule_nr = 34;
2438 } else {
2439 dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n");
2440 *rule_nr = 36;
2441 }
2442
2443 return 1;
2444 }
2445
2446 if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) {
2447
2448 if (mdev->agreed_pro_version < 91)
2449 return -1001;
2450
2451 if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) &&
2452 (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) {
2453 dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n");
2454
2455 mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START];
2456 mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP];
2457 mdev->p_uuid[UI_BITMAP] = 0UL;
2458
2459 drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
2460 *rule_nr = 35;
2461 } else {
2462 dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n");
2463 *rule_nr = 37;
2464 }
2465
2466 return -1;
2467 }
2468
2469 /* Common power [off|failure] */
2470 rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) +
2471 (mdev->p_uuid[UI_FLAGS] & 2);
2472 /* lowest bit is set when we were primary,
2473 * next bit (weight 2) is set when peer was primary */
2474 *rule_nr = 40;
2475
2476 switch (rct) {
2477 case 0: /* !self_pri && !peer_pri */ return 0;
2478 case 1: /* self_pri && !peer_pri */ return 1;
2479 case 2: /* !self_pri && peer_pri */ return -1;
2480 case 3: /* self_pri && peer_pri */
2481 dc = test_bit(DISCARD_CONCURRENT, &mdev->flags);
2482 return dc ? -1 : 1;
2483 }
2484 }
2485
2486 *rule_nr = 50;
2487 peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
2488 if (self == peer)
2489 return -1;
2490
2491 *rule_nr = 51;
2492 peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1);
2493 if (self == peer) {
2494 self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
2495 peer = mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1);
2496 if (self == peer) {
2497 /* The last P_SYNC_UUID did not get though. Undo the last start of
2498 resync as sync source modifications of the peer's UUIDs. */
2499
2500 if (mdev->agreed_pro_version < 91)
2501 return -1001;
2502
2503 mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START];
2504 mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1];
2505 return -1;
2506 }
2507 }
2508
2509 *rule_nr = 60;
2510 self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
2511 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2512 peer = mdev->p_uuid[i] & ~((u64)1);
2513 if (self == peer)
2514 return -2;
2515 }
2516
2517 *rule_nr = 70;
2518 self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
2519 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
2520 if (self == peer)
2521 return 1;
2522
2523 *rule_nr = 71;
2524 self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
2525 if (self == peer) {
2526 self = mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1);
2527 peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1);
2528 if (self == peer) {
2529 /* The last P_SYNC_UUID did not get though. Undo the last start of
2530 resync as sync source modifications of our UUIDs. */
2531
2532 if (mdev->agreed_pro_version < 91)
2533 return -1001;
2534
2535 _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]);
2536 _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]);
2537
2538 dev_info(DEV, "Undid last start of resync:\n");
2539
2540 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
2541 mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
2542
2543 return 1;
2544 }
2545 }
2546
2547
2548 *rule_nr = 80;
Philipp Reisnerd8c2a362009-11-18 15:52:51 +01002549 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002550 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2551 self = mdev->ldev->md.uuid[i] & ~((u64)1);
2552 if (self == peer)
2553 return 2;
2554 }
2555
2556 *rule_nr = 90;
2557 self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
2558 peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
2559 if (self == peer && self != ((u64)0))
2560 return 100;
2561
2562 *rule_nr = 100;
2563 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2564 self = mdev->ldev->md.uuid[i] & ~((u64)1);
2565 for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) {
2566 peer = mdev->p_uuid[j] & ~((u64)1);
2567 if (self == peer)
2568 return -100;
2569 }
2570 }
2571
2572 return -1000;
2573}
2574
2575/* drbd_sync_handshake() returns the new conn state on success, or
2576 CONN_MASK (-1) on failure.
2577 */
2578static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role,
2579 enum drbd_disk_state peer_disk) __must_hold(local)
2580{
2581 int hg, rule_nr;
2582 enum drbd_conns rv = C_MASK;
2583 enum drbd_disk_state mydisk;
2584
2585 mydisk = mdev->state.disk;
2586 if (mydisk == D_NEGOTIATING)
2587 mydisk = mdev->new_state_tmp.disk;
2588
2589 dev_info(DEV, "drbd_sync_handshake:\n");
2590 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0);
2591 drbd_uuid_dump(mdev, "peer", mdev->p_uuid,
2592 mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
2593
2594 hg = drbd_uuid_compare(mdev, &rule_nr);
2595
2596 dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr);
2597
2598 if (hg == -1000) {
2599 dev_alert(DEV, "Unrelated data, aborting!\n");
2600 return C_MASK;
2601 }
2602 if (hg == -1001) {
2603 dev_alert(DEV, "To resolve this both sides have to support at least protocol\n");
2604 return C_MASK;
2605 }
2606
2607 if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) ||
2608 (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) {
2609 int f = (hg == -100) || abs(hg) == 2;
2610 hg = mydisk > D_INCONSISTENT ? 1 : -1;
2611 if (f)
2612 hg = hg*2;
2613 dev_info(DEV, "Becoming sync %s due to disk states.\n",
2614 hg > 0 ? "source" : "target");
2615 }
2616
Adam Gandelman3a11a482010-04-08 16:48:23 -07002617 if (abs(hg) == 100)
2618 drbd_khelper(mdev, "initial-split-brain");
2619
Philipp Reisnerb411b362009-09-25 16:07:19 -07002620 if (hg == 100 || (hg == -100 && mdev->net_conf->always_asbp)) {
2621 int pcount = (mdev->state.role == R_PRIMARY)
2622 + (peer_role == R_PRIMARY);
2623 int forced = (hg == -100);
2624
2625 switch (pcount) {
2626 case 0:
2627 hg = drbd_asb_recover_0p(mdev);
2628 break;
2629 case 1:
2630 hg = drbd_asb_recover_1p(mdev);
2631 break;
2632 case 2:
2633 hg = drbd_asb_recover_2p(mdev);
2634 break;
2635 }
2636 if (abs(hg) < 100) {
2637 dev_warn(DEV, "Split-Brain detected, %d primaries, "
2638 "automatically solved. Sync from %s node\n",
2639 pcount, (hg < 0) ? "peer" : "this");
2640 if (forced) {
2641 dev_warn(DEV, "Doing a full sync, since"
2642 " UUIDs where ambiguous.\n");
2643 hg = hg*2;
2644 }
2645 }
2646 }
2647
2648 if (hg == -100) {
2649 if (mdev->net_conf->want_lose && !(mdev->p_uuid[UI_FLAGS]&1))
2650 hg = -1;
2651 if (!mdev->net_conf->want_lose && (mdev->p_uuid[UI_FLAGS]&1))
2652 hg = 1;
2653
2654 if (abs(hg) < 100)
2655 dev_warn(DEV, "Split-Brain detected, manually solved. "
2656 "Sync from %s node\n",
2657 (hg < 0) ? "peer" : "this");
2658 }
2659
2660 if (hg == -100) {
Lars Ellenberg580b9762010-02-26 23:15:23 +01002661 /* FIXME this log message is not correct if we end up here
2662 * after an attempted attach on a diskless node.
2663 * We just refuse to attach -- well, we drop the "connection"
2664 * to that disk, in a way... */
Adam Gandelman3a11a482010-04-08 16:48:23 -07002665 dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07002666 drbd_khelper(mdev, "split-brain");
2667 return C_MASK;
2668 }
2669
2670 if (hg > 0 && mydisk <= D_INCONSISTENT) {
2671 dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n");
2672 return C_MASK;
2673 }
2674
2675 if (hg < 0 && /* by intention we do not use mydisk here. */
2676 mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) {
2677 switch (mdev->net_conf->rr_conflict) {
2678 case ASB_CALL_HELPER:
2679 drbd_khelper(mdev, "pri-lost");
2680 /* fall through */
2681 case ASB_DISCONNECT:
2682 dev_err(DEV, "I shall become SyncTarget, but I am primary!\n");
2683 return C_MASK;
2684 case ASB_VIOLENTLY:
2685 dev_warn(DEV, "Becoming SyncTarget, violating the stable-data"
2686 "assumption\n");
2687 }
2688 }
2689
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002690 if (mdev->net_conf->dry_run || test_bit(CONN_DRY_RUN, &mdev->flags)) {
2691 if (hg == 0)
2692 dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n");
2693 else
2694 dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.",
2695 drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET),
2696 abs(hg) >= 2 ? "full" : "bit-map based");
2697 return C_MASK;
2698 }
2699
Philipp Reisnerb411b362009-09-25 16:07:19 -07002700 if (abs(hg) >= 2) {
2701 dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n");
2702 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake"))
2703 return C_MASK;
2704 }
2705
2706 if (hg > 0) { /* become sync source. */
2707 rv = C_WF_BITMAP_S;
2708 } else if (hg < 0) { /* become sync target */
2709 rv = C_WF_BITMAP_T;
2710 } else {
2711 rv = C_CONNECTED;
2712 if (drbd_bm_total_weight(mdev)) {
2713 dev_info(DEV, "No resync, but %lu bits in bitmap!\n",
2714 drbd_bm_total_weight(mdev));
2715 }
2716 }
2717
2718 return rv;
2719}
2720
2721/* returns 1 if invalid */
2722static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self)
2723{
2724 /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */
2725 if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) ||
2726 (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL))
2727 return 0;
2728
2729 /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */
2730 if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL ||
2731 self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL)
2732 return 1;
2733
2734 /* everything else is valid if they are equal on both sides. */
2735 if (peer == self)
2736 return 0;
2737
2738 /* everything es is invalid. */
2739 return 1;
2740}
2741
Philipp Reisner02918be2010-08-20 14:35:10 +02002742static int receive_protocol(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002743{
Philipp Reisner02918be2010-08-20 14:35:10 +02002744 struct p_protocol *p = &mdev->data.rbuf.protocol;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002745 int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p;
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002746 int p_want_lose, p_two_primaries, cf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002747 char p_integrity_alg[SHARED_SECRET_MAX] = "";
2748
Philipp Reisnerb411b362009-09-25 16:07:19 -07002749 p_proto = be32_to_cpu(p->protocol);
2750 p_after_sb_0p = be32_to_cpu(p->after_sb_0p);
2751 p_after_sb_1p = be32_to_cpu(p->after_sb_1p);
2752 p_after_sb_2p = be32_to_cpu(p->after_sb_2p);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002753 p_two_primaries = be32_to_cpu(p->two_primaries);
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002754 cf = be32_to_cpu(p->conn_flags);
2755 p_want_lose = cf & CF_WANT_LOSE;
2756
2757 clear_bit(CONN_DRY_RUN, &mdev->flags);
2758
2759 if (cf & CF_DRY_RUN)
2760 set_bit(CONN_DRY_RUN, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002761
2762 if (p_proto != mdev->net_conf->wire_protocol) {
2763 dev_err(DEV, "incompatible communication protocols\n");
2764 goto disconnect;
2765 }
2766
2767 if (cmp_after_sb(p_after_sb_0p, mdev->net_conf->after_sb_0p)) {
2768 dev_err(DEV, "incompatible after-sb-0pri settings\n");
2769 goto disconnect;
2770 }
2771
2772 if (cmp_after_sb(p_after_sb_1p, mdev->net_conf->after_sb_1p)) {
2773 dev_err(DEV, "incompatible after-sb-1pri settings\n");
2774 goto disconnect;
2775 }
2776
2777 if (cmp_after_sb(p_after_sb_2p, mdev->net_conf->after_sb_2p)) {
2778 dev_err(DEV, "incompatible after-sb-2pri settings\n");
2779 goto disconnect;
2780 }
2781
2782 if (p_want_lose && mdev->net_conf->want_lose) {
2783 dev_err(DEV, "both sides have the 'want_lose' flag set\n");
2784 goto disconnect;
2785 }
2786
2787 if (p_two_primaries != mdev->net_conf->two_primaries) {
2788 dev_err(DEV, "incompatible setting of the two-primaries options\n");
2789 goto disconnect;
2790 }
2791
2792 if (mdev->agreed_pro_version >= 87) {
2793 unsigned char *my_alg = mdev->net_conf->integrity_alg;
2794
2795 if (drbd_recv(mdev, p_integrity_alg, data_size) != data_size)
2796 return FALSE;
2797
2798 p_integrity_alg[SHARED_SECRET_MAX-1] = 0;
2799 if (strcmp(p_integrity_alg, my_alg)) {
2800 dev_err(DEV, "incompatible setting of the data-integrity-alg\n");
2801 goto disconnect;
2802 }
2803 dev_info(DEV, "data-integrity-alg: %s\n",
2804 my_alg[0] ? my_alg : (unsigned char *)"<not-used>");
2805 }
2806
2807 return TRUE;
2808
2809disconnect:
2810 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
2811 return FALSE;
2812}
2813
2814/* helper function
2815 * input: alg name, feature name
2816 * return: NULL (alg name was "")
2817 * ERR_PTR(error) if something goes wrong
2818 * or the crypto hash ptr, if it worked out ok. */
2819struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev,
2820 const char *alg, const char *name)
2821{
2822 struct crypto_hash *tfm;
2823
2824 if (!alg[0])
2825 return NULL;
2826
2827 tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC);
2828 if (IS_ERR(tfm)) {
2829 dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n",
2830 alg, name, PTR_ERR(tfm));
2831 return tfm;
2832 }
2833 if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) {
2834 crypto_free_hash(tfm);
2835 dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name);
2836 return ERR_PTR(-EINVAL);
2837 }
2838 return tfm;
2839}
2840
Philipp Reisner02918be2010-08-20 14:35:10 +02002841static int receive_SyncParam(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int packet_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002842{
2843 int ok = TRUE;
Philipp Reisner02918be2010-08-20 14:35:10 +02002844 struct p_rs_param_95 *p = &mdev->data.rbuf.rs_param_95;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002845 unsigned int header_size, data_size, exp_max_sz;
2846 struct crypto_hash *verify_tfm = NULL;
2847 struct crypto_hash *csums_tfm = NULL;
2848 const int apv = mdev->agreed_pro_version;
Philipp Reisner778f2712010-07-06 11:14:00 +02002849 int *rs_plan_s = NULL;
2850 int fifo_size = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002851
2852 exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param)
2853 : apv == 88 ? sizeof(struct p_rs_param)
2854 + SHARED_SECRET_MAX
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002855 : apv <= 94 ? sizeof(struct p_rs_param_89)
2856 : /* apv >= 95 */ sizeof(struct p_rs_param_95);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002857
Philipp Reisner02918be2010-08-20 14:35:10 +02002858 if (packet_size > exp_max_sz) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002859 dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02002860 packet_size, exp_max_sz);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002861 return FALSE;
2862 }
2863
2864 if (apv <= 88) {
Philipp Reisner02918be2010-08-20 14:35:10 +02002865 header_size = sizeof(struct p_rs_param) - sizeof(struct p_header80);
2866 data_size = packet_size - header_size;
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002867 } else if (apv <= 94) {
Philipp Reisner02918be2010-08-20 14:35:10 +02002868 header_size = sizeof(struct p_rs_param_89) - sizeof(struct p_header80);
2869 data_size = packet_size - header_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002870 D_ASSERT(data_size == 0);
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002871 } else {
Philipp Reisner02918be2010-08-20 14:35:10 +02002872 header_size = sizeof(struct p_rs_param_95) - sizeof(struct p_header80);
2873 data_size = packet_size - header_size;
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002874 D_ASSERT(data_size == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002875 }
2876
2877 /* initialize verify_alg and csums_alg */
2878 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
2879
Philipp Reisner02918be2010-08-20 14:35:10 +02002880 if (drbd_recv(mdev, &p->head.payload, header_size) != header_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002881 return FALSE;
2882
2883 mdev->sync_conf.rate = be32_to_cpu(p->rate);
2884
2885 if (apv >= 88) {
2886 if (apv == 88) {
2887 if (data_size > SHARED_SECRET_MAX) {
2888 dev_err(DEV, "verify-alg too long, "
2889 "peer wants %u, accepting only %u byte\n",
2890 data_size, SHARED_SECRET_MAX);
2891 return FALSE;
2892 }
2893
2894 if (drbd_recv(mdev, p->verify_alg, data_size) != data_size)
2895 return FALSE;
2896
2897 /* we expect NUL terminated string */
2898 /* but just in case someone tries to be evil */
2899 D_ASSERT(p->verify_alg[data_size-1] == 0);
2900 p->verify_alg[data_size-1] = 0;
2901
2902 } else /* apv >= 89 */ {
2903 /* we still expect NUL terminated strings */
2904 /* but just in case someone tries to be evil */
2905 D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0);
2906 D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0);
2907 p->verify_alg[SHARED_SECRET_MAX-1] = 0;
2908 p->csums_alg[SHARED_SECRET_MAX-1] = 0;
2909 }
2910
2911 if (strcmp(mdev->sync_conf.verify_alg, p->verify_alg)) {
2912 if (mdev->state.conn == C_WF_REPORT_PARAMS) {
2913 dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n",
2914 mdev->sync_conf.verify_alg, p->verify_alg);
2915 goto disconnect;
2916 }
2917 verify_tfm = drbd_crypto_alloc_digest_safe(mdev,
2918 p->verify_alg, "verify-alg");
2919 if (IS_ERR(verify_tfm)) {
2920 verify_tfm = NULL;
2921 goto disconnect;
2922 }
2923 }
2924
2925 if (apv >= 89 && strcmp(mdev->sync_conf.csums_alg, p->csums_alg)) {
2926 if (mdev->state.conn == C_WF_REPORT_PARAMS) {
2927 dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n",
2928 mdev->sync_conf.csums_alg, p->csums_alg);
2929 goto disconnect;
2930 }
2931 csums_tfm = drbd_crypto_alloc_digest_safe(mdev,
2932 p->csums_alg, "csums-alg");
2933 if (IS_ERR(csums_tfm)) {
2934 csums_tfm = NULL;
2935 goto disconnect;
2936 }
2937 }
2938
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002939 if (apv > 94) {
2940 mdev->sync_conf.rate = be32_to_cpu(p->rate);
2941 mdev->sync_conf.c_plan_ahead = be32_to_cpu(p->c_plan_ahead);
2942 mdev->sync_conf.c_delay_target = be32_to_cpu(p->c_delay_target);
2943 mdev->sync_conf.c_fill_target = be32_to_cpu(p->c_fill_target);
2944 mdev->sync_conf.c_max_rate = be32_to_cpu(p->c_max_rate);
Philipp Reisner778f2712010-07-06 11:14:00 +02002945
2946 fifo_size = (mdev->sync_conf.c_plan_ahead * 10 * SLEEP_TIME) / HZ;
2947 if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
2948 rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
2949 if (!rs_plan_s) {
2950 dev_err(DEV, "kmalloc of fifo_buffer failed");
2951 goto disconnect;
2952 }
2953 }
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02002954 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002955
2956 spin_lock(&mdev->peer_seq_lock);
2957 /* lock against drbd_nl_syncer_conf() */
2958 if (verify_tfm) {
2959 strcpy(mdev->sync_conf.verify_alg, p->verify_alg);
2960 mdev->sync_conf.verify_alg_len = strlen(p->verify_alg) + 1;
2961 crypto_free_hash(mdev->verify_tfm);
2962 mdev->verify_tfm = verify_tfm;
2963 dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg);
2964 }
2965 if (csums_tfm) {
2966 strcpy(mdev->sync_conf.csums_alg, p->csums_alg);
2967 mdev->sync_conf.csums_alg_len = strlen(p->csums_alg) + 1;
2968 crypto_free_hash(mdev->csums_tfm);
2969 mdev->csums_tfm = csums_tfm;
2970 dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg);
2971 }
Philipp Reisner778f2712010-07-06 11:14:00 +02002972 if (fifo_size != mdev->rs_plan_s.size) {
2973 kfree(mdev->rs_plan_s.values);
2974 mdev->rs_plan_s.values = rs_plan_s;
2975 mdev->rs_plan_s.size = fifo_size;
2976 mdev->rs_planed = 0;
2977 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002978 spin_unlock(&mdev->peer_seq_lock);
2979 }
2980
2981 return ok;
2982disconnect:
2983 /* just for completeness: actually not needed,
2984 * as this is not reached if csums_tfm was ok. */
2985 crypto_free_hash(csums_tfm);
2986 /* but free the verify_tfm again, if csums_tfm did not work out */
2987 crypto_free_hash(verify_tfm);
2988 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
2989 return FALSE;
2990}
2991
2992static void drbd_setup_order_type(struct drbd_conf *mdev, int peer)
2993{
2994 /* sorry, we currently have no working implementation
2995 * of distributed TCQ */
2996}
2997
2998/* warn if the arguments differ by more than 12.5% */
2999static void warn_if_differ_considerably(struct drbd_conf *mdev,
3000 const char *s, sector_t a, sector_t b)
3001{
3002 sector_t d;
3003 if (a == 0 || b == 0)
3004 return;
3005 d = (a > b) ? (a - b) : (b - a);
3006 if (d > (a>>3) || d > (b>>3))
3007 dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s,
3008 (unsigned long long)a, (unsigned long long)b);
3009}
3010
Philipp Reisner02918be2010-08-20 14:35:10 +02003011static int receive_sizes(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003012{
Philipp Reisner02918be2010-08-20 14:35:10 +02003013 struct p_sizes *p = &mdev->data.rbuf.sizes;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003014 enum determine_dev_size dd = unchanged;
3015 unsigned int max_seg_s;
3016 sector_t p_size, p_usize, my_usize;
3017 int ldsc = 0; /* local disk size changed */
Philipp Reisnere89b5912010-03-24 17:11:33 +01003018 enum dds_flags ddsf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003019
Philipp Reisnerb411b362009-09-25 16:07:19 -07003020 p_size = be64_to_cpu(p->d_size);
3021 p_usize = be64_to_cpu(p->u_size);
3022
3023 if (p_size == 0 && mdev->state.disk == D_DISKLESS) {
3024 dev_err(DEV, "some backing storage is needed\n");
3025 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3026 return FALSE;
3027 }
3028
3029 /* just store the peer's disk size for now.
3030 * we still need to figure out whether we accept that. */
3031 mdev->p_size = p_size;
3032
3033#define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
3034 if (get_ldev(mdev)) {
3035 warn_if_differ_considerably(mdev, "lower level device sizes",
3036 p_size, drbd_get_max_capacity(mdev->ldev));
3037 warn_if_differ_considerably(mdev, "user requested size",
3038 p_usize, mdev->ldev->dc.disk_size);
3039
3040 /* if this is the first connect, or an otherwise expected
3041 * param exchange, choose the minimum */
3042 if (mdev->state.conn == C_WF_REPORT_PARAMS)
3043 p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size,
3044 p_usize);
3045
3046 my_usize = mdev->ldev->dc.disk_size;
3047
3048 if (mdev->ldev->dc.disk_size != p_usize) {
3049 mdev->ldev->dc.disk_size = p_usize;
3050 dev_info(DEV, "Peer sets u_size to %lu sectors\n",
3051 (unsigned long)mdev->ldev->dc.disk_size);
3052 }
3053
3054 /* Never shrink a device with usable data during connect.
3055 But allow online shrinking if we are connected. */
Philipp Reisnera393db62009-12-22 13:35:52 +01003056 if (drbd_new_dev_size(mdev, mdev->ldev, 0) <
Philipp Reisnerb411b362009-09-25 16:07:19 -07003057 drbd_get_capacity(mdev->this_bdev) &&
3058 mdev->state.disk >= D_OUTDATED &&
3059 mdev->state.conn < C_CONNECTED) {
3060 dev_err(DEV, "The peer's disk size is too small!\n");
3061 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3062 mdev->ldev->dc.disk_size = my_usize;
3063 put_ldev(mdev);
3064 return FALSE;
3065 }
3066 put_ldev(mdev);
3067 }
3068#undef min_not_zero
3069
Philipp Reisnere89b5912010-03-24 17:11:33 +01003070 ddsf = be16_to_cpu(p->dds_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003071 if (get_ldev(mdev)) {
Philipp Reisnere89b5912010-03-24 17:11:33 +01003072 dd = drbd_determin_dev_size(mdev, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003073 put_ldev(mdev);
3074 if (dd == dev_size_error)
3075 return FALSE;
3076 drbd_md_sync(mdev);
3077 } else {
3078 /* I am diskless, need to accept the peer's size. */
3079 drbd_set_my_capacity(mdev, p_size);
3080 }
3081
Philipp Reisnerb411b362009-09-25 16:07:19 -07003082 if (get_ldev(mdev)) {
3083 if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) {
3084 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
3085 ldsc = 1;
3086 }
3087
Lars Ellenberga1c88d02010-05-14 19:16:41 +02003088 if (mdev->agreed_pro_version < 94)
3089 max_seg_s = be32_to_cpu(p->max_segment_size);
3090 else /* drbd 8.3.8 onwards */
3091 max_seg_s = DRBD_MAX_SEGMENT_SIZE;
3092
Philipp Reisnerb411b362009-09-25 16:07:19 -07003093 if (max_seg_s != queue_max_segment_size(mdev->rq_queue))
3094 drbd_setup_queue_param(mdev, max_seg_s);
3095
Philipp Reisnere89b5912010-03-24 17:11:33 +01003096 drbd_setup_order_type(mdev, be16_to_cpu(p->queue_order_type));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003097 put_ldev(mdev);
3098 }
3099
3100 if (mdev->state.conn > C_WF_REPORT_PARAMS) {
3101 if (be64_to_cpu(p->c_size) !=
3102 drbd_get_capacity(mdev->this_bdev) || ldsc) {
3103 /* we have different sizes, probably peer
3104 * needs to know my new size... */
Philipp Reisnere89b5912010-03-24 17:11:33 +01003105 drbd_send_sizes(mdev, 0, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003106 }
3107 if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) ||
3108 (dd == grew && mdev->state.conn == C_CONNECTED)) {
3109 if (mdev->state.pdsk >= D_INCONSISTENT &&
Philipp Reisnere89b5912010-03-24 17:11:33 +01003110 mdev->state.disk >= D_INCONSISTENT) {
3111 if (ddsf & DDSF_NO_RESYNC)
3112 dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n");
3113 else
3114 resync_after_online_grow(mdev);
3115 } else
Philipp Reisnerb411b362009-09-25 16:07:19 -07003116 set_bit(RESYNC_AFTER_NEG, &mdev->flags);
3117 }
3118 }
3119
3120 return TRUE;
3121}
3122
Philipp Reisner02918be2010-08-20 14:35:10 +02003123static int receive_uuids(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003124{
Philipp Reisner02918be2010-08-20 14:35:10 +02003125 struct p_uuids *p = &mdev->data.rbuf.uuids;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003126 u64 *p_uuid;
3127 int i;
3128
Philipp Reisnerb411b362009-09-25 16:07:19 -07003129 p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO);
3130
3131 for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++)
3132 p_uuid[i] = be64_to_cpu(p->uuid[i]);
3133
3134 kfree(mdev->p_uuid);
3135 mdev->p_uuid = p_uuid;
3136
3137 if (mdev->state.conn < C_CONNECTED &&
3138 mdev->state.disk < D_INCONSISTENT &&
3139 mdev->state.role == R_PRIMARY &&
3140 (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
3141 dev_err(DEV, "Can only connect to data with current UUID=%016llX\n",
3142 (unsigned long long)mdev->ed_uuid);
3143 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3144 return FALSE;
3145 }
3146
3147 if (get_ldev(mdev)) {
3148 int skip_initial_sync =
3149 mdev->state.conn == C_CONNECTED &&
3150 mdev->agreed_pro_version >= 90 &&
3151 mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED &&
3152 (p_uuid[UI_FLAGS] & 8);
3153 if (skip_initial_sync) {
3154 dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n");
3155 drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
3156 "clear_n_write from receive_uuids");
3157 _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]);
3158 _drbd_uuid_set(mdev, UI_BITMAP, 0);
3159 _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
3160 CS_VERBOSE, NULL);
3161 drbd_md_sync(mdev);
3162 }
3163 put_ldev(mdev);
Philipp Reisner18a50fa2010-06-21 14:14:15 +02003164 } else if (mdev->state.disk < D_INCONSISTENT &&
3165 mdev->state.role == R_PRIMARY) {
3166 /* I am a diskless primary, the peer just created a new current UUID
3167 for me. */
3168 drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003169 }
3170
3171 /* Before we test for the disk state, we should wait until an eventually
3172 ongoing cluster wide state change is finished. That is important if
3173 we are primary and are detaching from our disk. We need to see the
3174 new disk state... */
3175 wait_event(mdev->misc_wait, !test_bit(CLUSTER_ST_CHANGE, &mdev->flags));
3176 if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT)
3177 drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
3178
3179 return TRUE;
3180}
3181
3182/**
3183 * convert_state() - Converts the peer's view of the cluster state to our point of view
3184 * @ps: The state as seen by the peer.
3185 */
3186static union drbd_state convert_state(union drbd_state ps)
3187{
3188 union drbd_state ms;
3189
3190 static enum drbd_conns c_tab[] = {
3191 [C_CONNECTED] = C_CONNECTED,
3192
3193 [C_STARTING_SYNC_S] = C_STARTING_SYNC_T,
3194 [C_STARTING_SYNC_T] = C_STARTING_SYNC_S,
3195 [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */
3196 [C_VERIFY_S] = C_VERIFY_T,
3197 [C_MASK] = C_MASK,
3198 };
3199
3200 ms.i = ps.i;
3201
3202 ms.conn = c_tab[ps.conn];
3203 ms.peer = ps.role;
3204 ms.role = ps.peer;
3205 ms.pdsk = ps.disk;
3206 ms.disk = ps.pdsk;
3207 ms.peer_isp = (ps.aftr_isp | ps.user_isp);
3208
3209 return ms;
3210}
3211
Philipp Reisner02918be2010-08-20 14:35:10 +02003212static int receive_req_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003213{
Philipp Reisner02918be2010-08-20 14:35:10 +02003214 struct p_req_state *p = &mdev->data.rbuf.req_state;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003215 union drbd_state mask, val;
3216 int rv;
3217
Philipp Reisnerb411b362009-09-25 16:07:19 -07003218 mask.i = be32_to_cpu(p->mask);
3219 val.i = be32_to_cpu(p->val);
3220
3221 if (test_bit(DISCARD_CONCURRENT, &mdev->flags) &&
3222 test_bit(CLUSTER_ST_CHANGE, &mdev->flags)) {
3223 drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG);
3224 return TRUE;
3225 }
3226
3227 mask = convert_state(mask);
3228 val = convert_state(val);
3229
3230 rv = drbd_change_state(mdev, CS_VERBOSE, mask, val);
3231
3232 drbd_send_sr_reply(mdev, rv);
3233 drbd_md_sync(mdev);
3234
3235 return TRUE;
3236}
3237
Philipp Reisner02918be2010-08-20 14:35:10 +02003238static int receive_state(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003239{
Philipp Reisner02918be2010-08-20 14:35:10 +02003240 struct p_state *p = &mdev->data.rbuf.state;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003241 enum drbd_conns nconn, oconn;
3242 union drbd_state ns, peer_state;
3243 enum drbd_disk_state real_peer_disk;
Philipp Reisner65d922c2010-06-16 16:18:09 +02003244 enum chg_state_flags cs_flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003245 int rv;
3246
Philipp Reisnerb411b362009-09-25 16:07:19 -07003247 peer_state.i = be32_to_cpu(p->state);
3248
3249 real_peer_disk = peer_state.disk;
3250 if (peer_state.disk == D_NEGOTIATING) {
3251 real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT;
3252 dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk));
3253 }
3254
3255 spin_lock_irq(&mdev->req_lock);
3256 retry:
3257 oconn = nconn = mdev->state.conn;
3258 spin_unlock_irq(&mdev->req_lock);
3259
3260 if (nconn == C_WF_REPORT_PARAMS)
3261 nconn = C_CONNECTED;
3262
3263 if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING &&
3264 get_ldev_if_state(mdev, D_NEGOTIATING)) {
3265 int cr; /* consider resync */
3266
3267 /* if we established a new connection */
3268 cr = (oconn < C_CONNECTED);
3269 /* if we had an established connection
3270 * and one of the nodes newly attaches a disk */
3271 cr |= (oconn == C_CONNECTED &&
3272 (peer_state.disk == D_NEGOTIATING ||
3273 mdev->state.disk == D_NEGOTIATING));
3274 /* if we have both been inconsistent, and the peer has been
3275 * forced to be UpToDate with --overwrite-data */
3276 cr |= test_bit(CONSIDER_RESYNC, &mdev->flags);
3277 /* if we had been plain connected, and the admin requested to
3278 * start a sync by "invalidate" or "invalidate-remote" */
3279 cr |= (oconn == C_CONNECTED &&
3280 (peer_state.conn >= C_STARTING_SYNC_S &&
3281 peer_state.conn <= C_WF_BITMAP_T));
3282
3283 if (cr)
3284 nconn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk);
3285
3286 put_ldev(mdev);
3287 if (nconn == C_MASK) {
Lars Ellenberg580b9762010-02-26 23:15:23 +01003288 nconn = C_CONNECTED;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003289 if (mdev->state.disk == D_NEGOTIATING) {
3290 drbd_force_state(mdev, NS(disk, D_DISKLESS));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003291 } else if (peer_state.disk == D_NEGOTIATING) {
3292 dev_err(DEV, "Disk attach process on the peer node was aborted.\n");
3293 peer_state.disk = D_DISKLESS;
Lars Ellenberg580b9762010-02-26 23:15:23 +01003294 real_peer_disk = D_DISKLESS;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003295 } else {
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01003296 if (test_and_clear_bit(CONN_DRY_RUN, &mdev->flags))
3297 return FALSE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003298 D_ASSERT(oconn == C_WF_REPORT_PARAMS);
3299 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3300 return FALSE;
3301 }
3302 }
3303 }
3304
3305 spin_lock_irq(&mdev->req_lock);
3306 if (mdev->state.conn != oconn)
3307 goto retry;
3308 clear_bit(CONSIDER_RESYNC, &mdev->flags);
3309 ns.i = mdev->state.i;
3310 ns.conn = nconn;
3311 ns.peer = peer_state.role;
3312 ns.pdsk = real_peer_disk;
3313 ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp);
3314 if ((nconn == C_CONNECTED || nconn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING)
3315 ns.disk = mdev->new_state_tmp.disk;
Philipp Reisner65d922c2010-06-16 16:18:09 +02003316 cs_flags = CS_VERBOSE + (oconn < C_CONNECTED && nconn >= C_CONNECTED ? 0 : CS_HARD);
Philipp Reisner481c6f52010-06-22 14:03:27 +02003317 if (ns.pdsk == D_CONSISTENT && ns.susp && nconn == C_CONNECTED && oconn < C_CONNECTED &&
3318 test_bit(NEW_CUR_UUID, &mdev->flags)) {
3319 /* Do not allow tl_restart(resend) for a rebooted peer. We can only allow this
3320 for temporal network outages! */
3321 spin_unlock_irq(&mdev->req_lock);
3322 dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n");
3323 tl_clear(mdev);
3324 drbd_uuid_new_current(mdev);
3325 clear_bit(NEW_CUR_UUID, &mdev->flags);
3326 drbd_force_state(mdev, NS2(conn, C_PROTOCOL_ERROR, susp, 0));
3327 return FALSE;
3328 }
Philipp Reisner65d922c2010-06-16 16:18:09 +02003329 rv = _drbd_set_state(mdev, ns, cs_flags, NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003330 ns = mdev->state;
3331 spin_unlock_irq(&mdev->req_lock);
3332
3333 if (rv < SS_SUCCESS) {
3334 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
3335 return FALSE;
3336 }
3337
3338 if (oconn > C_WF_REPORT_PARAMS) {
3339 if (nconn > C_CONNECTED && peer_state.conn <= C_CONNECTED &&
3340 peer_state.disk != D_NEGOTIATING ) {
3341 /* we want resync, peer has not yet decided to sync... */
3342 /* Nowadays only used when forcing a node into primary role and
3343 setting its disk to UpToDate with that */
3344 drbd_send_uuids(mdev);
3345 drbd_send_state(mdev);
3346 }
3347 }
3348
3349 mdev->net_conf->want_lose = 0;
3350
3351 drbd_md_sync(mdev); /* update connected indicator, la_size, ... */
3352
3353 return TRUE;
3354}
3355
Philipp Reisner02918be2010-08-20 14:35:10 +02003356static int receive_sync_uuid(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003357{
Philipp Reisner02918be2010-08-20 14:35:10 +02003358 struct p_rs_uuid *p = &mdev->data.rbuf.rs_uuid;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003359
3360 wait_event(mdev->misc_wait,
3361 mdev->state.conn == C_WF_SYNC_UUID ||
3362 mdev->state.conn < C_CONNECTED ||
3363 mdev->state.disk < D_NEGOTIATING);
3364
3365 /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */
3366
Philipp Reisnerb411b362009-09-25 16:07:19 -07003367 /* Here the _drbd_uuid_ functions are right, current should
3368 _not_ be rotated into the history */
3369 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
3370 _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid));
3371 _drbd_uuid_set(mdev, UI_BITMAP, 0UL);
3372
3373 drbd_start_resync(mdev, C_SYNC_TARGET);
3374
3375 put_ldev(mdev);
3376 } else
3377 dev_err(DEV, "Ignoring SyncUUID packet!\n");
3378
3379 return TRUE;
3380}
3381
3382enum receive_bitmap_ret { OK, DONE, FAILED };
3383
3384static enum receive_bitmap_ret
Philipp Reisner02918be2010-08-20 14:35:10 +02003385receive_bitmap_plain(struct drbd_conf *mdev, unsigned int data_size,
3386 unsigned long *buffer, struct bm_xfer_ctx *c)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003387{
3388 unsigned num_words = min_t(size_t, BM_PACKET_WORDS, c->bm_words - c->word_offset);
3389 unsigned want = num_words * sizeof(long);
3390
Philipp Reisner02918be2010-08-20 14:35:10 +02003391 if (want != data_size) {
3392 dev_err(DEV, "%s:want (%u) != data_size (%u)\n", __func__, want, data_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003393 return FAILED;
3394 }
3395 if (want == 0)
3396 return DONE;
3397 if (drbd_recv(mdev, buffer, want) != want)
3398 return FAILED;
3399
3400 drbd_bm_merge_lel(mdev, c->word_offset, num_words, buffer);
3401
3402 c->word_offset += num_words;
3403 c->bit_offset = c->word_offset * BITS_PER_LONG;
3404 if (c->bit_offset > c->bm_bits)
3405 c->bit_offset = c->bm_bits;
3406
3407 return OK;
3408}
3409
3410static enum receive_bitmap_ret
3411recv_bm_rle_bits(struct drbd_conf *mdev,
3412 struct p_compressed_bm *p,
3413 struct bm_xfer_ctx *c)
3414{
3415 struct bitstream bs;
3416 u64 look_ahead;
3417 u64 rl;
3418 u64 tmp;
3419 unsigned long s = c->bit_offset;
3420 unsigned long e;
3421 int len = p->head.length - (sizeof(*p) - sizeof(p->head));
3422 int toggle = DCBP_get_start(p);
3423 int have;
3424 int bits;
3425
3426 bitstream_init(&bs, p->code, len, DCBP_get_pad_bits(p));
3427
3428 bits = bitstream_get_bits(&bs, &look_ahead, 64);
3429 if (bits < 0)
3430 return FAILED;
3431
3432 for (have = bits; have > 0; s += rl, toggle = !toggle) {
3433 bits = vli_decode_bits(&rl, look_ahead);
3434 if (bits <= 0)
3435 return FAILED;
3436
3437 if (toggle) {
3438 e = s + rl -1;
3439 if (e >= c->bm_bits) {
3440 dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e);
3441 return FAILED;
3442 }
3443 _drbd_bm_set_bits(mdev, s, e);
3444 }
3445
3446 if (have < bits) {
3447 dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n",
3448 have, bits, look_ahead,
3449 (unsigned int)(bs.cur.b - p->code),
3450 (unsigned int)bs.buf_len);
3451 return FAILED;
3452 }
3453 look_ahead >>= bits;
3454 have -= bits;
3455
3456 bits = bitstream_get_bits(&bs, &tmp, 64 - have);
3457 if (bits < 0)
3458 return FAILED;
3459 look_ahead |= tmp << have;
3460 have += bits;
3461 }
3462
3463 c->bit_offset = s;
3464 bm_xfer_ctx_bit_to_word_offset(c);
3465
3466 return (s == c->bm_bits) ? DONE : OK;
3467}
3468
3469static enum receive_bitmap_ret
3470decode_bitmap_c(struct drbd_conf *mdev,
3471 struct p_compressed_bm *p,
3472 struct bm_xfer_ctx *c)
3473{
3474 if (DCBP_get_code(p) == RLE_VLI_Bits)
3475 return recv_bm_rle_bits(mdev, p, c);
3476
3477 /* other variants had been implemented for evaluation,
3478 * but have been dropped as this one turned out to be "best"
3479 * during all our tests. */
3480
3481 dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding);
3482 drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
3483 return FAILED;
3484}
3485
3486void INFO_bm_xfer_stats(struct drbd_conf *mdev,
3487 const char *direction, struct bm_xfer_ctx *c)
3488{
3489 /* what would it take to transfer it "plaintext" */
Philipp Reisner0b70a132010-08-20 13:36:10 +02003490 unsigned plain = sizeof(struct p_header80) *
Philipp Reisnerb411b362009-09-25 16:07:19 -07003491 ((c->bm_words+BM_PACKET_WORDS-1)/BM_PACKET_WORDS+1)
3492 + c->bm_words * sizeof(long);
3493 unsigned total = c->bytes[0] + c->bytes[1];
3494 unsigned r;
3495
3496 /* total can not be zero. but just in case: */
3497 if (total == 0)
3498 return;
3499
3500 /* don't report if not compressed */
3501 if (total >= plain)
3502 return;
3503
3504 /* total < plain. check for overflow, still */
3505 r = (total > UINT_MAX/1000) ? (total / (plain/1000))
3506 : (1000 * total / plain);
3507
3508 if (r > 1000)
3509 r = 1000;
3510
3511 r = 1000 - r;
3512 dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), "
3513 "total %u; compression: %u.%u%%\n",
3514 direction,
3515 c->bytes[1], c->packets[1],
3516 c->bytes[0], c->packets[0],
3517 total, r/10, r % 10);
3518}
3519
3520/* Since we are processing the bitfield from lower addresses to higher,
3521 it does not matter if the process it in 32 bit chunks or 64 bit
3522 chunks as long as it is little endian. (Understand it as byte stream,
3523 beginning with the lowest byte...) If we would use big endian
3524 we would need to process it from the highest address to the lowest,
3525 in order to be agnostic to the 32 vs 64 bits issue.
3526
3527 returns 0 on failure, 1 if we successfully received it. */
Philipp Reisner02918be2010-08-20 14:35:10 +02003528static int receive_bitmap(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003529{
3530 struct bm_xfer_ctx c;
3531 void *buffer;
3532 enum receive_bitmap_ret ret;
3533 int ok = FALSE;
Philipp Reisner02918be2010-08-20 14:35:10 +02003534 struct p_header80 *h = &mdev->data.rbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003535
3536 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
3537
3538 drbd_bm_lock(mdev, "receive bitmap");
3539
3540 /* maybe we should use some per thread scratch page,
3541 * and allocate that during initial device creation? */
3542 buffer = (unsigned long *) __get_free_page(GFP_NOIO);
3543 if (!buffer) {
3544 dev_err(DEV, "failed to allocate one page buffer in %s\n", __func__);
3545 goto out;
3546 }
3547
3548 c = (struct bm_xfer_ctx) {
3549 .bm_bits = drbd_bm_bits(mdev),
3550 .bm_words = drbd_bm_words(mdev),
3551 };
3552
3553 do {
Philipp Reisner02918be2010-08-20 14:35:10 +02003554 if (cmd == P_BITMAP) {
3555 ret = receive_bitmap_plain(mdev, data_size, buffer, &c);
3556 } else if (cmd == P_COMPRESSED_BITMAP) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003557 /* MAYBE: sanity check that we speak proto >= 90,
3558 * and the feature is enabled! */
3559 struct p_compressed_bm *p;
3560
Philipp Reisner02918be2010-08-20 14:35:10 +02003561 if (data_size > BM_PACKET_PAYLOAD_BYTES) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003562 dev_err(DEV, "ReportCBitmap packet too large\n");
3563 goto out;
3564 }
3565 /* use the page buff */
3566 p = buffer;
3567 memcpy(p, h, sizeof(*h));
Philipp Reisner02918be2010-08-20 14:35:10 +02003568 if (drbd_recv(mdev, p->head.payload, data_size) != data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003569 goto out;
3570 if (p->head.length <= (sizeof(*p) - sizeof(p->head))) {
3571 dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", p->head.length);
3572 return FAILED;
3573 }
3574 ret = decode_bitmap_c(mdev, p, &c);
3575 } else {
Philipp Reisner02918be2010-08-20 14:35:10 +02003576 dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003577 goto out;
3578 }
3579
Philipp Reisner02918be2010-08-20 14:35:10 +02003580 c.packets[cmd == P_BITMAP]++;
3581 c.bytes[cmd == P_BITMAP] += sizeof(struct p_header80) + data_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003582
3583 if (ret != OK)
3584 break;
3585
Philipp Reisner02918be2010-08-20 14:35:10 +02003586 if (!drbd_recv_header(mdev, &cmd, &data_size))
Philipp Reisnerb411b362009-09-25 16:07:19 -07003587 goto out;
3588 } while (ret == OK);
3589 if (ret == FAILED)
3590 goto out;
3591
3592 INFO_bm_xfer_stats(mdev, "receive", &c);
3593
3594 if (mdev->state.conn == C_WF_BITMAP_T) {
3595 ok = !drbd_send_bitmap(mdev);
3596 if (!ok)
3597 goto out;
3598 /* Omit CS_ORDERED with this state transition to avoid deadlocks. */
3599 ok = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
3600 D_ASSERT(ok == SS_SUCCESS);
3601 } else if (mdev->state.conn != C_WF_BITMAP_S) {
3602 /* admin may have requested C_DISCONNECTING,
3603 * other threads may have noticed network errors */
3604 dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n",
3605 drbd_conn_str(mdev->state.conn));
3606 }
3607
3608 ok = TRUE;
3609 out:
3610 drbd_bm_unlock(mdev);
3611 if (ok && mdev->state.conn == C_WF_BITMAP_S)
3612 drbd_start_resync(mdev, C_SYNC_SOURCE);
3613 free_page((unsigned long) buffer);
3614 return ok;
3615}
3616
Philipp Reisner02918be2010-08-20 14:35:10 +02003617static int receive_skip(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003618{
3619 /* TODO zero copy sink :) */
3620 static char sink[128];
3621 int size, want, r;
3622
Philipp Reisner02918be2010-08-20 14:35:10 +02003623 dev_warn(DEV, "skipping unknown optional packet type %d, l: %d!\n",
3624 cmd, data_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003625
Philipp Reisner02918be2010-08-20 14:35:10 +02003626 size = data_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003627 while (size > 0) {
3628 want = min_t(int, size, sizeof(sink));
3629 r = drbd_recv(mdev, sink, want);
3630 ERR_IF(r <= 0) break;
3631 size -= r;
3632 }
3633 return size == 0;
3634}
3635
Philipp Reisner02918be2010-08-20 14:35:10 +02003636static int receive_UnplugRemote(struct drbd_conf *mdev, enum drbd_packets cmd, unsigned int data_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003637{
3638 if (mdev->state.disk >= D_INCONSISTENT)
3639 drbd_kick_lo(mdev);
3640
3641 /* Make sure we've acked all the TCP data associated
3642 * with the data requests being unplugged */
3643 drbd_tcp_quickack(mdev->data.socket);
3644
3645 return TRUE;
3646}
3647
Philipp Reisner02918be2010-08-20 14:35:10 +02003648typedef int (*drbd_cmd_handler_f)(struct drbd_conf *, enum drbd_packets cmd, unsigned int to_receive);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003649
Philipp Reisner02918be2010-08-20 14:35:10 +02003650struct data_cmd {
3651 int expect_payload;
3652 size_t pkt_size;
3653 drbd_cmd_handler_f function;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003654};
3655
Philipp Reisner02918be2010-08-20 14:35:10 +02003656static struct data_cmd drbd_cmd_handler[] = {
3657 [P_DATA] = { 1, sizeof(struct p_data), receive_Data },
3658 [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply },
3659 [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } ,
3660 [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } ,
3661 [P_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } ,
3662 [P_COMPRESSED_BITMAP] = { 1, sizeof(struct p_header80), receive_bitmap } ,
3663 [P_UNPLUG_REMOTE] = { 0, sizeof(struct p_header80), receive_UnplugRemote },
3664 [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
3665 [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
3666 [P_SYNC_PARAM] = { 1, sizeof(struct p_header80), receive_SyncParam },
3667 [P_SYNC_PARAM89] = { 1, sizeof(struct p_header80), receive_SyncParam },
3668 [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol },
3669 [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids },
3670 [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes },
3671 [P_STATE] = { 0, sizeof(struct p_state), receive_state },
3672 [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state },
3673 [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid },
3674 [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
3675 [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest },
3676 [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest },
3677 [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip },
3678 /* anything missing from this table is in
3679 * the asender_tbl, see get_asender_cmd */
3680 [P_MAX_CMD] = { 0, 0, NULL },
3681};
3682
3683/* All handler functions that expect a sub-header get that sub-heder in
3684 mdev->data.rbuf.header.head.payload.
3685
3686 Usually in mdev->data.rbuf.header.head the callback can find the usual
3687 p_header, but they may not rely on that. Since there is also p_header95 !
3688 */
Philipp Reisnerb411b362009-09-25 16:07:19 -07003689
3690static void drbdd(struct drbd_conf *mdev)
3691{
Philipp Reisner02918be2010-08-20 14:35:10 +02003692 union p_header *header = &mdev->data.rbuf.header;
3693 unsigned int packet_size;
3694 enum drbd_packets cmd;
3695 size_t shs; /* sub header size */
3696 int rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003697
3698 while (get_t_state(&mdev->receiver) == Running) {
3699 drbd_thread_current_set_cpu(mdev);
Philipp Reisner02918be2010-08-20 14:35:10 +02003700 if (!drbd_recv_header(mdev, &cmd, &packet_size))
3701 goto err_out;
3702
3703 if (unlikely(cmd >= P_MAX_CMD || !drbd_cmd_handler[cmd].function)) {
3704 dev_err(DEV, "unknown packet type %d, l: %d!\n", cmd, packet_size);
3705 goto err_out;
Lars Ellenberg0b33a912009-11-16 15:58:04 +01003706 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003707
Philipp Reisner02918be2010-08-20 14:35:10 +02003708 shs = drbd_cmd_handler[cmd].pkt_size - sizeof(union p_header);
3709 rv = drbd_recv(mdev, &header->h80.payload, shs);
3710 if (unlikely(rv != shs)) {
3711 dev_err(DEV, "short read while reading sub header: rv=%d\n", rv);
3712 goto err_out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003713 }
Philipp Reisner02918be2010-08-20 14:35:10 +02003714
3715 if (packet_size - shs > 0 && !drbd_cmd_handler[cmd].expect_payload) {
3716 dev_err(DEV, "No payload expected %s l:%d\n", cmdname(cmd), packet_size);
3717 goto err_out;
3718 }
3719
3720 rv = drbd_cmd_handler[cmd].function(mdev, cmd, packet_size - shs);
3721
3722 if (unlikely(!rv)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003723 dev_err(DEV, "error receiving %s, l: %d!\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02003724 cmdname(cmd), packet_size);
3725 goto err_out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003726 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003727 }
Philipp Reisner02918be2010-08-20 14:35:10 +02003728
3729 if (0) {
3730 err_out:
3731 drbd_force_state(mdev, NS(conn, C_PROTOCOL_ERROR));
3732 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003733}
3734
Philipp Reisnerb411b362009-09-25 16:07:19 -07003735void drbd_flush_workqueue(struct drbd_conf *mdev)
3736{
3737 struct drbd_wq_barrier barr;
3738
3739 barr.w.cb = w_prev_work_done;
3740 init_completion(&barr.done);
3741 drbd_queue_work(&mdev->data.work, &barr.w);
3742 wait_for_completion(&barr.done);
3743}
3744
Philipp Reisnerf70b35112010-06-24 14:34:40 +02003745void drbd_free_tl_hash(struct drbd_conf *mdev)
3746{
3747 struct hlist_head *h;
3748
3749 spin_lock_irq(&mdev->req_lock);
3750
3751 if (!mdev->tl_hash || mdev->state.conn != C_STANDALONE) {
3752 spin_unlock_irq(&mdev->req_lock);
3753 return;
3754 }
3755 /* paranoia code */
3756 for (h = mdev->ee_hash; h < mdev->ee_hash + mdev->ee_hash_s; h++)
3757 if (h->first)
3758 dev_err(DEV, "ASSERT FAILED ee_hash[%u].first == %p, expected NULL\n",
3759 (int)(h - mdev->ee_hash), h->first);
3760 kfree(mdev->ee_hash);
3761 mdev->ee_hash = NULL;
3762 mdev->ee_hash_s = 0;
3763
3764 /* paranoia code */
3765 for (h = mdev->tl_hash; h < mdev->tl_hash + mdev->tl_hash_s; h++)
3766 if (h->first)
3767 dev_err(DEV, "ASSERT FAILED tl_hash[%u] == %p, expected NULL\n",
3768 (int)(h - mdev->tl_hash), h->first);
3769 kfree(mdev->tl_hash);
3770 mdev->tl_hash = NULL;
3771 mdev->tl_hash_s = 0;
3772 spin_unlock_irq(&mdev->req_lock);
3773}
3774
Philipp Reisnerb411b362009-09-25 16:07:19 -07003775static void drbd_disconnect(struct drbd_conf *mdev)
3776{
3777 enum drbd_fencing_p fp;
3778 union drbd_state os, ns;
3779 int rv = SS_UNKNOWN_ERROR;
3780 unsigned int i;
3781
3782 if (mdev->state.conn == C_STANDALONE)
3783 return;
3784 if (mdev->state.conn >= C_WF_CONNECTION)
3785 dev_err(DEV, "ASSERT FAILED cstate = %s, expected < WFConnection\n",
3786 drbd_conn_str(mdev->state.conn));
3787
3788 /* asender does not clean up anything. it must not interfere, either */
3789 drbd_thread_stop(&mdev->asender);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003790 drbd_free_sock(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003791
Philipp Reisner85719572010-07-21 10:20:17 +02003792 /* wait for current activity to cease. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07003793 spin_lock_irq(&mdev->req_lock);
3794 _drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
3795 _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee);
3796 _drbd_wait_ee_list_empty(mdev, &mdev->read_ee);
3797 spin_unlock_irq(&mdev->req_lock);
3798
3799 /* We do not have data structures that would allow us to
3800 * get the rs_pending_cnt down to 0 again.
3801 * * On C_SYNC_TARGET we do not have any data structures describing
3802 * the pending RSDataRequest's we have sent.
3803 * * On C_SYNC_SOURCE there is no data structure that tracks
3804 * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget.
3805 * And no, it is not the sum of the reference counts in the
3806 * resync_LRU. The resync_LRU tracks the whole operation including
3807 * the disk-IO, while the rs_pending_cnt only tracks the blocks
3808 * on the fly. */
3809 drbd_rs_cancel_all(mdev);
3810 mdev->rs_total = 0;
3811 mdev->rs_failed = 0;
3812 atomic_set(&mdev->rs_pending_cnt, 0);
3813 wake_up(&mdev->misc_wait);
3814
3815 /* make sure syncer is stopped and w_resume_next_sg queued */
3816 del_timer_sync(&mdev->resync_timer);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003817 resync_timer_fn((unsigned long)mdev);
3818
Philipp Reisnerb411b362009-09-25 16:07:19 -07003819 /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier,
3820 * w_make_resync_request etc. which may still be on the worker queue
3821 * to be "canceled" */
3822 drbd_flush_workqueue(mdev);
3823
3824 /* This also does reclaim_net_ee(). If we do this too early, we might
3825 * miss some resync ee and pages.*/
3826 drbd_process_done_ee(mdev);
3827
3828 kfree(mdev->p_uuid);
3829 mdev->p_uuid = NULL;
3830
3831 if (!mdev->state.susp)
3832 tl_clear(mdev);
3833
Philipp Reisnerb411b362009-09-25 16:07:19 -07003834 dev_info(DEV, "Connection closed\n");
3835
3836 drbd_md_sync(mdev);
3837
3838 fp = FP_DONT_CARE;
3839 if (get_ldev(mdev)) {
3840 fp = mdev->ldev->dc.fencing;
3841 put_ldev(mdev);
3842 }
3843
Philipp Reisner87f7be42010-06-11 13:56:33 +02003844 if (mdev->state.role == R_PRIMARY && fp >= FP_RESOURCE && mdev->state.pdsk >= D_UNKNOWN)
3845 drbd_try_outdate_peer_async(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003846
3847 spin_lock_irq(&mdev->req_lock);
3848 os = mdev->state;
3849 if (os.conn >= C_UNCONNECTED) {
3850 /* Do not restart in case we are C_DISCONNECTING */
3851 ns = os;
3852 ns.conn = C_UNCONNECTED;
3853 rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
3854 }
3855 spin_unlock_irq(&mdev->req_lock);
3856
3857 if (os.conn == C_DISCONNECTING) {
Philipp Reisner84dfb9f2010-06-23 11:20:05 +02003858 wait_event(mdev->net_cnt_wait, atomic_read(&mdev->net_cnt) == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003859
Philipp Reisnerf70b35112010-06-24 14:34:40 +02003860 if (!mdev->state.susp) {
3861 /* we must not free the tl_hash
3862 * while application io is still on the fly */
3863 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
3864 drbd_free_tl_hash(mdev);
3865 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003866
3867 crypto_free_hash(mdev->cram_hmac_tfm);
3868 mdev->cram_hmac_tfm = NULL;
3869
3870 kfree(mdev->net_conf);
3871 mdev->net_conf = NULL;
3872 drbd_request_state(mdev, NS(conn, C_STANDALONE));
3873 }
3874
3875 /* tcp_close and release of sendpage pages can be deferred. I don't
3876 * want to use SO_LINGER, because apparently it can be deferred for
3877 * more than 20 seconds (longest time I checked).
3878 *
3879 * Actually we don't care for exactly when the network stack does its
3880 * put_page(), but release our reference on these pages right here.
3881 */
3882 i = drbd_release_ee(mdev, &mdev->net_ee);
3883 if (i)
3884 dev_info(DEV, "net_ee not empty, killed %u entries\n", i);
Lars Ellenberg435f0742010-09-06 12:30:25 +02003885 i = atomic_read(&mdev->pp_in_use_by_net);
3886 if (i)
3887 dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003888 i = atomic_read(&mdev->pp_in_use);
3889 if (i)
Lars Ellenberg45bb9122010-05-14 17:10:48 +02003890 dev_info(DEV, "pp_in_use = %d, expected 0\n", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003891
3892 D_ASSERT(list_empty(&mdev->read_ee));
3893 D_ASSERT(list_empty(&mdev->active_ee));
3894 D_ASSERT(list_empty(&mdev->sync_ee));
3895 D_ASSERT(list_empty(&mdev->done_ee));
3896
3897 /* ok, no more ee's on the fly, it is safe to reset the epoch_size */
3898 atomic_set(&mdev->current_epoch->epoch_size, 0);
3899 D_ASSERT(list_empty(&mdev->current_epoch->list));
3900}
3901
3902/*
3903 * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version
3904 * we can agree on is stored in agreed_pro_version.
3905 *
3906 * feature flags and the reserved array should be enough room for future
3907 * enhancements of the handshake protocol, and possible plugins...
3908 *
3909 * for now, they are expected to be zero, but ignored.
3910 */
3911static int drbd_send_handshake(struct drbd_conf *mdev)
3912{
3913 /* ASSERT current == mdev->receiver ... */
3914 struct p_handshake *p = &mdev->data.sbuf.handshake;
3915 int ok;
3916
3917 if (mutex_lock_interruptible(&mdev->data.mutex)) {
3918 dev_err(DEV, "interrupted during initial handshake\n");
3919 return 0; /* interrupted. not ok. */
3920 }
3921
3922 if (mdev->data.socket == NULL) {
3923 mutex_unlock(&mdev->data.mutex);
3924 return 0;
3925 }
3926
3927 memset(p, 0, sizeof(*p));
3928 p->protocol_min = cpu_to_be32(PRO_VERSION_MIN);
3929 p->protocol_max = cpu_to_be32(PRO_VERSION_MAX);
3930 ok = _drbd_send_cmd( mdev, mdev->data.socket, P_HAND_SHAKE,
Philipp Reisner0b70a132010-08-20 13:36:10 +02003931 (struct p_header80 *)p, sizeof(*p), 0 );
Philipp Reisnerb411b362009-09-25 16:07:19 -07003932 mutex_unlock(&mdev->data.mutex);
3933 return ok;
3934}
3935
3936/*
3937 * return values:
3938 * 1 yes, we have a valid connection
3939 * 0 oops, did not work out, please try again
3940 * -1 peer talks different language,
3941 * no point in trying again, please go standalone.
3942 */
3943static int drbd_do_handshake(struct drbd_conf *mdev)
3944{
3945 /* ASSERT current == mdev->receiver ... */
3946 struct p_handshake *p = &mdev->data.rbuf.handshake;
Philipp Reisner02918be2010-08-20 14:35:10 +02003947 const int expect = sizeof(struct p_handshake) - sizeof(struct p_header80);
3948 unsigned int length;
3949 enum drbd_packets cmd;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003950 int rv;
3951
3952 rv = drbd_send_handshake(mdev);
3953 if (!rv)
3954 return 0;
3955
Philipp Reisner02918be2010-08-20 14:35:10 +02003956 rv = drbd_recv_header(mdev, &cmd, &length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003957 if (!rv)
3958 return 0;
3959
Philipp Reisner02918be2010-08-20 14:35:10 +02003960 if (cmd != P_HAND_SHAKE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003961 dev_err(DEV, "expected HandShake packet, received: %s (0x%04x)\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02003962 cmdname(cmd), cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003963 return -1;
3964 }
3965
Philipp Reisner02918be2010-08-20 14:35:10 +02003966 if (length != expect) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003967 dev_err(DEV, "expected HandShake length: %u, received: %u\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02003968 expect, length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003969 return -1;
3970 }
3971
3972 rv = drbd_recv(mdev, &p->head.payload, expect);
3973
3974 if (rv != expect) {
3975 dev_err(DEV, "short read receiving handshake packet: l=%u\n", rv);
3976 return 0;
3977 }
3978
Philipp Reisnerb411b362009-09-25 16:07:19 -07003979 p->protocol_min = be32_to_cpu(p->protocol_min);
3980 p->protocol_max = be32_to_cpu(p->protocol_max);
3981 if (p->protocol_max == 0)
3982 p->protocol_max = p->protocol_min;
3983
3984 if (PRO_VERSION_MAX < p->protocol_min ||
3985 PRO_VERSION_MIN > p->protocol_max)
3986 goto incompat;
3987
3988 mdev->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max);
3989
3990 dev_info(DEV, "Handshake successful: "
3991 "Agreed network protocol version %d\n", mdev->agreed_pro_version);
3992
3993 return 1;
3994
3995 incompat:
3996 dev_err(DEV, "incompatible DRBD dialects: "
3997 "I support %d-%d, peer supports %d-%d\n",
3998 PRO_VERSION_MIN, PRO_VERSION_MAX,
3999 p->protocol_min, p->protocol_max);
4000 return -1;
4001}
4002
4003#if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE)
4004static int drbd_do_auth(struct drbd_conf *mdev)
4005{
4006 dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n");
4007 dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004008 return -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004009}
4010#else
4011#define CHALLENGE_LEN 64
Johannes Thomab10d96c2010-01-07 16:02:50 +01004012
4013/* Return value:
4014 1 - auth succeeded,
4015 0 - failed, try again (network error),
4016 -1 - auth failed, don't try again.
4017*/
4018
Philipp Reisnerb411b362009-09-25 16:07:19 -07004019static int drbd_do_auth(struct drbd_conf *mdev)
4020{
4021 char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */
4022 struct scatterlist sg;
4023 char *response = NULL;
4024 char *right_response = NULL;
4025 char *peers_ch = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004026 unsigned int key_len = strlen(mdev->net_conf->shared_secret);
4027 unsigned int resp_size;
4028 struct hash_desc desc;
Philipp Reisner02918be2010-08-20 14:35:10 +02004029 enum drbd_packets cmd;
4030 unsigned int length;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004031 int rv;
4032
4033 desc.tfm = mdev->cram_hmac_tfm;
4034 desc.flags = 0;
4035
4036 rv = crypto_hash_setkey(mdev->cram_hmac_tfm,
4037 (u8 *)mdev->net_conf->shared_secret, key_len);
4038 if (rv) {
4039 dev_err(DEV, "crypto_hash_setkey() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004040 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004041 goto fail;
4042 }
4043
4044 get_random_bytes(my_challenge, CHALLENGE_LEN);
4045
4046 rv = drbd_send_cmd2(mdev, P_AUTH_CHALLENGE, my_challenge, CHALLENGE_LEN);
4047 if (!rv)
4048 goto fail;
4049
Philipp Reisner02918be2010-08-20 14:35:10 +02004050 rv = drbd_recv_header(mdev, &cmd, &length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004051 if (!rv)
4052 goto fail;
4053
Philipp Reisner02918be2010-08-20 14:35:10 +02004054 if (cmd != P_AUTH_CHALLENGE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004055 dev_err(DEV, "expected AuthChallenge packet, received: %s (0x%04x)\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02004056 cmdname(cmd), cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004057 rv = 0;
4058 goto fail;
4059 }
4060
Philipp Reisner02918be2010-08-20 14:35:10 +02004061 if (length > CHALLENGE_LEN * 2) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004062 dev_err(DEV, "expected AuthChallenge payload too big.\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004063 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004064 goto fail;
4065 }
4066
Philipp Reisner02918be2010-08-20 14:35:10 +02004067 peers_ch = kmalloc(length, GFP_NOIO);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004068 if (peers_ch == NULL) {
4069 dev_err(DEV, "kmalloc of peers_ch failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004070 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004071 goto fail;
4072 }
4073
Philipp Reisner02918be2010-08-20 14:35:10 +02004074 rv = drbd_recv(mdev, peers_ch, length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004075
Philipp Reisner02918be2010-08-20 14:35:10 +02004076 if (rv != length) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004077 dev_err(DEV, "short read AuthChallenge: l=%u\n", rv);
4078 rv = 0;
4079 goto fail;
4080 }
4081
4082 resp_size = crypto_hash_digestsize(mdev->cram_hmac_tfm);
4083 response = kmalloc(resp_size, GFP_NOIO);
4084 if (response == NULL) {
4085 dev_err(DEV, "kmalloc of response failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004086 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004087 goto fail;
4088 }
4089
4090 sg_init_table(&sg, 1);
Philipp Reisner02918be2010-08-20 14:35:10 +02004091 sg_set_buf(&sg, peers_ch, length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004092
4093 rv = crypto_hash_digest(&desc, &sg, sg.length, response);
4094 if (rv) {
4095 dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004096 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004097 goto fail;
4098 }
4099
4100 rv = drbd_send_cmd2(mdev, P_AUTH_RESPONSE, response, resp_size);
4101 if (!rv)
4102 goto fail;
4103
Philipp Reisner02918be2010-08-20 14:35:10 +02004104 rv = drbd_recv_header(mdev, &cmd, &length);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004105 if (!rv)
4106 goto fail;
4107
Philipp Reisner02918be2010-08-20 14:35:10 +02004108 if (cmd != P_AUTH_RESPONSE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004109 dev_err(DEV, "expected AuthResponse packet, received: %s (0x%04x)\n",
Philipp Reisner02918be2010-08-20 14:35:10 +02004110 cmdname(cmd), cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004111 rv = 0;
4112 goto fail;
4113 }
4114
Philipp Reisner02918be2010-08-20 14:35:10 +02004115 if (length != resp_size) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004116 dev_err(DEV, "expected AuthResponse payload of wrong size\n");
4117 rv = 0;
4118 goto fail;
4119 }
4120
4121 rv = drbd_recv(mdev, response , resp_size);
4122
4123 if (rv != resp_size) {
4124 dev_err(DEV, "short read receiving AuthResponse: l=%u\n", rv);
4125 rv = 0;
4126 goto fail;
4127 }
4128
4129 right_response = kmalloc(resp_size, GFP_NOIO);
Julia Lawall2d1ee872009-12-27 22:27:11 +01004130 if (right_response == NULL) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004131 dev_err(DEV, "kmalloc of right_response failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004132 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004133 goto fail;
4134 }
4135
4136 sg_set_buf(&sg, my_challenge, CHALLENGE_LEN);
4137
4138 rv = crypto_hash_digest(&desc, &sg, sg.length, right_response);
4139 if (rv) {
4140 dev_err(DEV, "crypto_hash_digest() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004141 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004142 goto fail;
4143 }
4144
4145 rv = !memcmp(response, right_response, resp_size);
4146
4147 if (rv)
4148 dev_info(DEV, "Peer authenticated using %d bytes of '%s' HMAC\n",
4149 resp_size, mdev->net_conf->cram_hmac_alg);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004150 else
4151 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004152
4153 fail:
4154 kfree(peers_ch);
4155 kfree(response);
4156 kfree(right_response);
4157
4158 return rv;
4159}
4160#endif
4161
4162int drbdd_init(struct drbd_thread *thi)
4163{
4164 struct drbd_conf *mdev = thi->mdev;
4165 unsigned int minor = mdev_to_minor(mdev);
4166 int h;
4167
4168 sprintf(current->comm, "drbd%d_receiver", minor);
4169
4170 dev_info(DEV, "receiver (re)started\n");
4171
4172 do {
4173 h = drbd_connect(mdev);
4174 if (h == 0) {
4175 drbd_disconnect(mdev);
4176 __set_current_state(TASK_INTERRUPTIBLE);
4177 schedule_timeout(HZ);
4178 }
4179 if (h == -1) {
4180 dev_warn(DEV, "Discarding network configuration.\n");
4181 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
4182 }
4183 } while (h == 0);
4184
4185 if (h > 0) {
4186 if (get_net_conf(mdev)) {
4187 drbdd(mdev);
4188 put_net_conf(mdev);
4189 }
4190 }
4191
4192 drbd_disconnect(mdev);
4193
4194 dev_info(DEV, "receiver terminated\n");
4195 return 0;
4196}
4197
4198/* ********* acknowledge sender ******** */
4199
Philipp Reisner0b70a132010-08-20 13:36:10 +02004200static int got_RqSReply(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004201{
4202 struct p_req_state_reply *p = (struct p_req_state_reply *)h;
4203
4204 int retcode = be32_to_cpu(p->retcode);
4205
4206 if (retcode >= SS_SUCCESS) {
4207 set_bit(CL_ST_CHG_SUCCESS, &mdev->flags);
4208 } else {
4209 set_bit(CL_ST_CHG_FAIL, &mdev->flags);
4210 dev_err(DEV, "Requested state change failed by peer: %s (%d)\n",
4211 drbd_set_st_err_str(retcode), retcode);
4212 }
4213 wake_up(&mdev->state_wait);
4214
4215 return TRUE;
4216}
4217
Philipp Reisner0b70a132010-08-20 13:36:10 +02004218static int got_Ping(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004219{
4220 return drbd_send_ping_ack(mdev);
4221
4222}
4223
Philipp Reisner0b70a132010-08-20 13:36:10 +02004224static int got_PingAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004225{
4226 /* restore idle timeout */
4227 mdev->meta.socket->sk->sk_rcvtimeo = mdev->net_conf->ping_int*HZ;
Philipp Reisner309d1602010-03-02 15:03:44 +01004228 if (!test_and_set_bit(GOT_PING_ACK, &mdev->flags))
4229 wake_up(&mdev->misc_wait);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004230
4231 return TRUE;
4232}
4233
Philipp Reisner0b70a132010-08-20 13:36:10 +02004234static int got_IsInSync(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004235{
4236 struct p_block_ack *p = (struct p_block_ack *)h;
4237 sector_t sector = be64_to_cpu(p->sector);
4238 int blksize = be32_to_cpu(p->blksize);
4239
4240 D_ASSERT(mdev->agreed_pro_version >= 89);
4241
4242 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4243
4244 drbd_rs_complete_io(mdev, sector);
4245 drbd_set_in_sync(mdev, sector, blksize);
4246 /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */
4247 mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT);
4248 dec_rs_pending(mdev);
Philipp Reisner778f2712010-07-06 11:14:00 +02004249 atomic_add(blksize >> 9, &mdev->rs_sect_in);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004250
4251 return TRUE;
4252}
4253
4254/* when we receive the ACK for a write request,
4255 * verify that we actually know about it */
4256static struct drbd_request *_ack_id_to_req(struct drbd_conf *mdev,
4257 u64 id, sector_t sector)
4258{
4259 struct hlist_head *slot = tl_hash_slot(mdev, sector);
4260 struct hlist_node *n;
4261 struct drbd_request *req;
4262
4263 hlist_for_each_entry(req, n, slot, colision) {
4264 if ((unsigned long)req == (unsigned long)id) {
4265 if (req->sector != sector) {
4266 dev_err(DEV, "_ack_id_to_req: found req %p but it has "
4267 "wrong sector (%llus versus %llus)\n", req,
4268 (unsigned long long)req->sector,
4269 (unsigned long long)sector);
4270 break;
4271 }
4272 return req;
4273 }
4274 }
4275 dev_err(DEV, "_ack_id_to_req: failed to find req %p, sector %llus in list\n",
4276 (void *)(unsigned long)id, (unsigned long long)sector);
4277 return NULL;
4278}
4279
4280typedef struct drbd_request *(req_validator_fn)
4281 (struct drbd_conf *mdev, u64 id, sector_t sector);
4282
4283static int validate_req_change_req_state(struct drbd_conf *mdev,
4284 u64 id, sector_t sector, req_validator_fn validator,
4285 const char *func, enum drbd_req_event what)
4286{
4287 struct drbd_request *req;
4288 struct bio_and_error m;
4289
4290 spin_lock_irq(&mdev->req_lock);
4291 req = validator(mdev, id, sector);
4292 if (unlikely(!req)) {
4293 spin_unlock_irq(&mdev->req_lock);
4294 dev_err(DEV, "%s: got a corrupt block_id/sector pair\n", func);
4295 return FALSE;
4296 }
4297 __req_mod(req, what, &m);
4298 spin_unlock_irq(&mdev->req_lock);
4299
4300 if (m.bio)
4301 complete_master_bio(mdev, &m);
4302 return TRUE;
4303}
4304
Philipp Reisner0b70a132010-08-20 13:36:10 +02004305static int got_BlockAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004306{
4307 struct p_block_ack *p = (struct p_block_ack *)h;
4308 sector_t sector = be64_to_cpu(p->sector);
4309 int blksize = be32_to_cpu(p->blksize);
4310 enum drbd_req_event what;
4311
4312 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4313
4314 if (is_syncer_block_id(p->block_id)) {
4315 drbd_set_in_sync(mdev, sector, blksize);
4316 dec_rs_pending(mdev);
4317 return TRUE;
4318 }
4319 switch (be16_to_cpu(h->command)) {
4320 case P_RS_WRITE_ACK:
4321 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
4322 what = write_acked_by_peer_and_sis;
4323 break;
4324 case P_WRITE_ACK:
4325 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
4326 what = write_acked_by_peer;
4327 break;
4328 case P_RECV_ACK:
4329 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_B);
4330 what = recv_acked_by_peer;
4331 break;
4332 case P_DISCARD_ACK:
4333 D_ASSERT(mdev->net_conf->wire_protocol == DRBD_PROT_C);
4334 what = conflict_discarded_by_peer;
4335 break;
4336 default:
4337 D_ASSERT(0);
4338 return FALSE;
4339 }
4340
4341 return validate_req_change_req_state(mdev, p->block_id, sector,
4342 _ack_id_to_req, __func__ , what);
4343}
4344
Philipp Reisner0b70a132010-08-20 13:36:10 +02004345static int got_NegAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004346{
4347 struct p_block_ack *p = (struct p_block_ack *)h;
4348 sector_t sector = be64_to_cpu(p->sector);
4349
4350 if (__ratelimit(&drbd_ratelimit_state))
4351 dev_warn(DEV, "Got NegAck packet. Peer is in troubles?\n");
4352
4353 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4354
4355 if (is_syncer_block_id(p->block_id)) {
4356 int size = be32_to_cpu(p->blksize);
4357 dec_rs_pending(mdev);
4358 drbd_rs_failed_io(mdev, sector, size);
4359 return TRUE;
4360 }
4361 return validate_req_change_req_state(mdev, p->block_id, sector,
4362 _ack_id_to_req, __func__ , neg_acked);
4363}
4364
Philipp Reisner0b70a132010-08-20 13:36:10 +02004365static int got_NegDReply(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004366{
4367 struct p_block_ack *p = (struct p_block_ack *)h;
4368 sector_t sector = be64_to_cpu(p->sector);
4369
4370 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4371 dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n",
4372 (unsigned long long)sector, be32_to_cpu(p->blksize));
4373
4374 return validate_req_change_req_state(mdev, p->block_id, sector,
4375 _ar_id_to_req, __func__ , neg_acked);
4376}
4377
Philipp Reisner0b70a132010-08-20 13:36:10 +02004378static int got_NegRSDReply(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004379{
4380 sector_t sector;
4381 int size;
4382 struct p_block_ack *p = (struct p_block_ack *)h;
4383
4384 sector = be64_to_cpu(p->sector);
4385 size = be32_to_cpu(p->blksize);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004386
4387 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4388
4389 dec_rs_pending(mdev);
4390
4391 if (get_ldev_if_state(mdev, D_FAILED)) {
4392 drbd_rs_complete_io(mdev, sector);
4393 drbd_rs_failed_io(mdev, sector, size);
4394 put_ldev(mdev);
4395 }
4396
4397 return TRUE;
4398}
4399
Philipp Reisner0b70a132010-08-20 13:36:10 +02004400static int got_BarrierAck(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004401{
4402 struct p_barrier_ack *p = (struct p_barrier_ack *)h;
4403
4404 tl_release(mdev, p->barrier, be32_to_cpu(p->set_size));
4405
4406 return TRUE;
4407}
4408
Philipp Reisner0b70a132010-08-20 13:36:10 +02004409static int got_OVResult(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004410{
4411 struct p_block_ack *p = (struct p_block_ack *)h;
4412 struct drbd_work *w;
4413 sector_t sector;
4414 int size;
4415
4416 sector = be64_to_cpu(p->sector);
4417 size = be32_to_cpu(p->blksize);
4418
4419 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4420
4421 if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC)
4422 drbd_ov_oos_found(mdev, sector, size);
4423 else
4424 ov_oos_print(mdev);
4425
4426 drbd_rs_complete_io(mdev, sector);
4427 dec_rs_pending(mdev);
4428
4429 if (--mdev->ov_left == 0) {
4430 w = kmalloc(sizeof(*w), GFP_NOIO);
4431 if (w) {
4432 w->cb = w_ov_finished;
4433 drbd_queue_work_front(&mdev->data.work, w);
4434 } else {
4435 dev_err(DEV, "kmalloc(w) failed.");
4436 ov_oos_print(mdev);
4437 drbd_resync_finished(mdev);
4438 }
4439 }
4440 return TRUE;
4441}
4442
Philipp Reisner02918be2010-08-20 14:35:10 +02004443static int got_skip(struct drbd_conf *mdev, struct p_header80 *h)
Philipp Reisner0ced55a2010-04-30 15:26:20 +02004444{
Philipp Reisner0ced55a2010-04-30 15:26:20 +02004445 return TRUE;
4446}
4447
Philipp Reisnerb411b362009-09-25 16:07:19 -07004448struct asender_cmd {
4449 size_t pkt_size;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004450 int (*process)(struct drbd_conf *mdev, struct p_header80 *h);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004451};
4452
4453static struct asender_cmd *get_asender_cmd(int cmd)
4454{
4455 static struct asender_cmd asender_tbl[] = {
4456 /* anything missing from this table is in
4457 * the drbd_cmd_handler (drbd_default_handler) table,
4458 * see the beginning of drbdd() */
Philipp Reisner0b70a132010-08-20 13:36:10 +02004459 [P_PING] = { sizeof(struct p_header80), got_Ping },
4460 [P_PING_ACK] = { sizeof(struct p_header80), got_PingAck },
Philipp Reisnerb411b362009-09-25 16:07:19 -07004461 [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4462 [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4463 [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4464 [P_DISCARD_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4465 [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck },
4466 [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply },
4467 [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply},
4468 [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult },
4469 [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck },
4470 [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply },
4471 [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync },
Philipp Reisner02918be2010-08-20 14:35:10 +02004472 [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip },
Philipp Reisnerb411b362009-09-25 16:07:19 -07004473 [P_MAX_CMD] = { 0, NULL },
4474 };
4475 if (cmd > P_MAX_CMD || asender_tbl[cmd].process == NULL)
4476 return NULL;
4477 return &asender_tbl[cmd];
4478}
4479
4480int drbd_asender(struct drbd_thread *thi)
4481{
4482 struct drbd_conf *mdev = thi->mdev;
Philipp Reisner02918be2010-08-20 14:35:10 +02004483 struct p_header80 *h = &mdev->meta.rbuf.header.h80;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004484 struct asender_cmd *cmd = NULL;
4485
4486 int rv, len;
4487 void *buf = h;
4488 int received = 0;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004489 int expect = sizeof(struct p_header80);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004490 int empty;
4491
4492 sprintf(current->comm, "drbd%d_asender", mdev_to_minor(mdev));
4493
4494 current->policy = SCHED_RR; /* Make this a realtime task! */
4495 current->rt_priority = 2; /* more important than all other tasks */
4496
4497 while (get_t_state(thi) == Running) {
4498 drbd_thread_current_set_cpu(mdev);
4499 if (test_and_clear_bit(SEND_PING, &mdev->flags)) {
4500 ERR_IF(!drbd_send_ping(mdev)) goto reconnect;
4501 mdev->meta.socket->sk->sk_rcvtimeo =
4502 mdev->net_conf->ping_timeo*HZ/10;
4503 }
4504
4505 /* conditionally cork;
4506 * it may hurt latency if we cork without much to send */
4507 if (!mdev->net_conf->no_cork &&
4508 3 < atomic_read(&mdev->unacked_cnt))
4509 drbd_tcp_cork(mdev->meta.socket);
4510 while (1) {
4511 clear_bit(SIGNAL_ASENDER, &mdev->flags);
4512 flush_signals(current);
4513 if (!drbd_process_done_ee(mdev)) {
4514 dev_err(DEV, "process_done_ee() = NOT_OK\n");
4515 goto reconnect;
4516 }
4517 /* to avoid race with newly queued ACKs */
4518 set_bit(SIGNAL_ASENDER, &mdev->flags);
4519 spin_lock_irq(&mdev->req_lock);
4520 empty = list_empty(&mdev->done_ee);
4521 spin_unlock_irq(&mdev->req_lock);
4522 /* new ack may have been queued right here,
4523 * but then there is also a signal pending,
4524 * and we start over... */
4525 if (empty)
4526 break;
4527 }
4528 /* but unconditionally uncork unless disabled */
4529 if (!mdev->net_conf->no_cork)
4530 drbd_tcp_uncork(mdev->meta.socket);
4531
4532 /* short circuit, recv_msg would return EINTR anyways. */
4533 if (signal_pending(current))
4534 continue;
4535
4536 rv = drbd_recv_short(mdev, mdev->meta.socket,
4537 buf, expect-received, 0);
4538 clear_bit(SIGNAL_ASENDER, &mdev->flags);
4539
4540 flush_signals(current);
4541
4542 /* Note:
4543 * -EINTR (on meta) we got a signal
4544 * -EAGAIN (on meta) rcvtimeo expired
4545 * -ECONNRESET other side closed the connection
4546 * -ERESTARTSYS (on data) we got a signal
4547 * rv < 0 other than above: unexpected error!
4548 * rv == expected: full header or command
4549 * rv < expected: "woken" by signal during receive
4550 * rv == 0 : "connection shut down by peer"
4551 */
4552 if (likely(rv > 0)) {
4553 received += rv;
4554 buf += rv;
4555 } else if (rv == 0) {
4556 dev_err(DEV, "meta connection shut down by peer.\n");
4557 goto reconnect;
4558 } else if (rv == -EAGAIN) {
4559 if (mdev->meta.socket->sk->sk_rcvtimeo ==
4560 mdev->net_conf->ping_timeo*HZ/10) {
4561 dev_err(DEV, "PingAck did not arrive in time.\n");
4562 goto reconnect;
4563 }
4564 set_bit(SEND_PING, &mdev->flags);
4565 continue;
4566 } else if (rv == -EINTR) {
4567 continue;
4568 } else {
4569 dev_err(DEV, "sock_recvmsg returned %d\n", rv);
4570 goto reconnect;
4571 }
4572
4573 if (received == expect && cmd == NULL) {
4574 if (unlikely(h->magic != BE_DRBD_MAGIC)) {
4575 dev_err(DEV, "magic?? on meta m: 0x%lx c: %d l: %d\n",
4576 (long)be32_to_cpu(h->magic),
4577 h->command, h->length);
4578 goto reconnect;
4579 }
4580 cmd = get_asender_cmd(be16_to_cpu(h->command));
4581 len = be16_to_cpu(h->length);
4582 if (unlikely(cmd == NULL)) {
4583 dev_err(DEV, "unknown command?? on meta m: 0x%lx c: %d l: %d\n",
4584 (long)be32_to_cpu(h->magic),
4585 h->command, h->length);
4586 goto disconnect;
4587 }
4588 expect = cmd->pkt_size;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004589 ERR_IF(len != expect-sizeof(struct p_header80))
Philipp Reisnerb411b362009-09-25 16:07:19 -07004590 goto reconnect;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004591 }
4592 if (received == expect) {
4593 D_ASSERT(cmd != NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004594 if (!cmd->process(mdev, h))
4595 goto reconnect;
4596
4597 buf = h;
4598 received = 0;
Philipp Reisner0b70a132010-08-20 13:36:10 +02004599 expect = sizeof(struct p_header80);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004600 cmd = NULL;
4601 }
4602 }
4603
4604 if (0) {
4605reconnect:
4606 drbd_force_state(mdev, NS(conn, C_NETWORK_FAILURE));
4607 }
4608 if (0) {
4609disconnect:
4610 drbd_force_state(mdev, NS(conn, C_DISCONNECTING));
4611 }
4612 clear_bit(SIGNAL_ASENDER, &mdev->flags);
4613
4614 D_ASSERT(mdev->state.conn < C_CONNECTED);
4615 dev_info(DEV, "asender terminated\n");
4616
4617 return 0;
4618}