blob: 98f03b143b3852a2062a7dd173cf39003f0fdb42 [file] [log] [blame]
Philipp Reisnerb411b362009-09-25 16:07:19 -07001/*
2 drbd_receiver.c
3
4 This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
5
6 Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
7 Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
8 Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
9
10 drbd is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
13 any later version.
14
15 drbd is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with drbd; see the file COPYING. If not, write to
22 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25
Philipp Reisnerb411b362009-09-25 16:07:19 -070026#include <linux/module.h>
27
28#include <asm/uaccess.h>
29#include <net/sock.h>
30
Philipp Reisnerb411b362009-09-25 16:07:19 -070031#include <linux/drbd.h>
32#include <linux/fs.h>
33#include <linux/file.h>
34#include <linux/in.h>
35#include <linux/mm.h>
36#include <linux/memcontrol.h>
37#include <linux/mm_inline.h>
38#include <linux/slab.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070039#include <linux/pkt_sched.h>
40#define __KERNEL_SYSCALLS__
41#include <linux/unistd.h>
42#include <linux/vmalloc.h>
43#include <linux/random.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070044#include <linux/string.h>
45#include <linux/scatterlist.h>
46#include "drbd_int.h"
Philipp Reisnerb411b362009-09-25 16:07:19 -070047#include "drbd_req.h"
48
49#include "drbd_vli.h"
50
Philipp Reisner77351055b2011-02-07 17:24:26 +010051struct packet_info {
52 enum drbd_packet cmd;
Andreas Gruenbachere2857212011-03-25 00:57:38 +010053 unsigned int size;
54 unsigned int vnr;
Andreas Gruenbachere6589832011-03-30 12:54:42 +020055 void *data;
Philipp Reisner77351055b2011-02-07 17:24:26 +010056};
57
Philipp Reisnerb411b362009-09-25 16:07:19 -070058enum finish_epoch {
59 FE_STILL_LIVE,
60 FE_DESTROYED,
61 FE_RECYCLED,
62};
63
Andreas Gruenbacher60381782011-03-28 17:05:50 +020064static int drbd_do_features(struct drbd_tconn *tconn);
Philipp Reisner13e60372011-02-08 09:54:40 +010065static int drbd_do_auth(struct drbd_tconn *tconn);
Philipp Reisner360cc742011-02-08 14:29:53 +010066static int drbd_disconnected(int vnr, void *p, void *data);
Philipp Reisnerb411b362009-09-25 16:07:19 -070067
68static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *, struct drbd_epoch *, enum epoch_event);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +010069static int e_end_block(struct drbd_work *, int);
Philipp Reisnerb411b362009-09-25 16:07:19 -070070
Philipp Reisnerb411b362009-09-25 16:07:19 -070071
72#define GFP_TRY (__GFP_HIGHMEM | __GFP_NOWARN)
73
Lars Ellenberg45bb9122010-05-14 17:10:48 +020074/*
75 * some helper functions to deal with single linked page lists,
76 * page->private being our "next" pointer.
77 */
78
79/* If at least n pages are linked at head, get n pages off.
80 * Otherwise, don't modify head, and return NULL.
81 * Locking is the responsibility of the caller.
82 */
83static struct page *page_chain_del(struct page **head, int n)
84{
85 struct page *page;
86 struct page *tmp;
87
88 BUG_ON(!n);
89 BUG_ON(!head);
90
91 page = *head;
Philipp Reisner23ce4222010-05-20 13:35:31 +020092
93 if (!page)
94 return NULL;
95
Lars Ellenberg45bb9122010-05-14 17:10:48 +020096 while (page) {
97 tmp = page_chain_next(page);
98 if (--n == 0)
99 break; /* found sufficient pages */
100 if (tmp == NULL)
101 /* insufficient pages, don't use any of them. */
102 return NULL;
103 page = tmp;
104 }
105
106 /* add end of list marker for the returned list */
107 set_page_private(page, 0);
108 /* actual return value, and adjustment of head */
109 page = *head;
110 *head = tmp;
111 return page;
112}
113
114/* may be used outside of locks to find the tail of a (usually short)
115 * "private" page chain, before adding it back to a global chain head
116 * with page_chain_add() under a spinlock. */
117static struct page *page_chain_tail(struct page *page, int *len)
118{
119 struct page *tmp;
120 int i = 1;
121 while ((tmp = page_chain_next(page)))
122 ++i, page = tmp;
123 if (len)
124 *len = i;
125 return page;
126}
127
128static int page_chain_free(struct page *page)
129{
130 struct page *tmp;
131 int i = 0;
132 page_chain_for_each_safe(page, tmp) {
133 put_page(page);
134 ++i;
135 }
136 return i;
137}
138
139static void page_chain_add(struct page **head,
140 struct page *chain_first, struct page *chain_last)
141{
142#if 1
143 struct page *tmp;
144 tmp = page_chain_tail(chain_first, NULL);
145 BUG_ON(tmp != chain_last);
146#endif
147
148 /* add chain to head */
149 set_page_private(chain_last, (unsigned long)*head);
150 *head = chain_first;
151}
152
Andreas Gruenbacher18c2d522011-04-07 21:08:50 +0200153static struct page *__drbd_alloc_pages(struct drbd_conf *mdev,
154 unsigned int number)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700155{
156 struct page *page = NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200157 struct page *tmp = NULL;
Andreas Gruenbacher18c2d522011-04-07 21:08:50 +0200158 unsigned int i = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700159
160 /* Yes, testing drbd_pp_vacant outside the lock is racy.
161 * So what. It saves a spin_lock. */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200162 if (drbd_pp_vacant >= number) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700163 spin_lock(&drbd_pp_lock);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200164 page = page_chain_del(&drbd_pp_pool, number);
165 if (page)
166 drbd_pp_vacant -= number;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700167 spin_unlock(&drbd_pp_lock);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200168 if (page)
169 return page;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700170 }
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200171
Philipp Reisnerb411b362009-09-25 16:07:19 -0700172 /* GFP_TRY, because we must not cause arbitrary write-out: in a DRBD
173 * "criss-cross" setup, that might cause write-out on some other DRBD,
174 * which in turn might block on the other node at this very place. */
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200175 for (i = 0; i < number; i++) {
176 tmp = alloc_page(GFP_TRY);
177 if (!tmp)
178 break;
179 set_page_private(tmp, (unsigned long)page);
180 page = tmp;
181 }
182
183 if (i == number)
184 return page;
185
186 /* Not enough pages immediately available this time.
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +0200187 * No need to jump around here, drbd_alloc_pages will retry this
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200188 * function "soon". */
189 if (page) {
190 tmp = page_chain_tail(page, NULL);
191 spin_lock(&drbd_pp_lock);
192 page_chain_add(&drbd_pp_pool, page, tmp);
193 drbd_pp_vacant += i;
194 spin_unlock(&drbd_pp_lock);
195 }
196 return NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700197}
198
Andreas Gruenbachera990be42011-04-06 17:56:48 +0200199static void reclaim_finished_net_peer_reqs(struct drbd_conf *mdev,
200 struct list_head *to_be_freed)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700201{
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100202 struct drbd_peer_request *peer_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700203 struct list_head *le, *tle;
204
205 /* The EEs are always appended to the end of the list. Since
206 they are sent in order over the wire, they have to finish
207 in order. As soon as we see the first not finished we can
208 stop to examine the list... */
209
210 list_for_each_safe(le, tle, &mdev->net_ee) {
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100211 peer_req = list_entry(le, struct drbd_peer_request, w.list);
Andreas Gruenbacher045417f2011-04-07 21:34:24 +0200212 if (drbd_peer_req_has_active_page(peer_req))
Philipp Reisnerb411b362009-09-25 16:07:19 -0700213 break;
214 list_move(le, to_be_freed);
215 }
216}
217
218static void drbd_kick_lo_and_reclaim_net(struct drbd_conf *mdev)
219{
220 LIST_HEAD(reclaimed);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100221 struct drbd_peer_request *peer_req, *t;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700222
Philipp Reisner87eeee42011-01-19 14:16:30 +0100223 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbachera990be42011-04-06 17:56:48 +0200224 reclaim_finished_net_peer_reqs(mdev, &reclaimed);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100225 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700226
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100227 list_for_each_entry_safe(peer_req, t, &reclaimed, w.list)
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +0200228 drbd_free_net_peer_req(mdev, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700229}
230
231/**
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +0200232 * drbd_alloc_pages() - Returns @number pages, retries forever (or until signalled)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700233 * @mdev: DRBD device.
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200234 * @number: number of pages requested
235 * @retry: whether to retry, if not enough pages are available right now
Philipp Reisnerb411b362009-09-25 16:07:19 -0700236 *
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200237 * Tries to allocate number pages, first from our own page pool, then from
238 * the kernel, unless this allocation would exceed the max_buffers setting.
239 * Possibly retry until DRBD frees sufficient pages somewhere else.
240 *
241 * Returns a page chain linked via page->private.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700242 */
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +0200243struct page *drbd_alloc_pages(struct drbd_conf *mdev, unsigned int number,
244 bool retry)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700245{
246 struct page *page = NULL;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200247 struct net_conf *nc;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700248 DEFINE_WAIT(wait);
Philipp Reisner44ed1672011-04-19 17:10:19 +0200249 int mxb;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700250
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200251 /* Yes, we may run up to @number over max_buffers. If we
252 * follow it strictly, the admin will get it wrong anyways. */
Philipp Reisner44ed1672011-04-19 17:10:19 +0200253 rcu_read_lock();
254 nc = rcu_dereference(mdev->tconn->net_conf);
255 mxb = nc ? nc->max_buffers : 1000000;
256 rcu_read_unlock();
257
258 if (atomic_read(&mdev->pp_in_use) < mxb)
Andreas Gruenbacher18c2d522011-04-07 21:08:50 +0200259 page = __drbd_alloc_pages(mdev, number);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700260
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200261 while (page == NULL) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700262 prepare_to_wait(&drbd_pp_wait, &wait, TASK_INTERRUPTIBLE);
263
264 drbd_kick_lo_and_reclaim_net(mdev);
265
Philipp Reisner44ed1672011-04-19 17:10:19 +0200266 if (atomic_read(&mdev->pp_in_use) < mxb) {
Andreas Gruenbacher18c2d522011-04-07 21:08:50 +0200267 page = __drbd_alloc_pages(mdev, number);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700268 if (page)
269 break;
270 }
271
272 if (!retry)
273 break;
274
275 if (signal_pending(current)) {
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +0200276 dev_warn(DEV, "drbd_alloc_pages interrupted!\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700277 break;
278 }
279
280 schedule();
281 }
282 finish_wait(&drbd_pp_wait, &wait);
283
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200284 if (page)
285 atomic_add(number, &mdev->pp_in_use);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700286 return page;
287}
288
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +0200289/* Must not be used from irq, as that may deadlock: see drbd_alloc_pages.
Philipp Reisner87eeee42011-01-19 14:16:30 +0100290 * Is also used from inside an other spin_lock_irq(&mdev->tconn->req_lock);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200291 * Either links the page chain back to the global pool,
292 * or returns all pages to the system. */
Andreas Gruenbacher5cc287e2011-04-07 21:02:59 +0200293static void drbd_free_pages(struct drbd_conf *mdev, struct page *page, int is_net)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700294{
Lars Ellenberg435f0742010-09-06 12:30:25 +0200295 atomic_t *a = is_net ? &mdev->pp_in_use_by_net : &mdev->pp_in_use;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700296 int i;
Lars Ellenberg435f0742010-09-06 12:30:25 +0200297
Philipp Reisner81a5d602011-02-22 19:53:16 -0500298 if (drbd_pp_vacant > (DRBD_MAX_BIO_SIZE/PAGE_SIZE) * minor_count)
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200299 i = page_chain_free(page);
300 else {
301 struct page *tmp;
302 tmp = page_chain_tail(page, &i);
303 spin_lock(&drbd_pp_lock);
304 page_chain_add(&drbd_pp_pool, page, tmp);
305 drbd_pp_vacant += i;
306 spin_unlock(&drbd_pp_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700307 }
Lars Ellenberg435f0742010-09-06 12:30:25 +0200308 i = atomic_sub_return(i, a);
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200309 if (i < 0)
Lars Ellenberg435f0742010-09-06 12:30:25 +0200310 dev_warn(DEV, "ASSERTION FAILED: %s: %d < 0\n",
311 is_net ? "pp_in_use_by_net" : "pp_in_use", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700312 wake_up(&drbd_pp_wait);
313}
314
315/*
316You need to hold the req_lock:
317 _drbd_wait_ee_list_empty()
318
319You must not have the req_lock:
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +0200320 drbd_free_peer_req()
Andreas Gruenbacher0db55362011-04-06 16:09:15 +0200321 drbd_alloc_peer_req()
Andreas Gruenbacher7721f562011-04-06 17:14:02 +0200322 drbd_free_peer_reqs()
Philipp Reisnerb411b362009-09-25 16:07:19 -0700323 drbd_ee_fix_bhs()
Andreas Gruenbachera990be42011-04-06 17:56:48 +0200324 drbd_finish_peer_reqs()
Philipp Reisnerb411b362009-09-25 16:07:19 -0700325 drbd_clear_done_ee()
326 drbd_wait_ee_list_empty()
327*/
328
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +0100329struct drbd_peer_request *
Andreas Gruenbacher0db55362011-04-06 16:09:15 +0200330drbd_alloc_peer_req(struct drbd_conf *mdev, u64 id, sector_t sector,
331 unsigned int data_size, gfp_t gfp_mask) __must_hold(local)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700332{
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100333 struct drbd_peer_request *peer_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700334 struct page *page;
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200335 unsigned nr_pages = (data_size + PAGE_SIZE -1) >> PAGE_SHIFT;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700336
Andreas Gruenbacher0cf9d272010-12-07 10:43:29 +0100337 if (drbd_insert_fault(mdev, DRBD_FAULT_AL_EE))
Philipp Reisnerb411b362009-09-25 16:07:19 -0700338 return NULL;
339
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100340 peer_req = mempool_alloc(drbd_ee_mempool, gfp_mask & ~__GFP_HIGHMEM);
341 if (!peer_req) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700342 if (!(gfp_mask & __GFP_NOWARN))
Andreas Gruenbacher0db55362011-04-06 16:09:15 +0200343 dev_err(DEV, "%s: allocation failed\n", __func__);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700344 return NULL;
345 }
346
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +0200347 page = drbd_alloc_pages(mdev, nr_pages, (gfp_mask & __GFP_WAIT));
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200348 if (!page)
349 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700350
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100351 drbd_clear_interval(&peer_req->i);
352 peer_req->i.size = data_size;
353 peer_req->i.sector = sector;
354 peer_req->i.local = false;
355 peer_req->i.waiting = false;
Andreas Gruenbacher53840642011-01-28 10:31:04 +0100356
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100357 peer_req->epoch = NULL;
Philipp Reisnera21e9292011-02-08 15:08:49 +0100358 peer_req->w.mdev = mdev;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100359 peer_req->pages = page;
360 atomic_set(&peer_req->pending_bios, 0);
361 peer_req->flags = 0;
Andreas Gruenbacher9a8e7752011-01-11 14:04:09 +0100362 /*
363 * The block_id is opaque to the receiver. It is not endianness
364 * converted, and sent back to the sender unchanged.
365 */
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100366 peer_req->block_id = id;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700367
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100368 return peer_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700369
Lars Ellenberg45bb9122010-05-14 17:10:48 +0200370 fail:
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100371 mempool_free(peer_req, drbd_ee_mempool);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700372 return NULL;
373}
374
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +0200375void __drbd_free_peer_req(struct drbd_conf *mdev, struct drbd_peer_request *peer_req,
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +0100376 int is_net)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700377{
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100378 if (peer_req->flags & EE_HAS_DIGEST)
379 kfree(peer_req->digest);
Andreas Gruenbacher5cc287e2011-04-07 21:02:59 +0200380 drbd_free_pages(mdev, peer_req->pages, is_net);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100381 D_ASSERT(atomic_read(&peer_req->pending_bios) == 0);
382 D_ASSERT(drbd_interval_empty(&peer_req->i));
383 mempool_free(peer_req, drbd_ee_mempool);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700384}
385
Andreas Gruenbacher7721f562011-04-06 17:14:02 +0200386int drbd_free_peer_reqs(struct drbd_conf *mdev, struct list_head *list)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700387{
388 LIST_HEAD(work_list);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100389 struct drbd_peer_request *peer_req, *t;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700390 int count = 0;
Lars Ellenberg435f0742010-09-06 12:30:25 +0200391 int is_net = list == &mdev->net_ee;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700392
Philipp Reisner87eeee42011-01-19 14:16:30 +0100393 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700394 list_splice_init(list, &work_list);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100395 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700396
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100397 list_for_each_entry_safe(peer_req, t, &work_list, w.list) {
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +0200398 __drbd_free_peer_req(mdev, peer_req, is_net);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700399 count++;
400 }
401 return count;
402}
403
Andreas Gruenbachera990be42011-04-06 17:56:48 +0200404/*
405 * See also comments in _req_mod(,BARRIER_ACKED) and receive_Barrier.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700406 */
Andreas Gruenbachera990be42011-04-06 17:56:48 +0200407static int drbd_finish_peer_reqs(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700408{
409 LIST_HEAD(work_list);
410 LIST_HEAD(reclaimed);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100411 struct drbd_peer_request *peer_req, *t;
Andreas Gruenbachere2b30322011-03-16 17:16:12 +0100412 int err = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700413
Philipp Reisner87eeee42011-01-19 14:16:30 +0100414 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbachera990be42011-04-06 17:56:48 +0200415 reclaim_finished_net_peer_reqs(mdev, &reclaimed);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700416 list_splice_init(&mdev->done_ee, &work_list);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100417 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700418
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100419 list_for_each_entry_safe(peer_req, t, &reclaimed, w.list)
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +0200420 drbd_free_net_peer_req(mdev, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700421
422 /* possible callbacks here:
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +0100423 * e_end_block, and e_end_resync_block, e_send_discard_write.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700424 * all ignore the last argument.
425 */
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +0100426 list_for_each_entry_safe(peer_req, t, &work_list, w.list) {
Andreas Gruenbachere2b30322011-03-16 17:16:12 +0100427 int err2;
428
Philipp Reisnerb411b362009-09-25 16:07:19 -0700429 /* list_del not necessary, next/prev members not touched */
Andreas Gruenbachere2b30322011-03-16 17:16:12 +0100430 err2 = peer_req->w.cb(&peer_req->w, !!err);
431 if (!err)
432 err = err2;
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +0200433 drbd_free_peer_req(mdev, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700434 }
435 wake_up(&mdev->ee_wait);
436
Andreas Gruenbachere2b30322011-03-16 17:16:12 +0100437 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700438}
439
Andreas Gruenbacherd4da1532011-04-07 00:06:56 +0200440static void _drbd_wait_ee_list_empty(struct drbd_conf *mdev,
441 struct list_head *head)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700442{
443 DEFINE_WAIT(wait);
444
445 /* avoids spin_lock/unlock
446 * and calling prepare_to_wait in the fast path */
447 while (!list_empty(head)) {
448 prepare_to_wait(&mdev->ee_wait, &wait, TASK_UNINTERRUPTIBLE);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100449 spin_unlock_irq(&mdev->tconn->req_lock);
Jens Axboe7eaceac2011-03-10 08:52:07 +0100450 io_schedule();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700451 finish_wait(&mdev->ee_wait, &wait);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100452 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700453 }
454}
455
Andreas Gruenbacherd4da1532011-04-07 00:06:56 +0200456static void drbd_wait_ee_list_empty(struct drbd_conf *mdev,
457 struct list_head *head)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700458{
Philipp Reisner87eeee42011-01-19 14:16:30 +0100459 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700460 _drbd_wait_ee_list_empty(mdev, head);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100461 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700462}
463
464/* see also kernel_accept; which is only present since 2.6.18.
465 * also we want to log which part of it failed, exactly */
Philipp Reisner76536202011-02-07 14:09:54 +0100466static int drbd_accept(const char **what, struct socket *sock, struct socket **newsock)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700467{
468 struct sock *sk = sock->sk;
469 int err = 0;
470
471 *what = "listen";
472 err = sock->ops->listen(sock, 5);
473 if (err < 0)
474 goto out;
475
476 *what = "sock_create_lite";
477 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
478 newsock);
479 if (err < 0)
480 goto out;
481
482 *what = "accept";
483 err = sock->ops->accept(sock, *newsock, 0);
484 if (err < 0) {
485 sock_release(*newsock);
486 *newsock = NULL;
487 goto out;
488 }
489 (*newsock)->ops = sock->ops;
490
491out:
492 return err;
493}
494
Philipp Reisnerdbd9eea2011-02-07 15:34:16 +0100495static int drbd_recv_short(struct socket *sock, void *buf, size_t size, int flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700496{
497 mm_segment_t oldfs;
498 struct kvec iov = {
499 .iov_base = buf,
500 .iov_len = size,
501 };
502 struct msghdr msg = {
503 .msg_iovlen = 1,
504 .msg_iov = (struct iovec *)&iov,
505 .msg_flags = (flags ? flags : MSG_WAITALL | MSG_NOSIGNAL)
506 };
507 int rv;
508
509 oldfs = get_fs();
510 set_fs(KERNEL_DS);
511 rv = sock_recvmsg(sock, &msg, size, msg.msg_flags);
512 set_fs(oldfs);
513
514 return rv;
515}
516
Philipp Reisnerde0ff332011-02-07 16:56:20 +0100517static int drbd_recv(struct drbd_tconn *tconn, void *buf, size_t size)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700518{
519 mm_segment_t oldfs;
520 struct kvec iov = {
521 .iov_base = buf,
522 .iov_len = size,
523 };
524 struct msghdr msg = {
525 .msg_iovlen = 1,
526 .msg_iov = (struct iovec *)&iov,
527 .msg_flags = MSG_WAITALL | MSG_NOSIGNAL
528 };
529 int rv;
530
531 oldfs = get_fs();
532 set_fs(KERNEL_DS);
533
534 for (;;) {
Philipp Reisnerde0ff332011-02-07 16:56:20 +0100535 rv = sock_recvmsg(tconn->data.socket, &msg, size, msg.msg_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700536 if (rv == size)
537 break;
538
539 /* Note:
540 * ECONNRESET other side closed the connection
541 * ERESTARTSYS (on sock) we got a signal
542 */
543
544 if (rv < 0) {
545 if (rv == -ECONNRESET)
Philipp Reisnerde0ff332011-02-07 16:56:20 +0100546 conn_info(tconn, "sock was reset by peer\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700547 else if (rv != -ERESTARTSYS)
Philipp Reisnerde0ff332011-02-07 16:56:20 +0100548 conn_err(tconn, "sock_recvmsg returned %d\n", rv);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700549 break;
550 } else if (rv == 0) {
Philipp Reisnerde0ff332011-02-07 16:56:20 +0100551 conn_info(tconn, "sock was shut down by peer\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700552 break;
553 } else {
554 /* signal came in, or peer/link went down,
555 * after we read a partial message
556 */
557 /* D_ASSERT(signal_pending(current)); */
558 break;
559 }
560 };
561
562 set_fs(oldfs);
563
564 if (rv != size)
Philipp Reisnerbbeb6412011-02-10 13:45:46 +0100565 conn_request_state(tconn, NS(conn, C_BROKEN_PIPE), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700566
567 return rv;
568}
569
Andreas Gruenbacherc6967742011-03-17 17:15:20 +0100570static int drbd_recv_all(struct drbd_tconn *tconn, void *buf, size_t size)
571{
572 int err;
573
574 err = drbd_recv(tconn, buf, size);
575 if (err != size) {
576 if (err >= 0)
577 err = -EIO;
578 } else
579 err = 0;
580 return err;
581}
582
Andreas Gruenbachera5c31902011-03-24 03:28:04 +0100583static int drbd_recv_all_warn(struct drbd_tconn *tconn, void *buf, size_t size)
584{
585 int err;
586
587 err = drbd_recv_all(tconn, buf, size);
588 if (err && !signal_pending(current))
589 conn_warn(tconn, "short read (expected size %d)\n", (int)size);
590 return err;
591}
592
Lars Ellenberg5dbf1672010-05-25 16:18:01 +0200593/* quoting tcp(7):
594 * On individual connections, the socket buffer size must be set prior to the
595 * listen(2) or connect(2) calls in order to have it take effect.
596 * This is our wrapper to do so.
597 */
598static void drbd_setbufsize(struct socket *sock, unsigned int snd,
599 unsigned int rcv)
600{
601 /* open coded SO_SNDBUF, SO_RCVBUF */
602 if (snd) {
603 sock->sk->sk_sndbuf = snd;
604 sock->sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
605 }
606 if (rcv) {
607 sock->sk->sk_rcvbuf = rcv;
608 sock->sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
609 }
610}
611
Philipp Reisnereac3e992011-02-07 14:05:07 +0100612static struct socket *drbd_try_connect(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700613{
614 const char *what;
615 struct socket *sock;
616 struct sockaddr_in6 src_in6;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200617 struct sockaddr_in6 peer_in6;
618 struct net_conf *nc;
619 int err, peer_addr_len, my_addr_len;
620 int sndbuf_size, rcvbuf_size, try_connect_int;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700621 int disconnect_on_error = 1;
622
Philipp Reisner44ed1672011-04-19 17:10:19 +0200623 rcu_read_lock();
624 nc = rcu_dereference(tconn->net_conf);
625 if (!nc) {
626 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700627 return NULL;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200628 }
629
630 sndbuf_size = nc->sndbuf_size;
631 rcvbuf_size = nc->rcvbuf_size;
632 try_connect_int = nc->try_connect_int;
633
634 my_addr_len = min_t(int, nc->my_addr_len, sizeof(src_in6));
635 memcpy(&src_in6, nc->my_addr, my_addr_len);
636
637 if (((struct sockaddr *)nc->my_addr)->sa_family == AF_INET6)
638 src_in6.sin6_port = 0;
639 else
640 ((struct sockaddr_in *)&src_in6)->sin_port = 0; /* AF_INET & AF_SCI */
641
642 peer_addr_len = min_t(int, nc->peer_addr_len, sizeof(src_in6));
643 memcpy(&peer_in6, nc->peer_addr, peer_addr_len);
644
645 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700646
647 what = "sock_create_kern";
Philipp Reisner44ed1672011-04-19 17:10:19 +0200648 err = sock_create_kern(((struct sockaddr *)&src_in6)->sa_family,
649 SOCK_STREAM, IPPROTO_TCP, &sock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700650 if (err < 0) {
651 sock = NULL;
652 goto out;
653 }
654
655 sock->sk->sk_rcvtimeo =
Philipp Reisner44ed1672011-04-19 17:10:19 +0200656 sock->sk->sk_sndtimeo = try_connect_int * HZ;
657 drbd_setbufsize(sock, sndbuf_size, rcvbuf_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700658
659 /* explicitly bind to the configured IP as source IP
660 * for the outgoing connections.
661 * This is needed for multihomed hosts and to be
662 * able to use lo: interfaces for drbd.
663 * Make sure to use 0 as port number, so linux selects
664 * a free one dynamically.
665 */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700666 what = "bind before connect";
Philipp Reisner44ed1672011-04-19 17:10:19 +0200667 err = sock->ops->bind(sock, (struct sockaddr *) &src_in6, my_addr_len);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700668 if (err < 0)
669 goto out;
670
671 /* connect may fail, peer not yet available.
672 * stay C_WF_CONNECTION, don't go Disconnecting! */
673 disconnect_on_error = 0;
674 what = "connect";
Philipp Reisner44ed1672011-04-19 17:10:19 +0200675 err = sock->ops->connect(sock, (struct sockaddr *) &peer_in6, peer_addr_len, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700676
677out:
678 if (err < 0) {
679 if (sock) {
680 sock_release(sock);
681 sock = NULL;
682 }
683 switch (-err) {
684 /* timeout, busy, signal pending */
685 case ETIMEDOUT: case EAGAIN: case EINPROGRESS:
686 case EINTR: case ERESTARTSYS:
687 /* peer not (yet) available, network problem */
688 case ECONNREFUSED: case ENETUNREACH:
689 case EHOSTDOWN: case EHOSTUNREACH:
690 disconnect_on_error = 0;
691 break;
692 default:
Philipp Reisnereac3e992011-02-07 14:05:07 +0100693 conn_err(tconn, "%s failed, err = %d\n", what, err);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700694 }
695 if (disconnect_on_error)
Philipp Reisnerbbeb6412011-02-10 13:45:46 +0100696 conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700697 }
Philipp Reisner44ed1672011-04-19 17:10:19 +0200698
Philipp Reisnerb411b362009-09-25 16:07:19 -0700699 return sock;
700}
701
Philipp Reisner76536202011-02-07 14:09:54 +0100702static struct socket *drbd_wait_for_connect(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700703{
Philipp Reisner44ed1672011-04-19 17:10:19 +0200704 int timeo, err, my_addr_len;
705 int sndbuf_size, rcvbuf_size, try_connect_int;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700706 struct socket *s_estab = NULL, *s_listen;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200707 struct sockaddr_in6 my_addr;
708 struct net_conf *nc;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700709 const char *what;
710
Philipp Reisner44ed1672011-04-19 17:10:19 +0200711 rcu_read_lock();
712 nc = rcu_dereference(tconn->net_conf);
713 if (!nc) {
714 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700715 return NULL;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200716 }
717
718 sndbuf_size = nc->sndbuf_size;
719 rcvbuf_size = nc->rcvbuf_size;
720 try_connect_int = nc->try_connect_int;
721
722 my_addr_len = min_t(int, nc->my_addr_len, sizeof(struct sockaddr_in6));
723 memcpy(&my_addr, nc->my_addr, my_addr_len);
724 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700725
726 what = "sock_create_kern";
Philipp Reisner44ed1672011-04-19 17:10:19 +0200727 err = sock_create_kern(((struct sockaddr *)&my_addr)->sa_family,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700728 SOCK_STREAM, IPPROTO_TCP, &s_listen);
729 if (err) {
730 s_listen = NULL;
731 goto out;
732 }
733
Philipp Reisner44ed1672011-04-19 17:10:19 +0200734 timeo = try_connect_int * HZ;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700735 timeo += (random32() & 1) ? timeo / 7 : -timeo / 7; /* 28.5% random jitter */
736
737 s_listen->sk->sk_reuse = 1; /* SO_REUSEADDR */
738 s_listen->sk->sk_rcvtimeo = timeo;
739 s_listen->sk->sk_sndtimeo = timeo;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200740 drbd_setbufsize(s_listen, sndbuf_size, rcvbuf_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700741
742 what = "bind before listen";
Philipp Reisner44ed1672011-04-19 17:10:19 +0200743 err = s_listen->ops->bind(s_listen, (struct sockaddr *)&my_addr, my_addr_len);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700744 if (err < 0)
745 goto out;
746
Philipp Reisner76536202011-02-07 14:09:54 +0100747 err = drbd_accept(&what, s_listen, &s_estab);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700748
749out:
750 if (s_listen)
751 sock_release(s_listen);
752 if (err < 0) {
753 if (err != -EAGAIN && err != -EINTR && err != -ERESTARTSYS) {
Philipp Reisner76536202011-02-07 14:09:54 +0100754 conn_err(tconn, "%s failed, err = %d\n", what, err);
Philipp Reisnerbbeb6412011-02-10 13:45:46 +0100755 conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700756 }
757 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700758
759 return s_estab;
760}
761
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200762static int decode_header(struct drbd_tconn *, void *, struct packet_info *);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700763
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200764static int send_first_packet(struct drbd_tconn *tconn, struct drbd_socket *sock,
765 enum drbd_packet cmd)
766{
767 if (!conn_prepare_command(tconn, sock))
768 return -EIO;
Andreas Gruenbachere6589832011-03-30 12:54:42 +0200769 return conn_send_command(tconn, sock, cmd, 0, NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700770}
771
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200772static int receive_first_packet(struct drbd_tconn *tconn, struct socket *sock)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700773{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200774 unsigned int header_size = drbd_header_size(tconn);
775 struct packet_info pi;
776 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700777
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200778 err = drbd_recv_short(sock, tconn->data.rbuf, header_size, 0);
779 if (err != header_size) {
780 if (err >= 0)
781 err = -EIO;
782 return err;
783 }
784 err = decode_header(tconn, tconn->data.rbuf, &pi);
785 if (err)
786 return err;
787 return pi.cmd;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700788}
789
790/**
791 * drbd_socket_okay() - Free the socket if its connection is not okay
Philipp Reisnerb411b362009-09-25 16:07:19 -0700792 * @sock: pointer to the pointer to the socket.
793 */
Philipp Reisnerdbd9eea2011-02-07 15:34:16 +0100794static int drbd_socket_okay(struct socket **sock)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700795{
796 int rr;
797 char tb[4];
798
799 if (!*sock)
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100800 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700801
Philipp Reisnerdbd9eea2011-02-07 15:34:16 +0100802 rr = drbd_recv_short(*sock, tb, 4, MSG_DONTWAIT | MSG_PEEK);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700803
804 if (rr > 0 || rr == -EAGAIN) {
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100805 return true;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700806 } else {
807 sock_release(*sock);
808 *sock = NULL;
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100809 return false;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700810 }
811}
Philipp Reisner2325eb62011-03-15 16:56:18 +0100812/* Gets called if a connection is established, or if a new minor gets created
813 in a connection */
814int drbd_connected(int vnr, void *p, void *data)
Philipp Reisner907599e2011-02-08 11:25:37 +0100815{
816 struct drbd_conf *mdev = (struct drbd_conf *)p;
Andreas Gruenbacher0829f5e2011-03-24 14:31:22 +0100817 int err;
Philipp Reisner907599e2011-02-08 11:25:37 +0100818
819 atomic_set(&mdev->packet_seq, 0);
820 mdev->peer_seq = 0;
821
Philipp Reisner8410da82011-02-11 20:11:10 +0100822 mdev->state_mutex = mdev->tconn->agreed_pro_version < 100 ?
823 &mdev->tconn->cstate_mutex :
824 &mdev->own_state_mutex;
825
Andreas Gruenbacher0829f5e2011-03-24 14:31:22 +0100826 err = drbd_send_sync_param(mdev);
827 if (!err)
828 err = drbd_send_sizes(mdev, 0, 0);
829 if (!err)
830 err = drbd_send_uuids(mdev);
831 if (!err)
832 err = drbd_send_state(mdev);
Philipp Reisner907599e2011-02-08 11:25:37 +0100833 clear_bit(USE_DEGR_WFC_T, &mdev->flags);
834 clear_bit(RESIZE_PENDING, &mdev->flags);
Philipp Reisner8b924f12011-03-01 11:08:28 +0100835 mod_timer(&mdev->request_timer, jiffies + HZ); /* just start it here. */
Andreas Gruenbacher0829f5e2011-03-24 14:31:22 +0100836 return err;
Philipp Reisner907599e2011-02-08 11:25:37 +0100837}
838
Philipp Reisnerb411b362009-09-25 16:07:19 -0700839/*
840 * return values:
841 * 1 yes, we have a valid connection
842 * 0 oops, did not work out, please try again
843 * -1 peer talks different language,
844 * no point in trying again, please go standalone.
845 * -2 We do not have a network config...
846 */
Philipp Reisner907599e2011-02-08 11:25:37 +0100847static int drbd_connect(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700848{
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200849 struct socket *sock, *msock;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200850 struct net_conf *nc;
851 int timeout, try, h, ok;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700852
Philipp Reisnerbbeb6412011-02-10 13:45:46 +0100853 if (conn_request_state(tconn, NS(conn, C_WF_CONNECTION), CS_VERBOSE) < SS_SUCCESS)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700854 return -2;
855
Philipp Reisner907599e2011-02-08 11:25:37 +0100856 clear_bit(DISCARD_CONCURRENT, &tconn->flags);
Andreas Gruenbacher0916e0e2011-03-21 14:10:15 +0100857
858 /* Assume that the peer only understands protocol 80 until we know better. */
859 tconn->agreed_pro_version = 80;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700860
Philipp Reisnerb411b362009-09-25 16:07:19 -0700861 do {
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200862 struct socket *s;
863
Philipp Reisnerb411b362009-09-25 16:07:19 -0700864 for (try = 0;;) {
865 /* 3 tries, this should take less than a second! */
Philipp Reisner907599e2011-02-08 11:25:37 +0100866 s = drbd_try_connect(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700867 if (s || ++try >= 3)
868 break;
869 /* give the other side time to call bind() & listen() */
Philipp Reisner20ee6392011-01-18 15:28:59 +0100870 schedule_timeout_interruptible(HZ / 10);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700871 }
872
873 if (s) {
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200874 if (!tconn->data.socket) {
875 tconn->data.socket = s;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200876 send_first_packet(tconn, &tconn->data, P_INITIAL_DATA);
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200877 } else if (!tconn->meta.socket) {
878 tconn->meta.socket = s;
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200879 send_first_packet(tconn, &tconn->meta, P_INITIAL_META);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700880 } else {
Philipp Reisner907599e2011-02-08 11:25:37 +0100881 conn_err(tconn, "Logic error in drbd_connect()\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700882 goto out_release_sockets;
883 }
884 }
885
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200886 if (tconn->data.socket && tconn->meta.socket) {
Philipp Reisner907599e2011-02-08 11:25:37 +0100887 schedule_timeout_interruptible(tconn->net_conf->ping_timeo*HZ/10);
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200888 ok = drbd_socket_okay(&tconn->data.socket);
889 ok = drbd_socket_okay(&tconn->meta.socket) && ok;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700890 if (ok)
891 break;
892 }
893
894retry:
Philipp Reisner907599e2011-02-08 11:25:37 +0100895 s = drbd_wait_for_connect(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700896 if (s) {
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +0200897 try = receive_first_packet(tconn, s);
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200898 drbd_socket_okay(&tconn->data.socket);
899 drbd_socket_okay(&tconn->meta.socket);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700900 switch (try) {
Andreas Gruenbachere5d6f332011-03-28 16:44:40 +0200901 case P_INITIAL_DATA:
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200902 if (tconn->data.socket) {
Philipp Reisner907599e2011-02-08 11:25:37 +0100903 conn_warn(tconn, "initial packet S crossed\n");
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200904 sock_release(tconn->data.socket);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700905 }
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200906 tconn->data.socket = s;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700907 break;
Andreas Gruenbachere5d6f332011-03-28 16:44:40 +0200908 case P_INITIAL_META:
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200909 if (tconn->meta.socket) {
Philipp Reisner907599e2011-02-08 11:25:37 +0100910 conn_warn(tconn, "initial packet M crossed\n");
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200911 sock_release(tconn->meta.socket);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700912 }
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200913 tconn->meta.socket = s;
Philipp Reisner907599e2011-02-08 11:25:37 +0100914 set_bit(DISCARD_CONCURRENT, &tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700915 break;
916 default:
Philipp Reisner907599e2011-02-08 11:25:37 +0100917 conn_warn(tconn, "Error receiving initial packet\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700918 sock_release(s);
919 if (random32() & 1)
920 goto retry;
921 }
922 }
923
Philipp Reisnerbbeb6412011-02-10 13:45:46 +0100924 if (tconn->cstate <= C_DISCONNECTING)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700925 goto out_release_sockets;
926 if (signal_pending(current)) {
927 flush_signals(current);
928 smp_rmb();
Philipp Reisner907599e2011-02-08 11:25:37 +0100929 if (get_t_state(&tconn->receiver) == EXITING)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700930 goto out_release_sockets;
931 }
932
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200933 if (tconn->data.socket && &tconn->meta.socket) {
934 ok = drbd_socket_okay(&tconn->data.socket);
935 ok = drbd_socket_okay(&tconn->meta.socket) && ok;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700936 if (ok)
937 break;
938 }
939 } while (1);
940
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +0200941 sock = tconn->data.socket;
942 msock = tconn->meta.socket;
943
Philipp Reisnerb411b362009-09-25 16:07:19 -0700944 msock->sk->sk_reuse = 1; /* SO_REUSEADDR */
945 sock->sk->sk_reuse = 1; /* SO_REUSEADDR */
946
947 sock->sk->sk_allocation = GFP_NOIO;
948 msock->sk->sk_allocation = GFP_NOIO;
949
950 sock->sk->sk_priority = TC_PRIO_INTERACTIVE_BULK;
951 msock->sk->sk_priority = TC_PRIO_INTERACTIVE;
952
Philipp Reisnerb411b362009-09-25 16:07:19 -0700953 /* NOT YET ...
Philipp Reisner907599e2011-02-08 11:25:37 +0100954 * sock->sk->sk_sndtimeo = tconn->net_conf->timeout*HZ/10;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700955 * sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
Andreas Gruenbacher60381782011-03-28 17:05:50 +0200956 * first set it to the P_CONNECTION_FEATURES timeout,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700957 * which we set to 4x the configured ping_timeout. */
Philipp Reisner44ed1672011-04-19 17:10:19 +0200958 rcu_read_lock();
959 nc = rcu_dereference(tconn->net_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700960
Philipp Reisner44ed1672011-04-19 17:10:19 +0200961 sock->sk->sk_sndtimeo =
962 sock->sk->sk_rcvtimeo = nc->ping_timeo*4*HZ/10;
963
964 msock->sk->sk_rcvtimeo = nc->ping_int*HZ;
965 timeout = nc->timeout * HZ / 10;
966 rcu_read_unlock();
967
968 msock->sk->sk_sndtimeo = timeout;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700969
970 /* we don't want delays.
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300971 * we use TCP_CORK where appropriate, though */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700972 drbd_tcp_nodelay(sock);
973 drbd_tcp_nodelay(msock);
974
Philipp Reisner907599e2011-02-08 11:25:37 +0100975 tconn->last_received = jiffies;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700976
Andreas Gruenbacher60381782011-03-28 17:05:50 +0200977 h = drbd_do_features(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700978 if (h <= 0)
979 return h;
980
Philipp Reisner907599e2011-02-08 11:25:37 +0100981 if (tconn->cram_hmac_tfm) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700982 /* drbd_request_state(mdev, NS(conn, WFAuth)); */
Philipp Reisner907599e2011-02-08 11:25:37 +0100983 switch (drbd_do_auth(tconn)) {
Johannes Thomab10d96c2010-01-07 16:02:50 +0100984 case -1:
Philipp Reisner907599e2011-02-08 11:25:37 +0100985 conn_err(tconn, "Authentication of peer failed\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700986 return -1;
Johannes Thomab10d96c2010-01-07 16:02:50 +0100987 case 0:
Philipp Reisner907599e2011-02-08 11:25:37 +0100988 conn_err(tconn, "Authentication of peer failed, trying again.\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +0100989 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700990 }
991 }
992
Philipp Reisnerbbeb6412011-02-10 13:45:46 +0100993 if (conn_request_state(tconn, NS(conn, C_WF_REPORT_PARAMS), CS_VERBOSE) < SS_SUCCESS)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700994 return 0;
995
Philipp Reisner44ed1672011-04-19 17:10:19 +0200996 sock->sk->sk_sndtimeo = timeout;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700997 sock->sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
998
Philipp Reisner907599e2011-02-08 11:25:37 +0100999 drbd_thread_start(&tconn->asender);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001000
Andreas Gruenbacher387eb302011-03-16 01:05:37 +01001001 if (drbd_send_protocol(tconn) == -EOPNOTSUPP)
Philipp Reisner7e2455c2010-04-22 14:50:23 +02001002 return -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001003
Philipp Reisnerd3fcb492011-04-13 14:46:05 -07001004 down_read(&drbd_cfg_rwsem);
1005 h = !idr_for_each(&tconn->volumes, drbd_connected, tconn);
1006 up_read(&drbd_cfg_rwsem);
1007 return h;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001008
1009out_release_sockets:
Andreas Gruenbacher2bf89622011-03-28 16:33:12 +02001010 if (tconn->data.socket) {
1011 sock_release(tconn->data.socket);
1012 tconn->data.socket = NULL;
1013 }
1014 if (tconn->meta.socket) {
1015 sock_release(tconn->meta.socket);
1016 tconn->meta.socket = NULL;
1017 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001018 return -1;
1019}
1020
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001021static int decode_header(struct drbd_tconn *tconn, void *header, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001022{
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001023 unsigned int header_size = drbd_header_size(tconn);
1024
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +02001025 if (header_size == sizeof(struct p_header100) &&
1026 *(__be32 *)header == cpu_to_be32(DRBD_MAGIC_100)) {
1027 struct p_header100 *h = header;
1028 if (h->pad != 0) {
1029 conn_err(tconn, "Header padding is not zero\n");
1030 return -EINVAL;
1031 }
1032 pi->vnr = be16_to_cpu(h->volume);
1033 pi->cmd = be16_to_cpu(h->command);
1034 pi->size = be32_to_cpu(h->length);
1035 } else if (header_size == sizeof(struct p_header95) &&
1036 *(__be16 *)header == cpu_to_be16(DRBD_MAGIC_BIG)) {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001037 struct p_header95 *h = header;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001038 pi->cmd = be16_to_cpu(h->command);
Andreas Gruenbacherb55d84b2011-03-22 13:17:47 +01001039 pi->size = be32_to_cpu(h->length);
1040 pi->vnr = 0;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001041 } else if (header_size == sizeof(struct p_header80) &&
1042 *(__be32 *)header == cpu_to_be32(DRBD_MAGIC)) {
1043 struct p_header80 *h = header;
1044 pi->cmd = be16_to_cpu(h->command);
1045 pi->size = be16_to_cpu(h->length);
Philipp Reisner77351055b2011-02-07 17:24:26 +01001046 pi->vnr = 0;
Philipp Reisner02918be2010-08-20 14:35:10 +02001047 } else {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001048 conn_err(tconn, "Wrong magic value 0x%08x in protocol version %d\n",
1049 be32_to_cpu(*(__be32 *)header),
1050 tconn->agreed_pro_version);
Andreas Gruenbacher8172f3e2011-03-16 17:22:39 +01001051 return -EINVAL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001052 }
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001053 pi->data = header + header_size;
Andreas Gruenbacher8172f3e2011-03-16 17:22:39 +01001054 return 0;
Philipp Reisner257d0af2011-01-26 12:15:29 +01001055}
1056
Philipp Reisner9ba7aa02011-02-07 17:32:41 +01001057static int drbd_recv_header(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisner257d0af2011-01-26 12:15:29 +01001058{
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001059 void *buffer = tconn->data.rbuf;
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01001060 int err;
Philipp Reisner257d0af2011-01-26 12:15:29 +01001061
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001062 err = drbd_recv_all_warn(tconn, buffer, drbd_header_size(tconn));
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001063 if (err)
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01001064 return err;
Philipp Reisner257d0af2011-01-26 12:15:29 +01001065
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001066 err = decode_header(tconn, buffer, pi);
Philipp Reisner9ba7aa02011-02-07 17:32:41 +01001067 tconn->last_received = jiffies;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001068
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01001069 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001070}
1071
Philipp Reisner2451fc32010-08-24 13:43:11 +02001072static void drbd_flush(struct drbd_conf *mdev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001073{
1074 int rv;
1075
1076 if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) {
Dmitry Monakhovfbd9b092010-04-28 17:55:06 +04001077 rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL,
Christoph Hellwigdd3932e2010-09-16 20:51:46 +02001078 NULL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001079 if (rv) {
1080 dev_err(DEV, "local disk flush failed with status %d\n", rv);
1081 /* would rather check on EOPNOTSUPP, but that is not reliable.
1082 * don't try again for ANY return value != 0
1083 * if (rv == -EOPNOTSUPP) */
1084 drbd_bump_write_ordering(mdev, WO_drain_io);
1085 }
1086 put_ldev(mdev);
1087 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001088}
1089
1090/**
1091 * drbd_may_finish_epoch() - Applies an epoch_event to the epoch's state, eventually finishes it.
1092 * @mdev: DRBD device.
1093 * @epoch: Epoch object.
1094 * @ev: Epoch event.
1095 */
1096static enum finish_epoch drbd_may_finish_epoch(struct drbd_conf *mdev,
1097 struct drbd_epoch *epoch,
1098 enum epoch_event ev)
1099{
Philipp Reisner2451fc32010-08-24 13:43:11 +02001100 int epoch_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001101 struct drbd_epoch *next_epoch;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001102 enum finish_epoch rv = FE_STILL_LIVE;
1103
1104 spin_lock(&mdev->epoch_lock);
1105 do {
1106 next_epoch = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001107
1108 epoch_size = atomic_read(&epoch->epoch_size);
1109
1110 switch (ev & ~EV_CLEANUP) {
1111 case EV_PUT:
1112 atomic_dec(&epoch->active);
1113 break;
1114 case EV_GOT_BARRIER_NR:
1115 set_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001116 break;
1117 case EV_BECAME_LAST:
1118 /* nothing to do*/
1119 break;
1120 }
1121
Philipp Reisnerb411b362009-09-25 16:07:19 -07001122 if (epoch_size != 0 &&
1123 atomic_read(&epoch->active) == 0 &&
Philipp Reisner2451fc32010-08-24 13:43:11 +02001124 test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001125 if (!(ev & EV_CLEANUP)) {
1126 spin_unlock(&mdev->epoch_lock);
1127 drbd_send_b_ack(mdev, epoch->barrier_nr, epoch_size);
1128 spin_lock(&mdev->epoch_lock);
1129 }
1130 dec_unacked(mdev);
1131
1132 if (mdev->current_epoch != epoch) {
1133 next_epoch = list_entry(epoch->list.next, struct drbd_epoch, list);
1134 list_del(&epoch->list);
1135 ev = EV_BECAME_LAST | (ev & EV_CLEANUP);
1136 mdev->epochs--;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001137 kfree(epoch);
1138
1139 if (rv == FE_STILL_LIVE)
1140 rv = FE_DESTROYED;
1141 } else {
1142 epoch->flags = 0;
1143 atomic_set(&epoch->epoch_size, 0);
Uwe Kleine-König698f9312010-07-02 20:41:51 +02001144 /* atomic_set(&epoch->active, 0); is already zero */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001145 if (rv == FE_STILL_LIVE)
1146 rv = FE_RECYCLED;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001147 wake_up(&mdev->ee_wait);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001148 }
1149 }
1150
1151 if (!next_epoch)
1152 break;
1153
1154 epoch = next_epoch;
1155 } while (1);
1156
1157 spin_unlock(&mdev->epoch_lock);
1158
Philipp Reisnerb411b362009-09-25 16:07:19 -07001159 return rv;
1160}
1161
1162/**
1163 * drbd_bump_write_ordering() - Fall back to an other write ordering method
1164 * @mdev: DRBD device.
1165 * @wo: Write ordering method to try.
1166 */
1167void drbd_bump_write_ordering(struct drbd_conf *mdev, enum write_ordering_e wo) __must_hold(local)
1168{
1169 enum write_ordering_e pwo;
1170 static char *write_ordering_str[] = {
1171 [WO_none] = "none",
1172 [WO_drain_io] = "drain",
1173 [WO_bdev_flush] = "flush",
Philipp Reisnerb411b362009-09-25 16:07:19 -07001174 };
1175
1176 pwo = mdev->write_ordering;
1177 wo = min(pwo, wo);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001178 if (wo == WO_bdev_flush && mdev->ldev->dc.no_disk_flush)
1179 wo = WO_drain_io;
1180 if (wo == WO_drain_io && mdev->ldev->dc.no_disk_drain)
1181 wo = WO_none;
1182 mdev->write_ordering = wo;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001183 if (pwo != mdev->write_ordering || wo == WO_bdev_flush)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001184 dev_info(DEV, "Method to ensure write ordering: %s\n", write_ordering_str[mdev->write_ordering]);
1185}
1186
1187/**
Andreas Gruenbacherfbe29de2011-02-17 16:38:35 +01001188 * drbd_submit_peer_request()
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001189 * @mdev: DRBD device.
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001190 * @peer_req: peer request
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001191 * @rw: flag field, see bio->bi_rw
Lars Ellenberg10f6d9922011-01-24 14:47:09 +01001192 *
1193 * May spread the pages to multiple bios,
1194 * depending on bio_add_page restrictions.
1195 *
1196 * Returns 0 if all bios have been submitted,
1197 * -ENOMEM if we could not allocate enough bios,
1198 * -ENOSPC (any better suggestion?) if we have not been able to bio_add_page a
1199 * single page to an empty bio (which should never happen and likely indicates
1200 * that the lower level IO stack is in some way broken). This has been observed
1201 * on certain Xen deployments.
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001202 */
1203/* TODO allocate from our own bio_set. */
Andreas Gruenbacherfbe29de2011-02-17 16:38:35 +01001204int drbd_submit_peer_request(struct drbd_conf *mdev,
1205 struct drbd_peer_request *peer_req,
1206 const unsigned rw, const int fault_type)
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001207{
1208 struct bio *bios = NULL;
1209 struct bio *bio;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001210 struct page *page = peer_req->pages;
1211 sector_t sector = peer_req->i.sector;
1212 unsigned ds = peer_req->i.size;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001213 unsigned n_bios = 0;
1214 unsigned nr_pages = (ds + PAGE_SIZE -1) >> PAGE_SHIFT;
Lars Ellenberg10f6d9922011-01-24 14:47:09 +01001215 int err = -ENOMEM;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001216
1217 /* In most cases, we will only need one bio. But in case the lower
1218 * level restrictions happen to be different at this offset on this
1219 * side than those of the sending peer, we may need to submit the
Lars Ellenbergda4a75d2011-02-23 17:02:01 +01001220 * request in more than one bio.
1221 *
1222 * Plain bio_alloc is good enough here, this is no DRBD internally
1223 * generated bio, but a bio allocated on behalf of the peer.
1224 */
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001225next_bio:
1226 bio = bio_alloc(GFP_NOIO, nr_pages);
1227 if (!bio) {
1228 dev_err(DEV, "submit_ee: Allocation of a bio failed\n");
1229 goto fail;
1230 }
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001231 /* > peer_req->i.sector, unless this is the first bio */
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001232 bio->bi_sector = sector;
1233 bio->bi_bdev = mdev->ldev->backing_bdev;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001234 bio->bi_rw = rw;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001235 bio->bi_private = peer_req;
Andreas Gruenbacherfcefa622011-02-17 16:46:59 +01001236 bio->bi_end_io = drbd_peer_request_endio;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001237
1238 bio->bi_next = bios;
1239 bios = bio;
1240 ++n_bios;
1241
1242 page_chain_for_each(page) {
1243 unsigned len = min_t(unsigned, ds, PAGE_SIZE);
1244 if (!bio_add_page(bio, page, len, 0)) {
Lars Ellenberg10f6d9922011-01-24 14:47:09 +01001245 /* A single page must always be possible!
1246 * But in case it fails anyways,
1247 * we deal with it, and complain (below). */
1248 if (bio->bi_vcnt == 0) {
1249 dev_err(DEV,
1250 "bio_add_page failed for len=%u, "
1251 "bi_vcnt=0 (bi_sector=%llu)\n",
1252 len, (unsigned long long)bio->bi_sector);
1253 err = -ENOSPC;
1254 goto fail;
1255 }
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001256 goto next_bio;
1257 }
1258 ds -= len;
1259 sector += len >> 9;
1260 --nr_pages;
1261 }
1262 D_ASSERT(page == NULL);
1263 D_ASSERT(ds == 0);
1264
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001265 atomic_set(&peer_req->pending_bios, n_bios);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001266 do {
1267 bio = bios;
1268 bios = bios->bi_next;
1269 bio->bi_next = NULL;
1270
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001271 drbd_generic_make_request(mdev, fault_type, bio);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001272 } while (bios);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001273 return 0;
1274
1275fail:
1276 while (bios) {
1277 bio = bios;
1278 bios = bios->bi_next;
1279 bio_put(bio);
1280 }
Lars Ellenberg10f6d9922011-01-24 14:47:09 +01001281 return err;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001282}
1283
Andreas Gruenbacher53840642011-01-28 10:31:04 +01001284static void drbd_remove_epoch_entry_interval(struct drbd_conf *mdev,
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001285 struct drbd_peer_request *peer_req)
Andreas Gruenbacher53840642011-01-28 10:31:04 +01001286{
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001287 struct drbd_interval *i = &peer_req->i;
Andreas Gruenbacher53840642011-01-28 10:31:04 +01001288
1289 drbd_remove_interval(&mdev->write_requests, i);
1290 drbd_clear_interval(i);
1291
Andreas Gruenbacher6c852be2011-02-04 15:38:52 +01001292 /* Wake up any processes waiting for this peer request to complete. */
Andreas Gruenbacher53840642011-01-28 10:31:04 +01001293 if (i->waiting)
1294 wake_up(&mdev->misc_wait);
1295}
1296
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001297static int receive_Barrier(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001298{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001299 struct drbd_conf *mdev;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001300 int rv;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001301 struct p_barrier *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001302 struct drbd_epoch *epoch;
1303
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001304 mdev = vnr_to_mdev(tconn, pi->vnr);
1305 if (!mdev)
1306 return -EIO;
1307
Philipp Reisnerb411b362009-09-25 16:07:19 -07001308 inc_unacked(mdev);
1309
Philipp Reisnerb411b362009-09-25 16:07:19 -07001310 mdev->current_epoch->barrier_nr = p->barrier;
1311 rv = drbd_may_finish_epoch(mdev, mdev->current_epoch, EV_GOT_BARRIER_NR);
1312
1313 /* P_BARRIER_ACK may imply that the corresponding extent is dropped from
1314 * the activity log, which means it would not be resynced in case the
1315 * R_PRIMARY crashes now.
1316 * Therefore we must send the barrier_ack after the barrier request was
1317 * completed. */
1318 switch (mdev->write_ordering) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001319 case WO_none:
1320 if (rv == FE_RECYCLED)
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001321 return 0;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001322
1323 /* receiver context, in the writeout path of the other node.
1324 * avoid potential distributed deadlock */
1325 epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
1326 if (epoch)
1327 break;
1328 else
1329 dev_warn(DEV, "Allocation of an epoch failed, slowing down\n");
1330 /* Fall through */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001331
1332 case WO_bdev_flush:
1333 case WO_drain_io:
Philipp Reisnerb411b362009-09-25 16:07:19 -07001334 drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
Philipp Reisner2451fc32010-08-24 13:43:11 +02001335 drbd_flush(mdev);
1336
1337 if (atomic_read(&mdev->current_epoch->epoch_size)) {
1338 epoch = kmalloc(sizeof(struct drbd_epoch), GFP_NOIO);
1339 if (epoch)
1340 break;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001341 }
1342
Philipp Reisner2451fc32010-08-24 13:43:11 +02001343 epoch = mdev->current_epoch;
1344 wait_event(mdev->ee_wait, atomic_read(&epoch->epoch_size) == 0);
1345
1346 D_ASSERT(atomic_read(&epoch->active) == 0);
1347 D_ASSERT(epoch->flags == 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001348
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001349 return 0;
Philipp Reisner2451fc32010-08-24 13:43:11 +02001350 default:
1351 dev_err(DEV, "Strangeness in mdev->write_ordering %d\n", mdev->write_ordering);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001352 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001353 }
1354
1355 epoch->flags = 0;
1356 atomic_set(&epoch->epoch_size, 0);
1357 atomic_set(&epoch->active, 0);
1358
1359 spin_lock(&mdev->epoch_lock);
1360 if (atomic_read(&mdev->current_epoch->epoch_size)) {
1361 list_add(&epoch->list, &mdev->current_epoch->list);
1362 mdev->current_epoch = epoch;
1363 mdev->epochs++;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001364 } else {
1365 /* The current_epoch got recycled while we allocated this one... */
1366 kfree(epoch);
1367 }
1368 spin_unlock(&mdev->epoch_lock);
1369
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001370 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001371}
1372
1373/* used from receive_RSDataReply (recv_resync_read)
1374 * and from receive_Data */
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +01001375static struct drbd_peer_request *
1376read_in_block(struct drbd_conf *mdev, u64 id, sector_t sector,
1377 int data_size) __must_hold(local)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001378{
Lars Ellenberg66660322010-04-06 12:15:04 +02001379 const sector_t capacity = drbd_get_capacity(mdev->this_bdev);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001380 struct drbd_peer_request *peer_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001381 struct page *page;
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001382 int dgs, ds, err;
Philipp Reisnera0638452011-01-19 14:31:32 +01001383 void *dig_in = mdev->tconn->int_dig_in;
1384 void *dig_vv = mdev->tconn->int_dig_vv;
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001385 unsigned long *data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001386
Philipp Reisnera0638452011-01-19 14:31:32 +01001387 dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ?
1388 crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001389
1390 if (dgs) {
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02001391 /*
1392 * FIXME: Receive the incoming digest into the receive buffer
1393 * here, together with its struct p_data?
1394 */
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001395 err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs);
1396 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001397 return NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001398 }
1399
1400 data_size -= dgs;
1401
Andreas Gruenbacher841ce242010-12-15 19:31:20 +01001402 if (!expect(data_size != 0))
1403 return NULL;
1404 if (!expect(IS_ALIGNED(data_size, 512)))
1405 return NULL;
1406 if (!expect(data_size <= DRBD_MAX_BIO_SIZE))
1407 return NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001408
Lars Ellenberg66660322010-04-06 12:15:04 +02001409 /* even though we trust out peer,
1410 * we sometimes have to double check. */
1411 if (sector + (data_size>>9) > capacity) {
Lars Ellenbergfdda6542011-01-24 15:11:01 +01001412 dev_err(DEV, "request from peer beyond end of local disk: "
1413 "capacity: %llus < sector: %llus + size: %u\n",
Lars Ellenberg66660322010-04-06 12:15:04 +02001414 (unsigned long long)capacity,
1415 (unsigned long long)sector, data_size);
1416 return NULL;
1417 }
1418
Philipp Reisnerb411b362009-09-25 16:07:19 -07001419 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
1420 * "criss-cross" setup, that might cause write-out on some other DRBD,
1421 * which in turn might block on the other node at this very place. */
Andreas Gruenbacher0db55362011-04-06 16:09:15 +02001422 peer_req = drbd_alloc_peer_req(mdev, id, sector, data_size, GFP_NOIO);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001423 if (!peer_req)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001424 return NULL;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001425
Philipp Reisnerb411b362009-09-25 16:07:19 -07001426 ds = data_size;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001427 page = peer_req->pages;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001428 page_chain_for_each(page) {
1429 unsigned len = min_t(int, ds, PAGE_SIZE);
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001430 data = kmap(page);
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001431 err = drbd_recv_all_warn(mdev->tconn, data, len);
Andreas Gruenbacher0cf9d272010-12-07 10:43:29 +01001432 if (drbd_insert_fault(mdev, DRBD_FAULT_RECEIVE)) {
Philipp Reisner6b4388a2010-04-26 14:11:45 +02001433 dev_err(DEV, "Fault injection: Corrupting data on receive\n");
1434 data[0] = data[0] ^ (unsigned long)-1;
1435 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001436 kunmap(page);
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001437 if (err) {
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +02001438 drbd_free_peer_req(mdev, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001439 return NULL;
1440 }
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001441 ds -= len;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001442 }
1443
1444 if (dgs) {
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001445 drbd_csum_ee(mdev, mdev->tconn->integrity_r_tfm, peer_req, dig_vv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001446 if (memcmp(dig_in, dig_vv, dgs)) {
Lars Ellenberg470be442010-11-10 10:36:52 +01001447 dev_err(DEV, "Digest integrity check FAILED: %llus +%u\n",
1448 (unsigned long long)sector, data_size);
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +02001449 drbd_free_peer_req(mdev, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001450 return NULL;
1451 }
1452 }
1453 mdev->recv_cnt += data_size>>9;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001454 return peer_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001455}
1456
1457/* drbd_drain_block() just takes a data block
1458 * out of the socket input buffer, and discards it.
1459 */
1460static int drbd_drain_block(struct drbd_conf *mdev, int data_size)
1461{
1462 struct page *page;
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001463 int err = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001464 void *data;
1465
Lars Ellenbergc3470cd2010-04-01 16:57:19 +02001466 if (!data_size)
Andreas Gruenbacherfc5be832011-03-16 17:50:50 +01001467 return 0;
Lars Ellenbergc3470cd2010-04-01 16:57:19 +02001468
Andreas Gruenbacherc37c8ec2011-04-07 21:02:09 +02001469 page = drbd_alloc_pages(mdev, 1, 1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001470
1471 data = kmap(page);
1472 while (data_size) {
Andreas Gruenbacherfc5be832011-03-16 17:50:50 +01001473 unsigned int len = min_t(int, data_size, PAGE_SIZE);
1474
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001475 err = drbd_recv_all_warn(mdev->tconn, data, len);
1476 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001477 break;
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001478 data_size -= len;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001479 }
1480 kunmap(page);
Andreas Gruenbacher5cc287e2011-04-07 21:02:59 +02001481 drbd_free_pages(mdev, page, 0);
Andreas Gruenbacherfc5be832011-03-16 17:50:50 +01001482 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001483}
1484
1485static int recv_dless_read(struct drbd_conf *mdev, struct drbd_request *req,
1486 sector_t sector, int data_size)
1487{
1488 struct bio_vec *bvec;
1489 struct bio *bio;
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001490 int dgs, err, i, expect;
Philipp Reisnera0638452011-01-19 14:31:32 +01001491 void *dig_in = mdev->tconn->int_dig_in;
1492 void *dig_vv = mdev->tconn->int_dig_vv;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001493
Philipp Reisnera0638452011-01-19 14:31:32 +01001494 dgs = (mdev->tconn->agreed_pro_version >= 87 && mdev->tconn->integrity_r_tfm) ?
1495 crypto_hash_digestsize(mdev->tconn->integrity_r_tfm) : 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001496
1497 if (dgs) {
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001498 err = drbd_recv_all_warn(mdev->tconn, dig_in, dgs);
1499 if (err)
1500 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001501 }
1502
1503 data_size -= dgs;
1504
1505 /* optimistically update recv_cnt. if receiving fails below,
1506 * we disconnect anyways, and counters will be reset. */
1507 mdev->recv_cnt += data_size>>9;
1508
1509 bio = req->master_bio;
1510 D_ASSERT(sector == bio->bi_sector);
1511
1512 bio_for_each_segment(bvec, bio, i) {
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001513 void *mapped = kmap(bvec->bv_page) + bvec->bv_offset;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001514 expect = min_t(int, data_size, bvec->bv_len);
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001515 err = drbd_recv_all_warn(mdev->tconn, mapped, expect);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001516 kunmap(bvec->bv_page);
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01001517 if (err)
1518 return err;
1519 data_size -= expect;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001520 }
1521
1522 if (dgs) {
Philipp Reisnera0638452011-01-19 14:31:32 +01001523 drbd_csum_bio(mdev, mdev->tconn->integrity_r_tfm, bio, dig_vv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001524 if (memcmp(dig_in, dig_vv, dgs)) {
1525 dev_err(DEV, "Digest integrity check FAILED. Broken NICs?\n");
Andreas Gruenbacher28284ce2011-03-16 17:54:02 +01001526 return -EINVAL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001527 }
1528 }
1529
1530 D_ASSERT(data_size == 0);
Andreas Gruenbacher28284ce2011-03-16 17:54:02 +01001531 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001532}
1533
Andreas Gruenbachera990be42011-04-06 17:56:48 +02001534/*
1535 * e_end_resync_block() is called in asender context via
1536 * drbd_finish_peer_reqs().
1537 */
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001538static int e_end_resync_block(struct drbd_work *w, int unused)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001539{
Andreas Gruenbacher8050e6d2011-02-18 16:12:48 +01001540 struct drbd_peer_request *peer_req =
1541 container_of(w, struct drbd_peer_request, w);
Philipp Reisner00d56942011-02-09 18:09:48 +01001542 struct drbd_conf *mdev = w->mdev;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001543 sector_t sector = peer_req->i.sector;
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001544 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001545
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001546 D_ASSERT(drbd_interval_empty(&peer_req->i));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001547
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001548 if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) {
1549 drbd_set_in_sync(mdev, sector, peer_req->i.size);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001550 err = drbd_send_ack(mdev, P_RS_WRITE_ACK, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001551 } else {
1552 /* Record failure to sync */
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001553 drbd_rs_failed_io(mdev, sector, peer_req->i.size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001554
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001555 err = drbd_send_ack(mdev, P_NEG_ACK, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001556 }
1557 dec_unacked(mdev);
1558
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001559 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001560}
1561
1562static int recv_resync_read(struct drbd_conf *mdev, sector_t sector, int data_size) __releases(local)
1563{
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001564 struct drbd_peer_request *peer_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001565
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001566 peer_req = read_in_block(mdev, ID_SYNCER, sector, data_size);
1567 if (!peer_req)
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001568 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001569
1570 dec_rs_pending(mdev);
1571
Philipp Reisnerb411b362009-09-25 16:07:19 -07001572 inc_unacked(mdev);
1573 /* corresponding dec_unacked() in e_end_resync_block()
1574 * respective _drbd_clear_done_ee */
1575
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001576 peer_req->w.cb = e_end_resync_block;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001577
Philipp Reisner87eeee42011-01-19 14:16:30 +01001578 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001579 list_add(&peer_req->w.list, &mdev->sync_ee);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001580 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001581
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001582 atomic_add(data_size >> 9, &mdev->rs_sect_ev);
Andreas Gruenbacherfbe29de2011-02-17 16:38:35 +01001583 if (drbd_submit_peer_request(mdev, peer_req, WRITE, DRBD_FAULT_RS_WR) == 0)
Andreas Gruenbachere1c1b0f2011-03-16 17:58:27 +01001584 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001585
Lars Ellenberg10f6d9922011-01-24 14:47:09 +01001586 /* don't care for the reason here */
1587 dev_err(DEV, "submit failed, triggering re-connect\n");
Philipp Reisner87eeee42011-01-19 14:16:30 +01001588 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001589 list_del(&peer_req->w.list);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001590 spin_unlock_irq(&mdev->tconn->req_lock);
Lars Ellenberg22cc37a2010-09-14 20:40:41 +02001591
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +02001592 drbd_free_peer_req(mdev, peer_req);
Lars Ellenberg45bb9122010-05-14 17:10:48 +02001593fail:
1594 put_ldev(mdev);
Andreas Gruenbachere1c1b0f2011-03-16 17:58:27 +01001595 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001596}
1597
Andreas Gruenbacher668eebc2011-01-20 17:14:26 +01001598static struct drbd_request *
Andreas Gruenbacherbc9c5c42011-01-21 18:00:55 +01001599find_request(struct drbd_conf *mdev, struct rb_root *root, u64 id,
1600 sector_t sector, bool missing_ok, const char *func)
Andreas Gruenbacher668eebc2011-01-20 17:14:26 +01001601{
Andreas Gruenbacher668eebc2011-01-20 17:14:26 +01001602 struct drbd_request *req;
1603
Andreas Gruenbacherbc9c5c42011-01-21 18:00:55 +01001604 /* Request object according to our peer */
1605 req = (struct drbd_request *)(unsigned long)id;
Andreas Gruenbacher5e472262011-01-27 14:42:51 +01001606 if (drbd_contains_interval(root, sector, &req->i) && req->i.local)
Andreas Gruenbacher668eebc2011-01-20 17:14:26 +01001607 return req;
Andreas Gruenbacherc3afd8f2011-01-20 22:25:40 +01001608 if (!missing_ok) {
1609 dev_err(DEV, "%s: failed to find request %lu, sector %llus\n", func,
1610 (unsigned long)id, (unsigned long long)sector);
1611 }
Andreas Gruenbacher668eebc2011-01-20 17:14:26 +01001612 return NULL;
1613}
1614
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001615static int receive_DataReply(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001616{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001617 struct drbd_conf *mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001618 struct drbd_request *req;
1619 sector_t sector;
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001620 int err;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001621 struct p_data *p = pi->data;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001622
1623 mdev = vnr_to_mdev(tconn, pi->vnr);
1624 if (!mdev)
1625 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001626
1627 sector = be64_to_cpu(p->sector);
1628
Philipp Reisner87eeee42011-01-19 14:16:30 +01001629 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherbc9c5c42011-01-21 18:00:55 +01001630 req = find_request(mdev, &mdev->read_requests, p->block_id, sector, false, __func__);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001631 spin_unlock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherc3afd8f2011-01-20 22:25:40 +01001632 if (unlikely(!req))
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001633 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001634
Bart Van Assche24c48302011-05-21 18:32:29 +02001635 /* hlist_del(&req->collision) is done in _req_may_be_done, to avoid
Philipp Reisnerb411b362009-09-25 16:07:19 -07001636 * special casing it there for the various failure cases.
1637 * still no race with drbd_fail_pending_reads */
Andreas Gruenbachere2857212011-03-25 00:57:38 +01001638 err = recv_dless_read(mdev, req, sector, pi->size);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001639 if (!err)
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01001640 req_mod(req, DATA_RECEIVED);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001641 /* else: nothing. handled from drbd_disconnect...
1642 * I don't think we may complete this just yet
1643 * in case we are "on-disconnect: freeze" */
1644
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001645 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001646}
1647
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001648static int receive_RSDataReply(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001649{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001650 struct drbd_conf *mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001651 sector_t sector;
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001652 int err;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02001653 struct p_data *p = pi->data;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01001654
1655 mdev = vnr_to_mdev(tconn, pi->vnr);
1656 if (!mdev)
1657 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001658
1659 sector = be64_to_cpu(p->sector);
1660 D_ASSERT(p->block_id == ID_SYNCER);
1661
1662 if (get_ldev(mdev)) {
1663 /* data is submitted to disk within recv_resync_read.
1664 * corresponding put_ldev done below on error,
Andreas Gruenbacherfcefa622011-02-17 16:46:59 +01001665 * or in drbd_peer_request_endio. */
Andreas Gruenbachere2857212011-03-25 00:57:38 +01001666 err = recv_resync_read(mdev, sector, pi->size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001667 } else {
1668 if (__ratelimit(&drbd_ratelimit_state))
1669 dev_err(DEV, "Can not write resync data to local disk.\n");
1670
Andreas Gruenbachere2857212011-03-25 00:57:38 +01001671 err = drbd_drain_block(mdev, pi->size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001672
Andreas Gruenbachere2857212011-03-25 00:57:38 +01001673 drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001674 }
1675
Andreas Gruenbachere2857212011-03-25 00:57:38 +01001676 atomic_add(pi->size >> 9, &mdev->rs_sect_in);
Philipp Reisner778f2712010-07-06 11:14:00 +02001677
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01001678 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001679}
1680
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001681static int w_restart_write(struct drbd_work *w, int cancel)
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001682{
1683 struct drbd_request *req = container_of(w, struct drbd_request, w);
1684 struct drbd_conf *mdev = w->mdev;
1685 struct bio *bio;
1686 unsigned long start_time;
1687 unsigned long flags;
1688
1689 spin_lock_irqsave(&mdev->tconn->req_lock, flags);
1690 if (!expect(req->rq_state & RQ_POSTPONED)) {
1691 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001692 return -EIO;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001693 }
1694 bio = req->master_bio;
1695 start_time = req->start_time;
1696 /* Postponed requests will not have their master_bio completed! */
1697 __req_mod(req, DISCARD_WRITE, NULL);
1698 spin_unlock_irqrestore(&mdev->tconn->req_lock, flags);
1699
1700 while (__drbd_make_request(mdev, bio, start_time))
1701 /* retry */ ;
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001702 return 0;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001703}
1704
1705static void restart_conflicting_writes(struct drbd_conf *mdev,
1706 sector_t sector, int size)
1707{
1708 struct drbd_interval *i;
1709 struct drbd_request *req;
1710
1711 drbd_for_each_overlap(i, &mdev->write_requests, sector, size) {
1712 if (!i->local)
1713 continue;
1714 req = container_of(i, struct drbd_request, i);
1715 if (req->rq_state & RQ_LOCAL_PENDING ||
1716 !(req->rq_state & RQ_POSTPONED))
1717 continue;
1718 if (expect(list_empty(&req->w.list))) {
1719 req->w.mdev = mdev;
1720 req->w.cb = w_restart_write;
1721 drbd_queue_work(&mdev->tconn->data.work, &req->w);
1722 }
1723 }
1724}
1725
Andreas Gruenbachera990be42011-04-06 17:56:48 +02001726/*
1727 * e_end_block() is called in asender context via drbd_finish_peer_reqs().
Philipp Reisnerb411b362009-09-25 16:07:19 -07001728 */
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001729static int e_end_block(struct drbd_work *w, int cancel)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001730{
Andreas Gruenbacher8050e6d2011-02-18 16:12:48 +01001731 struct drbd_peer_request *peer_req =
1732 container_of(w, struct drbd_peer_request, w);
Philipp Reisner00d56942011-02-09 18:09:48 +01001733 struct drbd_conf *mdev = w->mdev;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001734 sector_t sector = peer_req->i.sector;
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001735 int err = 0, pcmd;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001736
Philipp Reisner303d1442011-04-13 16:24:47 -07001737 if (peer_req->flags & EE_SEND_WRITE_ACK) {
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001738 if (likely((peer_req->flags & EE_WAS_ERROR) == 0)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001739 pcmd = (mdev->state.conn >= C_SYNC_SOURCE &&
1740 mdev->state.conn <= C_PAUSED_SYNC_T &&
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001741 peer_req->flags & EE_MAY_SET_IN_SYNC) ?
Philipp Reisnerb411b362009-09-25 16:07:19 -07001742 P_RS_WRITE_ACK : P_WRITE_ACK;
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001743 err = drbd_send_ack(mdev, pcmd, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001744 if (pcmd == P_RS_WRITE_ACK)
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001745 drbd_set_in_sync(mdev, sector, peer_req->i.size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001746 } else {
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001747 err = drbd_send_ack(mdev, P_NEG_ACK, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001748 /* we expect it to be marked out of sync anyways...
1749 * maybe assert this? */
1750 }
1751 dec_unacked(mdev);
1752 }
1753 /* we delete from the conflict detection hash _after_ we sent out the
1754 * P_WRITE_ACK / P_NEG_ACK, to get the sequence number right. */
Philipp Reisner302bdea2011-04-21 11:36:49 +02001755 if (peer_req->flags & EE_IN_INTERVAL_TREE) {
Philipp Reisner87eeee42011-01-19 14:16:30 +01001756 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001757 D_ASSERT(!drbd_interval_empty(&peer_req->i));
1758 drbd_remove_epoch_entry_interval(mdev, peer_req);
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001759 if (peer_req->flags & EE_RESTART_REQUESTS)
1760 restart_conflicting_writes(mdev, sector, peer_req->i.size);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001761 spin_unlock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherbb3bfe92011-01-21 15:59:23 +01001762 } else
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001763 D_ASSERT(drbd_interval_empty(&peer_req->i));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001764
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01001765 drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + (cancel ? EV_CLEANUP : 0));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001766
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001767 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001768}
1769
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001770static int e_send_ack(struct drbd_work *w, enum drbd_packet ack)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001771{
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001772 struct drbd_conf *mdev = w->mdev;
Andreas Gruenbacher8050e6d2011-02-18 16:12:48 +01001773 struct drbd_peer_request *peer_req =
1774 container_of(w, struct drbd_peer_request, w);
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001775 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001776
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001777 err = drbd_send_ack(mdev, ack, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001778 dec_unacked(mdev);
1779
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001780 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001781}
1782
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001783static int e_send_discard_write(struct drbd_work *w, int unused)
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001784{
1785 return e_send_ack(w, P_DISCARD_WRITE);
1786}
1787
Andreas Gruenbacher99920dc2011-03-16 15:31:39 +01001788static int e_send_retry_write(struct drbd_work *w, int unused)
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001789{
1790 struct drbd_tconn *tconn = w->mdev->tconn;
1791
1792 return e_send_ack(w, tconn->agreed_pro_version >= 100 ?
1793 P_RETRY_WRITE : P_DISCARD_WRITE);
1794}
1795
Andreas Gruenbacher3e394da2011-01-26 18:36:55 +01001796static bool seq_greater(u32 a, u32 b)
1797{
1798 /*
1799 * We assume 32-bit wrap-around here.
1800 * For 24-bit wrap-around, we would have to shift:
1801 * a <<= 8; b <<= 8;
1802 */
1803 return (s32)a - (s32)b > 0;
1804}
1805
1806static u32 seq_max(u32 a, u32 b)
1807{
1808 return seq_greater(a, b) ? a : b;
1809}
1810
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001811static bool need_peer_seq(struct drbd_conf *mdev)
1812{
1813 struct drbd_tconn *tconn = mdev->tconn;
Philipp Reisner302bdea2011-04-21 11:36:49 +02001814 int tp;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001815
1816 /*
1817 * We only need to keep track of the last packet_seq number of our peer
1818 * if we are in dual-primary mode and we have the discard flag set; see
1819 * handle_write_conflicts().
1820 */
Philipp Reisner302bdea2011-04-21 11:36:49 +02001821
1822 rcu_read_lock();
1823 tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries;
1824 rcu_read_unlock();
1825
1826 return tp && test_bit(DISCARD_CONCURRENT, &tconn->flags);
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001827}
1828
Andreas Gruenbacher43ae0772011-02-03 18:42:08 +01001829static void update_peer_seq(struct drbd_conf *mdev, unsigned int peer_seq)
Andreas Gruenbacher3e394da2011-01-26 18:36:55 +01001830{
Lars Ellenberg3c13b682011-02-23 16:10:01 +01001831 unsigned int newest_peer_seq;
Andreas Gruenbacher3e394da2011-01-26 18:36:55 +01001832
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001833 if (need_peer_seq(mdev)) {
1834 spin_lock(&mdev->peer_seq_lock);
Lars Ellenberg3c13b682011-02-23 16:10:01 +01001835 newest_peer_seq = seq_max(mdev->peer_seq, peer_seq);
1836 mdev->peer_seq = newest_peer_seq;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001837 spin_unlock(&mdev->peer_seq_lock);
Lars Ellenberg3c13b682011-02-23 16:10:01 +01001838 /* wake up only if we actually changed mdev->peer_seq */
1839 if (peer_seq == newest_peer_seq)
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001840 wake_up(&mdev->seq_wait);
1841 }
Andreas Gruenbacher3e394da2011-01-26 18:36:55 +01001842}
1843
Philipp Reisnerb411b362009-09-25 16:07:19 -07001844/* Called from receive_Data.
1845 * Synchronize packets on sock with packets on msock.
1846 *
1847 * This is here so even when a P_DATA packet traveling via sock overtook an Ack
1848 * packet traveling on msock, they are still processed in the order they have
1849 * been sent.
1850 *
1851 * Note: we don't care for Ack packets overtaking P_DATA packets.
1852 *
1853 * In case packet_seq is larger than mdev->peer_seq number, there are
1854 * outstanding packets on the msock. We wait for them to arrive.
1855 * In case we are the logically next packet, we update mdev->peer_seq
1856 * ourselves. Correctly handles 32bit wrap around.
1857 *
1858 * Assume we have a 10 GBit connection, that is about 1<<30 byte per second,
1859 * about 1<<21 sectors per second. So "worst" case, we have 1<<3 == 8 seconds
1860 * for the 24bit wrap (historical atomic_t guarantee on some archs), and we have
1861 * 1<<9 == 512 seconds aka ages for the 32bit wrap around...
1862 *
1863 * returns 0 if we may process the packet,
1864 * -ERESTARTSYS if we were interrupted (by disconnect signal). */
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001865static int wait_for_and_update_peer_seq(struct drbd_conf *mdev, const u32 peer_seq)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001866{
1867 DEFINE_WAIT(wait);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001868 long timeout;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001869 int ret;
1870
1871 if (!need_peer_seq(mdev))
1872 return 0;
1873
Philipp Reisnerb411b362009-09-25 16:07:19 -07001874 spin_lock(&mdev->peer_seq_lock);
1875 for (;;) {
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001876 if (!seq_greater(peer_seq - 1, mdev->peer_seq)) {
1877 mdev->peer_seq = seq_max(mdev->peer_seq, peer_seq);
1878 ret = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001879 break;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001880 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001881 if (signal_pending(current)) {
1882 ret = -ERESTARTSYS;
1883 break;
1884 }
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001885 prepare_to_wait(&mdev->seq_wait, &wait, TASK_INTERRUPTIBLE);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001886 spin_unlock(&mdev->peer_seq_lock);
Philipp Reisner44ed1672011-04-19 17:10:19 +02001887 rcu_read_lock();
1888 timeout = rcu_dereference(mdev->tconn->net_conf)->ping_timeo*HZ/10;
1889 rcu_read_unlock();
Andreas Gruenbacher71b1c1e2011-03-01 15:40:43 +01001890 timeout = schedule_timeout(timeout);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001891 spin_lock(&mdev->peer_seq_lock);
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001892 if (!timeout) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001893 ret = -ETIMEDOUT;
Andreas Gruenbacher71b1c1e2011-03-01 15:40:43 +01001894 dev_err(DEV, "Timed out waiting for missing ack packets; disconnecting\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07001895 break;
1896 }
1897 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001898 spin_unlock(&mdev->peer_seq_lock);
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001899 finish_wait(&mdev->seq_wait, &wait);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001900 return ret;
1901}
1902
Lars Ellenberg688593c2010-11-17 22:25:03 +01001903/* see also bio_flags_to_wire()
1904 * DRBD_REQ_*, because we need to semantically map the flags to data packet
1905 * flags and back. We may replicate to other kernel versions. */
1906static unsigned long wire_flags_to_bio(struct drbd_conf *mdev, u32 dpf)
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001907{
Lars Ellenberg688593c2010-11-17 22:25:03 +01001908 return (dpf & DP_RW_SYNC ? REQ_SYNC : 0) |
1909 (dpf & DP_FUA ? REQ_FUA : 0) |
1910 (dpf & DP_FLUSH ? REQ_FLUSH : 0) |
1911 (dpf & DP_DISCARD ? REQ_DISCARD : 0);
Philipp Reisner76d2e7e2010-08-25 11:58:05 +02001912}
1913
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01001914static void fail_postponed_requests(struct drbd_conf *mdev, sector_t sector,
1915 unsigned int size)
1916{
1917 struct drbd_interval *i;
1918
1919 repeat:
1920 drbd_for_each_overlap(i, &mdev->write_requests, sector, size) {
1921 struct drbd_request *req;
1922 struct bio_and_error m;
1923
1924 if (!i->local)
1925 continue;
1926 req = container_of(i, struct drbd_request, i);
1927 if (!(req->rq_state & RQ_POSTPONED))
1928 continue;
1929 req->rq_state &= ~RQ_POSTPONED;
1930 __req_mod(req, NEG_ACKED, &m);
1931 spin_unlock_irq(&mdev->tconn->req_lock);
1932 if (m.bio)
1933 complete_master_bio(mdev, &m);
1934 spin_lock_irq(&mdev->tconn->req_lock);
1935 goto repeat;
1936 }
1937}
1938
1939static int handle_write_conflicts(struct drbd_conf *mdev,
1940 struct drbd_peer_request *peer_req)
1941{
1942 struct drbd_tconn *tconn = mdev->tconn;
1943 bool resolve_conflicts = test_bit(DISCARD_CONCURRENT, &tconn->flags);
1944 sector_t sector = peer_req->i.sector;
1945 const unsigned int size = peer_req->i.size;
1946 struct drbd_interval *i;
1947 bool equal;
1948 int err;
1949
1950 /*
1951 * Inserting the peer request into the write_requests tree will prevent
1952 * new conflicting local requests from being added.
1953 */
1954 drbd_insert_interval(&mdev->write_requests, &peer_req->i);
1955
1956 repeat:
1957 drbd_for_each_overlap(i, &mdev->write_requests, sector, size) {
1958 if (i == &peer_req->i)
1959 continue;
1960
1961 if (!i->local) {
1962 /*
1963 * Our peer has sent a conflicting remote request; this
1964 * should not happen in a two-node setup. Wait for the
1965 * earlier peer request to complete.
1966 */
1967 err = drbd_wait_misc(mdev, i);
1968 if (err)
1969 goto out;
1970 goto repeat;
1971 }
1972
1973 equal = i->sector == sector && i->size == size;
1974 if (resolve_conflicts) {
1975 /*
1976 * If the peer request is fully contained within the
1977 * overlapping request, it can be discarded; otherwise,
1978 * it will be retried once all overlapping requests
1979 * have completed.
1980 */
1981 bool discard = i->sector <= sector && i->sector +
1982 (i->size >> 9) >= sector + (size >> 9);
1983
1984 if (!equal)
1985 dev_alert(DEV, "Concurrent writes detected: "
1986 "local=%llus +%u, remote=%llus +%u, "
1987 "assuming %s came first\n",
1988 (unsigned long long)i->sector, i->size,
1989 (unsigned long long)sector, size,
1990 discard ? "local" : "remote");
1991
1992 inc_unacked(mdev);
1993 peer_req->w.cb = discard ? e_send_discard_write :
1994 e_send_retry_write;
1995 list_add_tail(&peer_req->w.list, &mdev->done_ee);
1996 wake_asender(mdev->tconn);
1997
1998 err = -ENOENT;
1999 goto out;
2000 } else {
2001 struct drbd_request *req =
2002 container_of(i, struct drbd_request, i);
2003
2004 if (!equal)
2005 dev_alert(DEV, "Concurrent writes detected: "
2006 "local=%llus +%u, remote=%llus +%u\n",
2007 (unsigned long long)i->sector, i->size,
2008 (unsigned long long)sector, size);
2009
2010 if (req->rq_state & RQ_LOCAL_PENDING ||
2011 !(req->rq_state & RQ_POSTPONED)) {
2012 /*
2013 * Wait for the node with the discard flag to
2014 * decide if this request will be discarded or
2015 * retried. Requests that are discarded will
2016 * disappear from the write_requests tree.
2017 *
2018 * In addition, wait for the conflicting
2019 * request to finish locally before submitting
2020 * the conflicting peer request.
2021 */
2022 err = drbd_wait_misc(mdev, &req->i);
2023 if (err) {
2024 _conn_request_state(mdev->tconn,
2025 NS(conn, C_TIMEOUT),
2026 CS_HARD);
2027 fail_postponed_requests(mdev, sector, size);
2028 goto out;
2029 }
2030 goto repeat;
2031 }
2032 /*
2033 * Remember to restart the conflicting requests after
2034 * the new peer request has completed.
2035 */
2036 peer_req->flags |= EE_RESTART_REQUESTS;
2037 }
2038 }
2039 err = 0;
2040
2041 out:
2042 if (err)
2043 drbd_remove_epoch_entry_interval(mdev, peer_req);
2044 return err;
2045}
2046
Philipp Reisnerb411b362009-09-25 16:07:19 -07002047/* mirrored write */
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01002048static int receive_Data(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002049{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01002050 struct drbd_conf *mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002051 sector_t sector;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002052 struct drbd_peer_request *peer_req;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02002053 struct p_data *p = pi->data;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01002054 u32 peer_seq = be32_to_cpu(p->seq_num);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002055 int rw = WRITE;
2056 u32 dp_flags;
Philipp Reisner302bdea2011-04-21 11:36:49 +02002057 int err, tp;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01002058
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01002059 mdev = vnr_to_mdev(tconn, pi->vnr);
2060 if (!mdev)
2061 return -EIO;
2062
Philipp Reisnerb411b362009-09-25 16:07:19 -07002063 if (!get_ldev(mdev)) {
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002064 int err2;
2065
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01002066 err = wait_for_and_update_peer_seq(mdev, peer_seq);
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002067 drbd_send_ack_dp(mdev, P_NEG_ACK, p, pi->size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002068 atomic_inc(&mdev->current_epoch->epoch_size);
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002069 err2 = drbd_drain_block(mdev, pi->size);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002070 if (!err)
2071 err = err2;
2072 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002073 }
2074
Andreas Gruenbacherfcefa622011-02-17 16:46:59 +01002075 /*
2076 * Corresponding put_ldev done either below (on various errors), or in
2077 * drbd_peer_request_endio, if we successfully submit the data at the
2078 * end of this function.
2079 */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002080
2081 sector = be64_to_cpu(p->sector);
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002082 peer_req = read_in_block(mdev, p->block_id, sector, pi->size);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002083 if (!peer_req) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002084 put_ldev(mdev);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002085 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002086 }
2087
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002088 peer_req->w.cb = e_end_block;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002089
Lars Ellenberg688593c2010-11-17 22:25:03 +01002090 dp_flags = be32_to_cpu(p->dp_flags);
2091 rw |= wire_flags_to_bio(mdev, dp_flags);
2092
2093 if (dp_flags & DP_MAY_SET_IN_SYNC)
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002094 peer_req->flags |= EE_MAY_SET_IN_SYNC;
Lars Ellenberg688593c2010-11-17 22:25:03 +01002095
Philipp Reisnerb411b362009-09-25 16:07:19 -07002096 spin_lock(&mdev->epoch_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002097 peer_req->epoch = mdev->current_epoch;
2098 atomic_inc(&peer_req->epoch->epoch_size);
2099 atomic_inc(&peer_req->epoch->active);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002100 spin_unlock(&mdev->epoch_lock);
2101
Philipp Reisner302bdea2011-04-21 11:36:49 +02002102 rcu_read_lock();
2103 tp = rcu_dereference(mdev->tconn->net_conf)->two_primaries;
2104 rcu_read_unlock();
2105 if (tp) {
2106 peer_req->flags |= EE_IN_INTERVAL_TREE;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01002107 err = wait_for_and_update_peer_seq(mdev, peer_seq);
2108 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002109 goto out_interrupted;
Philipp Reisner87eeee42011-01-19 14:16:30 +01002110 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01002111 err = handle_write_conflicts(mdev, peer_req);
2112 if (err) {
2113 spin_unlock_irq(&mdev->tconn->req_lock);
2114 if (err == -ENOENT) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002115 put_ldev(mdev);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002116 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002117 }
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01002118 goto out_interrupted;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002119 }
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01002120 } else
2121 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002122 list_add(&peer_req->w.list, &mdev->active_ee);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002123 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002124
Philipp Reisner303d1442011-04-13 16:24:47 -07002125 if (mdev->tconn->agreed_pro_version < 100) {
Philipp Reisner44ed1672011-04-19 17:10:19 +02002126 rcu_read_lock();
2127 switch (rcu_dereference(mdev->tconn->net_conf)->wire_protocol) {
Philipp Reisner303d1442011-04-13 16:24:47 -07002128 case DRBD_PROT_C:
2129 dp_flags |= DP_SEND_WRITE_ACK;
2130 break;
2131 case DRBD_PROT_B:
2132 dp_flags |= DP_SEND_RECEIVE_ACK;
2133 break;
2134 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02002135 rcu_read_unlock();
Philipp Reisner303d1442011-04-13 16:24:47 -07002136 }
2137
2138 if (dp_flags & DP_SEND_WRITE_ACK) {
2139 peer_req->flags |= EE_SEND_WRITE_ACK;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002140 inc_unacked(mdev);
2141 /* corresponding dec_unacked() in e_end_block()
2142 * respective _drbd_clear_done_ee */
Philipp Reisner303d1442011-04-13 16:24:47 -07002143 }
2144
2145 if (dp_flags & DP_SEND_RECEIVE_ACK) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002146 /* I really don't like it that the receiver thread
2147 * sends on the msock, but anyways */
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002148 drbd_send_ack(mdev, P_RECV_ACK, peer_req);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002149 }
2150
Lars Ellenberg6719fb02010-10-18 23:04:07 +02002151 if (mdev->state.pdsk < D_INCONSISTENT) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002152 /* In case we have the only disk of the cluster, */
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002153 drbd_set_out_of_sync(mdev, peer_req->i.sector, peer_req->i.size);
2154 peer_req->flags |= EE_CALL_AL_COMPLETE_IO;
2155 peer_req->flags &= ~EE_MAY_SET_IN_SYNC;
Lars Ellenberg181286a2011-03-31 15:18:56 +02002156 drbd_al_begin_io(mdev, &peer_req->i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002157 }
2158
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002159 err = drbd_submit_peer_request(mdev, peer_req, rw, DRBD_FAULT_DT_WR);
2160 if (!err)
2161 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002162
Lars Ellenberg10f6d9922011-01-24 14:47:09 +01002163 /* don't care for the reason here */
2164 dev_err(DEV, "submit failed, triggering re-connect\n");
Philipp Reisner87eeee42011-01-19 14:16:30 +01002165 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002166 list_del(&peer_req->w.list);
2167 drbd_remove_epoch_entry_interval(mdev, peer_req);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002168 spin_unlock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002169 if (peer_req->flags & EE_CALL_AL_COMPLETE_IO)
Lars Ellenberg181286a2011-03-31 15:18:56 +02002170 drbd_al_complete_io(mdev, &peer_req->i);
Lars Ellenberg22cc37a2010-09-14 20:40:41 +02002171
Philipp Reisnerb411b362009-09-25 16:07:19 -07002172out_interrupted:
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002173 drbd_may_finish_epoch(mdev, peer_req->epoch, EV_PUT + EV_CLEANUP);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002174 put_ldev(mdev);
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +02002175 drbd_free_peer_req(mdev, peer_req);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002176 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002177}
2178
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002179/* We may throttle resync, if the lower device seems to be busy,
2180 * and current sync rate is above c_min_rate.
2181 *
2182 * To decide whether or not the lower device is busy, we use a scheme similar
2183 * to MD RAID is_mddev_idle(): if the partition stats reveal "significant"
2184 * (more than 64 sectors) of activity we cannot account for with our own resync
2185 * activity, it obviously is "busy".
2186 *
2187 * The current sync rate used here uses only the most recent two step marks,
2188 * to have a short time average so we can react faster.
2189 */
Philipp Reisnere3555d82010-11-07 15:56:29 +01002190int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector)
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002191{
2192 struct gendisk *disk = mdev->ldev->backing_bdev->bd_contains->bd_disk;
2193 unsigned long db, dt, dbdt;
Philipp Reisnere3555d82010-11-07 15:56:29 +01002194 struct lc_element *tmp;
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002195 int curr_events;
2196 int throttle = 0;
2197
2198 /* feature disabled? */
Lars Ellenbergf3990022011-03-23 14:31:09 +01002199 if (mdev->ldev->dc.c_min_rate == 0)
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002200 return 0;
2201
Philipp Reisnere3555d82010-11-07 15:56:29 +01002202 spin_lock_irq(&mdev->al_lock);
2203 tmp = lc_find(mdev->resync, BM_SECT_TO_EXT(sector));
2204 if (tmp) {
2205 struct bm_extent *bm_ext = lc_entry(tmp, struct bm_extent, lce);
2206 if (test_bit(BME_PRIORITY, &bm_ext->flags)) {
2207 spin_unlock_irq(&mdev->al_lock);
2208 return 0;
2209 }
2210 /* Do not slow down if app IO is already waiting for this extent */
2211 }
2212 spin_unlock_irq(&mdev->al_lock);
2213
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002214 curr_events = (int)part_stat_read(&disk->part0, sectors[0]) +
2215 (int)part_stat_read(&disk->part0, sectors[1]) -
2216 atomic_read(&mdev->rs_sect_ev);
Philipp Reisnere3555d82010-11-07 15:56:29 +01002217
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002218 if (!mdev->rs_last_events || curr_events - mdev->rs_last_events > 64) {
2219 unsigned long rs_left;
2220 int i;
2221
2222 mdev->rs_last_events = curr_events;
2223
2224 /* sync speed average over the last 2*DRBD_SYNC_MARK_STEP,
2225 * approx. */
Lars Ellenberg2649f082010-11-05 10:05:47 +01002226 i = (mdev->rs_last_mark + DRBD_SYNC_MARKS-1) % DRBD_SYNC_MARKS;
2227
2228 if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)
2229 rs_left = mdev->ov_left;
2230 else
2231 rs_left = drbd_bm_total_weight(mdev) - mdev->rs_failed;
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002232
2233 dt = ((long)jiffies - (long)mdev->rs_mark_time[i]) / HZ;
2234 if (!dt)
2235 dt++;
2236 db = mdev->rs_mark_left[i] - rs_left;
2237 dbdt = Bit2KB(db/dt);
2238
Lars Ellenbergf3990022011-03-23 14:31:09 +01002239 if (dbdt > mdev->ldev->dc.c_min_rate)
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002240 throttle = 1;
2241 }
2242 return throttle;
2243}
2244
2245
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01002246static int receive_DataRequest(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002247{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01002248 struct drbd_conf *mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002249 sector_t sector;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01002250 sector_t capacity;
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002251 struct drbd_peer_request *peer_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002252 struct digest_info *di = NULL;
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02002253 int size, verb;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002254 unsigned int fault_type;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02002255 struct p_block_req *p = pi->data;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01002256
2257 mdev = vnr_to_mdev(tconn, pi->vnr);
2258 if (!mdev)
2259 return -EIO;
2260 capacity = drbd_get_capacity(mdev->this_bdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002261
2262 sector = be64_to_cpu(p->sector);
2263 size = be32_to_cpu(p->blksize);
2264
Andreas Gruenbacherc670a392011-02-21 12:41:39 +01002265 if (size <= 0 || !IS_ALIGNED(size, 512) || size > DRBD_MAX_BIO_SIZE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002266 dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
2267 (unsigned long long)sector, size);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002268 return -EINVAL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002269 }
2270 if (sector + (size>>9) > capacity) {
2271 dev_err(DEV, "%s:%d: sector: %llus, size: %u\n", __FILE__, __LINE__,
2272 (unsigned long long)sector, size);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002273 return -EINVAL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002274 }
2275
2276 if (!get_ldev_if_state(mdev, D_UP_TO_DATE)) {
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02002277 verb = 1;
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002278 switch (pi->cmd) {
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02002279 case P_DATA_REQUEST:
2280 drbd_send_ack_rp(mdev, P_NEG_DREPLY, p);
2281 break;
2282 case P_RS_DATA_REQUEST:
2283 case P_CSUM_RS_REQUEST:
2284 case P_OV_REQUEST:
2285 drbd_send_ack_rp(mdev, P_NEG_RS_DREPLY , p);
2286 break;
2287 case P_OV_REPLY:
2288 verb = 0;
2289 dec_rs_pending(mdev);
2290 drbd_send_ack_ex(mdev, P_OV_RESULT, sector, size, ID_IN_SYNC);
2291 break;
2292 default:
Andreas Gruenbacher49ba9b12011-03-25 00:35:45 +01002293 BUG();
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02002294 }
2295 if (verb && __ratelimit(&drbd_ratelimit_state))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002296 dev_err(DEV, "Can not satisfy peer's read request, "
2297 "no local data.\n");
Philipp Reisnerb18b37b2010-10-13 15:32:44 +02002298
Lars Ellenberga821cc42010-09-06 12:31:37 +02002299 /* drain possibly payload */
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002300 return drbd_drain_block(mdev, pi->size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002301 }
2302
2303 /* GFP_NOIO, because we must not cause arbitrary write-out: in a DRBD
2304 * "criss-cross" setup, that might cause write-out on some other DRBD,
2305 * which in turn might block on the other node at this very place. */
Andreas Gruenbacher0db55362011-04-06 16:09:15 +02002306 peer_req = drbd_alloc_peer_req(mdev, p->block_id, sector, size, GFP_NOIO);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002307 if (!peer_req) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002308 put_ldev(mdev);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002309 return -ENOMEM;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002310 }
2311
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002312 switch (pi->cmd) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002313 case P_DATA_REQUEST:
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002314 peer_req->w.cb = w_e_end_data_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002315 fault_type = DRBD_FAULT_DT_RD;
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002316 /* application IO, don't drbd_rs_begin_io */
2317 goto submit;
2318
Philipp Reisnerb411b362009-09-25 16:07:19 -07002319 case P_RS_DATA_REQUEST:
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002320 peer_req->w.cb = w_e_end_rsdata_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002321 fault_type = DRBD_FAULT_RS_RD;
Lars Ellenberg5f9915b2010-11-09 14:15:24 +01002322 /* used in the sector offset progress display */
2323 mdev->bm_resync_fo = BM_SECT_TO_BIT(sector);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002324 break;
2325
2326 case P_OV_REPLY:
2327 case P_CSUM_RS_REQUEST:
2328 fault_type = DRBD_FAULT_RS_RD;
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002329 di = kmalloc(sizeof(*di) + pi->size, GFP_NOIO);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002330 if (!di)
2331 goto out_free_e;
2332
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002333 di->digest_size = pi->size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002334 di->digest = (((char *)di)+sizeof(struct digest_info));
2335
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002336 peer_req->digest = di;
2337 peer_req->flags |= EE_HAS_DIGEST;
Lars Ellenbergc36c3ce2010-08-11 20:42:55 +02002338
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002339 if (drbd_recv_all(mdev->tconn, di->digest, pi->size))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002340 goto out_free_e;
2341
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002342 if (pi->cmd == P_CSUM_RS_REQUEST) {
Philipp Reisner31890f42011-01-19 14:12:51 +01002343 D_ASSERT(mdev->tconn->agreed_pro_version >= 89);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002344 peer_req->w.cb = w_e_end_csum_rs_req;
Lars Ellenberg5f9915b2010-11-09 14:15:24 +01002345 /* used in the sector offset progress display */
2346 mdev->bm_resync_fo = BM_SECT_TO_BIT(sector);
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002347 } else if (pi->cmd == P_OV_REPLY) {
Lars Ellenberg2649f082010-11-05 10:05:47 +01002348 /* track progress, we may need to throttle */
2349 atomic_add(size >> 9, &mdev->rs_sect_in);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002350 peer_req->w.cb = w_e_end_ov_reply;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002351 dec_rs_pending(mdev);
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002352 /* drbd_rs_begin_io done when we sent this request,
2353 * but accounting still needs to be done. */
2354 goto submit_for_resync;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002355 }
2356 break;
2357
2358 case P_OV_REQUEST:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002359 if (mdev->ov_start_sector == ~(sector_t)0 &&
Philipp Reisner31890f42011-01-19 14:12:51 +01002360 mdev->tconn->agreed_pro_version >= 90) {
Lars Ellenbergde228bb2010-11-05 09:43:15 +01002361 unsigned long now = jiffies;
2362 int i;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002363 mdev->ov_start_sector = sector;
2364 mdev->ov_position = sector;
Lars Ellenberg30b743a2010-11-05 09:39:06 +01002365 mdev->ov_left = drbd_bm_bits(mdev) - BM_SECT_TO_BIT(sector);
2366 mdev->rs_total = mdev->ov_left;
Lars Ellenbergde228bb2010-11-05 09:43:15 +01002367 for (i = 0; i < DRBD_SYNC_MARKS; i++) {
2368 mdev->rs_mark_left[i] = mdev->ov_left;
2369 mdev->rs_mark_time[i] = now;
2370 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002371 dev_info(DEV, "Online Verify start sector: %llu\n",
2372 (unsigned long long)sector);
2373 }
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002374 peer_req->w.cb = w_e_end_ov_req;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002375 fault_type = DRBD_FAULT_RS_RD;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002376 break;
2377
Philipp Reisnerb411b362009-09-25 16:07:19 -07002378 default:
Andreas Gruenbacher49ba9b12011-03-25 00:35:45 +01002379 BUG();
Philipp Reisnerb411b362009-09-25 16:07:19 -07002380 }
2381
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002382 /* Throttle, drbd_rs_begin_io and submit should become asynchronous
2383 * wrt the receiver, but it is not as straightforward as it may seem.
2384 * Various places in the resync start and stop logic assume resync
2385 * requests are processed in order, requeuing this on the worker thread
2386 * introduces a bunch of new code for synchronization between threads.
2387 *
2388 * Unlimited throttling before drbd_rs_begin_io may stall the resync
2389 * "forever", throttling after drbd_rs_begin_io will lock that extent
2390 * for application writes for the same time. For now, just throttle
2391 * here, where the rest of the code expects the receiver to sleep for
2392 * a while, anyways.
2393 */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002394
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002395 /* Throttle before drbd_rs_begin_io, as that locks out application IO;
2396 * this defers syncer requests for some time, before letting at least
2397 * on request through. The resync controller on the receiving side
2398 * will adapt to the incoming rate accordingly.
2399 *
2400 * We cannot throttle here if remote is Primary/SyncTarget:
2401 * we would also throttle its application reads.
2402 * In that case, throttling is done on the SyncTarget only.
2403 */
Philipp Reisnere3555d82010-11-07 15:56:29 +01002404 if (mdev->state.peer != R_PRIMARY && drbd_rs_should_slow_down(mdev, sector))
2405 schedule_timeout_uninterruptible(HZ/10);
2406 if (drbd_rs_begin_io(mdev, sector))
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002407 goto out_free_e;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002408
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02002409submit_for_resync:
2410 atomic_add(size >> 9, &mdev->rs_sect_ev);
2411
Lars Ellenberg80a40e42010-08-11 23:28:00 +02002412submit:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002413 inc_unacked(mdev);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002414 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002415 list_add_tail(&peer_req->w.list, &mdev->read_ee);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002416 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002417
Andreas Gruenbacherfbe29de2011-02-17 16:38:35 +01002418 if (drbd_submit_peer_request(mdev, peer_req, READ, fault_type) == 0)
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002419 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002420
Lars Ellenberg10f6d9922011-01-24 14:47:09 +01002421 /* don't care for the reason here */
2422 dev_err(DEV, "submit failed, triggering re-connect\n");
Philipp Reisner87eeee42011-01-19 14:16:30 +01002423 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002424 list_del(&peer_req->w.list);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002425 spin_unlock_irq(&mdev->tconn->req_lock);
Lars Ellenberg22cc37a2010-09-14 20:40:41 +02002426 /* no drbd_rs_complete_io(), we are dropping the connection anyways */
2427
Philipp Reisnerb411b362009-09-25 16:07:19 -07002428out_free_e:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002429 put_ldev(mdev);
Andreas Gruenbacher3967deb2011-04-06 16:16:56 +02002430 drbd_free_peer_req(mdev, peer_req);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01002431 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002432}
2433
2434static int drbd_asb_recover_0p(struct drbd_conf *mdev) __must_hold(local)
2435{
2436 int self, peer, rv = -100;
2437 unsigned long ch_self, ch_peer;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002438 enum drbd_after_sb_p after_sb_0p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002439
2440 self = mdev->ldev->md.uuid[UI_BITMAP] & 1;
2441 peer = mdev->p_uuid[UI_BITMAP] & 1;
2442
2443 ch_peer = mdev->p_uuid[UI_SIZE];
2444 ch_self = mdev->comm_bm_set;
2445
Philipp Reisner44ed1672011-04-19 17:10:19 +02002446 rcu_read_lock();
2447 after_sb_0p = rcu_dereference(mdev->tconn->net_conf)->after_sb_0p;
2448 rcu_read_unlock();
2449 switch (after_sb_0p) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002450 case ASB_CONSENSUS:
2451 case ASB_DISCARD_SECONDARY:
2452 case ASB_CALL_HELPER:
Philipp Reisner44ed1672011-04-19 17:10:19 +02002453 case ASB_VIOLENTLY:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002454 dev_err(DEV, "Configuration error.\n");
2455 break;
2456 case ASB_DISCONNECT:
2457 break;
2458 case ASB_DISCARD_YOUNGER_PRI:
2459 if (self == 0 && peer == 1) {
2460 rv = -1;
2461 break;
2462 }
2463 if (self == 1 && peer == 0) {
2464 rv = 1;
2465 break;
2466 }
2467 /* Else fall through to one of the other strategies... */
2468 case ASB_DISCARD_OLDER_PRI:
2469 if (self == 0 && peer == 1) {
2470 rv = 1;
2471 break;
2472 }
2473 if (self == 1 && peer == 0) {
2474 rv = -1;
2475 break;
2476 }
2477 /* Else fall through to one of the other strategies... */
Lars Ellenbergad19bf62009-10-14 09:36:49 +02002478 dev_warn(DEV, "Discard younger/older primary did not find a decision\n"
Philipp Reisnerb411b362009-09-25 16:07:19 -07002479 "Using discard-least-changes instead\n");
2480 case ASB_DISCARD_ZERO_CHG:
2481 if (ch_peer == 0 && ch_self == 0) {
Philipp Reisner25703f82011-02-07 14:35:25 +01002482 rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002483 ? -1 : 1;
2484 break;
2485 } else {
2486 if (ch_peer == 0) { rv = 1; break; }
2487 if (ch_self == 0) { rv = -1; break; }
2488 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02002489 if (after_sb_0p == ASB_DISCARD_ZERO_CHG)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002490 break;
2491 case ASB_DISCARD_LEAST_CHG:
2492 if (ch_self < ch_peer)
2493 rv = -1;
2494 else if (ch_self > ch_peer)
2495 rv = 1;
2496 else /* ( ch_self == ch_peer ) */
2497 /* Well, then use something else. */
Philipp Reisner25703f82011-02-07 14:35:25 +01002498 rv = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002499 ? -1 : 1;
2500 break;
2501 case ASB_DISCARD_LOCAL:
2502 rv = -1;
2503 break;
2504 case ASB_DISCARD_REMOTE:
2505 rv = 1;
2506 }
2507
2508 return rv;
2509}
2510
2511static int drbd_asb_recover_1p(struct drbd_conf *mdev) __must_hold(local)
2512{
Andreas Gruenbacher6184ea22010-12-09 14:23:27 +01002513 int hg, rv = -100;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002514 enum drbd_after_sb_p after_sb_1p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002515
Philipp Reisner44ed1672011-04-19 17:10:19 +02002516 rcu_read_lock();
2517 after_sb_1p = rcu_dereference(mdev->tconn->net_conf)->after_sb_1p;
2518 rcu_read_unlock();
2519 switch (after_sb_1p) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002520 case ASB_DISCARD_YOUNGER_PRI:
2521 case ASB_DISCARD_OLDER_PRI:
2522 case ASB_DISCARD_LEAST_CHG:
2523 case ASB_DISCARD_LOCAL:
2524 case ASB_DISCARD_REMOTE:
Philipp Reisner44ed1672011-04-19 17:10:19 +02002525 case ASB_DISCARD_ZERO_CHG:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002526 dev_err(DEV, "Configuration error.\n");
2527 break;
2528 case ASB_DISCONNECT:
2529 break;
2530 case ASB_CONSENSUS:
2531 hg = drbd_asb_recover_0p(mdev);
2532 if (hg == -1 && mdev->state.role == R_SECONDARY)
2533 rv = hg;
2534 if (hg == 1 && mdev->state.role == R_PRIMARY)
2535 rv = hg;
2536 break;
2537 case ASB_VIOLENTLY:
2538 rv = drbd_asb_recover_0p(mdev);
2539 break;
2540 case ASB_DISCARD_SECONDARY:
2541 return mdev->state.role == R_PRIMARY ? 1 : -1;
2542 case ASB_CALL_HELPER:
2543 hg = drbd_asb_recover_0p(mdev);
2544 if (hg == -1 && mdev->state.role == R_PRIMARY) {
Andreas Gruenbacherbb437942010-12-09 14:02:35 +01002545 enum drbd_state_rv rv2;
2546
2547 drbd_set_role(mdev, R_SECONDARY, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002548 /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
2549 * we might be here in C_WF_REPORT_PARAMS which is transient.
2550 * we do not need to wait for the after state change work either. */
Andreas Gruenbacherbb437942010-12-09 14:02:35 +01002551 rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
2552 if (rv2 != SS_SUCCESS) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002553 drbd_khelper(mdev, "pri-lost-after-sb");
2554 } else {
2555 dev_warn(DEV, "Successfully gave up primary role.\n");
2556 rv = hg;
2557 }
2558 } else
2559 rv = hg;
2560 }
2561
2562 return rv;
2563}
2564
2565static int drbd_asb_recover_2p(struct drbd_conf *mdev) __must_hold(local)
2566{
Andreas Gruenbacher6184ea22010-12-09 14:23:27 +01002567 int hg, rv = -100;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002568 enum drbd_after_sb_p after_sb_2p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002569
Philipp Reisner44ed1672011-04-19 17:10:19 +02002570 rcu_read_lock();
2571 after_sb_2p = rcu_dereference(mdev->tconn->net_conf)->after_sb_2p;
2572 rcu_read_unlock();
2573 switch (after_sb_2p) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002574 case ASB_DISCARD_YOUNGER_PRI:
2575 case ASB_DISCARD_OLDER_PRI:
2576 case ASB_DISCARD_LEAST_CHG:
2577 case ASB_DISCARD_LOCAL:
2578 case ASB_DISCARD_REMOTE:
2579 case ASB_CONSENSUS:
2580 case ASB_DISCARD_SECONDARY:
Philipp Reisner44ed1672011-04-19 17:10:19 +02002581 case ASB_DISCARD_ZERO_CHG:
Philipp Reisnerb411b362009-09-25 16:07:19 -07002582 dev_err(DEV, "Configuration error.\n");
2583 break;
2584 case ASB_VIOLENTLY:
2585 rv = drbd_asb_recover_0p(mdev);
2586 break;
2587 case ASB_DISCONNECT:
2588 break;
2589 case ASB_CALL_HELPER:
2590 hg = drbd_asb_recover_0p(mdev);
2591 if (hg == -1) {
Andreas Gruenbacherbb437942010-12-09 14:02:35 +01002592 enum drbd_state_rv rv2;
2593
Philipp Reisnerb411b362009-09-25 16:07:19 -07002594 /* drbd_change_state() does not sleep while in SS_IN_TRANSIENT_STATE,
2595 * we might be here in C_WF_REPORT_PARAMS which is transient.
2596 * we do not need to wait for the after state change work either. */
Andreas Gruenbacherbb437942010-12-09 14:02:35 +01002597 rv2 = drbd_change_state(mdev, CS_VERBOSE, NS(role, R_SECONDARY));
2598 if (rv2 != SS_SUCCESS) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002599 drbd_khelper(mdev, "pri-lost-after-sb");
2600 } else {
2601 dev_warn(DEV, "Successfully gave up primary role.\n");
2602 rv = hg;
2603 }
2604 } else
2605 rv = hg;
2606 }
2607
2608 return rv;
2609}
2610
2611static void drbd_uuid_dump(struct drbd_conf *mdev, char *text, u64 *uuid,
2612 u64 bits, u64 flags)
2613{
2614 if (!uuid) {
2615 dev_info(DEV, "%s uuid info vanished while I was looking!\n", text);
2616 return;
2617 }
2618 dev_info(DEV, "%s %016llX:%016llX:%016llX:%016llX bits:%llu flags:%llX\n",
2619 text,
2620 (unsigned long long)uuid[UI_CURRENT],
2621 (unsigned long long)uuid[UI_BITMAP],
2622 (unsigned long long)uuid[UI_HISTORY_START],
2623 (unsigned long long)uuid[UI_HISTORY_END],
2624 (unsigned long long)bits,
2625 (unsigned long long)flags);
2626}
2627
2628/*
2629 100 after split brain try auto recover
2630 2 C_SYNC_SOURCE set BitMap
2631 1 C_SYNC_SOURCE use BitMap
2632 0 no Sync
2633 -1 C_SYNC_TARGET use BitMap
2634 -2 C_SYNC_TARGET set BitMap
2635 -100 after split brain, disconnect
2636-1000 unrelated data
Philipp Reisner4a23f262011-01-11 17:42:17 +01002637-1091 requires proto 91
2638-1096 requires proto 96
Philipp Reisnerb411b362009-09-25 16:07:19 -07002639 */
2640static int drbd_uuid_compare(struct drbd_conf *mdev, int *rule_nr) __must_hold(local)
2641{
2642 u64 self, peer;
2643 int i, j;
2644
2645 self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
2646 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
2647
2648 *rule_nr = 10;
2649 if (self == UUID_JUST_CREATED && peer == UUID_JUST_CREATED)
2650 return 0;
2651
2652 *rule_nr = 20;
2653 if ((self == UUID_JUST_CREATED || self == (u64)0) &&
2654 peer != UUID_JUST_CREATED)
2655 return -2;
2656
2657 *rule_nr = 30;
2658 if (self != UUID_JUST_CREATED &&
2659 (peer == UUID_JUST_CREATED || peer == (u64)0))
2660 return 2;
2661
2662 if (self == peer) {
2663 int rct, dc; /* roles at crash time */
2664
2665 if (mdev->p_uuid[UI_BITMAP] == (u64)0 && mdev->ldev->md.uuid[UI_BITMAP] != (u64)0) {
2666
Philipp Reisner31890f42011-01-19 14:12:51 +01002667 if (mdev->tconn->agreed_pro_version < 91)
Philipp Reisner4a23f262011-01-11 17:42:17 +01002668 return -1091;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002669
2670 if ((mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) &&
2671 (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1))) {
2672 dev_info(DEV, "was SyncSource, missed the resync finished event, corrected myself:\n");
2673 drbd_uuid_set_bm(mdev, 0UL);
2674
2675 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
2676 mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
2677 *rule_nr = 34;
2678 } else {
2679 dev_info(DEV, "was SyncSource (peer failed to write sync_uuid)\n");
2680 *rule_nr = 36;
2681 }
2682
2683 return 1;
2684 }
2685
2686 if (mdev->ldev->md.uuid[UI_BITMAP] == (u64)0 && mdev->p_uuid[UI_BITMAP] != (u64)0) {
2687
Philipp Reisner31890f42011-01-19 14:12:51 +01002688 if (mdev->tconn->agreed_pro_version < 91)
Philipp Reisner4a23f262011-01-11 17:42:17 +01002689 return -1091;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002690
2691 if ((mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) == (mdev->p_uuid[UI_BITMAP] & ~((u64)1)) &&
2692 (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) == (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1))) {
2693 dev_info(DEV, "was SyncTarget, peer missed the resync finished event, corrected peer:\n");
2694
2695 mdev->p_uuid[UI_HISTORY_START + 1] = mdev->p_uuid[UI_HISTORY_START];
2696 mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_BITMAP];
2697 mdev->p_uuid[UI_BITMAP] = 0UL;
2698
2699 drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
2700 *rule_nr = 35;
2701 } else {
2702 dev_info(DEV, "was SyncTarget (failed to write sync_uuid)\n");
2703 *rule_nr = 37;
2704 }
2705
2706 return -1;
2707 }
2708
2709 /* Common power [off|failure] */
2710 rct = (test_bit(CRASHED_PRIMARY, &mdev->flags) ? 1 : 0) +
2711 (mdev->p_uuid[UI_FLAGS] & 2);
2712 /* lowest bit is set when we were primary,
2713 * next bit (weight 2) is set when peer was primary */
2714 *rule_nr = 40;
2715
2716 switch (rct) {
2717 case 0: /* !self_pri && !peer_pri */ return 0;
2718 case 1: /* self_pri && !peer_pri */ return 1;
2719 case 2: /* !self_pri && peer_pri */ return -1;
2720 case 3: /* self_pri && peer_pri */
Philipp Reisner25703f82011-02-07 14:35:25 +01002721 dc = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002722 return dc ? -1 : 1;
2723 }
2724 }
2725
2726 *rule_nr = 50;
2727 peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
2728 if (self == peer)
2729 return -1;
2730
2731 *rule_nr = 51;
2732 peer = mdev->p_uuid[UI_HISTORY_START] & ~((u64)1);
2733 if (self == peer) {
Philipp Reisner31890f42011-01-19 14:12:51 +01002734 if (mdev->tconn->agreed_pro_version < 96 ?
Philipp Reisner4a23f262011-01-11 17:42:17 +01002735 (mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1)) ==
2736 (mdev->p_uuid[UI_HISTORY_START + 1] & ~((u64)1)) :
2737 peer + UUID_NEW_BM_OFFSET == (mdev->p_uuid[UI_BITMAP] & ~((u64)1))) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002738 /* The last P_SYNC_UUID did not get though. Undo the last start of
2739 resync as sync source modifications of the peer's UUIDs. */
2740
Philipp Reisner31890f42011-01-19 14:12:51 +01002741 if (mdev->tconn->agreed_pro_version < 91)
Philipp Reisner4a23f262011-01-11 17:42:17 +01002742 return -1091;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002743
2744 mdev->p_uuid[UI_BITMAP] = mdev->p_uuid[UI_HISTORY_START];
2745 mdev->p_uuid[UI_HISTORY_START] = mdev->p_uuid[UI_HISTORY_START + 1];
Philipp Reisner4a23f262011-01-11 17:42:17 +01002746
2747 dev_info(DEV, "Did not got last syncUUID packet, corrected:\n");
2748 drbd_uuid_dump(mdev, "peer", mdev->p_uuid, mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
2749
Philipp Reisnerb411b362009-09-25 16:07:19 -07002750 return -1;
2751 }
2752 }
2753
2754 *rule_nr = 60;
2755 self = mdev->ldev->md.uuid[UI_CURRENT] & ~((u64)1);
2756 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2757 peer = mdev->p_uuid[i] & ~((u64)1);
2758 if (self == peer)
2759 return -2;
2760 }
2761
2762 *rule_nr = 70;
2763 self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
2764 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
2765 if (self == peer)
2766 return 1;
2767
2768 *rule_nr = 71;
2769 self = mdev->ldev->md.uuid[UI_HISTORY_START] & ~((u64)1);
2770 if (self == peer) {
Philipp Reisner31890f42011-01-19 14:12:51 +01002771 if (mdev->tconn->agreed_pro_version < 96 ?
Philipp Reisner4a23f262011-01-11 17:42:17 +01002772 (mdev->ldev->md.uuid[UI_HISTORY_START + 1] & ~((u64)1)) ==
2773 (mdev->p_uuid[UI_HISTORY_START] & ~((u64)1)) :
2774 self + UUID_NEW_BM_OFFSET == (mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1))) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002775 /* The last P_SYNC_UUID did not get though. Undo the last start of
2776 resync as sync source modifications of our UUIDs. */
2777
Philipp Reisner31890f42011-01-19 14:12:51 +01002778 if (mdev->tconn->agreed_pro_version < 91)
Philipp Reisner4a23f262011-01-11 17:42:17 +01002779 return -1091;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002780
2781 _drbd_uuid_set(mdev, UI_BITMAP, mdev->ldev->md.uuid[UI_HISTORY_START]);
2782 _drbd_uuid_set(mdev, UI_HISTORY_START, mdev->ldev->md.uuid[UI_HISTORY_START + 1]);
2783
Philipp Reisner4a23f262011-01-11 17:42:17 +01002784 dev_info(DEV, "Last syncUUID did not get through, corrected:\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07002785 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid,
2786 mdev->state.disk >= D_NEGOTIATING ? drbd_bm_total_weight(mdev) : 0, 0);
2787
2788 return 1;
2789 }
2790 }
2791
2792
2793 *rule_nr = 80;
Philipp Reisnerd8c2a362009-11-18 15:52:51 +01002794 peer = mdev->p_uuid[UI_CURRENT] & ~((u64)1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002795 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2796 self = mdev->ldev->md.uuid[i] & ~((u64)1);
2797 if (self == peer)
2798 return 2;
2799 }
2800
2801 *rule_nr = 90;
2802 self = mdev->ldev->md.uuid[UI_BITMAP] & ~((u64)1);
2803 peer = mdev->p_uuid[UI_BITMAP] & ~((u64)1);
2804 if (self == peer && self != ((u64)0))
2805 return 100;
2806
2807 *rule_nr = 100;
2808 for (i = UI_HISTORY_START; i <= UI_HISTORY_END; i++) {
2809 self = mdev->ldev->md.uuid[i] & ~((u64)1);
2810 for (j = UI_HISTORY_START; j <= UI_HISTORY_END; j++) {
2811 peer = mdev->p_uuid[j] & ~((u64)1);
2812 if (self == peer)
2813 return -100;
2814 }
2815 }
2816
2817 return -1000;
2818}
2819
2820/* drbd_sync_handshake() returns the new conn state on success, or
2821 CONN_MASK (-1) on failure.
2822 */
2823static enum drbd_conns drbd_sync_handshake(struct drbd_conf *mdev, enum drbd_role peer_role,
2824 enum drbd_disk_state peer_disk) __must_hold(local)
2825{
Philipp Reisnerb411b362009-09-25 16:07:19 -07002826 enum drbd_conns rv = C_MASK;
2827 enum drbd_disk_state mydisk;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002828 struct net_conf *nc;
2829 int hg, rule_nr, rr_conflict, dry_run;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002830
2831 mydisk = mdev->state.disk;
2832 if (mydisk == D_NEGOTIATING)
2833 mydisk = mdev->new_state_tmp.disk;
2834
2835 dev_info(DEV, "drbd_sync_handshake:\n");
2836 drbd_uuid_dump(mdev, "self", mdev->ldev->md.uuid, mdev->comm_bm_set, 0);
2837 drbd_uuid_dump(mdev, "peer", mdev->p_uuid,
2838 mdev->p_uuid[UI_SIZE], mdev->p_uuid[UI_FLAGS]);
2839
2840 hg = drbd_uuid_compare(mdev, &rule_nr);
2841
2842 dev_info(DEV, "uuid_compare()=%d by rule %d\n", hg, rule_nr);
2843
2844 if (hg == -1000) {
2845 dev_alert(DEV, "Unrelated data, aborting!\n");
2846 return C_MASK;
2847 }
Philipp Reisner4a23f262011-01-11 17:42:17 +01002848 if (hg < -1000) {
2849 dev_alert(DEV, "To resolve this both sides have to support at least protocol %d\n", -hg - 1000);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002850 return C_MASK;
2851 }
2852
2853 if ((mydisk == D_INCONSISTENT && peer_disk > D_INCONSISTENT) ||
2854 (peer_disk == D_INCONSISTENT && mydisk > D_INCONSISTENT)) {
2855 int f = (hg == -100) || abs(hg) == 2;
2856 hg = mydisk > D_INCONSISTENT ? 1 : -1;
2857 if (f)
2858 hg = hg*2;
2859 dev_info(DEV, "Becoming sync %s due to disk states.\n",
2860 hg > 0 ? "source" : "target");
2861 }
2862
Adam Gandelman3a11a482010-04-08 16:48:23 -07002863 if (abs(hg) == 100)
2864 drbd_khelper(mdev, "initial-split-brain");
2865
Philipp Reisner44ed1672011-04-19 17:10:19 +02002866 rcu_read_lock();
2867 nc = rcu_dereference(mdev->tconn->net_conf);
2868
2869 if (hg == 100 || (hg == -100 && nc->always_asbp)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002870 int pcount = (mdev->state.role == R_PRIMARY)
2871 + (peer_role == R_PRIMARY);
2872 int forced = (hg == -100);
2873
2874 switch (pcount) {
2875 case 0:
2876 hg = drbd_asb_recover_0p(mdev);
2877 break;
2878 case 1:
2879 hg = drbd_asb_recover_1p(mdev);
2880 break;
2881 case 2:
2882 hg = drbd_asb_recover_2p(mdev);
2883 break;
2884 }
2885 if (abs(hg) < 100) {
2886 dev_warn(DEV, "Split-Brain detected, %d primaries, "
2887 "automatically solved. Sync from %s node\n",
2888 pcount, (hg < 0) ? "peer" : "this");
2889 if (forced) {
2890 dev_warn(DEV, "Doing a full sync, since"
2891 " UUIDs where ambiguous.\n");
2892 hg = hg*2;
2893 }
2894 }
2895 }
2896
2897 if (hg == -100) {
Philipp Reisner44ed1672011-04-19 17:10:19 +02002898 if (nc->want_lose && !(mdev->p_uuid[UI_FLAGS]&1))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002899 hg = -1;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002900 if (!nc->want_lose && (mdev->p_uuid[UI_FLAGS]&1))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002901 hg = 1;
2902
2903 if (abs(hg) < 100)
2904 dev_warn(DEV, "Split-Brain detected, manually solved. "
2905 "Sync from %s node\n",
2906 (hg < 0) ? "peer" : "this");
2907 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02002908 rr_conflict = nc->rr_conflict;
2909 dry_run = nc->dry_run;
2910 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -07002911
2912 if (hg == -100) {
Lars Ellenberg580b9762010-02-26 23:15:23 +01002913 /* FIXME this log message is not correct if we end up here
2914 * after an attempted attach on a diskless node.
2915 * We just refuse to attach -- well, we drop the "connection"
2916 * to that disk, in a way... */
Adam Gandelman3a11a482010-04-08 16:48:23 -07002917 dev_alert(DEV, "Split-Brain detected but unresolved, dropping connection!\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07002918 drbd_khelper(mdev, "split-brain");
2919 return C_MASK;
2920 }
2921
2922 if (hg > 0 && mydisk <= D_INCONSISTENT) {
2923 dev_err(DEV, "I shall become SyncSource, but I am inconsistent!\n");
2924 return C_MASK;
2925 }
2926
2927 if (hg < 0 && /* by intention we do not use mydisk here. */
2928 mdev->state.role == R_PRIMARY && mdev->state.disk >= D_CONSISTENT) {
Philipp Reisner44ed1672011-04-19 17:10:19 +02002929 switch (rr_conflict) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002930 case ASB_CALL_HELPER:
2931 drbd_khelper(mdev, "pri-lost");
2932 /* fall through */
2933 case ASB_DISCONNECT:
2934 dev_err(DEV, "I shall become SyncTarget, but I am primary!\n");
2935 return C_MASK;
2936 case ASB_VIOLENTLY:
2937 dev_warn(DEV, "Becoming SyncTarget, violating the stable-data"
2938 "assumption\n");
2939 }
2940 }
2941
Philipp Reisner44ed1672011-04-19 17:10:19 +02002942 if (dry_run || test_bit(CONN_DRY_RUN, &mdev->tconn->flags)) {
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002943 if (hg == 0)
2944 dev_info(DEV, "dry-run connect: No resync, would become Connected immediately.\n");
2945 else
2946 dev_info(DEV, "dry-run connect: Would become %s, doing a %s resync.",
2947 drbd_conn_str(hg > 0 ? C_SYNC_SOURCE : C_SYNC_TARGET),
2948 abs(hg) >= 2 ? "full" : "bit-map based");
2949 return C_MASK;
2950 }
2951
Philipp Reisnerb411b362009-09-25 16:07:19 -07002952 if (abs(hg) >= 2) {
2953 dev_info(DEV, "Writing the whole bitmap, full sync required after drbd_sync_handshake.\n");
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01002954 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write, "set_n_write from sync_handshake",
2955 BM_LOCKED_SET_ALLOWED))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002956 return C_MASK;
2957 }
2958
2959 if (hg > 0) { /* become sync source. */
2960 rv = C_WF_BITMAP_S;
2961 } else if (hg < 0) { /* become sync target */
2962 rv = C_WF_BITMAP_T;
2963 } else {
2964 rv = C_CONNECTED;
2965 if (drbd_bm_total_weight(mdev)) {
2966 dev_info(DEV, "No resync, but %lu bits in bitmap!\n",
2967 drbd_bm_total_weight(mdev));
2968 }
2969 }
2970
2971 return rv;
2972}
2973
2974/* returns 1 if invalid */
2975static int cmp_after_sb(enum drbd_after_sb_p peer, enum drbd_after_sb_p self)
2976{
2977 /* ASB_DISCARD_REMOTE - ASB_DISCARD_LOCAL is valid */
2978 if ((peer == ASB_DISCARD_REMOTE && self == ASB_DISCARD_LOCAL) ||
2979 (self == ASB_DISCARD_REMOTE && peer == ASB_DISCARD_LOCAL))
2980 return 0;
2981
2982 /* any other things with ASB_DISCARD_REMOTE or ASB_DISCARD_LOCAL are invalid */
2983 if (peer == ASB_DISCARD_REMOTE || peer == ASB_DISCARD_LOCAL ||
2984 self == ASB_DISCARD_REMOTE || self == ASB_DISCARD_LOCAL)
2985 return 1;
2986
2987 /* everything else is valid if they are equal on both sides. */
2988 if (peer == self)
2989 return 0;
2990
2991 /* everything es is invalid. */
2992 return 1;
2993}
2994
Andreas Gruenbachere2857212011-03-25 00:57:38 +01002995static int receive_protocol(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002996{
Andreas Gruenbachere6589832011-03-30 12:54:42 +02002997 struct p_protocol *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002998 int p_proto, p_after_sb_0p, p_after_sb_1p, p_after_sb_2p;
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01002999 int p_want_lose, p_two_primaries, cf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003000 char p_integrity_alg[SHARED_SECRET_MAX] = "";
Philipp Reisner44ed1672011-04-19 17:10:19 +02003001 struct net_conf *nc;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003002
Philipp Reisnerb411b362009-09-25 16:07:19 -07003003 p_proto = be32_to_cpu(p->protocol);
3004 p_after_sb_0p = be32_to_cpu(p->after_sb_0p);
3005 p_after_sb_1p = be32_to_cpu(p->after_sb_1p);
3006 p_after_sb_2p = be32_to_cpu(p->after_sb_2p);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003007 p_two_primaries = be32_to_cpu(p->two_primaries);
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01003008 cf = be32_to_cpu(p->conn_flags);
3009 p_want_lose = cf & CF_WANT_LOSE;
3010
Andreas Gruenbacher86db0612011-04-28 15:24:18 +02003011 if (tconn->agreed_pro_version >= 87) {
3012 int err;
3013
3014 if (pi->size > sizeof(p_integrity_alg))
3015 return -EIO;
3016 err = drbd_recv_all(tconn, p_integrity_alg, pi->size);
3017 if (err)
3018 return err;
3019
3020 p_integrity_alg[SHARED_SECRET_MAX-1] = 0;
3021 }
3022
Philipp Reisner7204624c2011-03-15 18:51:47 +01003023 clear_bit(CONN_DRY_RUN, &tconn->flags);
Philipp Reisnercf14c2e2010-02-02 21:03:50 +01003024
3025 if (cf & CF_DRY_RUN)
Philipp Reisner7204624c2011-03-15 18:51:47 +01003026 set_bit(CONN_DRY_RUN, &tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003027
Philipp Reisner44ed1672011-04-19 17:10:19 +02003028 rcu_read_lock();
3029 nc = rcu_dereference(tconn->net_conf);
3030
3031 if (p_proto != nc->wire_protocol && tconn->agreed_pro_version < 100) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003032 conn_err(tconn, "incompatible communication protocols\n");
Philipp Reisner44ed1672011-04-19 17:10:19 +02003033 goto disconnect_rcu_unlock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003034 }
3035
Philipp Reisner44ed1672011-04-19 17:10:19 +02003036 if (cmp_after_sb(p_after_sb_0p, nc->after_sb_0p)) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003037 conn_err(tconn, "incompatible after-sb-0pri settings\n");
Philipp Reisner44ed1672011-04-19 17:10:19 +02003038 goto disconnect_rcu_unlock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003039 }
3040
Philipp Reisner44ed1672011-04-19 17:10:19 +02003041 if (cmp_after_sb(p_after_sb_1p, nc->after_sb_1p)) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003042 conn_err(tconn, "incompatible after-sb-1pri settings\n");
Philipp Reisner44ed1672011-04-19 17:10:19 +02003043 goto disconnect_rcu_unlock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003044 }
3045
Philipp Reisner44ed1672011-04-19 17:10:19 +02003046 if (cmp_after_sb(p_after_sb_2p, nc->after_sb_2p)) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003047 conn_err(tconn, "incompatible after-sb-2pri settings\n");
Philipp Reisner44ed1672011-04-19 17:10:19 +02003048 goto disconnect_rcu_unlock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003049 }
3050
Philipp Reisner44ed1672011-04-19 17:10:19 +02003051 if (p_want_lose && nc->want_lose) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003052 conn_err(tconn, "both sides have the 'want_lose' flag set\n");
Philipp Reisner44ed1672011-04-19 17:10:19 +02003053 goto disconnect_rcu_unlock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003054 }
3055
Philipp Reisner44ed1672011-04-19 17:10:19 +02003056 if (p_two_primaries != nc->two_primaries) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003057 conn_err(tconn, "incompatible setting of the two-primaries options\n");
Philipp Reisner44ed1672011-04-19 17:10:19 +02003058 goto disconnect_rcu_unlock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003059 }
3060
Philipp Reisner7204624c2011-03-15 18:51:47 +01003061 if (tconn->agreed_pro_version >= 87) {
Andreas Gruenbacher86db0612011-04-28 15:24:18 +02003062 if (strcmp(p_integrity_alg, nc->integrity_alg)) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003063 conn_err(tconn, "incompatible setting of the data-integrity-alg\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07003064 goto disconnect;
3065 }
Andreas Gruenbacher86db0612011-04-28 15:24:18 +02003066 }
3067
3068 rcu_read_unlock();
3069
3070 if (tconn->agreed_pro_version >= 87) {
Philipp Reisner7204624c2011-03-15 18:51:47 +01003071 conn_info(tconn, "data-integrity-alg: %s\n",
Andreas Gruenbacher86db0612011-04-28 15:24:18 +02003072 nc->integrity_alg[0] ? nc->integrity_alg : (unsigned char *)"<not-used>");
Philipp Reisnerb411b362009-09-25 16:07:19 -07003073 }
3074
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003075 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003076
Philipp Reisner44ed1672011-04-19 17:10:19 +02003077disconnect_rcu_unlock:
3078 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -07003079disconnect:
Philipp Reisner7204624c2011-03-15 18:51:47 +01003080 conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003081 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003082}
3083
3084/* helper function
3085 * input: alg name, feature name
3086 * return: NULL (alg name was "")
3087 * ERR_PTR(error) if something goes wrong
3088 * or the crypto hash ptr, if it worked out ok. */
3089struct crypto_hash *drbd_crypto_alloc_digest_safe(const struct drbd_conf *mdev,
3090 const char *alg, const char *name)
3091{
3092 struct crypto_hash *tfm;
3093
3094 if (!alg[0])
3095 return NULL;
3096
3097 tfm = crypto_alloc_hash(alg, 0, CRYPTO_ALG_ASYNC);
3098 if (IS_ERR(tfm)) {
3099 dev_err(DEV, "Can not allocate \"%s\" as %s (reason: %ld)\n",
3100 alg, name, PTR_ERR(tfm));
3101 return tfm;
3102 }
3103 if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) {
3104 crypto_free_hash(tfm);
3105 dev_err(DEV, "\"%s\" is not a digest (%s)\n", alg, name);
3106 return ERR_PTR(-EINVAL);
3107 }
3108 return tfm;
3109}
3110
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003111static int ignore_remaining_packet(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003112{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003113 void *buffer = tconn->data.rbuf;
3114 int size = pi->size;
3115
3116 while (size) {
3117 int s = min_t(int, size, DRBD_SOCKET_BUFFER_SIZE);
3118 s = drbd_recv(tconn, buffer, s);
3119 if (s <= 0) {
3120 if (s < 0)
3121 return s;
3122 break;
3123 }
3124 size -= s;
3125 }
3126 if (size)
3127 return -EIO;
3128 return 0;
3129}
3130
3131/*
3132 * config_unknown_volume - device configuration command for unknown volume
3133 *
3134 * When a device is added to an existing connection, the node on which the
3135 * device is added first will send configuration commands to its peer but the
3136 * peer will not know about the device yet. It will warn and ignore these
3137 * commands. Once the device is added on the second node, the second node will
3138 * send the same device configuration commands, but in the other direction.
3139 *
3140 * (We can also end up here if drbd is misconfigured.)
3141 */
3142static int config_unknown_volume(struct drbd_tconn *tconn, struct packet_info *pi)
3143{
3144 conn_warn(tconn, "Volume %u unknown; ignoring %s packet\n",
3145 pi->vnr, cmdname(pi->cmd));
3146 return ignore_remaining_packet(tconn, pi);
3147}
3148
3149static int receive_SyncParam(struct drbd_tconn *tconn, struct packet_info *pi)
3150{
3151 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003152 struct p_rs_param_95 *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003153 unsigned int header_size, data_size, exp_max_sz;
3154 struct crypto_hash *verify_tfm = NULL;
3155 struct crypto_hash *csums_tfm = NULL;
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003156 struct net_conf *old_conf, *new_conf = NULL;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003157 const int apv = tconn->agreed_pro_version;
Philipp Reisner778f2712010-07-06 11:14:00 +02003158 int *rs_plan_s = NULL;
3159 int fifo_size = 0;
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003160 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003161
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003162 mdev = vnr_to_mdev(tconn, pi->vnr);
3163 if (!mdev)
3164 return config_unknown_volume(tconn, pi);
3165
Philipp Reisnerb411b362009-09-25 16:07:19 -07003166 exp_max_sz = apv <= 87 ? sizeof(struct p_rs_param)
3167 : apv == 88 ? sizeof(struct p_rs_param)
3168 + SHARED_SECRET_MAX
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02003169 : apv <= 94 ? sizeof(struct p_rs_param_89)
3170 : /* apv >= 95 */ sizeof(struct p_rs_param_95);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003171
Andreas Gruenbachere2857212011-03-25 00:57:38 +01003172 if (pi->size > exp_max_sz) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003173 dev_err(DEV, "SyncParam packet too long: received %u, expected <= %u bytes\n",
Andreas Gruenbachere2857212011-03-25 00:57:38 +01003174 pi->size, exp_max_sz);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003175 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003176 }
3177
3178 if (apv <= 88) {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003179 header_size = sizeof(struct p_rs_param);
Andreas Gruenbachere2857212011-03-25 00:57:38 +01003180 data_size = pi->size - header_size;
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02003181 } else if (apv <= 94) {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003182 header_size = sizeof(struct p_rs_param_89);
Andreas Gruenbachere2857212011-03-25 00:57:38 +01003183 data_size = pi->size - header_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003184 D_ASSERT(data_size == 0);
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02003185 } else {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003186 header_size = sizeof(struct p_rs_param_95);
Andreas Gruenbachere2857212011-03-25 00:57:38 +01003187 data_size = pi->size - header_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003188 D_ASSERT(data_size == 0);
3189 }
3190
3191 /* initialize verify_alg and csums_alg */
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003192 p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003193 memset(p->verify_alg, 0, 2 * SHARED_SECRET_MAX);
3194
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003195 err = drbd_recv_all(mdev->tconn, p, header_size);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003196 if (err)
3197 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003198
Lars Ellenbergf3990022011-03-23 14:31:09 +01003199 if (get_ldev(mdev)) {
3200 mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate);
3201 put_ldev(mdev);
3202 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003203
3204 if (apv >= 88) {
3205 if (apv == 88) {
3206 if (data_size > SHARED_SECRET_MAX) {
3207 dev_err(DEV, "verify-alg too long, "
3208 "peer wants %u, accepting only %u byte\n",
3209 data_size, SHARED_SECRET_MAX);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003210 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003211 }
3212
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003213 err = drbd_recv_all(mdev->tconn, p->verify_alg, data_size);
3214 if (err)
3215 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003216
3217 /* we expect NUL terminated string */
3218 /* but just in case someone tries to be evil */
3219 D_ASSERT(p->verify_alg[data_size-1] == 0);
3220 p->verify_alg[data_size-1] = 0;
3221
3222 } else /* apv >= 89 */ {
3223 /* we still expect NUL terminated strings */
3224 /* but just in case someone tries to be evil */
3225 D_ASSERT(p->verify_alg[SHARED_SECRET_MAX-1] == 0);
3226 D_ASSERT(p->csums_alg[SHARED_SECRET_MAX-1] == 0);
3227 p->verify_alg[SHARED_SECRET_MAX-1] = 0;
3228 p->csums_alg[SHARED_SECRET_MAX-1] = 0;
3229 }
3230
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003231 mutex_lock(&mdev->tconn->net_conf_update);
3232 old_conf = mdev->tconn->net_conf;
3233
3234 if (strcmp(old_conf->verify_alg, p->verify_alg)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003235 if (mdev->state.conn == C_WF_REPORT_PARAMS) {
3236 dev_err(DEV, "Different verify-alg settings. me=\"%s\" peer=\"%s\"\n",
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003237 old_conf->verify_alg, p->verify_alg);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003238 goto disconnect;
3239 }
3240 verify_tfm = drbd_crypto_alloc_digest_safe(mdev,
3241 p->verify_alg, "verify-alg");
3242 if (IS_ERR(verify_tfm)) {
3243 verify_tfm = NULL;
3244 goto disconnect;
3245 }
3246 }
3247
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003248 if (apv >= 89 && strcmp(old_conf->csums_alg, p->csums_alg)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003249 if (mdev->state.conn == C_WF_REPORT_PARAMS) {
3250 dev_err(DEV, "Different csums-alg settings. me=\"%s\" peer=\"%s\"\n",
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003251 old_conf->csums_alg, p->csums_alg);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003252 goto disconnect;
3253 }
3254 csums_tfm = drbd_crypto_alloc_digest_safe(mdev,
3255 p->csums_alg, "csums-alg");
3256 if (IS_ERR(csums_tfm)) {
3257 csums_tfm = NULL;
3258 goto disconnect;
3259 }
3260 }
3261
Lars Ellenbergf3990022011-03-23 14:31:09 +01003262 if (apv > 94 && get_ldev(mdev)) {
3263 mdev->ldev->dc.resync_rate = be32_to_cpu(p->rate);
3264 mdev->ldev->dc.c_plan_ahead = be32_to_cpu(p->c_plan_ahead);
3265 mdev->ldev->dc.c_delay_target = be32_to_cpu(p->c_delay_target);
3266 mdev->ldev->dc.c_fill_target = be32_to_cpu(p->c_fill_target);
3267 mdev->ldev->dc.c_max_rate = be32_to_cpu(p->c_max_rate);
Philipp Reisner778f2712010-07-06 11:14:00 +02003268
Lars Ellenbergf3990022011-03-23 14:31:09 +01003269 fifo_size = (mdev->ldev->dc.c_plan_ahead * 10 * SLEEP_TIME) / HZ;
Philipp Reisner778f2712010-07-06 11:14:00 +02003270 if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
3271 rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
3272 if (!rs_plan_s) {
3273 dev_err(DEV, "kmalloc of fifo_buffer failed");
Lars Ellenbergf3990022011-03-23 14:31:09 +01003274 put_ldev(mdev);
Philipp Reisner778f2712010-07-06 11:14:00 +02003275 goto disconnect;
3276 }
3277 }
Lars Ellenbergf3990022011-03-23 14:31:09 +01003278 put_ldev(mdev);
Philipp Reisner8e26f9c2010-07-06 17:25:54 +02003279 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003280
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003281 if (verify_tfm || csums_tfm) {
3282 new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
3283 if (!new_conf) {
3284 dev_err(DEV, "Allocation of new net_conf failed\n");
3285 goto disconnect;
3286 }
3287
3288 *new_conf = *old_conf;
3289
3290 if (verify_tfm) {
3291 strcpy(new_conf->verify_alg, p->verify_alg);
3292 new_conf->verify_alg_len = strlen(p->verify_alg) + 1;
3293 crypto_free_hash(mdev->tconn->verify_tfm);
3294 mdev->tconn->verify_tfm = verify_tfm;
3295 dev_info(DEV, "using verify-alg: \"%s\"\n", p->verify_alg);
3296 }
3297 if (csums_tfm) {
3298 strcpy(new_conf->csums_alg, p->csums_alg);
3299 new_conf->csums_alg_len = strlen(p->csums_alg) + 1;
3300 crypto_free_hash(mdev->tconn->csums_tfm);
3301 mdev->tconn->csums_tfm = csums_tfm;
3302 dev_info(DEV, "using csums-alg: \"%s\"\n", p->csums_alg);
3303 }
3304 rcu_assign_pointer(tconn->net_conf, new_conf);
3305 }
3306 mutex_unlock(&mdev->tconn->net_conf_update);
3307 if (new_conf) {
3308 synchronize_rcu();
3309 kfree(old_conf);
3310 }
3311
Philipp Reisnerb411b362009-09-25 16:07:19 -07003312 spin_lock(&mdev->peer_seq_lock);
Philipp Reisner778f2712010-07-06 11:14:00 +02003313 if (fifo_size != mdev->rs_plan_s.size) {
3314 kfree(mdev->rs_plan_s.values);
3315 mdev->rs_plan_s.values = rs_plan_s;
3316 mdev->rs_plan_s.size = fifo_size;
3317 mdev->rs_planed = 0;
3318 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003319 spin_unlock(&mdev->peer_seq_lock);
3320 }
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003321 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003322
Philipp Reisnerb411b362009-09-25 16:07:19 -07003323disconnect:
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003324 mutex_unlock(&mdev->tconn->net_conf_update);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003325 /* just for completeness: actually not needed,
3326 * as this is not reached if csums_tfm was ok. */
3327 crypto_free_hash(csums_tfm);
3328 /* but free the verify_tfm again, if csums_tfm did not work out */
3329 crypto_free_hash(verify_tfm);
Philipp Reisner38fa9982011-03-15 18:24:49 +01003330 conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003331 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003332}
3333
Philipp Reisnerb411b362009-09-25 16:07:19 -07003334/* warn if the arguments differ by more than 12.5% */
3335static void warn_if_differ_considerably(struct drbd_conf *mdev,
3336 const char *s, sector_t a, sector_t b)
3337{
3338 sector_t d;
3339 if (a == 0 || b == 0)
3340 return;
3341 d = (a > b) ? (a - b) : (b - a);
3342 if (d > (a>>3) || d > (b>>3))
3343 dev_warn(DEV, "Considerable difference in %s: %llus vs. %llus\n", s,
3344 (unsigned long long)a, (unsigned long long)b);
3345}
3346
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003347static int receive_sizes(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003348{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003349 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003350 struct p_sizes *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003351 enum determine_dev_size dd = unchanged;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003352 sector_t p_size, p_usize, my_usize;
3353 int ldsc = 0; /* local disk size changed */
Philipp Reisnere89b5912010-03-24 17:11:33 +01003354 enum dds_flags ddsf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003355
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003356 mdev = vnr_to_mdev(tconn, pi->vnr);
3357 if (!mdev)
3358 return config_unknown_volume(tconn, pi);
3359
Philipp Reisnerb411b362009-09-25 16:07:19 -07003360 p_size = be64_to_cpu(p->d_size);
3361 p_usize = be64_to_cpu(p->u_size);
3362
Philipp Reisnerb411b362009-09-25 16:07:19 -07003363 /* just store the peer's disk size for now.
3364 * we still need to figure out whether we accept that. */
3365 mdev->p_size = p_size;
3366
Philipp Reisnerb411b362009-09-25 16:07:19 -07003367 if (get_ldev(mdev)) {
3368 warn_if_differ_considerably(mdev, "lower level device sizes",
3369 p_size, drbd_get_max_capacity(mdev->ldev));
3370 warn_if_differ_considerably(mdev, "user requested size",
3371 p_usize, mdev->ldev->dc.disk_size);
3372
3373 /* if this is the first connect, or an otherwise expected
3374 * param exchange, choose the minimum */
3375 if (mdev->state.conn == C_WF_REPORT_PARAMS)
3376 p_usize = min_not_zero((sector_t)mdev->ldev->dc.disk_size,
3377 p_usize);
3378
3379 my_usize = mdev->ldev->dc.disk_size;
3380
3381 if (mdev->ldev->dc.disk_size != p_usize) {
3382 mdev->ldev->dc.disk_size = p_usize;
3383 dev_info(DEV, "Peer sets u_size to %lu sectors\n",
3384 (unsigned long)mdev->ldev->dc.disk_size);
3385 }
3386
3387 /* Never shrink a device with usable data during connect.
3388 But allow online shrinking if we are connected. */
Philipp Reisnera393db62009-12-22 13:35:52 +01003389 if (drbd_new_dev_size(mdev, mdev->ldev, 0) <
Philipp Reisnerb411b362009-09-25 16:07:19 -07003390 drbd_get_capacity(mdev->this_bdev) &&
3391 mdev->state.disk >= D_OUTDATED &&
3392 mdev->state.conn < C_CONNECTED) {
3393 dev_err(DEV, "The peer's disk size is too small!\n");
Philipp Reisner38fa9982011-03-15 18:24:49 +01003394 conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003395 mdev->ldev->dc.disk_size = my_usize;
3396 put_ldev(mdev);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003397 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003398 }
3399 put_ldev(mdev);
3400 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07003401
Philipp Reisnere89b5912010-03-24 17:11:33 +01003402 ddsf = be16_to_cpu(p->dds_flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003403 if (get_ldev(mdev)) {
Bart Van Assche24c48302011-05-21 18:32:29 +02003404 dd = drbd_determine_dev_size(mdev, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003405 put_ldev(mdev);
3406 if (dd == dev_size_error)
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003407 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003408 drbd_md_sync(mdev);
3409 } else {
3410 /* I am diskless, need to accept the peer's size. */
3411 drbd_set_my_capacity(mdev, p_size);
3412 }
3413
Philipp Reisner99432fc2011-05-20 16:39:13 +02003414 mdev->peer_max_bio_size = be32_to_cpu(p->max_bio_size);
3415 drbd_reconsider_max_bio_size(mdev);
3416
Philipp Reisnerb411b362009-09-25 16:07:19 -07003417 if (get_ldev(mdev)) {
3418 if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev)) {
3419 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
3420 ldsc = 1;
3421 }
3422
Philipp Reisnerb411b362009-09-25 16:07:19 -07003423 put_ldev(mdev);
3424 }
3425
3426 if (mdev->state.conn > C_WF_REPORT_PARAMS) {
3427 if (be64_to_cpu(p->c_size) !=
3428 drbd_get_capacity(mdev->this_bdev) || ldsc) {
3429 /* we have different sizes, probably peer
3430 * needs to know my new size... */
Philipp Reisnere89b5912010-03-24 17:11:33 +01003431 drbd_send_sizes(mdev, 0, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003432 }
3433 if (test_and_clear_bit(RESIZE_PENDING, &mdev->flags) ||
3434 (dd == grew && mdev->state.conn == C_CONNECTED)) {
3435 if (mdev->state.pdsk >= D_INCONSISTENT &&
Philipp Reisnere89b5912010-03-24 17:11:33 +01003436 mdev->state.disk >= D_INCONSISTENT) {
3437 if (ddsf & DDSF_NO_RESYNC)
3438 dev_info(DEV, "Resync of new storage suppressed with --assume-clean\n");
3439 else
3440 resync_after_online_grow(mdev);
3441 } else
Philipp Reisnerb411b362009-09-25 16:07:19 -07003442 set_bit(RESYNC_AFTER_NEG, &mdev->flags);
3443 }
3444 }
3445
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003446 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003447}
3448
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003449static int receive_uuids(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003450{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003451 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003452 struct p_uuids *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003453 u64 *p_uuid;
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003454 int i, updated_uuids = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003455
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003456 mdev = vnr_to_mdev(tconn, pi->vnr);
3457 if (!mdev)
3458 return config_unknown_volume(tconn, pi);
3459
Philipp Reisnerb411b362009-09-25 16:07:19 -07003460 p_uuid = kmalloc(sizeof(u64)*UI_EXTENDED_SIZE, GFP_NOIO);
3461
3462 for (i = UI_CURRENT; i < UI_EXTENDED_SIZE; i++)
3463 p_uuid[i] = be64_to_cpu(p->uuid[i]);
3464
3465 kfree(mdev->p_uuid);
3466 mdev->p_uuid = p_uuid;
3467
3468 if (mdev->state.conn < C_CONNECTED &&
3469 mdev->state.disk < D_INCONSISTENT &&
3470 mdev->state.role == R_PRIMARY &&
3471 (mdev->ed_uuid & ~((u64)1)) != (p_uuid[UI_CURRENT] & ~((u64)1))) {
3472 dev_err(DEV, "Can only connect to data with current UUID=%016llX\n",
3473 (unsigned long long)mdev->ed_uuid);
Philipp Reisner38fa9982011-03-15 18:24:49 +01003474 conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003475 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003476 }
3477
3478 if (get_ldev(mdev)) {
3479 int skip_initial_sync =
3480 mdev->state.conn == C_CONNECTED &&
Philipp Reisner31890f42011-01-19 14:12:51 +01003481 mdev->tconn->agreed_pro_version >= 90 &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07003482 mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED &&
3483 (p_uuid[UI_FLAGS] & 8);
3484 if (skip_initial_sync) {
3485 dev_info(DEV, "Accepted new current UUID, preparing to skip initial sync\n");
3486 drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003487 "clear_n_write from receive_uuids",
3488 BM_LOCKED_TEST_ALLOWED);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003489 _drbd_uuid_set(mdev, UI_CURRENT, p_uuid[UI_CURRENT]);
3490 _drbd_uuid_set(mdev, UI_BITMAP, 0);
3491 _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
3492 CS_VERBOSE, NULL);
3493 drbd_md_sync(mdev);
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003494 updated_uuids = 1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003495 }
3496 put_ldev(mdev);
Philipp Reisner18a50fa2010-06-21 14:14:15 +02003497 } else if (mdev->state.disk < D_INCONSISTENT &&
3498 mdev->state.role == R_PRIMARY) {
3499 /* I am a diskless primary, the peer just created a new current UUID
3500 for me. */
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003501 updated_uuids = drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003502 }
3503
3504 /* Before we test for the disk state, we should wait until an eventually
3505 ongoing cluster wide state change is finished. That is important if
3506 we are primary and are detaching from our disk. We need to see the
3507 new disk state... */
Philipp Reisner8410da82011-02-11 20:11:10 +01003508 mutex_lock(mdev->state_mutex);
3509 mutex_unlock(mdev->state_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003510 if (mdev->state.conn >= C_CONNECTED && mdev->state.disk < D_INCONSISTENT)
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003511 updated_uuids |= drbd_set_ed_uuid(mdev, p_uuid[UI_CURRENT]);
3512
3513 if (updated_uuids)
3514 drbd_print_uuids(mdev, "receiver updated UUIDs to");
Philipp Reisnerb411b362009-09-25 16:07:19 -07003515
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003516 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003517}
3518
3519/**
3520 * convert_state() - Converts the peer's view of the cluster state to our point of view
3521 * @ps: The state as seen by the peer.
3522 */
3523static union drbd_state convert_state(union drbd_state ps)
3524{
3525 union drbd_state ms;
3526
3527 static enum drbd_conns c_tab[] = {
3528 [C_CONNECTED] = C_CONNECTED,
3529
3530 [C_STARTING_SYNC_S] = C_STARTING_SYNC_T,
3531 [C_STARTING_SYNC_T] = C_STARTING_SYNC_S,
3532 [C_DISCONNECTING] = C_TEAR_DOWN, /* C_NETWORK_FAILURE, */
3533 [C_VERIFY_S] = C_VERIFY_T,
3534 [C_MASK] = C_MASK,
3535 };
3536
3537 ms.i = ps.i;
3538
3539 ms.conn = c_tab[ps.conn];
3540 ms.peer = ps.role;
3541 ms.role = ps.peer;
3542 ms.pdsk = ps.disk;
3543 ms.disk = ps.pdsk;
3544 ms.peer_isp = (ps.aftr_isp | ps.user_isp);
3545
3546 return ms;
3547}
3548
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003549static int receive_req_state(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003550{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003551 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003552 struct p_req_state *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003553 union drbd_state mask, val;
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +01003554 enum drbd_state_rv rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003555
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003556 mdev = vnr_to_mdev(tconn, pi->vnr);
3557 if (!mdev)
3558 return -EIO;
3559
Philipp Reisnerb411b362009-09-25 16:07:19 -07003560 mask.i = be32_to_cpu(p->mask);
3561 val.i = be32_to_cpu(p->val);
3562
Philipp Reisner25703f82011-02-07 14:35:25 +01003563 if (test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags) &&
Philipp Reisner8410da82011-02-11 20:11:10 +01003564 mutex_is_locked(mdev->state_mutex)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07003565 drbd_send_sr_reply(mdev, SS_CONCURRENT_ST_CHG);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003566 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003567 }
3568
3569 mask = convert_state(mask);
3570 val = convert_state(val);
3571
Philipp Reisnerdfafcc82011-03-16 10:55:07 +01003572 rv = drbd_change_state(mdev, CS_VERBOSE, mask, val);
3573 drbd_send_sr_reply(mdev, rv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003574
Philipp Reisnerb411b362009-09-25 16:07:19 -07003575 drbd_md_sync(mdev);
3576
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003577 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003578}
3579
Andreas Gruenbachere2857212011-03-25 00:57:38 +01003580static int receive_req_conn_state(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerdfafcc82011-03-16 10:55:07 +01003581{
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003582 struct p_req_state *p = pi->data;
Philipp Reisnerdfafcc82011-03-16 10:55:07 +01003583 union drbd_state mask, val;
3584 enum drbd_state_rv rv;
3585
3586 mask.i = be32_to_cpu(p->mask);
3587 val.i = be32_to_cpu(p->val);
3588
3589 if (test_bit(DISCARD_CONCURRENT, &tconn->flags) &&
3590 mutex_is_locked(&tconn->cstate_mutex)) {
3591 conn_send_sr_reply(tconn, SS_CONCURRENT_ST_CHG);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003592 return 0;
Philipp Reisnerdfafcc82011-03-16 10:55:07 +01003593 }
3594
3595 mask = convert_state(mask);
3596 val = convert_state(val);
3597
Philipp Reisner778bcf22011-03-28 12:55:03 +02003598 rv = conn_request_state(tconn, mask, val, CS_VERBOSE | CS_LOCAL_ONLY | CS_IGN_OUTD_FAIL);
Philipp Reisnerdfafcc82011-03-16 10:55:07 +01003599 conn_send_sr_reply(tconn, rv);
3600
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003601 return 0;
Philipp Reisnerdfafcc82011-03-16 10:55:07 +01003602}
3603
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003604static int receive_state(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003605{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003606 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003607 struct p_state *p = pi->data;
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003608 union drbd_state os, ns, peer_state;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003609 enum drbd_disk_state real_peer_disk;
Philipp Reisner65d922c2010-06-16 16:18:09 +02003610 enum chg_state_flags cs_flags;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003611 int rv;
3612
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003613 mdev = vnr_to_mdev(tconn, pi->vnr);
3614 if (!mdev)
3615 return config_unknown_volume(tconn, pi);
3616
Philipp Reisnerb411b362009-09-25 16:07:19 -07003617 peer_state.i = be32_to_cpu(p->state);
3618
3619 real_peer_disk = peer_state.disk;
3620 if (peer_state.disk == D_NEGOTIATING) {
3621 real_peer_disk = mdev->p_uuid[UI_FLAGS] & 4 ? D_INCONSISTENT : D_CONSISTENT;
3622 dev_info(DEV, "real peer disk state = %s\n", drbd_disk_str(real_peer_disk));
3623 }
3624
Philipp Reisner87eeee42011-01-19 14:16:30 +01003625 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003626 retry:
Philipp Reisner78bae592011-03-28 15:40:12 +02003627 os = ns = drbd_read_state(mdev);
Philipp Reisner87eeee42011-01-19 14:16:30 +01003628 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003629
Lars Ellenberge9ef7bb2010-10-07 15:55:39 +02003630 /* peer says his disk is uptodate, while we think it is inconsistent,
3631 * and this happens while we think we have a sync going on. */
3632 if (os.pdsk == D_INCONSISTENT && real_peer_disk == D_UP_TO_DATE &&
3633 os.conn > C_CONNECTED && os.disk == D_UP_TO_DATE) {
3634 /* If we are (becoming) SyncSource, but peer is still in sync
3635 * preparation, ignore its uptodate-ness to avoid flapping, it
3636 * will change to inconsistent once the peer reaches active
3637 * syncing states.
3638 * It may have changed syncer-paused flags, however, so we
3639 * cannot ignore this completely. */
3640 if (peer_state.conn > C_CONNECTED &&
3641 peer_state.conn < C_SYNC_SOURCE)
3642 real_peer_disk = D_INCONSISTENT;
3643
3644 /* if peer_state changes to connected at the same time,
3645 * it explicitly notifies us that it finished resync.
3646 * Maybe we should finish it up, too? */
3647 else if (os.conn >= C_SYNC_SOURCE &&
3648 peer_state.conn == C_CONNECTED) {
3649 if (drbd_bm_total_weight(mdev) <= mdev->rs_failed)
3650 drbd_resync_finished(mdev);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003651 return 0;
Lars Ellenberge9ef7bb2010-10-07 15:55:39 +02003652 }
3653 }
3654
3655 /* peer says his disk is inconsistent, while we think it is uptodate,
3656 * and this happens while the peer still thinks we have a sync going on,
3657 * but we think we are already done with the sync.
3658 * We ignore this to avoid flapping pdsk.
3659 * This should not happen, if the peer is a recent version of drbd. */
3660 if (os.pdsk == D_UP_TO_DATE && real_peer_disk == D_INCONSISTENT &&
3661 os.conn == C_CONNECTED && peer_state.conn > C_SYNC_SOURCE)
3662 real_peer_disk = D_UP_TO_DATE;
3663
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003664 if (ns.conn == C_WF_REPORT_PARAMS)
3665 ns.conn = C_CONNECTED;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003666
Philipp Reisner67531712010-10-27 12:21:30 +02003667 if (peer_state.conn == C_AHEAD)
3668 ns.conn = C_BEHIND;
3669
Philipp Reisnerb411b362009-09-25 16:07:19 -07003670 if (mdev->p_uuid && peer_state.disk >= D_NEGOTIATING &&
3671 get_ldev_if_state(mdev, D_NEGOTIATING)) {
3672 int cr; /* consider resync */
3673
3674 /* if we established a new connection */
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003675 cr = (os.conn < C_CONNECTED);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003676 /* if we had an established connection
3677 * and one of the nodes newly attaches a disk */
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003678 cr |= (os.conn == C_CONNECTED &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07003679 (peer_state.disk == D_NEGOTIATING ||
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003680 os.disk == D_NEGOTIATING));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003681 /* if we have both been inconsistent, and the peer has been
3682 * forced to be UpToDate with --overwrite-data */
3683 cr |= test_bit(CONSIDER_RESYNC, &mdev->flags);
3684 /* if we had been plain connected, and the admin requested to
3685 * start a sync by "invalidate" or "invalidate-remote" */
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003686 cr |= (os.conn == C_CONNECTED &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07003687 (peer_state.conn >= C_STARTING_SYNC_S &&
3688 peer_state.conn <= C_WF_BITMAP_T));
3689
3690 if (cr)
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003691 ns.conn = drbd_sync_handshake(mdev, peer_state.role, real_peer_disk);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003692
3693 put_ldev(mdev);
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003694 if (ns.conn == C_MASK) {
3695 ns.conn = C_CONNECTED;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003696 if (mdev->state.disk == D_NEGOTIATING) {
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02003697 drbd_force_state(mdev, NS(disk, D_FAILED));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003698 } else if (peer_state.disk == D_NEGOTIATING) {
3699 dev_err(DEV, "Disk attach process on the peer node was aborted.\n");
3700 peer_state.disk = D_DISKLESS;
Lars Ellenberg580b9762010-02-26 23:15:23 +01003701 real_peer_disk = D_DISKLESS;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003702 } else {
Philipp Reisner8169e412011-03-15 18:40:27 +01003703 if (test_and_clear_bit(CONN_DRY_RUN, &mdev->tconn->flags))
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003704 return -EIO;
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003705 D_ASSERT(os.conn == C_WF_REPORT_PARAMS);
Philipp Reisner38fa9982011-03-15 18:24:49 +01003706 conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003707 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003708 }
3709 }
3710 }
3711
Philipp Reisner87eeee42011-01-19 14:16:30 +01003712 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner78bae592011-03-28 15:40:12 +02003713 if (os.i != drbd_read_state(mdev).i)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003714 goto retry;
3715 clear_bit(CONSIDER_RESYNC, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003716 ns.peer = peer_state.role;
3717 ns.pdsk = real_peer_disk;
3718 ns.peer_isp = (peer_state.aftr_isp | peer_state.user_isp);
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003719 if ((ns.conn == C_CONNECTED || ns.conn == C_WF_BITMAP_S) && ns.disk == D_NEGOTIATING)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003720 ns.disk = mdev->new_state_tmp.disk;
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003721 cs_flags = CS_VERBOSE + (os.conn < C_CONNECTED && ns.conn >= C_CONNECTED ? 0 : CS_HARD);
Philipp Reisner2aebfab2011-03-28 16:48:11 +02003722 if (ns.pdsk == D_CONSISTENT && drbd_suspended(mdev) && ns.conn == C_CONNECTED && os.conn < C_CONNECTED &&
Philipp Reisner481c6f52010-06-22 14:03:27 +02003723 test_bit(NEW_CUR_UUID, &mdev->flags)) {
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01003724 /* Do not allow tl_restart(RESEND) for a rebooted peer. We can only allow this
Philipp Reisner481c6f52010-06-22 14:03:27 +02003725 for temporal network outages! */
Philipp Reisner87eeee42011-01-19 14:16:30 +01003726 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisner481c6f52010-06-22 14:03:27 +02003727 dev_err(DEV, "Aborting Connect, can not thaw IO with an only Consistent peer\n");
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01003728 tl_clear(mdev->tconn);
Philipp Reisner481c6f52010-06-22 14:03:27 +02003729 drbd_uuid_new_current(mdev);
3730 clear_bit(NEW_CUR_UUID, &mdev->flags);
Philipp Reisner38fa9982011-03-15 18:24:49 +01003731 conn_request_state(mdev->tconn, NS2(conn, C_PROTOCOL_ERROR, susp, 0), CS_HARD);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003732 return -EIO;
Philipp Reisner481c6f52010-06-22 14:03:27 +02003733 }
Philipp Reisner65d922c2010-06-16 16:18:09 +02003734 rv = _drbd_set_state(mdev, ns, cs_flags, NULL);
Philipp Reisner78bae592011-03-28 15:40:12 +02003735 ns = drbd_read_state(mdev);
Philipp Reisner87eeee42011-01-19 14:16:30 +01003736 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003737
3738 if (rv < SS_SUCCESS) {
Philipp Reisner38fa9982011-03-15 18:24:49 +01003739 conn_request_state(mdev->tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003740 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003741 }
3742
Lars Ellenberg4ac4aad2010-07-22 17:39:26 +02003743 if (os.conn > C_WF_REPORT_PARAMS) {
3744 if (ns.conn > C_CONNECTED && peer_state.conn <= C_CONNECTED &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07003745 peer_state.disk != D_NEGOTIATING ) {
3746 /* we want resync, peer has not yet decided to sync... */
3747 /* Nowadays only used when forcing a node into primary role and
3748 setting its disk to UpToDate with that */
3749 drbd_send_uuids(mdev);
3750 drbd_send_state(mdev);
3751 }
3752 }
3753
Philipp Reisner91fd4da2011-04-20 17:47:29 +02003754 mutex_lock(&mdev->tconn->net_conf_update);
3755 mdev->tconn->net_conf->want_lose = 0; /* without copy; single bit op is atomic */
3756 mutex_unlock(&mdev->tconn->net_conf_update);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003757
3758 drbd_md_sync(mdev); /* update connected indicator, la_size, ... */
3759
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003760 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003761}
3762
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003763static int receive_sync_uuid(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003764{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003765 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003766 struct p_rs_uuid *p = pi->data;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003767
3768 mdev = vnr_to_mdev(tconn, pi->vnr);
3769 if (!mdev)
3770 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003771
3772 wait_event(mdev->misc_wait,
3773 mdev->state.conn == C_WF_SYNC_UUID ||
Philipp Reisnerc4752ef2010-10-27 17:32:36 +02003774 mdev->state.conn == C_BEHIND ||
Philipp Reisnerb411b362009-09-25 16:07:19 -07003775 mdev->state.conn < C_CONNECTED ||
3776 mdev->state.disk < D_NEGOTIATING);
3777
3778 /* D_ASSERT( mdev->state.conn == C_WF_SYNC_UUID ); */
3779
Philipp Reisnerb411b362009-09-25 16:07:19 -07003780 /* Here the _drbd_uuid_ functions are right, current should
3781 _not_ be rotated into the history */
3782 if (get_ldev_if_state(mdev, D_NEGOTIATING)) {
3783 _drbd_uuid_set(mdev, UI_CURRENT, be64_to_cpu(p->uuid));
3784 _drbd_uuid_set(mdev, UI_BITMAP, 0UL);
3785
Lars Ellenberg62b0da32011-01-20 13:25:21 +01003786 drbd_print_uuids(mdev, "updated sync uuid");
Philipp Reisnerb411b362009-09-25 16:07:19 -07003787 drbd_start_resync(mdev, C_SYNC_TARGET);
3788
3789 put_ldev(mdev);
3790 } else
3791 dev_err(DEV, "Ignoring SyncUUID packet!\n");
3792
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003793 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003794}
3795
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003796/**
3797 * receive_bitmap_plain
3798 *
3799 * Return 0 when done, 1 when another iteration is needed, and a negative error
3800 * code upon failure.
3801 */
3802static int
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02003803receive_bitmap_plain(struct drbd_conf *mdev, unsigned int size,
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003804 unsigned long *p, struct bm_xfer_ctx *c)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003805{
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02003806 unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE -
3807 drbd_header_size(mdev->tconn);
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003808 unsigned int num_words = min_t(size_t, data_size / sizeof(*p),
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02003809 c->bm_words - c->word_offset);
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003810 unsigned int want = num_words * sizeof(*p);
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003811 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003812
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02003813 if (want != size) {
3814 dev_err(DEV, "%s:want (%u) != size (%u)\n", __func__, want, size);
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003815 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003816 }
3817 if (want == 0)
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003818 return 0;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003819 err = drbd_recv_all(mdev->tconn, p, want);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01003820 if (err)
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003821 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003822
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003823 drbd_bm_merge_lel(mdev, c->word_offset, num_words, p);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003824
3825 c->word_offset += num_words;
3826 c->bit_offset = c->word_offset * BITS_PER_LONG;
3827 if (c->bit_offset > c->bm_bits)
3828 c->bit_offset = c->bm_bits;
3829
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003830 return 1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003831}
3832
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01003833static enum drbd_bitmap_code dcbp_get_code(struct p_compressed_bm *p)
3834{
3835 return (enum drbd_bitmap_code)(p->encoding & 0x0f);
3836}
3837
3838static int dcbp_get_start(struct p_compressed_bm *p)
3839{
3840 return (p->encoding & 0x80) != 0;
3841}
3842
3843static int dcbp_get_pad_bits(struct p_compressed_bm *p)
3844{
3845 return (p->encoding >> 4) & 0x7;
3846}
3847
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003848/**
3849 * recv_bm_rle_bits
3850 *
3851 * Return 0 when done, 1 when another iteration is needed, and a negative error
3852 * code upon failure.
3853 */
3854static int
Philipp Reisnerb411b362009-09-25 16:07:19 -07003855recv_bm_rle_bits(struct drbd_conf *mdev,
3856 struct p_compressed_bm *p,
Philipp Reisnerc6d25cf2011-01-19 16:13:06 +01003857 struct bm_xfer_ctx *c,
3858 unsigned int len)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003859{
3860 struct bitstream bs;
3861 u64 look_ahead;
3862 u64 rl;
3863 u64 tmp;
3864 unsigned long s = c->bit_offset;
3865 unsigned long e;
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01003866 int toggle = dcbp_get_start(p);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003867 int have;
3868 int bits;
3869
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01003870 bitstream_init(&bs, p->code, len, dcbp_get_pad_bits(p));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003871
3872 bits = bitstream_get_bits(&bs, &look_ahead, 64);
3873 if (bits < 0)
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003874 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003875
3876 for (have = bits; have > 0; s += rl, toggle = !toggle) {
3877 bits = vli_decode_bits(&rl, look_ahead);
3878 if (bits <= 0)
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003879 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003880
3881 if (toggle) {
3882 e = s + rl -1;
3883 if (e >= c->bm_bits) {
3884 dev_err(DEV, "bitmap overflow (e:%lu) while decoding bm RLE packet\n", e);
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003885 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003886 }
3887 _drbd_bm_set_bits(mdev, s, e);
3888 }
3889
3890 if (have < bits) {
3891 dev_err(DEV, "bitmap decoding error: h:%d b:%d la:0x%08llx l:%u/%u\n",
3892 have, bits, look_ahead,
3893 (unsigned int)(bs.cur.b - p->code),
3894 (unsigned int)bs.buf_len);
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003895 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003896 }
3897 look_ahead >>= bits;
3898 have -= bits;
3899
3900 bits = bitstream_get_bits(&bs, &tmp, 64 - have);
3901 if (bits < 0)
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003902 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003903 look_ahead |= tmp << have;
3904 have += bits;
3905 }
3906
3907 c->bit_offset = s;
3908 bm_xfer_ctx_bit_to_word_offset(c);
3909
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003910 return (s != c->bm_bits);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003911}
3912
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003913/**
3914 * decode_bitmap_c
3915 *
3916 * Return 0 when done, 1 when another iteration is needed, and a negative error
3917 * code upon failure.
3918 */
3919static int
Philipp Reisnerb411b362009-09-25 16:07:19 -07003920decode_bitmap_c(struct drbd_conf *mdev,
3921 struct p_compressed_bm *p,
Philipp Reisnerc6d25cf2011-01-19 16:13:06 +01003922 struct bm_xfer_ctx *c,
3923 unsigned int len)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003924{
Andreas Gruenbachera02d1242011-03-22 17:20:45 +01003925 if (dcbp_get_code(p) == RLE_VLI_Bits)
Andreas Gruenbachere6589832011-03-30 12:54:42 +02003926 return recv_bm_rle_bits(mdev, p, c, len - sizeof(*p));
Philipp Reisnerb411b362009-09-25 16:07:19 -07003927
3928 /* other variants had been implemented for evaluation,
3929 * but have been dropped as this one turned out to be "best"
3930 * during all our tests. */
3931
3932 dev_err(DEV, "receive_bitmap_c: unknown encoding %u\n", p->encoding);
Philipp Reisner38fa9982011-03-15 18:24:49 +01003933 conn_request_state(mdev->tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003934 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003935}
3936
3937void INFO_bm_xfer_stats(struct drbd_conf *mdev,
3938 const char *direction, struct bm_xfer_ctx *c)
3939{
3940 /* what would it take to transfer it "plaintext" */
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02003941 unsigned int header_size = drbd_header_size(mdev->tconn);
3942 unsigned int data_size = DRBD_SOCKET_BUFFER_SIZE - header_size;
3943 unsigned int plain =
3944 header_size * (DIV_ROUND_UP(c->bm_words, data_size) + 1) +
3945 c->bm_words * sizeof(unsigned long);
3946 unsigned int total = c->bytes[0] + c->bytes[1];
3947 unsigned int r;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003948
3949 /* total can not be zero. but just in case: */
3950 if (total == 0)
3951 return;
3952
3953 /* don't report if not compressed */
3954 if (total >= plain)
3955 return;
3956
3957 /* total < plain. check for overflow, still */
3958 r = (total > UINT_MAX/1000) ? (total / (plain/1000))
3959 : (1000 * total / plain);
3960
3961 if (r > 1000)
3962 r = 1000;
3963
3964 r = 1000 - r;
3965 dev_info(DEV, "%s bitmap stats [Bytes(packets)]: plain %u(%u), RLE %u(%u), "
3966 "total %u; compression: %u.%u%%\n",
3967 direction,
3968 c->bytes[1], c->packets[1],
3969 c->bytes[0], c->packets[0],
3970 total, r/10, r % 10);
3971}
3972
3973/* Since we are processing the bitfield from lower addresses to higher,
3974 it does not matter if the process it in 32 bit chunks or 64 bit
3975 chunks as long as it is little endian. (Understand it as byte stream,
3976 beginning with the lowest byte...) If we would use big endian
3977 we would need to process it from the highest address to the lowest,
3978 in order to be agnostic to the 32 vs 64 bits issue.
3979
3980 returns 0 on failure, 1 if we successfully received it. */
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003981static int receive_bitmap(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003982{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003983 struct drbd_conf *mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003984 struct bm_xfer_ctx c;
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01003985 int err;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01003986
3987 mdev = vnr_to_mdev(tconn, pi->vnr);
3988 if (!mdev)
3989 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003990
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01003991 drbd_bm_lock(mdev, "receive bitmap", BM_LOCKED_SET_ALLOWED);
3992 /* you are supposed to send additional out-of-sync information
3993 * if you actually set bits during this phase */
Philipp Reisnerb411b362009-09-25 16:07:19 -07003994
Philipp Reisnerb411b362009-09-25 16:07:19 -07003995 c = (struct bm_xfer_ctx) {
3996 .bm_bits = drbd_bm_bits(mdev),
3997 .bm_words = drbd_bm_words(mdev),
3998 };
3999
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01004000 for(;;) {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004001 if (pi->cmd == P_BITMAP)
4002 err = receive_bitmap_plain(mdev, pi->size, pi->data, &c);
4003 else if (pi->cmd == P_COMPRESSED_BITMAP) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004004 /* MAYBE: sanity check that we speak proto >= 90,
4005 * and the feature is enabled! */
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004006 struct p_compressed_bm *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004007
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02004008 if (pi->size > DRBD_SOCKET_BUFFER_SIZE - drbd_header_size(tconn)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004009 dev_err(DEV, "ReportCBitmap packet too large\n");
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004010 err = -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004011 goto out;
4012 }
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004013 if (pi->size <= sizeof(*p)) {
Andreas Gruenbachere2857212011-03-25 00:57:38 +01004014 dev_err(DEV, "ReportCBitmap packet too small (l:%u)\n", pi->size);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004015 err = -EIO;
Andreas Gruenbacher78fcbda2010-12-10 22:18:27 +01004016 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004017 }
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004018 err = drbd_recv_all(mdev->tconn, p, pi->size);
4019 if (err)
4020 goto out;
Andreas Gruenbachere2857212011-03-25 00:57:38 +01004021 err = decode_bitmap_c(mdev, p, &c, pi->size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004022 } else {
Andreas Gruenbachere2857212011-03-25 00:57:38 +01004023 dev_warn(DEV, "receive_bitmap: cmd neither ReportBitMap nor ReportCBitMap (is 0x%x)", pi->cmd);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004024 err = -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004025 goto out;
4026 }
4027
Andreas Gruenbachere2857212011-03-25 00:57:38 +01004028 c.packets[pi->cmd == P_BITMAP]++;
Andreas Gruenbacher50d0b1a2011-03-30 11:53:51 +02004029 c.bytes[pi->cmd == P_BITMAP] += drbd_header_size(tconn) + pi->size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004030
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01004031 if (err <= 0) {
4032 if (err < 0)
4033 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004034 break;
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01004035 }
Andreas Gruenbachere2857212011-03-25 00:57:38 +01004036 err = drbd_recv_header(mdev->tconn, pi);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004037 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004038 goto out;
Andreas Gruenbacher2c464072010-12-11 21:53:12 +01004039 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004040
4041 INFO_bm_xfer_stats(mdev, "receive", &c);
4042
4043 if (mdev->state.conn == C_WF_BITMAP_T) {
Andreas Gruenbacherde1f8e42010-12-10 21:04:00 +01004044 enum drbd_state_rv rv;
4045
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004046 err = drbd_send_bitmap(mdev);
4047 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004048 goto out;
4049 /* Omit CS_ORDERED with this state transition to avoid deadlocks. */
Andreas Gruenbacherde1f8e42010-12-10 21:04:00 +01004050 rv = _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE);
4051 D_ASSERT(rv == SS_SUCCESS);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004052 } else if (mdev->state.conn != C_WF_BITMAP_S) {
4053 /* admin may have requested C_DISCONNECTING,
4054 * other threads may have noticed network errors */
4055 dev_info(DEV, "unexpected cstate (%s) in receive_bitmap\n",
4056 drbd_conn_str(mdev->state.conn));
4057 }
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004058 err = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004059
Philipp Reisnerb411b362009-09-25 16:07:19 -07004060 out:
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01004061 drbd_bm_unlock(mdev);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004062 if (!err && mdev->state.conn == C_WF_BITMAP_S)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004063 drbd_start_resync(mdev, C_SYNC_SOURCE);
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004064 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004065}
4066
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004067static int receive_skip(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004068{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004069 conn_warn(tconn, "skipping unknown optional packet type %d, l: %d!\n",
Andreas Gruenbachere2857212011-03-25 00:57:38 +01004070 pi->cmd, pi->size);
Philipp Reisner2de876e2011-03-15 14:38:01 +01004071
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004072 return ignore_remaining_packet(tconn, pi);
Philipp Reisner2de876e2011-03-15 14:38:01 +01004073}
4074
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004075static int receive_UnplugRemote(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004076{
Philipp Reisnerb411b362009-09-25 16:07:19 -07004077 /* Make sure we've acked all the TCP data associated
4078 * with the data requests being unplugged */
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004079 drbd_tcp_quickack(tconn->data.socket);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004080
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004081 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004082}
4083
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004084static int receive_out_of_sync(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisner73a01a12010-10-27 14:33:00 +02004085{
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004086 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004087 struct p_block_desc *p = pi->data;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004088
4089 mdev = vnr_to_mdev(tconn, pi->vnr);
4090 if (!mdev)
4091 return -EIO;
Philipp Reisner73a01a12010-10-27 14:33:00 +02004092
Lars Ellenbergf735e3632010-12-17 21:06:18 +01004093 switch (mdev->state.conn) {
4094 case C_WF_SYNC_UUID:
4095 case C_WF_BITMAP_T:
4096 case C_BEHIND:
4097 break;
4098 default:
4099 dev_err(DEV, "ASSERT FAILED cstate = %s, expected: WFSyncUUID|WFBitMapT|Behind\n",
4100 drbd_conn_str(mdev->state.conn));
4101 }
4102
Philipp Reisner73a01a12010-10-27 14:33:00 +02004103 drbd_set_out_of_sync(mdev, be64_to_cpu(p->sector), be32_to_cpu(p->blksize));
4104
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004105 return 0;
Philipp Reisner73a01a12010-10-27 14:33:00 +02004106}
4107
Philipp Reisner02918be2010-08-20 14:35:10 +02004108struct data_cmd {
4109 int expect_payload;
4110 size_t pkt_size;
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004111 int (*fn)(struct drbd_tconn *, struct packet_info *);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004112};
4113
Philipp Reisner02918be2010-08-20 14:35:10 +02004114static struct data_cmd drbd_cmd_handler[] = {
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004115 [P_DATA] = { 1, sizeof(struct p_data), receive_Data },
4116 [P_DATA_REPLY] = { 1, sizeof(struct p_data), receive_DataReply },
4117 [P_RS_DATA_REPLY] = { 1, sizeof(struct p_data), receive_RSDataReply } ,
4118 [P_BARRIER] = { 0, sizeof(struct p_barrier), receive_Barrier } ,
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004119 [P_BITMAP] = { 1, 0, receive_bitmap } ,
4120 [P_COMPRESSED_BITMAP] = { 1, 0, receive_bitmap } ,
4121 [P_UNPLUG_REMOTE] = { 0, 0, receive_UnplugRemote },
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004122 [P_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
4123 [P_RS_DATA_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004124 [P_SYNC_PARAM] = { 1, 0, receive_SyncParam },
4125 [P_SYNC_PARAM89] = { 1, 0, receive_SyncParam },
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004126 [P_PROTOCOL] = { 1, sizeof(struct p_protocol), receive_protocol },
4127 [P_UUIDS] = { 0, sizeof(struct p_uuids), receive_uuids },
4128 [P_SIZES] = { 0, sizeof(struct p_sizes), receive_sizes },
4129 [P_STATE] = { 0, sizeof(struct p_state), receive_state },
4130 [P_STATE_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_state },
4131 [P_SYNC_UUID] = { 0, sizeof(struct p_rs_uuid), receive_sync_uuid },
4132 [P_OV_REQUEST] = { 0, sizeof(struct p_block_req), receive_DataRequest },
4133 [P_OV_REPLY] = { 1, sizeof(struct p_block_req), receive_DataRequest },
4134 [P_CSUM_RS_REQUEST] = { 1, sizeof(struct p_block_req), receive_DataRequest },
4135 [P_DELAY_PROBE] = { 0, sizeof(struct p_delay_probe93), receive_skip },
4136 [P_OUT_OF_SYNC] = { 0, sizeof(struct p_block_desc), receive_out_of_sync },
4137 [P_CONN_ST_CHG_REQ] = { 0, sizeof(struct p_req_state), receive_req_conn_state },
Philipp Reisner02918be2010-08-20 14:35:10 +02004138};
4139
Philipp Reisnereefc2f72011-02-08 12:55:24 +01004140static void drbdd(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004141{
Philipp Reisner77351055b2011-02-07 17:24:26 +01004142 struct packet_info pi;
Philipp Reisner02918be2010-08-20 14:35:10 +02004143 size_t shs; /* sub header size */
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004144 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004145
Philipp Reisnereefc2f72011-02-08 12:55:24 +01004146 while (get_t_state(&tconn->receiver) == RUNNING) {
Andreas Gruenbacherdeebe192011-03-25 00:01:04 +01004147 struct data_cmd *cmd;
4148
Philipp Reisnereefc2f72011-02-08 12:55:24 +01004149 drbd_thread_current_set_cpu(&tconn->receiver);
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01004150 if (drbd_recv_header(tconn, &pi))
Philipp Reisner02918be2010-08-20 14:35:10 +02004151 goto err_out;
4152
Andreas Gruenbacherdeebe192011-03-25 00:01:04 +01004153 cmd = &drbd_cmd_handler[pi.cmd];
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004154 if (unlikely(pi.cmd >= ARRAY_SIZE(drbd_cmd_handler) || !cmd->fn)) {
Philipp Reisnereefc2f72011-02-08 12:55:24 +01004155 conn_err(tconn, "unknown packet type %d, l: %d!\n", pi.cmd, pi.size);
Philipp Reisner02918be2010-08-20 14:35:10 +02004156 goto err_out;
Lars Ellenberg0b33a912009-11-16 15:58:04 +01004157 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004158
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004159 shs = cmd->pkt_size;
4160 if (pi.size > shs && !cmd->expect_payload) {
Philipp Reisnereefc2f72011-02-08 12:55:24 +01004161 conn_err(tconn, "No payload expected %s l:%d\n", cmdname(pi.cmd), pi.size);
Philipp Reisner02918be2010-08-20 14:35:10 +02004162 goto err_out;
4163 }
4164
Lars Ellenbergc13f7e12010-10-29 23:32:01 +02004165 if (shs) {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004166 err = drbd_recv_all_warn(tconn, pi.data, shs);
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01004167 if (err)
Lars Ellenbergc13f7e12010-10-29 23:32:01 +02004168 goto err_out;
Andreas Gruenbachere2857212011-03-25 00:57:38 +01004169 pi.size -= shs;
Lars Ellenbergc13f7e12010-10-29 23:32:01 +02004170 }
4171
Andreas Gruenbacher4a76b162011-03-25 02:43:51 +01004172 err = cmd->fn(tconn, &pi);
4173 if (err) {
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004174 conn_err(tconn, "error receiving %s, e: %d l: %d!\n",
4175 cmdname(pi.cmd), err, pi.size);
Philipp Reisner02918be2010-08-20 14:35:10 +02004176 goto err_out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004177 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004178 }
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004179 return;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004180
Andreas Gruenbacher82bc0192011-03-17 12:10:19 +01004181 err_out:
4182 conn_request_state(tconn, NS(conn, C_PROTOCOL_ERROR), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004183}
4184
Philipp Reisner0e29d162011-02-18 14:23:11 +01004185void conn_flush_workqueue(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004186{
4187 struct drbd_wq_barrier barr;
4188
4189 barr.w.cb = w_prev_work_done;
Philipp Reisner0e29d162011-02-18 14:23:11 +01004190 barr.w.tconn = tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004191 init_completion(&barr.done);
Philipp Reisner0e29d162011-02-18 14:23:11 +01004192 drbd_queue_work(&tconn->data.work, &barr.w);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004193 wait_for_completion(&barr.done);
4194}
4195
Philipp Reisner360cc742011-02-08 14:29:53 +01004196static void drbd_disconnect(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004197{
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01004198 enum drbd_conns oc;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004199 int rv = SS_UNKNOWN_ERROR;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004200
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01004201 if (tconn->cstate == C_STANDALONE)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004202 return;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004203
4204 /* asender does not clean up anything. it must not interfere, either */
Philipp Reisner360cc742011-02-08 14:29:53 +01004205 drbd_thread_stop(&tconn->asender);
4206 drbd_free_sock(tconn);
4207
Philipp Reisnerd3fcb492011-04-13 14:46:05 -07004208 down_read(&drbd_cfg_rwsem);
Philipp Reisner360cc742011-02-08 14:29:53 +01004209 idr_for_each(&tconn->volumes, drbd_disconnected, tconn);
Philipp Reisnerd3fcb492011-04-13 14:46:05 -07004210 up_read(&drbd_cfg_rwsem);
Philipp Reisner360cc742011-02-08 14:29:53 +01004211 conn_info(tconn, "Connection closed\n");
4212
Philipp Reisnercb703452011-03-24 11:03:07 +01004213 if (conn_highest_role(tconn) == R_PRIMARY && conn_highest_pdsk(tconn) >= D_UNKNOWN)
4214 conn_try_outdate_peer_async(tconn);
4215
Philipp Reisner360cc742011-02-08 14:29:53 +01004216 spin_lock_irq(&tconn->req_lock);
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01004217 oc = tconn->cstate;
4218 if (oc >= C_UNCONNECTED)
4219 rv = _conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
4220
Philipp Reisner360cc742011-02-08 14:29:53 +01004221 spin_unlock_irq(&tconn->req_lock);
4222
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01004223 if (oc == C_DISCONNECTING) {
Philipp Reisner91fd4da2011-04-20 17:47:29 +02004224 struct net_conf *old_conf;
Philipp Reisner360cc742011-02-08 14:29:53 +01004225
Philipp Reisner91fd4da2011-04-20 17:47:29 +02004226 mutex_lock(&tconn->net_conf_update);
4227 old_conf = tconn->net_conf;
4228 rcu_assign_pointer(tconn->net_conf, NULL);
4229 conn_free_crypto(tconn);
4230 mutex_unlock(&tconn->net_conf_update);
Philipp Reisner360cc742011-02-08 14:29:53 +01004231
Philipp Reisner91fd4da2011-04-20 17:47:29 +02004232 synchronize_rcu();
4233 kfree(old_conf);
4234
Lars Ellenbergd9cc6e22011-04-27 10:25:28 +02004235 conn_request_state(tconn, NS(conn, C_STANDALONE), CS_VERBOSE | CS_HARD);
Philipp Reisner360cc742011-02-08 14:29:53 +01004236 }
4237}
4238
4239static int drbd_disconnected(int vnr, void *p, void *data)
4240{
4241 struct drbd_conf *mdev = (struct drbd_conf *)p;
4242 enum drbd_fencing_p fp;
4243 unsigned int i;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004244
Philipp Reisner85719572010-07-21 10:20:17 +02004245 /* wait for current activity to cease. */
Philipp Reisner87eeee42011-01-19 14:16:30 +01004246 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004247 _drbd_wait_ee_list_empty(mdev, &mdev->active_ee);
4248 _drbd_wait_ee_list_empty(mdev, &mdev->sync_ee);
4249 _drbd_wait_ee_list_empty(mdev, &mdev->read_ee);
Philipp Reisner87eeee42011-01-19 14:16:30 +01004250 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004251
4252 /* We do not have data structures that would allow us to
4253 * get the rs_pending_cnt down to 0 again.
4254 * * On C_SYNC_TARGET we do not have any data structures describing
4255 * the pending RSDataRequest's we have sent.
4256 * * On C_SYNC_SOURCE there is no data structure that tracks
4257 * the P_RS_DATA_REPLY blocks that we sent to the SyncTarget.
4258 * And no, it is not the sum of the reference counts in the
4259 * resync_LRU. The resync_LRU tracks the whole operation including
4260 * the disk-IO, while the rs_pending_cnt only tracks the blocks
4261 * on the fly. */
4262 drbd_rs_cancel_all(mdev);
4263 mdev->rs_total = 0;
4264 mdev->rs_failed = 0;
4265 atomic_set(&mdev->rs_pending_cnt, 0);
4266 wake_up(&mdev->misc_wait);
4267
Philipp Reisner7fde2be2011-03-01 11:08:28 +01004268 del_timer(&mdev->request_timer);
4269
Philipp Reisnerb411b362009-09-25 16:07:19 -07004270 del_timer_sync(&mdev->resync_timer);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004271 resync_timer_fn((unsigned long)mdev);
4272
Philipp Reisnerb411b362009-09-25 16:07:19 -07004273 /* wait for all w_e_end_data_req, w_e_end_rsdata_req, w_send_barrier,
4274 * w_make_resync_request etc. which may still be on the worker queue
4275 * to be "canceled" */
Philipp Reisnera21e9292011-02-08 15:08:49 +01004276 drbd_flush_workqueue(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004277
Andreas Gruenbachera990be42011-04-06 17:56:48 +02004278 drbd_finish_peer_reqs(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004279
4280 kfree(mdev->p_uuid);
4281 mdev->p_uuid = NULL;
4282
Philipp Reisner2aebfab2011-03-28 16:48:11 +02004283 if (!drbd_suspended(mdev))
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01004284 tl_clear(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004285
Philipp Reisnerb411b362009-09-25 16:07:19 -07004286 drbd_md_sync(mdev);
4287
4288 fp = FP_DONT_CARE;
4289 if (get_ldev(mdev)) {
4290 fp = mdev->ldev->dc.fencing;
4291 put_ldev(mdev);
4292 }
4293
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01004294 /* serialize with bitmap writeout triggered by the state change,
4295 * if any. */
4296 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
4297
Philipp Reisnerb411b362009-09-25 16:07:19 -07004298 /* tcp_close and release of sendpage pages can be deferred. I don't
4299 * want to use SO_LINGER, because apparently it can be deferred for
4300 * more than 20 seconds (longest time I checked).
4301 *
4302 * Actually we don't care for exactly when the network stack does its
4303 * put_page(), but release our reference on these pages right here.
4304 */
Andreas Gruenbacher7721f562011-04-06 17:14:02 +02004305 i = drbd_free_peer_reqs(mdev, &mdev->net_ee);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004306 if (i)
4307 dev_info(DEV, "net_ee not empty, killed %u entries\n", i);
Lars Ellenberg435f0742010-09-06 12:30:25 +02004308 i = atomic_read(&mdev->pp_in_use_by_net);
4309 if (i)
4310 dev_info(DEV, "pp_in_use_by_net = %d, expected 0\n", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004311 i = atomic_read(&mdev->pp_in_use);
4312 if (i)
Lars Ellenberg45bb9122010-05-14 17:10:48 +02004313 dev_info(DEV, "pp_in_use = %d, expected 0\n", i);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004314
4315 D_ASSERT(list_empty(&mdev->read_ee));
4316 D_ASSERT(list_empty(&mdev->active_ee));
4317 D_ASSERT(list_empty(&mdev->sync_ee));
4318 D_ASSERT(list_empty(&mdev->done_ee));
4319
4320 /* ok, no more ee's on the fly, it is safe to reset the epoch_size */
4321 atomic_set(&mdev->current_epoch->epoch_size, 0);
4322 D_ASSERT(list_empty(&mdev->current_epoch->list));
Philipp Reisner360cc742011-02-08 14:29:53 +01004323
4324 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004325}
4326
4327/*
4328 * We support PRO_VERSION_MIN to PRO_VERSION_MAX. The protocol version
4329 * we can agree on is stored in agreed_pro_version.
4330 *
4331 * feature flags and the reserved array should be enough room for future
4332 * enhancements of the handshake protocol, and possible plugins...
4333 *
4334 * for now, they are expected to be zero, but ignored.
4335 */
Andreas Gruenbacher60381782011-03-28 17:05:50 +02004336static int drbd_send_features(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004337{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004338 struct drbd_socket *sock;
4339 struct p_connection_features *p;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004340
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004341 sock = &tconn->data;
4342 p = conn_prepare_command(tconn, sock);
4343 if (!p)
Andreas Gruenbachere8d17b02011-03-16 00:54:19 +01004344 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004345 memset(p, 0, sizeof(*p));
4346 p->protocol_min = cpu_to_be32(PRO_VERSION_MIN);
4347 p->protocol_max = cpu_to_be32(PRO_VERSION_MAX);
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004348 return conn_send_command(tconn, sock, P_CONNECTION_FEATURES, sizeof(*p), NULL, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004349}
4350
4351/*
4352 * return values:
4353 * 1 yes, we have a valid connection
4354 * 0 oops, did not work out, please try again
4355 * -1 peer talks different language,
4356 * no point in trying again, please go standalone.
4357 */
Andreas Gruenbacher60381782011-03-28 17:05:50 +02004358static int drbd_do_features(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004359{
Philipp Reisner65d11ed2011-02-07 17:35:59 +01004360 /* ASSERT current == tconn->receiver ... */
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004361 struct p_connection_features *p;
4362 const int expect = sizeof(struct p_connection_features);
Philipp Reisner77351055b2011-02-07 17:24:26 +01004363 struct packet_info pi;
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01004364 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004365
Andreas Gruenbacher60381782011-03-28 17:05:50 +02004366 err = drbd_send_features(tconn);
Andreas Gruenbachere8d17b02011-03-16 00:54:19 +01004367 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004368 return 0;
4369
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01004370 err = drbd_recv_header(tconn, &pi);
4371 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004372 return 0;
4373
Andreas Gruenbacher60381782011-03-28 17:05:50 +02004374 if (pi.cmd != P_CONNECTION_FEATURES) {
4375 conn_err(tconn, "expected ConnectionFeatures packet, received: %s (0x%04x)\n",
Philipp Reisner77351055b2011-02-07 17:24:26 +01004376 cmdname(pi.cmd), pi.cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004377 return -1;
4378 }
4379
Philipp Reisner77351055b2011-02-07 17:24:26 +01004380 if (pi.size != expect) {
Andreas Gruenbacher60381782011-03-28 17:05:50 +02004381 conn_err(tconn, "expected ConnectionFeatures length: %u, received: %u\n",
Philipp Reisner77351055b2011-02-07 17:24:26 +01004382 expect, pi.size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004383 return -1;
4384 }
4385
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004386 p = pi.data;
4387 err = drbd_recv_all_warn(tconn, p, expect);
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01004388 if (err)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004389 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004390
Philipp Reisnerb411b362009-09-25 16:07:19 -07004391 p->protocol_min = be32_to_cpu(p->protocol_min);
4392 p->protocol_max = be32_to_cpu(p->protocol_max);
4393 if (p->protocol_max == 0)
4394 p->protocol_max = p->protocol_min;
4395
4396 if (PRO_VERSION_MAX < p->protocol_min ||
4397 PRO_VERSION_MIN > p->protocol_max)
4398 goto incompat;
4399
Philipp Reisner65d11ed2011-02-07 17:35:59 +01004400 tconn->agreed_pro_version = min_t(int, PRO_VERSION_MAX, p->protocol_max);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004401
Philipp Reisner65d11ed2011-02-07 17:35:59 +01004402 conn_info(tconn, "Handshake successful: "
4403 "Agreed network protocol version %d\n", tconn->agreed_pro_version);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004404
4405 return 1;
4406
4407 incompat:
Philipp Reisner65d11ed2011-02-07 17:35:59 +01004408 conn_err(tconn, "incompatible DRBD dialects: "
Philipp Reisnerb411b362009-09-25 16:07:19 -07004409 "I support %d-%d, peer supports %d-%d\n",
4410 PRO_VERSION_MIN, PRO_VERSION_MAX,
4411 p->protocol_min, p->protocol_max);
4412 return -1;
4413}
4414
4415#if !defined(CONFIG_CRYPTO_HMAC) && !defined(CONFIG_CRYPTO_HMAC_MODULE)
Philipp Reisner13e60372011-02-08 09:54:40 +01004416static int drbd_do_auth(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004417{
4418 dev_err(DEV, "This kernel was build without CONFIG_CRYPTO_HMAC.\n");
4419 dev_err(DEV, "You need to disable 'cram-hmac-alg' in drbd.conf.\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004420 return -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004421}
4422#else
4423#define CHALLENGE_LEN 64
Johannes Thomab10d96c2010-01-07 16:02:50 +01004424
4425/* Return value:
4426 1 - auth succeeded,
4427 0 - failed, try again (network error),
4428 -1 - auth failed, don't try again.
4429*/
4430
Philipp Reisner13e60372011-02-08 09:54:40 +01004431static int drbd_do_auth(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004432{
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004433 struct drbd_socket *sock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004434 char my_challenge[CHALLENGE_LEN]; /* 64 Bytes... */
4435 struct scatterlist sg;
4436 char *response = NULL;
4437 char *right_response = NULL;
4438 char *peers_ch = NULL;
Philipp Reisner44ed1672011-04-19 17:10:19 +02004439 unsigned int key_len;
4440 char secret[SHARED_SECRET_MAX]; /* 64 byte */
Philipp Reisnerb411b362009-09-25 16:07:19 -07004441 unsigned int resp_size;
4442 struct hash_desc desc;
Philipp Reisner77351055b2011-02-07 17:24:26 +01004443 struct packet_info pi;
Philipp Reisner44ed1672011-04-19 17:10:19 +02004444 struct net_conf *nc;
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01004445 int err, rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004446
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004447 /* FIXME: Put the challenge/response into the preallocated socket buffer. */
4448
Philipp Reisner44ed1672011-04-19 17:10:19 +02004449 rcu_read_lock();
4450 nc = rcu_dereference(tconn->net_conf);
4451 key_len = strlen(nc->shared_secret);
4452 memcpy(secret, nc->shared_secret, key_len);
4453 rcu_read_unlock();
4454
Philipp Reisner13e60372011-02-08 09:54:40 +01004455 desc.tfm = tconn->cram_hmac_tfm;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004456 desc.flags = 0;
4457
Philipp Reisner44ed1672011-04-19 17:10:19 +02004458 rv = crypto_hash_setkey(tconn->cram_hmac_tfm, (u8 *)secret, key_len);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004459 if (rv) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004460 conn_err(tconn, "crypto_hash_setkey() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004461 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004462 goto fail;
4463 }
4464
4465 get_random_bytes(my_challenge, CHALLENGE_LEN);
4466
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004467 sock = &tconn->data;
4468 if (!conn_prepare_command(tconn, sock)) {
4469 rv = 0;
4470 goto fail;
4471 }
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004472 rv = !conn_send_command(tconn, sock, P_AUTH_CHALLENGE, 0,
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004473 my_challenge, CHALLENGE_LEN);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004474 if (!rv)
4475 goto fail;
4476
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01004477 err = drbd_recv_header(tconn, &pi);
4478 if (err) {
4479 rv = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004480 goto fail;
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01004481 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004482
Philipp Reisner77351055b2011-02-07 17:24:26 +01004483 if (pi.cmd != P_AUTH_CHALLENGE) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004484 conn_err(tconn, "expected AuthChallenge packet, received: %s (0x%04x)\n",
Philipp Reisner77351055b2011-02-07 17:24:26 +01004485 cmdname(pi.cmd), pi.cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004486 rv = 0;
4487 goto fail;
4488 }
4489
Philipp Reisner77351055b2011-02-07 17:24:26 +01004490 if (pi.size > CHALLENGE_LEN * 2) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004491 conn_err(tconn, "expected AuthChallenge payload too big.\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004492 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004493 goto fail;
4494 }
4495
Philipp Reisner77351055b2011-02-07 17:24:26 +01004496 peers_ch = kmalloc(pi.size, GFP_NOIO);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004497 if (peers_ch == NULL) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004498 conn_err(tconn, "kmalloc of peers_ch failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004499 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004500 goto fail;
4501 }
4502
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01004503 err = drbd_recv_all_warn(tconn, peers_ch, pi.size);
4504 if (err) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004505 rv = 0;
4506 goto fail;
4507 }
4508
Philipp Reisner13e60372011-02-08 09:54:40 +01004509 resp_size = crypto_hash_digestsize(tconn->cram_hmac_tfm);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004510 response = kmalloc(resp_size, GFP_NOIO);
4511 if (response == NULL) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004512 conn_err(tconn, "kmalloc of response failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004513 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004514 goto fail;
4515 }
4516
4517 sg_init_table(&sg, 1);
Philipp Reisner77351055b2011-02-07 17:24:26 +01004518 sg_set_buf(&sg, peers_ch, pi.size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004519
4520 rv = crypto_hash_digest(&desc, &sg, sg.length, response);
4521 if (rv) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004522 conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004523 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004524 goto fail;
4525 }
4526
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004527 if (!conn_prepare_command(tconn, sock)) {
4528 rv = 0;
4529 goto fail;
4530 }
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004531 rv = !conn_send_command(tconn, sock, P_AUTH_RESPONSE, 0,
Andreas Gruenbacher9f5bdc32011-03-28 14:23:08 +02004532 response, resp_size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004533 if (!rv)
4534 goto fail;
4535
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01004536 err = drbd_recv_header(tconn, &pi);
4537 if (err) {
4538 rv = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004539 goto fail;
Andreas Gruenbacher69bc7bc2011-03-16 17:31:52 +01004540 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004541
Philipp Reisner77351055b2011-02-07 17:24:26 +01004542 if (pi.cmd != P_AUTH_RESPONSE) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004543 conn_err(tconn, "expected AuthResponse packet, received: %s (0x%04x)\n",
Philipp Reisner77351055b2011-02-07 17:24:26 +01004544 cmdname(pi.cmd), pi.cmd);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004545 rv = 0;
4546 goto fail;
4547 }
4548
Philipp Reisner77351055b2011-02-07 17:24:26 +01004549 if (pi.size != resp_size) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004550 conn_err(tconn, "expected AuthResponse payload of wrong size\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07004551 rv = 0;
4552 goto fail;
4553 }
4554
Andreas Gruenbachera5c31902011-03-24 03:28:04 +01004555 err = drbd_recv_all_warn(tconn, response , resp_size);
4556 if (err) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004557 rv = 0;
4558 goto fail;
4559 }
4560
4561 right_response = kmalloc(resp_size, GFP_NOIO);
Julia Lawall2d1ee872009-12-27 22:27:11 +01004562 if (right_response == NULL) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004563 conn_err(tconn, "kmalloc of right_response failed\n");
Johannes Thomab10d96c2010-01-07 16:02:50 +01004564 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004565 goto fail;
4566 }
4567
4568 sg_set_buf(&sg, my_challenge, CHALLENGE_LEN);
4569
4570 rv = crypto_hash_digest(&desc, &sg, sg.length, right_response);
4571 if (rv) {
Philipp Reisner13e60372011-02-08 09:54:40 +01004572 conn_err(tconn, "crypto_hash_digest() failed with %d\n", rv);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004573 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004574 goto fail;
4575 }
4576
4577 rv = !memcmp(response, right_response, resp_size);
4578
4579 if (rv)
Philipp Reisner44ed1672011-04-19 17:10:19 +02004580 conn_info(tconn, "Peer authenticated using %d bytes HMAC\n",
4581 resp_size);
Johannes Thomab10d96c2010-01-07 16:02:50 +01004582 else
4583 rv = -1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004584
4585 fail:
4586 kfree(peers_ch);
4587 kfree(response);
4588 kfree(right_response);
4589
4590 return rv;
4591}
4592#endif
4593
4594int drbdd_init(struct drbd_thread *thi)
4595{
Philipp Reisner392c8802011-02-09 10:33:31 +01004596 struct drbd_tconn *tconn = thi->tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004597 int h;
4598
Philipp Reisner4d641dd2011-02-08 15:40:24 +01004599 conn_info(tconn, "receiver (re)started\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07004600
4601 do {
Philipp Reisner4d641dd2011-02-08 15:40:24 +01004602 h = drbd_connect(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004603 if (h == 0) {
Philipp Reisner4d641dd2011-02-08 15:40:24 +01004604 drbd_disconnect(tconn);
Philipp Reisner20ee6392011-01-18 15:28:59 +01004605 schedule_timeout_interruptible(HZ);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004606 }
4607 if (h == -1) {
Philipp Reisner4d641dd2011-02-08 15:40:24 +01004608 conn_warn(tconn, "Discarding network configuration.\n");
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01004609 conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004610 }
4611 } while (h == 0);
4612
Philipp Reisner91fd4da2011-04-20 17:47:29 +02004613 if (h > 0)
4614 drbdd(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004615
Philipp Reisner4d641dd2011-02-08 15:40:24 +01004616 drbd_disconnect(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004617
Philipp Reisner4d641dd2011-02-08 15:40:24 +01004618 conn_info(tconn, "receiver terminated\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07004619 return 0;
4620}
4621
4622/* ********* acknowledge sender ******** */
4623
Andreas Gruenbachere05e1e52011-03-25 15:16:26 +01004624static int got_conn_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnere4f78ed2011-03-16 11:27:48 +01004625{
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004626 struct p_req_state_reply *p = pi->data;
Philipp Reisnere4f78ed2011-03-16 11:27:48 +01004627 int retcode = be32_to_cpu(p->retcode);
4628
4629 if (retcode >= SS_SUCCESS) {
4630 set_bit(CONN_WD_ST_CHG_OKAY, &tconn->flags);
4631 } else {
4632 set_bit(CONN_WD_ST_CHG_FAIL, &tconn->flags);
4633 conn_err(tconn, "Requested state change failed by peer: %s (%d)\n",
4634 drbd_set_st_err_str(retcode), retcode);
4635 }
4636 wake_up(&tconn->ping_wait);
4637
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004638 return 0;
Philipp Reisnere4f78ed2011-03-16 11:27:48 +01004639}
4640
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004641static int got_RqSReply(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004642{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004643 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004644 struct p_req_state_reply *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004645 int retcode = be32_to_cpu(p->retcode);
4646
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004647 mdev = vnr_to_mdev(tconn, pi->vnr);
4648 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004649 return -EIO;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004650
Philipp Reisnere4f78ed2011-03-16 11:27:48 +01004651 if (retcode >= SS_SUCCESS) {
4652 set_bit(CL_ST_CHG_SUCCESS, &mdev->flags);
4653 } else {
4654 set_bit(CL_ST_CHG_FAIL, &mdev->flags);
4655 dev_err(DEV, "Requested state change failed by peer: %s (%d)\n",
4656 drbd_set_st_err_str(retcode), retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004657 }
Philipp Reisnere4f78ed2011-03-16 11:27:48 +01004658 wake_up(&mdev->state_wait);
4659
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004660 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004661}
4662
Andreas Gruenbachere05e1e52011-03-25 15:16:26 +01004663static int got_Ping(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004664{
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004665 return drbd_send_ping_ack(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004666
4667}
4668
Andreas Gruenbachere05e1e52011-03-25 15:16:26 +01004669static int got_PingAck(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004670{
4671 /* restore idle timeout */
Philipp Reisner2a67d8b2011-02-09 14:10:32 +01004672 tconn->meta.socket->sk->sk_rcvtimeo = tconn->net_conf->ping_int*HZ;
4673 if (!test_and_set_bit(GOT_PING_ACK, &tconn->flags))
4674 wake_up(&tconn->ping_wait);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004675
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004676 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004677}
4678
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004679static int got_IsInSync(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004680{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004681 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004682 struct p_block_ack *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004683 sector_t sector = be64_to_cpu(p->sector);
4684 int blksize = be32_to_cpu(p->blksize);
4685
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004686 mdev = vnr_to_mdev(tconn, pi->vnr);
4687 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004688 return -EIO;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004689
Philipp Reisner31890f42011-01-19 14:12:51 +01004690 D_ASSERT(mdev->tconn->agreed_pro_version >= 89);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004691
4692 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4693
Lars Ellenberg1d53f092010-09-05 01:13:24 +02004694 if (get_ldev(mdev)) {
4695 drbd_rs_complete_io(mdev, sector);
4696 drbd_set_in_sync(mdev, sector, blksize);
4697 /* rs_same_csums is supposed to count in units of BM_BLOCK_SIZE */
4698 mdev->rs_same_csum += (blksize >> BM_BLOCK_SHIFT);
4699 put_ldev(mdev);
4700 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004701 dec_rs_pending(mdev);
Philipp Reisner778f2712010-07-06 11:14:00 +02004702 atomic_add(blksize >> 9, &mdev->rs_sect_in);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004703
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004704 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004705}
4706
Andreas Gruenbacherbc9c5c42011-01-21 18:00:55 +01004707static int
4708validate_req_change_req_state(struct drbd_conf *mdev, u64 id, sector_t sector,
4709 struct rb_root *root, const char *func,
4710 enum drbd_req_event what, bool missing_ok)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004711{
4712 struct drbd_request *req;
4713 struct bio_and_error m;
4714
Philipp Reisner87eeee42011-01-19 14:16:30 +01004715 spin_lock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacherbc9c5c42011-01-21 18:00:55 +01004716 req = find_request(mdev, root, id, sector, missing_ok, func);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004717 if (unlikely(!req)) {
Philipp Reisner87eeee42011-01-19 14:16:30 +01004718 spin_unlock_irq(&mdev->tconn->req_lock);
Andreas Gruenbacher85997672011-04-04 13:09:15 +02004719 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004720 }
4721 __req_mod(req, what, &m);
Philipp Reisner87eeee42011-01-19 14:16:30 +01004722 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004723
4724 if (m.bio)
4725 complete_master_bio(mdev, &m);
Andreas Gruenbacher85997672011-04-04 13:09:15 +02004726 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004727}
4728
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004729static int got_BlockAck(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004730{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004731 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004732 struct p_block_ack *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004733 sector_t sector = be64_to_cpu(p->sector);
4734 int blksize = be32_to_cpu(p->blksize);
4735 enum drbd_req_event what;
4736
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004737 mdev = vnr_to_mdev(tconn, pi->vnr);
4738 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004739 return -EIO;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004740
Philipp Reisnerb411b362009-09-25 16:07:19 -07004741 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4742
Andreas Gruenbacher579b57e2011-01-13 18:40:57 +01004743 if (p->block_id == ID_SYNCER) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004744 drbd_set_in_sync(mdev, sector, blksize);
4745 dec_rs_pending(mdev);
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004746 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004747 }
Andreas Gruenbachere05e1e52011-03-25 15:16:26 +01004748 switch (pi->cmd) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004749 case P_RS_WRITE_ACK:
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01004750 what = WRITE_ACKED_BY_PEER_AND_SIS;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004751 break;
4752 case P_WRITE_ACK:
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01004753 what = WRITE_ACKED_BY_PEER;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004754 break;
4755 case P_RECV_ACK:
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01004756 what = RECV_ACKED_BY_PEER;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004757 break;
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01004758 case P_DISCARD_WRITE:
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01004759 what = DISCARD_WRITE;
4760 break;
4761 case P_RETRY_WRITE:
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01004762 what = POSTPONE_WRITE;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004763 break;
4764 default:
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004765 BUG();
Philipp Reisnerb411b362009-09-25 16:07:19 -07004766 }
4767
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004768 return validate_req_change_req_state(mdev, p->block_id, sector,
4769 &mdev->write_requests, __func__,
4770 what, false);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004771}
4772
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004773static int got_NegAck(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004774{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004775 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004776 struct p_block_ack *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004777 sector_t sector = be64_to_cpu(p->sector);
Philipp Reisner2deb8332011-01-17 18:39:18 +01004778 int size = be32_to_cpu(p->blksize);
Andreas Gruenbacher85997672011-04-04 13:09:15 +02004779 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004780
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004781 mdev = vnr_to_mdev(tconn, pi->vnr);
4782 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004783 return -EIO;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004784
Philipp Reisnerb411b362009-09-25 16:07:19 -07004785 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4786
Andreas Gruenbacher579b57e2011-01-13 18:40:57 +01004787 if (p->block_id == ID_SYNCER) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004788 dec_rs_pending(mdev);
4789 drbd_rs_failed_io(mdev, sector, size);
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004790 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004791 }
Philipp Reisner2deb8332011-01-17 18:39:18 +01004792
Andreas Gruenbacher85997672011-04-04 13:09:15 +02004793 err = validate_req_change_req_state(mdev, p->block_id, sector,
4794 &mdev->write_requests, __func__,
Philipp Reisner303d1442011-04-13 16:24:47 -07004795 NEG_ACKED, true);
Andreas Gruenbacher85997672011-04-04 13:09:15 +02004796 if (err) {
Andreas Gruenbacherc3afd8f2011-01-20 22:25:40 +01004797 /* Protocol A has no P_WRITE_ACKs, but has P_NEG_ACKs.
4798 The master bio might already be completed, therefore the
4799 request is no longer in the collision hash. */
4800 /* In Protocol B we might already have got a P_RECV_ACK
4801 but then get a P_NEG_ACK afterwards. */
Andreas Gruenbacherc3afd8f2011-01-20 22:25:40 +01004802 drbd_set_out_of_sync(mdev, sector, size);
Philipp Reisner2deb8332011-01-17 18:39:18 +01004803 }
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004804 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004805}
4806
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004807static int got_NegDReply(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004808{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004809 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004810 struct p_block_ack *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004811 sector_t sector = be64_to_cpu(p->sector);
4812
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004813 mdev = vnr_to_mdev(tconn, pi->vnr);
4814 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004815 return -EIO;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004816
Philipp Reisnerb411b362009-09-25 16:07:19 -07004817 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
Andreas Gruenbacher7be8da02011-02-22 02:15:32 +01004818
Philipp Reisnerb411b362009-09-25 16:07:19 -07004819 dev_err(DEV, "Got NegDReply; Sector %llus, len %u; Fail original request.\n",
4820 (unsigned long long)sector, be32_to_cpu(p->blksize));
4821
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004822 return validate_req_change_req_state(mdev, p->block_id, sector,
4823 &mdev->read_requests, __func__,
4824 NEG_ACKED, false);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004825}
4826
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004827static int got_NegRSDReply(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004828{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004829 struct drbd_conf *mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004830 sector_t sector;
4831 int size;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004832 struct p_block_ack *p = pi->data;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004833
4834 mdev = vnr_to_mdev(tconn, pi->vnr);
4835 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004836 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004837
4838 sector = be64_to_cpu(p->sector);
4839 size = be32_to_cpu(p->blksize);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004840
4841 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4842
4843 dec_rs_pending(mdev);
4844
4845 if (get_ldev_if_state(mdev, D_FAILED)) {
4846 drbd_rs_complete_io(mdev, sector);
Andreas Gruenbachere05e1e52011-03-25 15:16:26 +01004847 switch (pi->cmd) {
Philipp Reisnerd612d302010-12-27 10:53:28 +01004848 case P_NEG_RS_DREPLY:
4849 drbd_rs_failed_io(mdev, sector, size);
4850 case P_RS_CANCEL:
4851 break;
4852 default:
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004853 BUG();
Philipp Reisnerd612d302010-12-27 10:53:28 +01004854 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07004855 put_ldev(mdev);
4856 }
4857
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004858 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004859}
4860
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004861static int got_BarrierAck(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004862{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004863 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004864 struct p_barrier_ack *p = pi->data;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004865
4866 mdev = vnr_to_mdev(tconn, pi->vnr);
4867 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004868 return -EIO;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004869
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01004870 tl_release(mdev->tconn, p->barrier, be32_to_cpu(p->set_size));
Philipp Reisnerb411b362009-09-25 16:07:19 -07004871
Philipp Reisnerc4752ef2010-10-27 17:32:36 +02004872 if (mdev->state.conn == C_AHEAD &&
4873 atomic_read(&mdev->ap_in_flight) == 0 &&
Philipp Reisner370a43e2011-01-14 16:03:11 +01004874 !test_and_set_bit(AHEAD_TO_SYNC_SOURCE, &mdev->current_epoch->flags)) {
4875 mdev->start_resync_timer.expires = jiffies + HZ;
4876 add_timer(&mdev->start_resync_timer);
Philipp Reisnerc4752ef2010-10-27 17:32:36 +02004877 }
4878
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004879 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004880}
4881
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004882static int got_OVResult(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisnerb411b362009-09-25 16:07:19 -07004883{
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004884 struct drbd_conf *mdev;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004885 struct p_block_ack *p = pi->data;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004886 struct drbd_work *w;
4887 sector_t sector;
4888 int size;
4889
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004890 mdev = vnr_to_mdev(tconn, pi->vnr);
4891 if (!mdev)
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004892 return -EIO;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004893
Philipp Reisnerb411b362009-09-25 16:07:19 -07004894 sector = be64_to_cpu(p->sector);
4895 size = be32_to_cpu(p->blksize);
4896
4897 update_peer_seq(mdev, be32_to_cpu(p->seq_num));
4898
4899 if (be64_to_cpu(p->block_id) == ID_OUT_OF_SYNC)
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01004900 drbd_ov_out_of_sync_found(mdev, sector, size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004901 else
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01004902 ov_out_of_sync_print(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004903
Lars Ellenberg1d53f092010-09-05 01:13:24 +02004904 if (!get_ldev(mdev))
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004905 return 0;
Lars Ellenberg1d53f092010-09-05 01:13:24 +02004906
Philipp Reisnerb411b362009-09-25 16:07:19 -07004907 drbd_rs_complete_io(mdev, sector);
4908 dec_rs_pending(mdev);
4909
Lars Ellenbergea5442a2010-11-05 09:48:01 +01004910 --mdev->ov_left;
4911
4912 /* let's advance progress step marks only for every other megabyte */
4913 if ((mdev->ov_left & 0x200) == 0x200)
4914 drbd_advance_rs_marks(mdev, mdev->ov_left);
4915
4916 if (mdev->ov_left == 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07004917 w = kmalloc(sizeof(*w), GFP_NOIO);
4918 if (w) {
4919 w->cb = w_ov_finished;
Philipp Reisnera21e9292011-02-08 15:08:49 +01004920 w->mdev = mdev;
Philipp Reisnere42325a2011-01-19 13:55:45 +01004921 drbd_queue_work_front(&mdev->tconn->data.work, w);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004922 } else {
4923 dev_err(DEV, "kmalloc(w) failed.");
Andreas Gruenbacher8f7bed72010-12-19 23:53:14 +01004924 ov_out_of_sync_print(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07004925 drbd_resync_finished(mdev);
4926 }
4927 }
Lars Ellenberg1d53f092010-09-05 01:13:24 +02004928 put_ldev(mdev);
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004929 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004930}
4931
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004932static int got_skip(struct drbd_tconn *tconn, struct packet_info *pi)
Philipp Reisner0ced55a2010-04-30 15:26:20 +02004933{
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02004934 return 0;
Philipp Reisner0ced55a2010-04-30 15:26:20 +02004935}
4936
Andreas Gruenbachera990be42011-04-06 17:56:48 +02004937static int tconn_finish_peer_reqs(struct drbd_tconn *tconn)
Philipp Reisner32862ec2011-02-08 16:41:01 +01004938{
Philipp Reisner082a3432011-03-15 16:05:42 +01004939 struct drbd_conf *mdev;
4940 int i, not_empty = 0;
Philipp Reisner32862ec2011-02-08 16:41:01 +01004941
4942 do {
4943 clear_bit(SIGNAL_ASENDER, &tconn->flags);
4944 flush_signals(current);
Philipp Reisnerd3fcb492011-04-13 14:46:05 -07004945 down_read(&drbd_cfg_rwsem);
Philipp Reisner082a3432011-03-15 16:05:42 +01004946 idr_for_each_entry(&tconn->volumes, mdev, i) {
Philipp Reisnerd3fcb492011-04-13 14:46:05 -07004947 if (drbd_finish_peer_reqs(mdev)) {
4948 up_read(&drbd_cfg_rwsem);
Philipp Reisner082a3432011-03-15 16:05:42 +01004949 return 1; /* error */
Philipp Reisnerd3fcb492011-04-13 14:46:05 -07004950 }
Philipp Reisner082a3432011-03-15 16:05:42 +01004951 }
Philipp Reisnerd3fcb492011-04-13 14:46:05 -07004952 up_read(&drbd_cfg_rwsem);
Philipp Reisner32862ec2011-02-08 16:41:01 +01004953 set_bit(SIGNAL_ASENDER, &tconn->flags);
Philipp Reisner082a3432011-03-15 16:05:42 +01004954
4955 spin_lock_irq(&tconn->req_lock);
Philipp Reisner695d08f2011-04-11 22:53:32 -07004956 rcu_read_lock();
Philipp Reisner082a3432011-03-15 16:05:42 +01004957 idr_for_each_entry(&tconn->volumes, mdev, i) {
4958 not_empty = !list_empty(&mdev->done_ee);
4959 if (not_empty)
4960 break;
4961 }
Philipp Reisner695d08f2011-04-11 22:53:32 -07004962 rcu_read_unlock();
Philipp Reisner082a3432011-03-15 16:05:42 +01004963 spin_unlock_irq(&tconn->req_lock);
Philipp Reisner32862ec2011-02-08 16:41:01 +01004964 } while (not_empty);
4965
4966 return 0;
4967}
4968
Andreas Gruenbacher7201b972011-03-14 18:23:00 +01004969struct asender_cmd {
4970 size_t pkt_size;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004971 int (*fn)(struct drbd_tconn *tconn, struct packet_info *);
Andreas Gruenbacher7201b972011-03-14 18:23:00 +01004972};
4973
4974static struct asender_cmd asender_tbl[] = {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02004975 [P_PING] = { 0, got_Ping },
4976 [P_PING_ACK] = { 0, got_PingAck },
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01004977 [P_RECV_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4978 [P_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4979 [P_RS_WRITE_ACK] = { sizeof(struct p_block_ack), got_BlockAck },
4980 [P_DISCARD_WRITE] = { sizeof(struct p_block_ack), got_BlockAck },
4981 [P_NEG_ACK] = { sizeof(struct p_block_ack), got_NegAck },
4982 [P_NEG_DREPLY] = { sizeof(struct p_block_ack), got_NegDReply },
4983 [P_NEG_RS_DREPLY] = { sizeof(struct p_block_ack), got_NegRSDReply },
4984 [P_OV_RESULT] = { sizeof(struct p_block_ack), got_OVResult },
4985 [P_BARRIER_ACK] = { sizeof(struct p_barrier_ack), got_BarrierAck },
4986 [P_STATE_CHG_REPLY] = { sizeof(struct p_req_state_reply), got_RqSReply },
4987 [P_RS_IS_IN_SYNC] = { sizeof(struct p_block_ack), got_IsInSync },
4988 [P_DELAY_PROBE] = { sizeof(struct p_delay_probe93), got_skip },
4989 [P_RS_CANCEL] = { sizeof(struct p_block_ack), got_NegRSDReply },
4990 [P_CONN_ST_CHG_REPLY]={ sizeof(struct p_req_state_reply), got_conn_RqSReply },
4991 [P_RETRY_WRITE] = { sizeof(struct p_block_ack), got_BlockAck },
Andreas Gruenbacher7201b972011-03-14 18:23:00 +01004992};
4993
Philipp Reisnerb411b362009-09-25 16:07:19 -07004994int drbd_asender(struct drbd_thread *thi)
4995{
Philipp Reisner392c8802011-02-09 10:33:31 +01004996 struct drbd_tconn *tconn = thi->tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -07004997 struct asender_cmd *cmd = NULL;
Philipp Reisner77351055b2011-02-07 17:24:26 +01004998 struct packet_info pi;
Philipp Reisner257d0af2011-01-26 12:15:29 +01004999 int rv;
Andreas Gruenbachere6589832011-03-30 12:54:42 +02005000 void *buf = tconn->meta.rbuf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07005001 int received = 0;
Andreas Gruenbacher52b061a2011-03-30 11:38:49 +02005002 unsigned int header_size = drbd_header_size(tconn);
5003 int expect = header_size;
Philipp Reisner44ed1672011-04-19 17:10:19 +02005004 bool ping_timeout_active = false;
5005 struct net_conf *nc;
5006 int ping_timeo, no_cork, ping_int;
Philipp Reisnerb411b362009-09-25 16:07:19 -07005007
Philipp Reisnerb411b362009-09-25 16:07:19 -07005008 current->policy = SCHED_RR; /* Make this a realtime task! */
5009 current->rt_priority = 2; /* more important than all other tasks */
5010
Andreas Gruenbachere77a0a52011-01-25 15:43:39 +01005011 while (get_t_state(thi) == RUNNING) {
Philipp Reisner80822282011-02-08 12:46:30 +01005012 drbd_thread_current_set_cpu(thi);
Philipp Reisner44ed1672011-04-19 17:10:19 +02005013
5014 rcu_read_lock();
5015 nc = rcu_dereference(tconn->net_conf);
5016 ping_timeo = nc->ping_timeo;
5017 no_cork = nc->no_cork;
5018 ping_int = nc->ping_int;
5019 rcu_read_unlock();
5020
Philipp Reisner32862ec2011-02-08 16:41:01 +01005021 if (test_and_clear_bit(SEND_PING, &tconn->flags)) {
Andreas Gruenbachera17647a2011-04-01 12:49:42 +02005022 if (drbd_send_ping(tconn)) {
Philipp Reisner32862ec2011-02-08 16:41:01 +01005023 conn_err(tconn, "drbd_send_ping has failed\n");
Andreas Gruenbacher841ce242010-12-15 19:31:20 +01005024 goto reconnect;
5025 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02005026 tconn->meta.socket->sk->sk_rcvtimeo = ping_timeo * HZ / 10;
5027 ping_timeout_active = true;
Philipp Reisnerb411b362009-09-25 16:07:19 -07005028 }
5029
Philipp Reisner32862ec2011-02-08 16:41:01 +01005030 /* TODO: conditionally cork; it may hurt latency if we cork without
5031 much to send */
Philipp Reisner44ed1672011-04-19 17:10:19 +02005032 if (!no_cork)
Philipp Reisner32862ec2011-02-08 16:41:01 +01005033 drbd_tcp_cork(tconn->meta.socket);
Andreas Gruenbachera990be42011-04-06 17:56:48 +02005034 if (tconn_finish_peer_reqs(tconn)) {
5035 conn_err(tconn, "tconn_finish_peer_reqs() failed\n");
Philipp Reisner32862ec2011-02-08 16:41:01 +01005036 goto reconnect;
Philipp Reisner082a3432011-03-15 16:05:42 +01005037 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07005038 /* but unconditionally uncork unless disabled */
Philipp Reisner44ed1672011-04-19 17:10:19 +02005039 if (!no_cork)
Philipp Reisner32862ec2011-02-08 16:41:01 +01005040 drbd_tcp_uncork(tconn->meta.socket);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005041
5042 /* short circuit, recv_msg would return EINTR anyways. */
5043 if (signal_pending(current))
5044 continue;
5045
Philipp Reisner32862ec2011-02-08 16:41:01 +01005046 rv = drbd_recv_short(tconn->meta.socket, buf, expect-received, 0);
5047 clear_bit(SIGNAL_ASENDER, &tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005048
5049 flush_signals(current);
5050
5051 /* Note:
5052 * -EINTR (on meta) we got a signal
5053 * -EAGAIN (on meta) rcvtimeo expired
5054 * -ECONNRESET other side closed the connection
5055 * -ERESTARTSYS (on data) we got a signal
5056 * rv < 0 other than above: unexpected error!
5057 * rv == expected: full header or command
5058 * rv < expected: "woken" by signal during receive
5059 * rv == 0 : "connection shut down by peer"
5060 */
5061 if (likely(rv > 0)) {
5062 received += rv;
5063 buf += rv;
5064 } else if (rv == 0) {
Philipp Reisner32862ec2011-02-08 16:41:01 +01005065 conn_err(tconn, "meta connection shut down by peer.\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07005066 goto reconnect;
5067 } else if (rv == -EAGAIN) {
Lars Ellenbergcb6518c2011-06-20 14:44:45 +02005068 /* If the data socket received something meanwhile,
5069 * that is good enough: peer is still alive. */
Philipp Reisner32862ec2011-02-08 16:41:01 +01005070 if (time_after(tconn->last_received,
5071 jiffies - tconn->meta.socket->sk->sk_rcvtimeo))
Lars Ellenbergcb6518c2011-06-20 14:44:45 +02005072 continue;
Lars Ellenbergf36af182011-03-09 22:44:55 +01005073 if (ping_timeout_active) {
Philipp Reisner32862ec2011-02-08 16:41:01 +01005074 conn_err(tconn, "PingAck did not arrive in time.\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07005075 goto reconnect;
5076 }
Philipp Reisner32862ec2011-02-08 16:41:01 +01005077 set_bit(SEND_PING, &tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005078 continue;
5079 } else if (rv == -EINTR) {
5080 continue;
5081 } else {
Philipp Reisner32862ec2011-02-08 16:41:01 +01005082 conn_err(tconn, "sock_recvmsg returned %d\n", rv);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005083 goto reconnect;
5084 }
5085
5086 if (received == expect && cmd == NULL) {
Andreas Gruenbachere6589832011-03-30 12:54:42 +02005087 if (decode_header(tconn, tconn->meta.rbuf, &pi))
Philipp Reisnerb411b362009-09-25 16:07:19 -07005088 goto reconnect;
Andreas Gruenbacher7201b972011-03-14 18:23:00 +01005089 cmd = &asender_tbl[pi.cmd];
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01005090 if (pi.cmd >= ARRAY_SIZE(asender_tbl) || !cmd->fn) {
Philipp Reisner32862ec2011-02-08 16:41:01 +01005091 conn_err(tconn, "unknown command %d on meta (l: %d)\n",
Philipp Reisner77351055b2011-02-07 17:24:26 +01005092 pi.cmd, pi.size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005093 goto disconnect;
5094 }
Andreas Gruenbachere6589832011-03-30 12:54:42 +02005095 expect = header_size + cmd->pkt_size;
Andreas Gruenbacher52b061a2011-03-30 11:38:49 +02005096 if (pi.size != expect - header_size) {
Philipp Reisner32862ec2011-02-08 16:41:01 +01005097 conn_err(tconn, "Wrong packet size on meta (c: %d, l: %d)\n",
Philipp Reisner77351055b2011-02-07 17:24:26 +01005098 pi.cmd, pi.size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005099 goto reconnect;
Philipp Reisner257d0af2011-01-26 12:15:29 +01005100 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07005101 }
5102 if (received == expect) {
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02005103 bool err;
Philipp Reisnera4fbda82011-03-16 11:13:17 +01005104
Andreas Gruenbacher2735a592011-04-04 15:30:24 +02005105 err = cmd->fn(tconn, &pi);
5106 if (err) {
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01005107 conn_err(tconn, "%pf failed\n", cmd->fn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005108 goto reconnect;
Andreas Gruenbacher1952e912011-03-25 15:37:43 +01005109 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07005110
Philipp Reisnera4fbda82011-03-16 11:13:17 +01005111 tconn->last_received = jiffies;
5112
Philipp Reisner44ed1672011-04-19 17:10:19 +02005113 if (cmd == &asender_tbl[P_PING_ACK]) {
5114 /* restore idle timeout */
5115 tconn->meta.socket->sk->sk_rcvtimeo = ping_int * HZ;
5116 ping_timeout_active = false;
5117 }
Lars Ellenbergf36af182011-03-09 22:44:55 +01005118
Andreas Gruenbachere6589832011-03-30 12:54:42 +02005119 buf = tconn->meta.rbuf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07005120 received = 0;
Andreas Gruenbacher52b061a2011-03-30 11:38:49 +02005121 expect = header_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07005122 cmd = NULL;
5123 }
5124 }
5125
5126 if (0) {
5127reconnect:
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01005128 conn_request_state(tconn, NS(conn, C_NETWORK_FAILURE), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005129 }
5130 if (0) {
5131disconnect:
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01005132 conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005133 }
Philipp Reisner32862ec2011-02-08 16:41:01 +01005134 clear_bit(SIGNAL_ASENDER, &tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07005135
Philipp Reisner32862ec2011-02-08 16:41:01 +01005136 conn_info(tconn, "asender terminated\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -07005137
5138 return 0;
5139}