blob: 90d7317232051f34ec54c2b429ba73d0ab441d5f [file] [log] [blame]
Philipp Reisnerb411b362009-09-25 16:07:19 -07001/*
2 drbd_nl.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#include <linux/drbd.h>
28#include <linux/in.h>
29#include <linux/fs.h>
30#include <linux/file.h>
31#include <linux/slab.h>
32#include <linux/connector.h>
33#include <linux/blkpg.h>
34#include <linux/cpumask.h>
35#include "drbd_int.h"
Philipp Reisner265be2d2010-05-31 10:14:17 +020036#include "drbd_req.h"
Philipp Reisnerb411b362009-09-25 16:07:19 -070037#include "drbd_wrappers.h"
38#include <asm/unaligned.h>
39#include <linux/drbd_tag_magic.h>
40#include <linux/drbd_limits.h>
Philipp Reisner87f7be42010-06-11 13:56:33 +020041#include <linux/compiler.h>
42#include <linux/kthread.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070043
44static unsigned short *tl_add_blob(unsigned short *, enum drbd_tags, const void *, int);
45static unsigned short *tl_add_str(unsigned short *, enum drbd_tags, const char *);
46static unsigned short *tl_add_int(unsigned short *, enum drbd_tags, const void *);
47
48/* see get_sb_bdev and bd_claim */
49static char *drbd_m_holder = "Hands off! this is DRBD's meta data device.";
50
51/* Generate the tag_list to struct functions */
52#define NL_PACKET(name, number, fields) \
53static int name ## _from_tags(struct drbd_conf *mdev, \
54 unsigned short *tags, struct name *arg) __attribute__ ((unused)); \
55static int name ## _from_tags(struct drbd_conf *mdev, \
56 unsigned short *tags, struct name *arg) \
57{ \
58 int tag; \
59 int dlen; \
60 \
61 while ((tag = get_unaligned(tags++)) != TT_END) { \
62 dlen = get_unaligned(tags++); \
63 switch (tag_number(tag)) { \
64 fields \
65 default: \
66 if (tag & T_MANDATORY) { \
67 dev_err(DEV, "Unknown tag: %d\n", tag_number(tag)); \
68 return 0; \
69 } \
70 } \
71 tags = (unsigned short *)((char *)tags + dlen); \
72 } \
73 return 1; \
74}
75#define NL_INTEGER(pn, pr, member) \
76 case pn: /* D_ASSERT( tag_type(tag) == TT_INTEGER ); */ \
77 arg->member = get_unaligned((int *)(tags)); \
78 break;
79#define NL_INT64(pn, pr, member) \
80 case pn: /* D_ASSERT( tag_type(tag) == TT_INT64 ); */ \
81 arg->member = get_unaligned((u64 *)(tags)); \
82 break;
83#define NL_BIT(pn, pr, member) \
84 case pn: /* D_ASSERT( tag_type(tag) == TT_BIT ); */ \
85 arg->member = *(char *)(tags) ? 1 : 0; \
86 break;
87#define NL_STRING(pn, pr, member, len) \
88 case pn: /* D_ASSERT( tag_type(tag) == TT_STRING ); */ \
89 if (dlen > len) { \
90 dev_err(DEV, "arg too long: %s (%u wanted, max len: %u bytes)\n", \
91 #member, dlen, (unsigned int)len); \
92 return 0; \
93 } \
94 arg->member ## _len = dlen; \
95 memcpy(arg->member, tags, min_t(size_t, dlen, len)); \
96 break;
97#include "linux/drbd_nl.h"
98
99/* Generate the struct to tag_list functions */
100#define NL_PACKET(name, number, fields) \
101static unsigned short* \
102name ## _to_tags(struct drbd_conf *mdev, \
103 struct name *arg, unsigned short *tags) __attribute__ ((unused)); \
104static unsigned short* \
105name ## _to_tags(struct drbd_conf *mdev, \
106 struct name *arg, unsigned short *tags) \
107{ \
108 fields \
109 return tags; \
110}
111
112#define NL_INTEGER(pn, pr, member) \
113 put_unaligned(pn | pr | TT_INTEGER, tags++); \
114 put_unaligned(sizeof(int), tags++); \
115 put_unaligned(arg->member, (int *)tags); \
116 tags = (unsigned short *)((char *)tags+sizeof(int));
117#define NL_INT64(pn, pr, member) \
118 put_unaligned(pn | pr | TT_INT64, tags++); \
119 put_unaligned(sizeof(u64), tags++); \
120 put_unaligned(arg->member, (u64 *)tags); \
121 tags = (unsigned short *)((char *)tags+sizeof(u64));
122#define NL_BIT(pn, pr, member) \
123 put_unaligned(pn | pr | TT_BIT, tags++); \
124 put_unaligned(sizeof(char), tags++); \
125 *(char *)tags = arg->member; \
126 tags = (unsigned short *)((char *)tags+sizeof(char));
127#define NL_STRING(pn, pr, member, len) \
128 put_unaligned(pn | pr | TT_STRING, tags++); \
129 put_unaligned(arg->member ## _len, tags++); \
130 memcpy(tags, arg->member, arg->member ## _len); \
131 tags = (unsigned short *)((char *)tags + arg->member ## _len);
132#include "linux/drbd_nl.h"
133
134void drbd_bcast_ev_helper(struct drbd_conf *mdev, char *helper_name);
135void drbd_nl_send_reply(struct cn_msg *, int);
136
137int drbd_khelper(struct drbd_conf *mdev, char *cmd)
138{
139 char *envp[] = { "HOME=/",
140 "TERM=linux",
141 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
142 NULL, /* Will be set to address family */
143 NULL, /* Will be set to address */
144 NULL };
145
146 char mb[12], af[20], ad[60], *afs;
147 char *argv[] = {usermode_helper, cmd, mb, NULL };
148 int ret;
149
150 snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev));
151
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +0100152 if (get_net_conf(mdev->tconn)) {
Philipp Reisner89e58e72011-01-19 13:12:45 +0100153 switch (((struct sockaddr *)mdev->tconn->net_conf->peer_addr)->sa_family) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700154 case AF_INET6:
155 afs = "ipv6";
156 snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI6",
Philipp Reisner89e58e72011-01-19 13:12:45 +0100157 &((struct sockaddr_in6 *)mdev->tconn->net_conf->peer_addr)->sin6_addr);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700158 break;
159 case AF_INET:
160 afs = "ipv4";
161 snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI4",
Philipp Reisner89e58e72011-01-19 13:12:45 +0100162 &((struct sockaddr_in *)mdev->tconn->net_conf->peer_addr)->sin_addr);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700163 break;
164 default:
165 afs = "ssocks";
166 snprintf(ad, 60, "DRBD_PEER_ADDRESS=%pI4",
Philipp Reisner89e58e72011-01-19 13:12:45 +0100167 &((struct sockaddr_in *)mdev->tconn->net_conf->peer_addr)->sin_addr);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700168 }
169 snprintf(af, 20, "DRBD_PEER_AF=%s", afs);
170 envp[3]=af;
171 envp[4]=ad;
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +0100172 put_net_conf(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700173 }
174
Lars Ellenberg1090c052010-07-19 17:41:04 +0200175 /* The helper may take some time.
176 * write out any unsynced meta data changes now */
177 drbd_md_sync(mdev);
178
Philipp Reisnerb411b362009-09-25 16:07:19 -0700179 dev_info(DEV, "helper command: %s %s %s\n", usermode_helper, cmd, mb);
180
181 drbd_bcast_ev_helper(mdev, cmd);
182 ret = call_usermodehelper(usermode_helper, argv, envp, 1);
183 if (ret)
184 dev_warn(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
185 usermode_helper, cmd, mb,
186 (ret >> 8) & 0xff, ret);
187 else
188 dev_info(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
189 usermode_helper, cmd, mb,
190 (ret >> 8) & 0xff, ret);
191
192 if (ret < 0) /* Ignore any ERRNOs we got. */
193 ret = 0;
194
195 return ret;
196}
197
198enum drbd_disk_state drbd_try_outdate_peer(struct drbd_conf *mdev)
199{
200 char *ex_to_string;
201 int r;
202 enum drbd_disk_state nps;
203 enum drbd_fencing_p fp;
204
205 D_ASSERT(mdev->state.pdsk == D_UNKNOWN);
206
207 if (get_ldev_if_state(mdev, D_CONSISTENT)) {
208 fp = mdev->ldev->dc.fencing;
209 put_ldev(mdev);
210 } else {
211 dev_warn(DEV, "Not fencing peer, I'm not even Consistent myself.\n");
Philipp Reisnerfb22c402010-09-08 23:20:21 +0200212 nps = mdev->state.pdsk;
213 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700214 }
215
Philipp Reisnerb411b362009-09-25 16:07:19 -0700216 r = drbd_khelper(mdev, "fence-peer");
217
218 switch ((r>>8) & 0xff) {
219 case 3: /* peer is inconsistent */
220 ex_to_string = "peer is inconsistent or worse";
221 nps = D_INCONSISTENT;
222 break;
223 case 4: /* peer got outdated, or was already outdated */
224 ex_to_string = "peer was fenced";
225 nps = D_OUTDATED;
226 break;
227 case 5: /* peer was down */
228 if (mdev->state.disk == D_UP_TO_DATE) {
229 /* we will(have) create(d) a new UUID anyways... */
230 ex_to_string = "peer is unreachable, assumed to be dead";
231 nps = D_OUTDATED;
232 } else {
233 ex_to_string = "peer unreachable, doing nothing since disk != UpToDate";
234 nps = mdev->state.pdsk;
235 }
236 break;
237 case 6: /* Peer is primary, voluntarily outdate myself.
238 * This is useful when an unconnected R_SECONDARY is asked to
239 * become R_PRIMARY, but finds the other peer being active. */
240 ex_to_string = "peer is active";
241 dev_warn(DEV, "Peer is primary, outdating myself.\n");
242 nps = D_UNKNOWN;
243 _drbd_request_state(mdev, NS(disk, D_OUTDATED), CS_WAIT_COMPLETE);
244 break;
245 case 7:
246 if (fp != FP_STONITH)
247 dev_err(DEV, "fence-peer() = 7 && fencing != Stonith !!!\n");
248 ex_to_string = "peer was stonithed";
249 nps = D_OUTDATED;
250 break;
251 default:
252 /* The script is broken ... */
253 nps = D_UNKNOWN;
254 dev_err(DEV, "fence-peer helper broken, returned %d\n", (r>>8)&0xff);
255 return nps;
256 }
257
258 dev_info(DEV, "fence-peer helper returned %d (%s)\n",
259 (r>>8) & 0xff, ex_to_string);
Philipp Reisnerfb22c402010-09-08 23:20:21 +0200260
261out:
262 if (mdev->state.susp_fen && nps >= D_UNKNOWN) {
263 /* The handler was not successful... unfreeze here, the
264 state engine can not unfreeze... */
265 _drbd_request_state(mdev, NS(susp_fen, 0), CS_VERBOSE);
266 }
267
Philipp Reisnerb411b362009-09-25 16:07:19 -0700268 return nps;
269}
270
Philipp Reisner87f7be42010-06-11 13:56:33 +0200271static int _try_outdate_peer_async(void *data)
272{
273 struct drbd_conf *mdev = (struct drbd_conf *)data;
274 enum drbd_disk_state nps;
Philipp Reisner21423fa2011-05-17 14:19:41 +0200275 union drbd_state ns;
Philipp Reisner87f7be42010-06-11 13:56:33 +0200276
277 nps = drbd_try_outdate_peer(mdev);
Philipp Reisner21423fa2011-05-17 14:19:41 +0200278
279 /* Not using
280 drbd_request_state(mdev, NS(pdsk, nps));
Philipp Reisner99432fc2011-05-20 16:39:13 +0200281 here, because we might were able to re-establish the connection
282 in the meantime. This can only partially be solved in the state's
283 engine is_valid_state() and is_valid_state_transition()
284 functions.
285
286 nps can be D_INCONSISTENT, D_OUTDATED or D_UNKNOWN.
287 pdsk == D_INCONSISTENT while conn >= C_CONNECTED is valid,
288 therefore we have to have the pre state change check here.
Philipp Reisner21423fa2011-05-17 14:19:41 +0200289 */
Philipp Reisner87eeee42011-01-19 14:16:30 +0100290 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner21423fa2011-05-17 14:19:41 +0200291 ns = mdev->state;
292 if (ns.conn < C_WF_REPORT_PARAMS) {
293 ns.pdsk = nps;
294 _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
295 }
Philipp Reisner87eeee42011-01-19 14:16:30 +0100296 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisner87f7be42010-06-11 13:56:33 +0200297
298 return 0;
299}
300
301void drbd_try_outdate_peer_async(struct drbd_conf *mdev)
302{
303 struct task_struct *opa;
304
305 opa = kthread_run(_try_outdate_peer_async, mdev, "drbd%d_a_helper", mdev_to_minor(mdev));
306 if (IS_ERR(opa))
307 dev_err(DEV, "out of mem, failed to invoke fence-peer helper\n");
308}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700309
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100310enum drbd_state_rv
311drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700312{
313 const int max_tries = 4;
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100314 enum drbd_state_rv rv = SS_UNKNOWN_ERROR;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700315 int try = 0;
316 int forced = 0;
317 union drbd_state mask, val;
318 enum drbd_disk_state nps;
319
320 if (new_role == R_PRIMARY)
Philipp Reisner0625ac12011-02-07 14:49:19 +0100321 request_ping(mdev->tconn); /* Detect a dead peer ASAP */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700322
Philipp Reisner8410da82011-02-11 20:11:10 +0100323 mutex_lock(mdev->state_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700324
325 mask.i = 0; mask.role = R_MASK;
326 val.i = 0; val.role = new_role;
327
328 while (try++ < max_tries) {
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100329 rv = _drbd_request_state(mdev, mask, val, CS_WAIT_COMPLETE);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700330
331 /* in case we first succeeded to outdate,
332 * but now suddenly could establish a connection */
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100333 if (rv == SS_CW_FAILED_BY_PEER && mask.pdsk != 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700334 val.pdsk = 0;
335 mask.pdsk = 0;
336 continue;
337 }
338
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100339 if (rv == SS_NO_UP_TO_DATE_DISK && force &&
Philipp Reisnerd10a33c2010-03-04 15:11:39 +0100340 (mdev->state.disk < D_UP_TO_DATE &&
341 mdev->state.disk >= D_INCONSISTENT)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700342 mask.disk = D_MASK;
343 val.disk = D_UP_TO_DATE;
344 forced = 1;
345 continue;
346 }
347
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100348 if (rv == SS_NO_UP_TO_DATE_DISK &&
Philipp Reisnerb411b362009-09-25 16:07:19 -0700349 mdev->state.disk == D_CONSISTENT && mask.pdsk == 0) {
350 D_ASSERT(mdev->state.pdsk == D_UNKNOWN);
351 nps = drbd_try_outdate_peer(mdev);
352
353 if (nps == D_OUTDATED || nps == D_INCONSISTENT) {
354 val.disk = D_UP_TO_DATE;
355 mask.disk = D_MASK;
356 }
357
358 val.pdsk = nps;
359 mask.pdsk = D_MASK;
360
361 continue;
362 }
363
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100364 if (rv == SS_NOTHING_TO_DO)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700365 goto fail;
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100366 if (rv == SS_PRIMARY_NOP && mask.pdsk == 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700367 nps = drbd_try_outdate_peer(mdev);
368
369 if (force && nps > D_OUTDATED) {
370 dev_warn(DEV, "Forced into split brain situation!\n");
371 nps = D_OUTDATED;
372 }
373
374 mask.pdsk = D_MASK;
375 val.pdsk = nps;
376
377 continue;
378 }
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100379 if (rv == SS_TWO_PRIMARIES) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700380 /* Maybe the peer is detected as dead very soon...
381 retry at most once more in this case. */
Philipp Reisner89e58e72011-01-19 13:12:45 +0100382 schedule_timeout_interruptible((mdev->tconn->net_conf->ping_timeo+1)*HZ/10);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700383 if (try < max_tries)
384 try = max_tries - 1;
385 continue;
386 }
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100387 if (rv < SS_SUCCESS) {
388 rv = _drbd_request_state(mdev, mask, val,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700389 CS_VERBOSE + CS_WAIT_COMPLETE);
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100390 if (rv < SS_SUCCESS)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700391 goto fail;
392 }
393 break;
394 }
395
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100396 if (rv < SS_SUCCESS)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700397 goto fail;
398
399 if (forced)
400 dev_warn(DEV, "Forced to consider local data as UpToDate!\n");
401
402 /* Wait until nothing is on the fly :) */
403 wait_event(mdev->misc_wait, atomic_read(&mdev->ap_pending_cnt) == 0);
404
405 if (new_role == R_SECONDARY) {
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100406 set_disk_ro(mdev->vdisk, true);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700407 if (get_ldev(mdev)) {
408 mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
409 put_ldev(mdev);
410 }
411 } else {
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +0100412 if (get_net_conf(mdev->tconn)) {
Philipp Reisner89e58e72011-01-19 13:12:45 +0100413 mdev->tconn->net_conf->want_lose = 0;
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +0100414 put_net_conf(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700415 }
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100416 set_disk_ro(mdev->vdisk, false);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700417 if (get_ldev(mdev)) {
418 if (((mdev->state.conn < C_CONNECTED ||
419 mdev->state.pdsk <= D_FAILED)
420 && mdev->ldev->md.uuid[UI_BITMAP] == 0) || forced)
421 drbd_uuid_new_current(mdev);
422
423 mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1;
424 put_ldev(mdev);
425 }
426 }
427
Lars Ellenberg19f843a2010-12-15 08:59:11 +0100428 /* writeout of activity log covered areas of the bitmap
429 * to stable storage done in after state change already */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700430
431 if (mdev->state.conn >= C_WF_REPORT_PARAMS) {
432 /* if this was forced, we should consider sync */
433 if (forced)
434 drbd_send_uuids(mdev);
435 drbd_send_state(mdev);
436 }
437
438 drbd_md_sync(mdev);
439
440 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
441 fail:
Philipp Reisner8410da82011-02-11 20:11:10 +0100442 mutex_unlock(mdev->state_mutex);
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100443 return rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700444}
445
Lars Ellenbergef50a3e2010-09-01 14:39:30 +0200446static struct drbd_conf *ensure_mdev(int minor, int create)
447{
448 struct drbd_conf *mdev;
449
450 if (minor >= minor_count)
451 return NULL;
452
453 mdev = minor_to_mdev(minor);
454
455 if (!mdev && create) {
456 struct gendisk *disk = NULL;
457 mdev = drbd_new_device(minor);
458
459 spin_lock_irq(&drbd_pp_lock);
460 if (minor_table[minor] == NULL) {
461 minor_table[minor] = mdev;
462 disk = mdev->vdisk;
463 mdev = NULL;
464 } /* else: we lost the race */
465 spin_unlock_irq(&drbd_pp_lock);
466
467 if (disk) /* we won the race above */
468 /* in case we ever add a drbd_delete_device(),
469 * don't forget the del_gendisk! */
470 add_disk(disk);
471 else /* we lost the race above */
472 drbd_free_mdev(mdev);
473
474 mdev = minor_to_mdev(minor);
475 }
476
477 return mdev;
478}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700479
480static int drbd_nl_primary(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
481 struct drbd_nl_cfg_reply *reply)
482{
483 struct primary primary_args;
484
485 memset(&primary_args, 0, sizeof(struct primary));
486 if (!primary_from_tags(mdev, nlp->tag_list, &primary_args)) {
487 reply->ret_code = ERR_MANDATORY_TAG;
488 return 0;
489 }
490
491 reply->ret_code =
Philipp Reisner1f552432010-03-04 15:51:01 +0100492 drbd_set_role(mdev, R_PRIMARY, primary_args.primary_force);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700493
494 return 0;
495}
496
497static int drbd_nl_secondary(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
498 struct drbd_nl_cfg_reply *reply)
499{
500 reply->ret_code = drbd_set_role(mdev, R_SECONDARY, 0);
501
502 return 0;
503}
504
505/* initializes the md.*_offset members, so we are able to find
506 * the on disk meta data */
507static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
508 struct drbd_backing_dev *bdev)
509{
510 sector_t md_size_sect = 0;
511 switch (bdev->dc.meta_dev_idx) {
512 default:
513 /* v07 style fixed size indexed meta data */
514 bdev->md.md_size_sect = MD_RESERVED_SECT;
515 bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
516 bdev->md.al_offset = MD_AL_OFFSET;
517 bdev->md.bm_offset = MD_BM_OFFSET;
518 break;
519 case DRBD_MD_INDEX_FLEX_EXT:
520 /* just occupy the full device; unit: sectors */
521 bdev->md.md_size_sect = drbd_get_capacity(bdev->md_bdev);
522 bdev->md.md_offset = 0;
523 bdev->md.al_offset = MD_AL_OFFSET;
524 bdev->md.bm_offset = MD_BM_OFFSET;
525 break;
526 case DRBD_MD_INDEX_INTERNAL:
527 case DRBD_MD_INDEX_FLEX_INT:
528 bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
529 /* al size is still fixed */
Lars Ellenberg7ad651b2011-02-21 13:21:03 +0100530 bdev->md.al_offset = -MD_AL_SECTORS;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700531 /* we need (slightly less than) ~ this much bitmap sectors: */
532 md_size_sect = drbd_get_capacity(bdev->backing_bdev);
533 md_size_sect = ALIGN(md_size_sect, BM_SECT_PER_EXT);
534 md_size_sect = BM_SECT_TO_EXT(md_size_sect);
535 md_size_sect = ALIGN(md_size_sect, 8);
536
537 /* plus the "drbd meta data super block",
538 * and the activity log; */
539 md_size_sect += MD_BM_OFFSET;
540
541 bdev->md.md_size_sect = md_size_sect;
542 /* bitmap offset is adjusted by 'super' block size */
543 bdev->md.bm_offset = -md_size_sect + MD_AL_OFFSET;
544 break;
545 }
546}
547
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100548/* input size is expected to be in KB */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700549char *ppsize(char *buf, unsigned long long size)
550{
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100551 /* Needs 9 bytes at max including trailing NUL:
552 * -1ULL ==> "16384 EB" */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700553 static char units[] = { 'K', 'M', 'G', 'T', 'P', 'E' };
554 int base = 0;
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100555 while (size >= 10000 && base < sizeof(units)-1) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700556 /* shift + round */
557 size = (size >> 10) + !!(size & (1<<9));
558 base++;
559 }
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100560 sprintf(buf, "%u %cB", (unsigned)size, units[base]);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700561
562 return buf;
563}
564
565/* there is still a theoretical deadlock when called from receiver
566 * on an D_INCONSISTENT R_PRIMARY:
567 * remote READ does inc_ap_bio, receiver would need to receive answer
568 * packet from remote to dec_ap_bio again.
569 * receiver receive_sizes(), comes here,
570 * waits for ap_bio_cnt == 0. -> deadlock.
571 * but this cannot happen, actually, because:
572 * R_PRIMARY D_INCONSISTENT, and peer's disk is unreachable
573 * (not connected, or bad/no disk on peer):
574 * see drbd_fail_request_early, ap_bio_cnt is zero.
575 * R_PRIMARY D_INCONSISTENT, and C_SYNC_TARGET:
576 * peer may not initiate a resize.
577 */
578void drbd_suspend_io(struct drbd_conf *mdev)
579{
580 set_bit(SUSPEND_IO, &mdev->flags);
Philipp Reisnerfb22c402010-09-08 23:20:21 +0200581 if (is_susp(mdev->state))
Philipp Reisner265be2d2010-05-31 10:14:17 +0200582 return;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700583 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
584}
585
586void drbd_resume_io(struct drbd_conf *mdev)
587{
588 clear_bit(SUSPEND_IO, &mdev->flags);
589 wake_up(&mdev->misc_wait);
590}
591
592/**
593 * drbd_determine_dev_size() - Sets the right device size obeying all constraints
594 * @mdev: DRBD device.
595 *
596 * Returns 0 on success, negative return values indicate errors.
597 * You should call drbd_md_sync() after calling this function.
598 */
Bart Van Assche24c48302011-05-21 18:32:29 +0200599enum determine_dev_size drbd_determine_dev_size(struct drbd_conf *mdev, enum dds_flags flags) __must_hold(local)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700600{
601 sector_t prev_first_sect, prev_size; /* previous meta location */
602 sector_t la_size;
603 sector_t size;
604 char ppb[10];
605
606 int md_moved, la_size_changed;
607 enum determine_dev_size rv = unchanged;
608
609 /* race:
610 * application request passes inc_ap_bio,
611 * but then cannot get an AL-reference.
612 * this function later may wait on ap_bio_cnt == 0. -> deadlock.
613 *
614 * to avoid that:
615 * Suspend IO right here.
616 * still lock the act_log to not trigger ASSERTs there.
617 */
618 drbd_suspend_io(mdev);
619
620 /* no wait necessary anymore, actually we could assert that */
621 wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
622
623 prev_first_sect = drbd_md_first_sector(mdev->ldev);
624 prev_size = mdev->ldev->md.md_size_sect;
625 la_size = mdev->ldev->md.la_size_sect;
626
627 /* TODO: should only be some assert here, not (re)init... */
628 drbd_md_set_sector_offsets(mdev, mdev->ldev);
629
Philipp Reisnerd8450302010-03-24 15:51:26 +0100630 size = drbd_new_dev_size(mdev, mdev->ldev, flags & DDSF_FORCED);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700631
632 if (drbd_get_capacity(mdev->this_bdev) != size ||
633 drbd_bm_capacity(mdev) != size) {
634 int err;
Philipp Reisner02d9a942010-03-24 16:23:03 +0100635 err = drbd_bm_resize(mdev, size, !(flags & DDSF_NO_RESYNC));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700636 if (unlikely(err)) {
637 /* currently there is only one error: ENOMEM! */
638 size = drbd_bm_capacity(mdev)>>1;
639 if (size == 0) {
640 dev_err(DEV, "OUT OF MEMORY! "
641 "Could not allocate bitmap!\n");
642 } else {
643 dev_err(DEV, "BM resizing failed. "
644 "Leaving size unchanged at size = %lu KB\n",
645 (unsigned long)size);
646 }
647 rv = dev_size_error;
648 }
649 /* racy, see comments above. */
650 drbd_set_my_capacity(mdev, size);
651 mdev->ldev->md.la_size_sect = size;
652 dev_info(DEV, "size = %s (%llu KB)\n", ppsize(ppb, size>>1),
653 (unsigned long long)size>>1);
654 }
655 if (rv == dev_size_error)
656 goto out;
657
658 la_size_changed = (la_size != mdev->ldev->md.la_size_sect);
659
660 md_moved = prev_first_sect != drbd_md_first_sector(mdev->ldev)
661 || prev_size != mdev->ldev->md.md_size_sect;
662
663 if (la_size_changed || md_moved) {
Andreas Gruenbacher24dccab2010-12-12 17:45:41 +0100664 int err;
665
Philipp Reisnerb411b362009-09-25 16:07:19 -0700666 drbd_al_shrink(mdev); /* All extents inactive. */
667 dev_info(DEV, "Writing the whole bitmap, %s\n",
668 la_size_changed && md_moved ? "size changed and md moved" :
669 la_size_changed ? "size changed" : "md moved");
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +0100670 /* next line implicitly does drbd_suspend_io()+drbd_resume_io() */
671 err = drbd_bitmap_io(mdev, &drbd_bm_write,
672 "size changed", BM_LOCKED_MASK);
Andreas Gruenbacher24dccab2010-12-12 17:45:41 +0100673 if (err) {
674 rv = dev_size_error;
675 goto out;
676 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700677 drbd_md_mark_dirty(mdev);
678 }
679
680 if (size > la_size)
681 rv = grew;
682 if (size < la_size)
683 rv = shrunk;
684out:
685 lc_unlock(mdev->act_log);
686 wake_up(&mdev->al_wait);
687 drbd_resume_io(mdev);
688
689 return rv;
690}
691
692sector_t
Philipp Reisnera393db62009-12-22 13:35:52 +0100693drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev, int assume_peer_has_space)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700694{
695 sector_t p_size = mdev->p_size; /* partner's disk size. */
696 sector_t la_size = bdev->md.la_size_sect; /* last agreed size. */
697 sector_t m_size; /* my size */
698 sector_t u_size = bdev->dc.disk_size; /* size requested by user. */
699 sector_t size = 0;
700
701 m_size = drbd_get_max_capacity(bdev);
702
Philipp Reisnera393db62009-12-22 13:35:52 +0100703 if (mdev->state.conn < C_CONNECTED && assume_peer_has_space) {
704 dev_warn(DEV, "Resize while not connected was forced by the user!\n");
705 p_size = m_size;
706 }
707
Philipp Reisnerb411b362009-09-25 16:07:19 -0700708 if (p_size && m_size) {
709 size = min_t(sector_t, p_size, m_size);
710 } else {
711 if (la_size) {
712 size = la_size;
713 if (m_size && m_size < size)
714 size = m_size;
715 if (p_size && p_size < size)
716 size = p_size;
717 } else {
718 if (m_size)
719 size = m_size;
720 if (p_size)
721 size = p_size;
722 }
723 }
724
725 if (size == 0)
726 dev_err(DEV, "Both nodes diskless!\n");
727
728 if (u_size) {
729 if (u_size > size)
730 dev_err(DEV, "Requested disk size is too big (%lu > %lu)\n",
731 (unsigned long)u_size>>1, (unsigned long)size>>1);
732 else
733 size = u_size;
734 }
735
736 return size;
737}
738
739/**
740 * drbd_check_al_size() - Ensures that the AL is of the right size
741 * @mdev: DRBD device.
742 *
743 * Returns -EBUSY if current al lru is still used, -ENOMEM when allocation
744 * failed, and 0 on success. You should call drbd_md_sync() after you called
745 * this function.
746 */
747static int drbd_check_al_size(struct drbd_conf *mdev)
748{
749 struct lru_cache *n, *t;
750 struct lc_element *e;
751 unsigned int in_use;
752 int i;
753
Lars Ellenberg7ad651b2011-02-21 13:21:03 +0100754 if (!expect(mdev->sync_conf.al_extents >= DRBD_AL_EXTENTS_MIN))
755 mdev->sync_conf.al_extents = DRBD_AL_EXTENTS_MIN;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700756
757 if (mdev->act_log &&
758 mdev->act_log->nr_elements == mdev->sync_conf.al_extents)
759 return 0;
760
761 in_use = 0;
762 t = mdev->act_log;
Lars Ellenberg7ad651b2011-02-21 13:21:03 +0100763 n = lc_create("act_log", drbd_al_ext_cache, AL_UPDATES_PER_TRANSACTION,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700764 mdev->sync_conf.al_extents, sizeof(struct lc_element), 0);
765
766 if (n == NULL) {
767 dev_err(DEV, "Cannot allocate act_log lru!\n");
768 return -ENOMEM;
769 }
770 spin_lock_irq(&mdev->al_lock);
771 if (t) {
772 for (i = 0; i < t->nr_elements; i++) {
773 e = lc_element_by_index(t, i);
774 if (e->refcnt)
775 dev_err(DEV, "refcnt(%d)==%d\n",
776 e->lc_number, e->refcnt);
777 in_use += e->refcnt;
778 }
779 }
780 if (!in_use)
781 mdev->act_log = n;
782 spin_unlock_irq(&mdev->al_lock);
783 if (in_use) {
784 dev_err(DEV, "Activity log still in use!\n");
785 lc_destroy(n);
786 return -EBUSY;
787 } else {
788 if (t)
789 lc_destroy(t);
790 }
791 drbd_md_mark_dirty(mdev); /* we changed mdev->act_log->nr_elemens */
792 return 0;
793}
794
Philipp Reisner99432fc2011-05-20 16:39:13 +0200795static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700796{
797 struct request_queue * const q = mdev->rq_queue;
Philipp Reisner99432fc2011-05-20 16:39:13 +0200798 int max_hw_sectors = max_bio_size >> 9;
799 int max_segments = 0;
800
801 if (get_ldev_if_state(mdev, D_ATTACHING)) {
802 struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
803
804 max_hw_sectors = min(queue_max_hw_sectors(b), max_bio_size >> 9);
805 max_segments = mdev->ldev->dc.max_bio_bvecs;
806 put_ldev(mdev);
807 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700808
Philipp Reisnerb411b362009-09-25 16:07:19 -0700809 blk_queue_logical_block_size(q, 512);
Lars Ellenberg1816a2b2010-11-11 15:19:07 +0100810 blk_queue_max_hw_sectors(q, max_hw_sectors);
811 /* This is the workaround for "bio would need to, but cannot, be split" */
812 blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
813 blk_queue_segment_boundary(q, PAGE_CACHE_SIZE-1);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700814
Philipp Reisner99432fc2011-05-20 16:39:13 +0200815 if (get_ldev_if_state(mdev, D_ATTACHING)) {
816 struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700817
Philipp Reisner99432fc2011-05-20 16:39:13 +0200818 blk_queue_stack_limits(q, b);
819
820 if (q->backing_dev_info.ra_pages != b->backing_dev_info.ra_pages) {
821 dev_info(DEV, "Adjusting my ra_pages to backing device's (%lu -> %lu)\n",
822 q->backing_dev_info.ra_pages,
823 b->backing_dev_info.ra_pages);
824 q->backing_dev_info.ra_pages = b->backing_dev_info.ra_pages;
825 }
826 put_ldev(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700827 }
828}
829
Philipp Reisner99432fc2011-05-20 16:39:13 +0200830void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
831{
832 int now, new, local, peer;
833
834 now = queue_max_hw_sectors(mdev->rq_queue) << 9;
835 local = mdev->local_max_bio_size; /* Eventually last known value, from volatile memory */
836 peer = mdev->peer_max_bio_size; /* Eventually last known value, from meta data */
837
838 if (get_ldev_if_state(mdev, D_ATTACHING)) {
839 local = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
840 mdev->local_max_bio_size = local;
841 put_ldev(mdev);
842 }
843
844 /* We may ignore peer limits if the peer is modern enough.
845 Because new from 8.3.8 onwards the peer can use multiple
846 BIOs for a single peer_request */
847 if (mdev->state.conn >= C_CONNECTED) {
Philipp Reisner31890f42011-01-19 14:12:51 +0100848 if (mdev->tconn->agreed_pro_version < 94)
Philipp Reisner99432fc2011-05-20 16:39:13 +0200849 peer = mdev->peer_max_bio_size;
Philipp Reisner31890f42011-01-19 14:12:51 +0100850 else if (mdev->tconn->agreed_pro_version == 94)
Philipp Reisner99432fc2011-05-20 16:39:13 +0200851 peer = DRBD_MAX_SIZE_H80_PACKET;
852 else /* drbd 8.3.8 onwards */
853 peer = DRBD_MAX_BIO_SIZE;
854 }
855
856 new = min_t(int, local, peer);
857
858 if (mdev->state.role == R_PRIMARY && new < now)
859 dev_err(DEV, "ASSERT FAILED new < now; (%d < %d)\n", new, now);
860
861 if (new != now)
862 dev_info(DEV, "max BIO size = %u\n", new);
863
864 drbd_setup_queue_param(mdev, new);
865}
866
Philipp Reisnerb411b362009-09-25 16:07:19 -0700867/* serialize deconfig (worker exiting, doing cleanup)
868 * and reconfig (drbdsetup disk, drbdsetup net)
869 *
Lars Ellenbergc518d042010-09-01 09:50:23 +0200870 * Wait for a potentially exiting worker, then restart it,
871 * or start a new one. Flush any pending work, there may still be an
872 * after_state_change queued.
Philipp Reisnerb411b362009-09-25 16:07:19 -0700873 */
874static void drbd_reconfig_start(struct drbd_conf *mdev)
875{
Lars Ellenberg6c6c7952009-11-16 15:48:54 +0100876 wait_event(mdev->state_wait, !test_and_set_bit(CONFIG_PENDING, &mdev->flags));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700877 wait_event(mdev->state_wait, !test_bit(DEVICE_DYING, &mdev->flags));
Philipp Reisnere6b3ea82011-01-19 14:02:01 +0100878 drbd_thread_start(&mdev->tconn->worker);
Philipp Reisnera21e9292011-02-08 15:08:49 +0100879 drbd_flush_workqueue(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700880}
881
882/* if still unconfigured, stops worker again.
883 * if configured now, clears CONFIG_PENDING.
884 * wakes potential waiters */
885static void drbd_reconfig_done(struct drbd_conf *mdev)
886{
Philipp Reisner87eeee42011-01-19 14:16:30 +0100887 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700888 if (mdev->state.disk == D_DISKLESS &&
889 mdev->state.conn == C_STANDALONE &&
890 mdev->state.role == R_SECONDARY) {
891 set_bit(DEVICE_DYING, &mdev->flags);
Philipp Reisnere6b3ea82011-01-19 14:02:01 +0100892 drbd_thread_stop_nowait(&mdev->tconn->worker);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700893 } else
894 clear_bit(CONFIG_PENDING, &mdev->flags);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100895 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700896 wake_up(&mdev->state_wait);
897}
898
Philipp Reisner07782862010-08-31 12:00:50 +0200899/* Make sure IO is suspended before calling this function(). */
900static void drbd_suspend_al(struct drbd_conf *mdev)
901{
902 int s = 0;
903
Lars Ellenberg61610422011-02-21 13:20:54 +0100904 if (!lc_try_lock(mdev->act_log)) {
Philipp Reisner07782862010-08-31 12:00:50 +0200905 dev_warn(DEV, "Failed to lock al in drbd_suspend_al()\n");
906 return;
907 }
908
Lars Ellenberg61610422011-02-21 13:20:54 +0100909 drbd_al_shrink(mdev);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100910 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner07782862010-08-31 12:00:50 +0200911 if (mdev->state.conn < C_CONNECTED)
912 s = !test_and_set_bit(AL_SUSPENDED, &mdev->flags);
Philipp Reisner87eeee42011-01-19 14:16:30 +0100913 spin_unlock_irq(&mdev->tconn->req_lock);
Lars Ellenberg61610422011-02-21 13:20:54 +0100914 lc_unlock(mdev->act_log);
Philipp Reisner07782862010-08-31 12:00:50 +0200915
916 if (s)
917 dev_info(DEV, "Suspended AL updates\n");
918}
919
Philipp Reisnerb411b362009-09-25 16:07:19 -0700920/* does always return 0;
921 * interesting return code is in reply->ret_code */
922static int drbd_nl_disk_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
923 struct drbd_nl_cfg_reply *reply)
924{
Andreas Gruenbacher116676c2010-12-08 13:33:11 +0100925 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700926 enum determine_dev_size dd;
927 sector_t max_possible_sectors;
928 sector_t min_md_device_sectors;
929 struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
Tejun Heoe525fd82010-11-13 11:55:17 +0100930 struct block_device *bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700931 struct lru_cache *resync_lru = NULL;
932 union drbd_state ns, os;
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +0100933 enum drbd_state_rv rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700934 int cp_discovered = 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700935
936 drbd_reconfig_start(mdev);
937
938 /* if you want to reconfigure, please tear down first */
939 if (mdev->state.disk > D_DISKLESS) {
940 retcode = ERR_DISK_CONFIGURED;
941 goto fail;
942 }
Lars Ellenberg82f59cc2010-10-16 12:13:47 +0200943 /* It may just now have detached because of IO error. Make sure
944 * drbd_ldev_destroy is done already, we may end up here very fast,
945 * e.g. if someone calls attach from the on-io-error handler,
946 * to realize a "hot spare" feature (not that I'd recommend that) */
947 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700948
949 /* allocation not in the IO path, cqueue thread context */
950 nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
951 if (!nbc) {
952 retcode = ERR_NOMEM;
953 goto fail;
954 }
955
956 nbc->dc.disk_size = DRBD_DISK_SIZE_SECT_DEF;
957 nbc->dc.on_io_error = DRBD_ON_IO_ERROR_DEF;
958 nbc->dc.fencing = DRBD_FENCING_DEF;
959 nbc->dc.max_bio_bvecs = DRBD_MAX_BIO_BVECS_DEF;
960
961 if (!disk_conf_from_tags(mdev, nlp->tag_list, &nbc->dc)) {
962 retcode = ERR_MANDATORY_TAG;
963 goto fail;
964 }
965
966 if (nbc->dc.meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
967 retcode = ERR_MD_IDX_INVALID;
968 goto fail;
969 }
970
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +0100971 if (get_net_conf(mdev->tconn)) {
Philipp Reisner89e58e72011-01-19 13:12:45 +0100972 int prot = mdev->tconn->net_conf->wire_protocol;
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +0100973 put_net_conf(mdev->tconn);
Philipp Reisner47ff2d02010-06-18 13:56:57 +0200974 if (nbc->dc.fencing == FP_STONITH && prot == DRBD_PROT_A) {
975 retcode = ERR_STONITH_AND_PROT_A;
976 goto fail;
977 }
978 }
979
Tejun Heod4d77622010-11-13 11:55:18 +0100980 bdev = blkdev_get_by_path(nbc->dc.backing_dev,
981 FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
Tejun Heoe525fd82010-11-13 11:55:17 +0100982 if (IS_ERR(bdev)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700983 dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.backing_dev,
Tejun Heoe525fd82010-11-13 11:55:17 +0100984 PTR_ERR(bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700985 retcode = ERR_OPEN_DISK;
986 goto fail;
987 }
Tejun Heoe525fd82010-11-13 11:55:17 +0100988 nbc->backing_bdev = bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700989
Tejun Heoe525fd82010-11-13 11:55:17 +0100990 /*
991 * meta_dev_idx >= 0: external fixed size, possibly multiple
992 * drbd sharing one meta device. TODO in that case, paranoia
993 * check that [md_bdev, meta_dev_idx] is not yet used by some
994 * other drbd minor! (if you use drbd.conf + drbdadm, that
995 * should check it for you already; but if you don't, or
996 * someone fooled it, we need to double check here)
997 */
Tejun Heod4d77622010-11-13 11:55:18 +0100998 bdev = blkdev_get_by_path(nbc->dc.meta_dev,
999 FMODE_READ | FMODE_WRITE | FMODE_EXCL,
1000 (nbc->dc.meta_dev_idx < 0) ?
1001 (void *)mdev : (void *)drbd_m_holder);
Tejun Heoe525fd82010-11-13 11:55:17 +01001002 if (IS_ERR(bdev)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001003 dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.meta_dev,
Tejun Heoe525fd82010-11-13 11:55:17 +01001004 PTR_ERR(bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001005 retcode = ERR_OPEN_MD_DISK;
1006 goto fail;
1007 }
Tejun Heoe525fd82010-11-13 11:55:17 +01001008 nbc->md_bdev = bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001009
Tejun Heoe525fd82010-11-13 11:55:17 +01001010 if ((nbc->backing_bdev == nbc->md_bdev) !=
1011 (nbc->dc.meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
1012 nbc->dc.meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
1013 retcode = ERR_MD_IDX_INVALID;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001014 goto fail;
1015 }
1016
1017 resync_lru = lc_create("resync", drbd_bm_ext_cache,
Lars Ellenberg46a15bc2011-02-21 13:21:01 +01001018 1, 61, sizeof(struct bm_extent),
Philipp Reisnerb411b362009-09-25 16:07:19 -07001019 offsetof(struct bm_extent, lce));
1020 if (!resync_lru) {
1021 retcode = ERR_NOMEM;
Tejun Heoe525fd82010-11-13 11:55:17 +01001022 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001023 }
1024
1025 /* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */
1026 drbd_md_set_sector_offsets(mdev, nbc);
1027
1028 if (drbd_get_max_capacity(nbc) < nbc->dc.disk_size) {
1029 dev_err(DEV, "max capacity %llu smaller than disk size %llu\n",
1030 (unsigned long long) drbd_get_max_capacity(nbc),
1031 (unsigned long long) nbc->dc.disk_size);
1032 retcode = ERR_DISK_TO_SMALL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001033 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001034 }
1035
1036 if (nbc->dc.meta_dev_idx < 0) {
1037 max_possible_sectors = DRBD_MAX_SECTORS_FLEX;
1038 /* at least one MB, otherwise it does not make sense */
1039 min_md_device_sectors = (2<<10);
1040 } else {
1041 max_possible_sectors = DRBD_MAX_SECTORS;
1042 min_md_device_sectors = MD_RESERVED_SECT * (nbc->dc.meta_dev_idx + 1);
1043 }
1044
Philipp Reisnerb411b362009-09-25 16:07:19 -07001045 if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) {
1046 retcode = ERR_MD_DISK_TO_SMALL;
1047 dev_warn(DEV, "refusing attach: md-device too small, "
1048 "at least %llu sectors needed for this meta-disk type\n",
1049 (unsigned long long) min_md_device_sectors);
Tejun Heoe525fd82010-11-13 11:55:17 +01001050 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001051 }
1052
1053 /* Make sure the new disk is big enough
1054 * (we may currently be R_PRIMARY with no local disk...) */
1055 if (drbd_get_max_capacity(nbc) <
1056 drbd_get_capacity(mdev->this_bdev)) {
1057 retcode = ERR_DISK_TO_SMALL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001058 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001059 }
1060
1061 nbc->known_size = drbd_get_capacity(nbc->backing_bdev);
1062
Lars Ellenberg13529942009-10-12 19:07:49 +02001063 if (nbc->known_size > max_possible_sectors) {
1064 dev_warn(DEV, "==> truncating very big lower level device "
1065 "to currently maximum possible %llu sectors <==\n",
1066 (unsigned long long) max_possible_sectors);
1067 if (nbc->dc.meta_dev_idx >= 0)
1068 dev_warn(DEV, "==>> using internal or flexible "
1069 "meta data may help <<==\n");
1070 }
1071
Philipp Reisnerb411b362009-09-25 16:07:19 -07001072 drbd_suspend_io(mdev);
1073 /* also wait for the last barrier ack. */
Philipp Reisnerfb22c402010-09-08 23:20:21 +02001074 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || is_susp(mdev->state));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001075 /* and for any other previously queued work */
Philipp Reisnera21e9292011-02-08 15:08:49 +01001076 drbd_flush_workqueue(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001077
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001078 rv = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE);
1079 retcode = rv; /* FIXME: Type mismatch. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001080 drbd_resume_io(mdev);
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001081 if (rv < SS_SUCCESS)
Tejun Heoe525fd82010-11-13 11:55:17 +01001082 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001083
1084 if (!get_ldev_if_state(mdev, D_ATTACHING))
1085 goto force_diskless;
1086
1087 drbd_md_set_sector_offsets(mdev, nbc);
1088
1089 if (!mdev->bitmap) {
1090 if (drbd_bm_init(mdev)) {
1091 retcode = ERR_NOMEM;
1092 goto force_diskless_dec;
1093 }
1094 }
1095
1096 retcode = drbd_md_read(mdev, nbc);
1097 if (retcode != NO_ERROR)
1098 goto force_diskless_dec;
1099
1100 if (mdev->state.conn < C_CONNECTED &&
1101 mdev->state.role == R_PRIMARY &&
1102 (mdev->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
1103 dev_err(DEV, "Can only attach to data with current UUID=%016llX\n",
1104 (unsigned long long)mdev->ed_uuid);
1105 retcode = ERR_DATA_NOT_CURRENT;
1106 goto force_diskless_dec;
1107 }
1108
1109 /* Since we are diskless, fix the activity log first... */
1110 if (drbd_check_al_size(mdev)) {
1111 retcode = ERR_NOMEM;
1112 goto force_diskless_dec;
1113 }
1114
1115 /* Prevent shrinking of consistent devices ! */
1116 if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
Philipp Reisnera393db62009-12-22 13:35:52 +01001117 drbd_new_dev_size(mdev, nbc, 0) < nbc->md.la_size_sect) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001118 dev_warn(DEV, "refusing to truncate a consistent device\n");
1119 retcode = ERR_DISK_TO_SMALL;
1120 goto force_diskless_dec;
1121 }
1122
1123 if (!drbd_al_read_log(mdev, nbc)) {
1124 retcode = ERR_IO_MD_DISK;
1125 goto force_diskless_dec;
1126 }
1127
Philipp Reisnerb411b362009-09-25 16:07:19 -07001128 /* Reset the "barriers don't work" bits here, then force meta data to
1129 * be written, to ensure we determine if barriers are supported. */
1130 if (nbc->dc.no_md_flush)
Philipp Reisnera8a4e512010-08-25 10:21:04 +02001131 set_bit(MD_NO_FUA, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001132 else
Philipp Reisnera8a4e512010-08-25 10:21:04 +02001133 clear_bit(MD_NO_FUA, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001134
1135 /* Point of no return reached.
1136 * Devices and memory are no longer released by error cleanup below.
1137 * now mdev takes over responsibility, and the state engine should
1138 * clean it up somewhere. */
1139 D_ASSERT(mdev->ldev == NULL);
1140 mdev->ldev = nbc;
1141 mdev->resync = resync_lru;
1142 nbc = NULL;
1143 resync_lru = NULL;
1144
Philipp Reisner2451fc32010-08-24 13:43:11 +02001145 mdev->write_ordering = WO_bdev_flush;
1146 drbd_bump_write_ordering(mdev, WO_bdev_flush);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001147
1148 if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
1149 set_bit(CRASHED_PRIMARY, &mdev->flags);
1150 else
1151 clear_bit(CRASHED_PRIMARY, &mdev->flags);
1152
Philipp Reisner894c6a92010-06-18 16:03:20 +02001153 if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
Philipp Reisnerfb22c402010-09-08 23:20:21 +02001154 !(mdev->state.role == R_PRIMARY && mdev->state.susp_nod)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001155 set_bit(CRASHED_PRIMARY, &mdev->flags);
1156 cp_discovered = 1;
1157 }
1158
1159 mdev->send_cnt = 0;
1160 mdev->recv_cnt = 0;
1161 mdev->read_cnt = 0;
1162 mdev->writ_cnt = 0;
1163
Philipp Reisner99432fc2011-05-20 16:39:13 +02001164 drbd_reconsider_max_bio_size(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001165
1166 /* If I am currently not R_PRIMARY,
1167 * but meta data primary indicator is set,
1168 * I just now recover from a hard crash,
1169 * and have been R_PRIMARY before that crash.
1170 *
1171 * Now, if I had no connection before that crash
1172 * (have been degraded R_PRIMARY), chances are that
1173 * I won't find my peer now either.
1174 *
1175 * In that case, and _only_ in that case,
1176 * we use the degr-wfc-timeout instead of the default,
1177 * so we can automatically recover from a crash of a
1178 * degraded but active "cluster" after a certain timeout.
1179 */
1180 clear_bit(USE_DEGR_WFC_T, &mdev->flags);
1181 if (mdev->state.role != R_PRIMARY &&
1182 drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
1183 !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND))
1184 set_bit(USE_DEGR_WFC_T, &mdev->flags);
1185
Bart Van Assche24c48302011-05-21 18:32:29 +02001186 dd = drbd_determine_dev_size(mdev, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001187 if (dd == dev_size_error) {
1188 retcode = ERR_NOMEM_BITMAP;
1189 goto force_diskless_dec;
1190 } else if (dd == grew)
1191 set_bit(RESYNC_AFTER_NEG, &mdev->flags);
1192
1193 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
1194 dev_info(DEV, "Assuming that all blocks are out of sync "
1195 "(aka FullSync)\n");
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001196 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
1197 "set_n_write from attaching", BM_LOCKED_MASK)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001198 retcode = ERR_IO_MD_DISK;
1199 goto force_diskless_dec;
1200 }
1201 } else {
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001202 if (drbd_bitmap_io(mdev, &drbd_bm_read,
1203 "read from attaching", BM_LOCKED_MASK) < 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001204 retcode = ERR_IO_MD_DISK;
1205 goto force_diskless_dec;
1206 }
1207 }
1208
1209 if (cp_discovered) {
1210 drbd_al_apply_to_bm(mdev);
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001211 if (drbd_bitmap_io(mdev, &drbd_bm_write,
1212 "crashed primary apply AL", BM_LOCKED_MASK)) {
Lars Ellenberg19f843a2010-12-15 08:59:11 +01001213 retcode = ERR_IO_MD_DISK;
1214 goto force_diskless_dec;
1215 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001216 }
1217
Philipp Reisner07782862010-08-31 12:00:50 +02001218 if (_drbd_bm_total_weight(mdev) == drbd_bm_bits(mdev))
1219 drbd_suspend_al(mdev); /* IO is still suspended here... */
1220
Philipp Reisner87eeee42011-01-19 14:16:30 +01001221 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001222 os = mdev->state;
1223 ns.i = os.i;
1224 /* If MDF_CONSISTENT is not set go into inconsistent state,
1225 otherwise investigate MDF_WasUpToDate...
1226 If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state,
1227 otherwise into D_CONSISTENT state.
1228 */
1229 if (drbd_md_test_flag(mdev->ldev, MDF_CONSISTENT)) {
1230 if (drbd_md_test_flag(mdev->ldev, MDF_WAS_UP_TO_DATE))
1231 ns.disk = D_CONSISTENT;
1232 else
1233 ns.disk = D_OUTDATED;
1234 } else {
1235 ns.disk = D_INCONSISTENT;
1236 }
1237
1238 if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED))
1239 ns.pdsk = D_OUTDATED;
1240
1241 if ( ns.disk == D_CONSISTENT &&
1242 (ns.pdsk == D_OUTDATED || mdev->ldev->dc.fencing == FP_DONT_CARE))
1243 ns.disk = D_UP_TO_DATE;
1244
1245 /* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND,
1246 MDF_CONSISTENT and MDF_WAS_UP_TO_DATE must happen before
1247 this point, because drbd_request_state() modifies these
1248 flags. */
1249
1250 /* In case we are C_CONNECTED postpone any decision on the new disk
1251 state after the negotiation phase. */
1252 if (mdev->state.conn == C_CONNECTED) {
1253 mdev->new_state_tmp.i = ns.i;
1254 ns.i = os.i;
1255 ns.disk = D_NEGOTIATING;
Philipp Reisnerdc66c742010-06-02 14:31:29 +02001256
1257 /* We expect to receive up-to-date UUIDs soon.
1258 To avoid a race in receive_state, free p_uuid while
1259 holding req_lock. I.e. atomic with the state change */
1260 kfree(mdev->p_uuid);
1261 mdev->p_uuid = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001262 }
1263
1264 rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
1265 ns = mdev->state;
Philipp Reisner87eeee42011-01-19 14:16:30 +01001266 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001267
1268 if (rv < SS_SUCCESS)
1269 goto force_diskless_dec;
1270
1271 if (mdev->state.role == R_PRIMARY)
1272 mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1;
1273 else
1274 mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
1275
1276 drbd_md_mark_dirty(mdev);
1277 drbd_md_sync(mdev);
1278
1279 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
1280 put_ldev(mdev);
1281 reply->ret_code = retcode;
1282 drbd_reconfig_done(mdev);
1283 return 0;
1284
1285 force_diskless_dec:
1286 put_ldev(mdev);
1287 force_diskless:
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001288 drbd_force_state(mdev, NS(disk, D_FAILED));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001289 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001290 fail:
1291 if (nbc) {
Tejun Heoe525fd82010-11-13 11:55:17 +01001292 if (nbc->backing_bdev)
1293 blkdev_put(nbc->backing_bdev,
1294 FMODE_READ | FMODE_WRITE | FMODE_EXCL);
1295 if (nbc->md_bdev)
1296 blkdev_put(nbc->md_bdev,
1297 FMODE_READ | FMODE_WRITE | FMODE_EXCL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001298 kfree(nbc);
1299 }
1300 lc_destroy(resync_lru);
1301
1302 reply->ret_code = retcode;
1303 drbd_reconfig_done(mdev);
1304 return 0;
1305}
1306
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001307/* Detaching the disk is a process in multiple stages. First we need to lock
1308 * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
1309 * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
1310 * internal references as well.
1311 * Only then we have finally detached. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001312static int drbd_nl_detach(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1313 struct drbd_nl_cfg_reply *reply)
1314{
Lars Ellenberg9a0d9d02011-05-02 11:51:31 +02001315 enum drbd_ret_code retcode;
1316 int ret;
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001317 drbd_suspend_io(mdev); /* so no-one is stuck in drbd_al_begin_io */
Lars Ellenberg9a0d9d02011-05-02 11:51:31 +02001318 retcode = drbd_request_state(mdev, NS(disk, D_FAILED));
1319 /* D_FAILED will transition to DISKLESS. */
1320 ret = wait_event_interruptible(mdev->misc_wait,
1321 mdev->state.disk != D_FAILED);
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001322 drbd_resume_io(mdev);
Philipp Reisner9b2f61a2011-05-24 10:27:38 +02001323 if ((int)retcode == (int)SS_IS_DISKLESS)
Lars Ellenberg9a0d9d02011-05-02 11:51:31 +02001324 retcode = SS_NOTHING_TO_DO;
1325 if (ret)
1326 retcode = ERR_INTR;
1327 reply->ret_code = retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001328 return 0;
1329}
1330
1331static int drbd_nl_net_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1332 struct drbd_nl_cfg_reply *reply)
1333{
Andreas Gruenbacherbb3bfe92011-01-21 15:59:23 +01001334 int i;
Andreas Gruenbacher116676c2010-12-08 13:33:11 +01001335 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001336 struct net_conf *new_conf = NULL;
1337 struct crypto_hash *tfm = NULL;
1338 struct crypto_hash *integrity_w_tfm = NULL;
1339 struct crypto_hash *integrity_r_tfm = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001340 struct drbd_conf *odev;
1341 char hmac_name[CRYPTO_MAX_ALG_NAME];
1342 void *int_dig_out = NULL;
1343 void *int_dig_in = NULL;
1344 void *int_dig_vv = NULL;
1345 struct sockaddr *new_my_addr, *new_peer_addr, *taken_addr;
1346
1347 drbd_reconfig_start(mdev);
1348
1349 if (mdev->state.conn > C_STANDALONE) {
1350 retcode = ERR_NET_CONFIGURED;
1351 goto fail;
1352 }
1353
1354 /* allocation not in the IO path, cqueue thread context */
Julia Lawall2db4e422010-05-13 22:02:21 +02001355 new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001356 if (!new_conf) {
1357 retcode = ERR_NOMEM;
1358 goto fail;
1359 }
1360
Philipp Reisnerb411b362009-09-25 16:07:19 -07001361 new_conf->timeout = DRBD_TIMEOUT_DEF;
1362 new_conf->try_connect_int = DRBD_CONNECT_INT_DEF;
1363 new_conf->ping_int = DRBD_PING_INT_DEF;
1364 new_conf->max_epoch_size = DRBD_MAX_EPOCH_SIZE_DEF;
1365 new_conf->max_buffers = DRBD_MAX_BUFFERS_DEF;
1366 new_conf->unplug_watermark = DRBD_UNPLUG_WATERMARK_DEF;
1367 new_conf->sndbuf_size = DRBD_SNDBUF_SIZE_DEF;
1368 new_conf->rcvbuf_size = DRBD_RCVBUF_SIZE_DEF;
1369 new_conf->ko_count = DRBD_KO_COUNT_DEF;
1370 new_conf->after_sb_0p = DRBD_AFTER_SB_0P_DEF;
1371 new_conf->after_sb_1p = DRBD_AFTER_SB_1P_DEF;
1372 new_conf->after_sb_2p = DRBD_AFTER_SB_2P_DEF;
1373 new_conf->want_lose = 0;
1374 new_conf->two_primaries = 0;
1375 new_conf->wire_protocol = DRBD_PROT_C;
1376 new_conf->ping_timeo = DRBD_PING_TIMEO_DEF;
1377 new_conf->rr_conflict = DRBD_RR_CONFLICT_DEF;
Philipp Reisner422028b2010-10-27 11:12:07 +02001378 new_conf->on_congestion = DRBD_ON_CONGESTION_DEF;
1379 new_conf->cong_extents = DRBD_CONG_EXTENTS_DEF;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001380
1381 if (!net_conf_from_tags(mdev, nlp->tag_list, new_conf)) {
1382 retcode = ERR_MANDATORY_TAG;
1383 goto fail;
1384 }
1385
1386 if (new_conf->two_primaries
1387 && (new_conf->wire_protocol != DRBD_PROT_C)) {
1388 retcode = ERR_NOT_PROTO_C;
1389 goto fail;
Philipp Reisner47ff2d02010-06-18 13:56:57 +02001390 }
1391
1392 if (get_ldev(mdev)) {
1393 enum drbd_fencing_p fp = mdev->ldev->dc.fencing;
1394 put_ldev(mdev);
1395 if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH) {
1396 retcode = ERR_STONITH_AND_PROT_A;
1397 goto fail;
1398 }
1399 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001400
Philipp Reisner422028b2010-10-27 11:12:07 +02001401 if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A) {
1402 retcode = ERR_CONG_NOT_PROTO_A;
1403 goto fail;
1404 }
1405
Philipp Reisnerb411b362009-09-25 16:07:19 -07001406 if (mdev->state.role == R_PRIMARY && new_conf->want_lose) {
1407 retcode = ERR_DISCARD;
1408 goto fail;
1409 }
1410
1411 retcode = NO_ERROR;
1412
1413 new_my_addr = (struct sockaddr *)&new_conf->my_addr;
1414 new_peer_addr = (struct sockaddr *)&new_conf->peer_addr;
1415 for (i = 0; i < minor_count; i++) {
1416 odev = minor_to_mdev(i);
1417 if (!odev || odev == mdev)
1418 continue;
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +01001419 if (get_net_conf(odev->tconn)) {
Philipp Reisner89e58e72011-01-19 13:12:45 +01001420 taken_addr = (struct sockaddr *)&odev->tconn->net_conf->my_addr;
1421 if (new_conf->my_addr_len == odev->tconn->net_conf->my_addr_len &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07001422 !memcmp(new_my_addr, taken_addr, new_conf->my_addr_len))
1423 retcode = ERR_LOCAL_ADDR;
1424
Philipp Reisner89e58e72011-01-19 13:12:45 +01001425 taken_addr = (struct sockaddr *)&odev->tconn->net_conf->peer_addr;
1426 if (new_conf->peer_addr_len == odev->tconn->net_conf->peer_addr_len &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07001427 !memcmp(new_peer_addr, taken_addr, new_conf->peer_addr_len))
1428 retcode = ERR_PEER_ADDR;
1429
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +01001430 put_net_conf(odev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001431 if (retcode != NO_ERROR)
1432 goto fail;
1433 }
1434 }
1435
1436 if (new_conf->cram_hmac_alg[0] != 0) {
1437 snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
1438 new_conf->cram_hmac_alg);
1439 tfm = crypto_alloc_hash(hmac_name, 0, CRYPTO_ALG_ASYNC);
1440 if (IS_ERR(tfm)) {
1441 tfm = NULL;
1442 retcode = ERR_AUTH_ALG;
1443 goto fail;
1444 }
1445
Philipp Reisner07982192009-12-28 16:58:38 +01001446 if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001447 retcode = ERR_AUTH_ALG_ND;
1448 goto fail;
1449 }
1450 }
1451
1452 if (new_conf->integrity_alg[0]) {
1453 integrity_w_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC);
1454 if (IS_ERR(integrity_w_tfm)) {
1455 integrity_w_tfm = NULL;
1456 retcode=ERR_INTEGRITY_ALG;
1457 goto fail;
1458 }
1459
1460 if (!drbd_crypto_is_hash(crypto_hash_tfm(integrity_w_tfm))) {
1461 retcode=ERR_INTEGRITY_ALG_ND;
1462 goto fail;
1463 }
1464
1465 integrity_r_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC);
1466 if (IS_ERR(integrity_r_tfm)) {
1467 integrity_r_tfm = NULL;
1468 retcode=ERR_INTEGRITY_ALG;
1469 goto fail;
1470 }
1471 }
1472
Philipp Reisnerb411b362009-09-25 16:07:19 -07001473 ((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;
1474
1475 if (integrity_w_tfm) {
1476 i = crypto_hash_digestsize(integrity_w_tfm);
1477 int_dig_out = kmalloc(i, GFP_KERNEL);
1478 if (!int_dig_out) {
1479 retcode = ERR_NOMEM;
1480 goto fail;
1481 }
1482 int_dig_in = kmalloc(i, GFP_KERNEL);
1483 if (!int_dig_in) {
1484 retcode = ERR_NOMEM;
1485 goto fail;
1486 }
1487 int_dig_vv = kmalloc(i, GFP_KERNEL);
1488 if (!int_dig_vv) {
1489 retcode = ERR_NOMEM;
1490 goto fail;
1491 }
1492 }
1493
1494 if (!mdev->bitmap) {
1495 if(drbd_bm_init(mdev)) {
1496 retcode = ERR_NOMEM;
1497 goto fail;
1498 }
1499 }
1500
Philipp Reisnera21e9292011-02-08 15:08:49 +01001501 drbd_flush_workqueue(mdev);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001502 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner89e58e72011-01-19 13:12:45 +01001503 if (mdev->tconn->net_conf != NULL) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001504 retcode = ERR_NET_CONFIGURED;
Philipp Reisner87eeee42011-01-19 14:16:30 +01001505 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001506 goto fail;
1507 }
Philipp Reisner89e58e72011-01-19 13:12:45 +01001508 mdev->tconn->net_conf = new_conf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001509
1510 mdev->send_cnt = 0;
1511 mdev->recv_cnt = 0;
1512
Philipp Reisnera0638452011-01-19 14:31:32 +01001513 crypto_free_hash(mdev->tconn->cram_hmac_tfm);
1514 mdev->tconn->cram_hmac_tfm = tfm;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001515
Philipp Reisnera0638452011-01-19 14:31:32 +01001516 crypto_free_hash(mdev->tconn->integrity_w_tfm);
1517 mdev->tconn->integrity_w_tfm = integrity_w_tfm;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001518
Philipp Reisnera0638452011-01-19 14:31:32 +01001519 crypto_free_hash(mdev->tconn->integrity_r_tfm);
1520 mdev->tconn->integrity_r_tfm = integrity_r_tfm;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001521
Philipp Reisnera0638452011-01-19 14:31:32 +01001522 kfree(mdev->tconn->int_dig_out);
1523 kfree(mdev->tconn->int_dig_in);
1524 kfree(mdev->tconn->int_dig_vv);
1525 mdev->tconn->int_dig_out=int_dig_out;
1526 mdev->tconn->int_dig_in=int_dig_in;
1527 mdev->tconn->int_dig_vv=int_dig_vv;
Philipp Reisnerbbeb6412011-02-10 13:45:46 +01001528 retcode = _conn_request_state(mdev->tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001529 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001530
Philipp Reisnerb411b362009-09-25 16:07:19 -07001531 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
1532 reply->ret_code = retcode;
1533 drbd_reconfig_done(mdev);
1534 return 0;
1535
1536fail:
1537 kfree(int_dig_out);
1538 kfree(int_dig_in);
1539 kfree(int_dig_vv);
1540 crypto_free_hash(tfm);
1541 crypto_free_hash(integrity_w_tfm);
1542 crypto_free_hash(integrity_r_tfm);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001543 kfree(new_conf);
1544
1545 reply->ret_code = retcode;
1546 drbd_reconfig_done(mdev);
1547 return 0;
1548}
1549
1550static int drbd_nl_disconnect(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1551 struct drbd_nl_cfg_reply *reply)
1552{
Philipp Reisnerdf24aa42011-02-15 11:14:44 +01001553 struct drbd_tconn *tconn = mdev->tconn;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001554 int retcode;
Philipp Reisner2561b9c2010-12-03 15:22:48 +01001555 struct disconnect dc;
1556
1557 memset(&dc, 0, sizeof(struct disconnect));
1558 if (!disconnect_from_tags(mdev, nlp->tag_list, &dc)) {
1559 retcode = ERR_MANDATORY_TAG;
1560 goto fail;
1561 }
1562
1563 if (dc.force) {
Philipp Reisnerdf24aa42011-02-15 11:14:44 +01001564 spin_lock_irq(&tconn->req_lock);
1565 if (tconn->cstate >= C_WF_CONNECTION)
1566 _conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
1567 spin_unlock_irq(&tconn->req_lock);
Philipp Reisner2561b9c2010-12-03 15:22:48 +01001568 goto done;
1569 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001570
Philipp Reisnerdf24aa42011-02-15 11:14:44 +01001571 retcode = conn_request_state(tconn, NS(conn, C_DISCONNECTING), 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001572
1573 if (retcode == SS_NOTHING_TO_DO)
1574 goto done;
1575 else if (retcode == SS_ALREADY_STANDALONE)
1576 goto done;
1577 else if (retcode == SS_PRIMARY_NOP) {
Philipp Reisnerdf24aa42011-02-15 11:14:44 +01001578 /* Our state checking code wants to see the peer outdated. */
1579 retcode = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
1580 pdsk, D_OUTDATED), CS_VERBOSE);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001581 } else if (retcode == SS_CW_FAILED_BY_PEER) {
1582 /* The peer probably wants to see us outdated. */
Philipp Reisnerdf24aa42011-02-15 11:14:44 +01001583 retcode = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
1584 disk, D_OUTDATED), 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001585 if (retcode == SS_IS_DISKLESS || retcode == SS_LOWER_THAN_OUTDATED) {
Philipp Reisnerdf24aa42011-02-15 11:14:44 +01001586 conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001587 retcode = SS_SUCCESS;
1588 }
1589 }
1590
1591 if (retcode < SS_SUCCESS)
1592 goto fail;
1593
Philipp Reisnerdf24aa42011-02-15 11:14:44 +01001594 if (wait_event_interruptible(tconn->ping_wait,
1595 tconn->cstate != C_DISCONNECTING)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001596 /* Do not test for mdev->state.conn == C_STANDALONE, since
1597 someone else might connect us in the mean time! */
1598 retcode = ERR_INTR;
1599 goto fail;
1600 }
1601
1602 done:
1603 retcode = NO_ERROR;
1604 fail:
1605 drbd_md_sync(mdev);
1606 reply->ret_code = retcode;
1607 return 0;
1608}
1609
1610void resync_after_online_grow(struct drbd_conf *mdev)
1611{
1612 int iass; /* I am sync source */
1613
1614 dev_info(DEV, "Resync of new storage after online grow\n");
1615 if (mdev->state.role != mdev->state.peer)
1616 iass = (mdev->state.role == R_PRIMARY);
1617 else
Philipp Reisner25703f82011-02-07 14:35:25 +01001618 iass = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001619
1620 if (iass)
1621 drbd_start_resync(mdev, C_SYNC_SOURCE);
1622 else
1623 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE);
1624}
1625
1626static int drbd_nl_resize(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1627 struct drbd_nl_cfg_reply *reply)
1628{
1629 struct resize rs;
1630 int retcode = NO_ERROR;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001631 enum determine_dev_size dd;
Philipp Reisner6495d2c2010-03-24 16:07:04 +01001632 enum dds_flags ddsf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001633
1634 memset(&rs, 0, sizeof(struct resize));
1635 if (!resize_from_tags(mdev, nlp->tag_list, &rs)) {
1636 retcode = ERR_MANDATORY_TAG;
1637 goto fail;
1638 }
1639
1640 if (mdev->state.conn > C_CONNECTED) {
1641 retcode = ERR_RESIZE_RESYNC;
1642 goto fail;
1643 }
1644
1645 if (mdev->state.role == R_SECONDARY &&
1646 mdev->state.peer == R_SECONDARY) {
1647 retcode = ERR_NO_PRIMARY;
1648 goto fail;
1649 }
1650
1651 if (!get_ldev(mdev)) {
1652 retcode = ERR_NO_DISK;
1653 goto fail;
1654 }
1655
Philipp Reisner31890f42011-01-19 14:12:51 +01001656 if (rs.no_resync && mdev->tconn->agreed_pro_version < 93) {
Philipp Reisner6495d2c2010-03-24 16:07:04 +01001657 retcode = ERR_NEED_APV_93;
1658 goto fail;
1659 }
1660
Philipp Reisner087c2492010-03-26 13:49:56 +01001661 if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001662 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001663
1664 mdev->ldev->dc.disk_size = (sector_t)rs.resize_size;
Philipp Reisner6495d2c2010-03-24 16:07:04 +01001665 ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0);
Bart Van Assche24c48302011-05-21 18:32:29 +02001666 dd = drbd_determine_dev_size(mdev, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001667 drbd_md_sync(mdev);
1668 put_ldev(mdev);
1669 if (dd == dev_size_error) {
1670 retcode = ERR_NOMEM_BITMAP;
1671 goto fail;
1672 }
1673
Philipp Reisner087c2492010-03-26 13:49:56 +01001674 if (mdev->state.conn == C_CONNECTED) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001675 if (dd == grew)
1676 set_bit(RESIZE_PENDING, &mdev->flags);
1677
1678 drbd_send_uuids(mdev);
Philipp Reisner6495d2c2010-03-24 16:07:04 +01001679 drbd_send_sizes(mdev, 1, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001680 }
1681
1682 fail:
1683 reply->ret_code = retcode;
1684 return 0;
1685}
1686
1687static int drbd_nl_syncer_conf(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1688 struct drbd_nl_cfg_reply *reply)
1689{
1690 int retcode = NO_ERROR;
1691 int err;
1692 int ovr; /* online verify running */
1693 int rsr; /* re-sync running */
1694 struct crypto_hash *verify_tfm = NULL;
1695 struct crypto_hash *csums_tfm = NULL;
1696 struct syncer_conf sc;
1697 cpumask_var_t new_cpu_mask;
Philipp Reisner778f2712010-07-06 11:14:00 +02001698 int *rs_plan_s = NULL;
1699 int fifo_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001700
1701 if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL)) {
1702 retcode = ERR_NOMEM;
1703 goto fail;
1704 }
1705
1706 if (nlp->flags & DRBD_NL_SET_DEFAULTS) {
1707 memset(&sc, 0, sizeof(struct syncer_conf));
1708 sc.rate = DRBD_RATE_DEF;
1709 sc.after = DRBD_AFTER_DEF;
1710 sc.al_extents = DRBD_AL_EXTENTS_DEF;
Philipp Reisner265be2d2010-05-31 10:14:17 +02001711 sc.on_no_data = DRBD_ON_NO_DATA_DEF;
Philipp Reisner9a31d712010-07-05 13:42:03 +02001712 sc.c_plan_ahead = DRBD_C_PLAN_AHEAD_DEF;
1713 sc.c_delay_target = DRBD_C_DELAY_TARGET_DEF;
1714 sc.c_fill_target = DRBD_C_FILL_TARGET_DEF;
Lars Ellenberg0f0601f2010-08-11 23:40:24 +02001715 sc.c_max_rate = DRBD_C_MAX_RATE_DEF;
1716 sc.c_min_rate = DRBD_C_MIN_RATE_DEF;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001717 } else
1718 memcpy(&sc, &mdev->sync_conf, sizeof(struct syncer_conf));
1719
1720 if (!syncer_conf_from_tags(mdev, nlp->tag_list, &sc)) {
1721 retcode = ERR_MANDATORY_TAG;
1722 goto fail;
1723 }
1724
1725 /* re-sync running */
1726 rsr = ( mdev->state.conn == C_SYNC_SOURCE ||
1727 mdev->state.conn == C_SYNC_TARGET ||
1728 mdev->state.conn == C_PAUSED_SYNC_S ||
1729 mdev->state.conn == C_PAUSED_SYNC_T );
1730
1731 if (rsr && strcmp(sc.csums_alg, mdev->sync_conf.csums_alg)) {
1732 retcode = ERR_CSUMS_RESYNC_RUNNING;
1733 goto fail;
1734 }
1735
1736 if (!rsr && sc.csums_alg[0]) {
1737 csums_tfm = crypto_alloc_hash(sc.csums_alg, 0, CRYPTO_ALG_ASYNC);
1738 if (IS_ERR(csums_tfm)) {
1739 csums_tfm = NULL;
1740 retcode = ERR_CSUMS_ALG;
1741 goto fail;
1742 }
1743
1744 if (!drbd_crypto_is_hash(crypto_hash_tfm(csums_tfm))) {
1745 retcode = ERR_CSUMS_ALG_ND;
1746 goto fail;
1747 }
1748 }
1749
1750 /* online verify running */
1751 ovr = (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T);
1752
1753 if (ovr) {
1754 if (strcmp(sc.verify_alg, mdev->sync_conf.verify_alg)) {
1755 retcode = ERR_VERIFY_RUNNING;
1756 goto fail;
1757 }
1758 }
1759
1760 if (!ovr && sc.verify_alg[0]) {
1761 verify_tfm = crypto_alloc_hash(sc.verify_alg, 0, CRYPTO_ALG_ASYNC);
1762 if (IS_ERR(verify_tfm)) {
1763 verify_tfm = NULL;
1764 retcode = ERR_VERIFY_ALG;
1765 goto fail;
1766 }
1767
1768 if (!drbd_crypto_is_hash(crypto_hash_tfm(verify_tfm))) {
1769 retcode = ERR_VERIFY_ALG_ND;
1770 goto fail;
1771 }
1772 }
1773
1774 /* silently ignore cpu mask on UP kernel */
1775 if (nr_cpu_ids > 1 && sc.cpu_mask[0] != 0) {
1776 err = __bitmap_parse(sc.cpu_mask, 32, 0,
1777 cpumask_bits(new_cpu_mask), nr_cpu_ids);
1778 if (err) {
1779 dev_warn(DEV, "__bitmap_parse() failed with %d\n", err);
1780 retcode = ERR_CPU_MASK_PARSE;
1781 goto fail;
1782 }
1783 }
1784
Andreas Gruenbacher841ce242010-12-15 19:31:20 +01001785 if (!expect(sc.rate >= 1))
1786 sc.rate = 1;
Lars Ellenberg7ad651b2011-02-21 13:21:03 +01001787
1788 /* clip to allowed range */
1789 if (!expect(sc.al_extents >= DRBD_AL_EXTENTS_MIN))
1790 sc.al_extents = DRBD_AL_EXTENTS_MIN;
1791 if (!expect(sc.al_extents <= DRBD_AL_EXTENTS_MAX))
1792 sc.al_extents = DRBD_AL_EXTENTS_MAX;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001793
Lars Ellenbergef50a3e2010-09-01 14:39:30 +02001794 /* to avoid spurious errors when configuring minors before configuring
1795 * the minors they depend on: if necessary, first create the minor we
1796 * depend on */
1797 if (sc.after >= 0)
1798 ensure_mdev(sc.after, 1);
1799
Philipp Reisnerb411b362009-09-25 16:07:19 -07001800 /* most sanity checks done, try to assign the new sync-after
1801 * dependency. need to hold the global lock in there,
1802 * to avoid a race in the dependency loop check. */
1803 retcode = drbd_alter_sa(mdev, sc.after);
1804 if (retcode != NO_ERROR)
1805 goto fail;
1806
Philipp Reisner778f2712010-07-06 11:14:00 +02001807 fifo_size = (sc.c_plan_ahead * 10 * SLEEP_TIME) / HZ;
1808 if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
1809 rs_plan_s = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
1810 if (!rs_plan_s) {
1811 dev_err(DEV, "kmalloc of fifo_buffer failed");
1812 retcode = ERR_NOMEM;
1813 goto fail;
1814 }
1815 }
1816
Philipp Reisnerb411b362009-09-25 16:07:19 -07001817 /* ok, assign the rest of it as well.
1818 * lock against receive_SyncParam() */
1819 spin_lock(&mdev->peer_seq_lock);
1820 mdev->sync_conf = sc;
1821
1822 if (!rsr) {
1823 crypto_free_hash(mdev->csums_tfm);
1824 mdev->csums_tfm = csums_tfm;
1825 csums_tfm = NULL;
1826 }
1827
1828 if (!ovr) {
1829 crypto_free_hash(mdev->verify_tfm);
1830 mdev->verify_tfm = verify_tfm;
1831 verify_tfm = NULL;
1832 }
Philipp Reisner778f2712010-07-06 11:14:00 +02001833
1834 if (fifo_size != mdev->rs_plan_s.size) {
1835 kfree(mdev->rs_plan_s.values);
1836 mdev->rs_plan_s.values = rs_plan_s;
1837 mdev->rs_plan_s.size = fifo_size;
1838 mdev->rs_planed = 0;
1839 rs_plan_s = NULL;
1840 }
1841
Philipp Reisnerb411b362009-09-25 16:07:19 -07001842 spin_unlock(&mdev->peer_seq_lock);
1843
1844 if (get_ldev(mdev)) {
1845 wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
1846 drbd_al_shrink(mdev);
1847 err = drbd_check_al_size(mdev);
1848 lc_unlock(mdev->act_log);
1849 wake_up(&mdev->al_wait);
1850
1851 put_ldev(mdev);
1852 drbd_md_sync(mdev);
1853
1854 if (err) {
1855 retcode = ERR_NOMEM;
1856 goto fail;
1857 }
1858 }
1859
1860 if (mdev->state.conn >= C_CONNECTED)
1861 drbd_send_sync_param(mdev, &sc);
1862
Philipp Reisner80822282011-02-08 12:46:30 +01001863 if (!cpumask_equal(mdev->tconn->cpu_mask, new_cpu_mask)) {
1864 cpumask_copy(mdev->tconn->cpu_mask, new_cpu_mask);
1865 drbd_calc_cpu_mask(mdev->tconn);
Philipp Reisnere6b3ea82011-01-19 14:02:01 +01001866 mdev->tconn->receiver.reset_cpu_mask = 1;
1867 mdev->tconn->asender.reset_cpu_mask = 1;
1868 mdev->tconn->worker.reset_cpu_mask = 1;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001869 }
1870
1871 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
1872fail:
Philipp Reisner778f2712010-07-06 11:14:00 +02001873 kfree(rs_plan_s);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001874 free_cpumask_var(new_cpu_mask);
1875 crypto_free_hash(csums_tfm);
1876 crypto_free_hash(verify_tfm);
1877 reply->ret_code = retcode;
1878 return 0;
1879}
1880
1881static int drbd_nl_invalidate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1882 struct drbd_nl_cfg_reply *reply)
1883{
1884 int retcode;
1885
Lars Ellenberg194bfb32011-01-18 10:38:01 +01001886 /* If there is still bitmap IO pending, probably because of a previous
1887 * resync just being finished, wait for it before requesting a new resync. */
1888 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
1889
Philipp Reisnerb411b362009-09-25 16:07:19 -07001890 retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED);
1891
1892 if (retcode < SS_SUCCESS && retcode != SS_NEED_CONNECTION)
1893 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
1894
1895 while (retcode == SS_NEED_CONNECTION) {
Philipp Reisner87eeee42011-01-19 14:16:30 +01001896 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001897 if (mdev->state.conn < C_CONNECTED)
1898 retcode = _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001899 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001900
1901 if (retcode != SS_NEED_CONNECTION)
1902 break;
1903
1904 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
1905 }
1906
1907 reply->ret_code = retcode;
1908 return 0;
1909}
1910
Philipp Reisner07782862010-08-31 12:00:50 +02001911static int drbd_bmio_set_susp_al(struct drbd_conf *mdev)
1912{
1913 int rv;
1914
1915 rv = drbd_bmio_set_n_write(mdev);
1916 drbd_suspend_al(mdev);
1917 return rv;
1918}
1919
Philipp Reisnerb411b362009-09-25 16:07:19 -07001920static int drbd_nl_invalidate_peer(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1921 struct drbd_nl_cfg_reply *reply)
1922{
Philipp Reisner07782862010-08-31 12:00:50 +02001923 int retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001924
Lars Ellenberg194bfb32011-01-18 10:38:01 +01001925 /* If there is still bitmap IO pending, probably because of a previous
1926 * resync just being finished, wait for it before requesting a new resync. */
1927 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
1928
Philipp Reisner07782862010-08-31 12:00:50 +02001929 retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_S), CS_ORDERED);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001930
Philipp Reisner07782862010-08-31 12:00:50 +02001931 if (retcode < SS_SUCCESS) {
1932 if (retcode == SS_NEED_CONNECTION && mdev->state.role == R_PRIMARY) {
1933 /* The peer will get a resync upon connect anyways. Just make that
1934 into a full resync. */
1935 retcode = drbd_request_state(mdev, NS(pdsk, D_INCONSISTENT));
1936 if (retcode >= SS_SUCCESS) {
Philipp Reisner07782862010-08-31 12:00:50 +02001937 if (drbd_bitmap_io(mdev, &drbd_bmio_set_susp_al,
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001938 "set_n_write from invalidate_peer",
1939 BM_LOCKED_SET_ALLOWED))
Philipp Reisner07782862010-08-31 12:00:50 +02001940 retcode = ERR_IO_MD_DISK;
1941 }
1942 } else
1943 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_S));
1944 }
1945
1946 reply->ret_code = retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001947 return 0;
1948}
1949
1950static int drbd_nl_pause_sync(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1951 struct drbd_nl_cfg_reply *reply)
1952{
1953 int retcode = NO_ERROR;
1954
1955 if (drbd_request_state(mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
1956 retcode = ERR_PAUSE_IS_SET;
1957
1958 reply->ret_code = retcode;
1959 return 0;
1960}
1961
1962static int drbd_nl_resume_sync(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1963 struct drbd_nl_cfg_reply *reply)
1964{
1965 int retcode = NO_ERROR;
Philipp Reisnercd88d032011-01-20 11:46:41 +01001966 union drbd_state s;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001967
Philipp Reisnercd88d032011-01-20 11:46:41 +01001968 if (drbd_request_state(mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
1969 s = mdev->state;
1970 if (s.conn == C_PAUSED_SYNC_S || s.conn == C_PAUSED_SYNC_T) {
1971 retcode = s.aftr_isp ? ERR_PIC_AFTER_DEP :
1972 s.peer_isp ? ERR_PIC_PEER_DEP : ERR_PAUSE_IS_CLEAR;
1973 } else {
1974 retcode = ERR_PAUSE_IS_CLEAR;
1975 }
1976 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001977
1978 reply->ret_code = retcode;
1979 return 0;
1980}
1981
1982static int drbd_nl_suspend_io(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1983 struct drbd_nl_cfg_reply *reply)
1984{
1985 reply->ret_code = drbd_request_state(mdev, NS(susp, 1));
1986
1987 return 0;
1988}
1989
1990static int drbd_nl_resume_io(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
1991 struct drbd_nl_cfg_reply *reply)
1992{
Philipp Reisner43a51822010-06-11 11:26:34 +02001993 if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
1994 drbd_uuid_new_current(mdev);
1995 clear_bit(NEW_CUR_UUID, &mdev->flags);
Philipp Reisner43a51822010-06-11 11:26:34 +02001996 }
Philipp Reisner265be2d2010-05-31 10:14:17 +02001997 drbd_suspend_io(mdev);
Philipp Reisnerfb22c402010-09-08 23:20:21 +02001998 reply->ret_code = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
Philipp Reisner265be2d2010-05-31 10:14:17 +02001999 if (reply->ret_code == SS_SUCCESS) {
2000 if (mdev->state.conn < C_CONNECTED)
2001 tl_clear(mdev);
2002 if (mdev->state.disk == D_DISKLESS || mdev->state.disk == D_FAILED)
Andreas Gruenbacher8554df12011-01-25 15:37:43 +01002003 tl_restart(mdev, FAIL_FROZEN_DISK_IO);
Philipp Reisner265be2d2010-05-31 10:14:17 +02002004 }
2005 drbd_resume_io(mdev);
2006
Philipp Reisnerb411b362009-09-25 16:07:19 -07002007 return 0;
2008}
2009
2010static int drbd_nl_outdate(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
2011 struct drbd_nl_cfg_reply *reply)
2012{
2013 reply->ret_code = drbd_request_state(mdev, NS(disk, D_OUTDATED));
2014 return 0;
2015}
2016
2017static int drbd_nl_get_config(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
2018 struct drbd_nl_cfg_reply *reply)
2019{
2020 unsigned short *tl;
2021
2022 tl = reply->tag_list;
2023
2024 if (get_ldev(mdev)) {
2025 tl = disk_conf_to_tags(mdev, &mdev->ldev->dc, tl);
2026 put_ldev(mdev);
2027 }
2028
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +01002029 if (get_net_conf(mdev->tconn)) {
Philipp Reisner89e58e72011-01-19 13:12:45 +01002030 tl = net_conf_to_tags(mdev, mdev->tconn->net_conf, tl);
Philipp Reisnerb2fb6dbe2011-01-19 13:48:44 +01002031 put_net_conf(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002032 }
2033 tl = syncer_conf_to_tags(mdev, &mdev->sync_conf, tl);
2034
2035 put_unaligned(TT_END, tl++); /* Close the tag list */
2036
2037 return (int)((char *)tl - (char *)reply->tag_list);
2038}
2039
2040static int drbd_nl_get_state(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
2041 struct drbd_nl_cfg_reply *reply)
2042{
2043 unsigned short *tl = reply->tag_list;
2044 union drbd_state s = mdev->state;
2045 unsigned long rs_left;
2046 unsigned int res;
2047
2048 tl = get_state_to_tags(mdev, (struct get_state *)&s, tl);
2049
2050 /* no local ref, no bitmap, no syncer progress. */
2051 if (s.conn >= C_SYNC_SOURCE && s.conn <= C_PAUSED_SYNC_T) {
2052 if (get_ldev(mdev)) {
2053 drbd_get_syncer_progress(mdev, &rs_left, &res);
2054 tl = tl_add_int(tl, T_sync_progress, &res);
2055 put_ldev(mdev);
2056 }
2057 }
2058 put_unaligned(TT_END, tl++); /* Close the tag list */
2059
2060 return (int)((char *)tl - (char *)reply->tag_list);
2061}
2062
2063static int drbd_nl_get_uuids(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
2064 struct drbd_nl_cfg_reply *reply)
2065{
2066 unsigned short *tl;
2067
2068 tl = reply->tag_list;
2069
2070 if (get_ldev(mdev)) {
2071 tl = tl_add_blob(tl, T_uuids, mdev->ldev->md.uuid, UI_SIZE*sizeof(u64));
2072 tl = tl_add_int(tl, T_uuids_flags, &mdev->ldev->md.flags);
2073 put_ldev(mdev);
2074 }
2075 put_unaligned(TT_END, tl++); /* Close the tag list */
2076
2077 return (int)((char *)tl - (char *)reply->tag_list);
2078}
2079
2080/**
2081 * drbd_nl_get_timeout_flag() - Used by drbdsetup to find out which timeout value to use
2082 * @mdev: DRBD device.
2083 * @nlp: Netlink/connector packet from drbdsetup
2084 * @reply: Reply packet for drbdsetup
2085 */
2086static int drbd_nl_get_timeout_flag(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
2087 struct drbd_nl_cfg_reply *reply)
2088{
2089 unsigned short *tl;
2090 char rv;
2091
2092 tl = reply->tag_list;
2093
2094 rv = mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED :
2095 test_bit(USE_DEGR_WFC_T, &mdev->flags) ? UT_DEGRADED : UT_DEFAULT;
2096
2097 tl = tl_add_blob(tl, T_use_degraded, &rv, sizeof(rv));
2098 put_unaligned(TT_END, tl++); /* Close the tag list */
2099
2100 return (int)((char *)tl - (char *)reply->tag_list);
2101}
2102
2103static int drbd_nl_start_ov(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
2104 struct drbd_nl_cfg_reply *reply)
2105{
2106 /* default to resume from last known position, if possible */
2107 struct start_ov args =
2108 { .start_sector = mdev->ov_start_sector };
2109
2110 if (!start_ov_from_tags(mdev, nlp->tag_list, &args)) {
2111 reply->ret_code = ERR_MANDATORY_TAG;
2112 return 0;
2113 }
Lars Ellenberg873b0d52011-01-21 22:53:48 +01002114
2115 /* If there is still bitmap IO pending, e.g. previous resync or verify
2116 * just being finished, wait for it before requesting a new resync. */
2117 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
2118
Philipp Reisnerb411b362009-09-25 16:07:19 -07002119 /* w_make_ov_request expects position to be aligned */
2120 mdev->ov_start_sector = args.start_sector & ~BM_SECT_PER_BIT;
2121 reply->ret_code = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
2122 return 0;
2123}
2124
2125
2126static int drbd_nl_new_c_uuid(struct drbd_conf *mdev, struct drbd_nl_cfg_req *nlp,
2127 struct drbd_nl_cfg_reply *reply)
2128{
2129 int retcode = NO_ERROR;
2130 int skip_initial_sync = 0;
2131 int err;
2132
2133 struct new_c_uuid args;
2134
2135 memset(&args, 0, sizeof(struct new_c_uuid));
2136 if (!new_c_uuid_from_tags(mdev, nlp->tag_list, &args)) {
2137 reply->ret_code = ERR_MANDATORY_TAG;
2138 return 0;
2139 }
2140
Philipp Reisner8410da82011-02-11 20:11:10 +01002141 mutex_lock(mdev->state_mutex); /* Protects us against serialized state changes. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002142
2143 if (!get_ldev(mdev)) {
2144 retcode = ERR_NO_DISK;
2145 goto out;
2146 }
2147
2148 /* this is "skip initial sync", assume to be clean */
Philipp Reisner31890f42011-01-19 14:12:51 +01002149 if (mdev->state.conn == C_CONNECTED && mdev->tconn->agreed_pro_version >= 90 &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07002150 mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) {
2151 dev_info(DEV, "Preparing to skip initial sync\n");
2152 skip_initial_sync = 1;
2153 } else if (mdev->state.conn != C_STANDALONE) {
2154 retcode = ERR_CONNECTED;
2155 goto out_dec;
2156 }
2157
2158 drbd_uuid_set(mdev, UI_BITMAP, 0); /* Rotate UI_BITMAP to History 1, etc... */
2159 drbd_uuid_new_current(mdev); /* New current, previous to UI_BITMAP */
2160
2161 if (args.clear_bm) {
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01002162 err = drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
2163 "clear_n_write from new_c_uuid", BM_LOCKED_MASK);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002164 if (err) {
2165 dev_err(DEV, "Writing bitmap failed with %d\n",err);
2166 retcode = ERR_IO_MD_DISK;
2167 }
2168 if (skip_initial_sync) {
2169 drbd_send_uuids_skip_initial_sync(mdev);
2170 _drbd_uuid_set(mdev, UI_BITMAP, 0);
Lars Ellenberg62b0da32011-01-20 13:25:21 +01002171 drbd_print_uuids(mdev, "cleared bitmap UUID");
Philipp Reisner87eeee42011-01-19 14:16:30 +01002172 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002173 _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
2174 CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002175 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002176 }
2177 }
2178
2179 drbd_md_sync(mdev);
2180out_dec:
2181 put_ldev(mdev);
2182out:
Philipp Reisner8410da82011-02-11 20:11:10 +01002183 mutex_unlock(mdev->state_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002184
2185 reply->ret_code = retcode;
2186 return 0;
2187}
2188
Philipp Reisnerb411b362009-09-25 16:07:19 -07002189struct cn_handler_struct {
2190 int (*function)(struct drbd_conf *,
2191 struct drbd_nl_cfg_req *,
2192 struct drbd_nl_cfg_reply *);
2193 int reply_body_size;
2194};
2195
2196static struct cn_handler_struct cnd_table[] = {
2197 [ P_primary ] = { &drbd_nl_primary, 0 },
2198 [ P_secondary ] = { &drbd_nl_secondary, 0 },
2199 [ P_disk_conf ] = { &drbd_nl_disk_conf, 0 },
2200 [ P_detach ] = { &drbd_nl_detach, 0 },
2201 [ P_net_conf ] = { &drbd_nl_net_conf, 0 },
2202 [ P_disconnect ] = { &drbd_nl_disconnect, 0 },
2203 [ P_resize ] = { &drbd_nl_resize, 0 },
2204 [ P_syncer_conf ] = { &drbd_nl_syncer_conf, 0 },
2205 [ P_invalidate ] = { &drbd_nl_invalidate, 0 },
2206 [ P_invalidate_peer ] = { &drbd_nl_invalidate_peer, 0 },
2207 [ P_pause_sync ] = { &drbd_nl_pause_sync, 0 },
2208 [ P_resume_sync ] = { &drbd_nl_resume_sync, 0 },
2209 [ P_suspend_io ] = { &drbd_nl_suspend_io, 0 },
2210 [ P_resume_io ] = { &drbd_nl_resume_io, 0 },
2211 [ P_outdate ] = { &drbd_nl_outdate, 0 },
2212 [ P_get_config ] = { &drbd_nl_get_config,
2213 sizeof(struct syncer_conf_tag_len_struct) +
2214 sizeof(struct disk_conf_tag_len_struct) +
2215 sizeof(struct net_conf_tag_len_struct) },
2216 [ P_get_state ] = { &drbd_nl_get_state,
2217 sizeof(struct get_state_tag_len_struct) +
2218 sizeof(struct sync_progress_tag_len_struct) },
2219 [ P_get_uuids ] = { &drbd_nl_get_uuids,
2220 sizeof(struct get_uuids_tag_len_struct) },
2221 [ P_get_timeout_flag ] = { &drbd_nl_get_timeout_flag,
2222 sizeof(struct get_timeout_flag_tag_len_struct)},
2223 [ P_start_ov ] = { &drbd_nl_start_ov, 0 },
2224 [ P_new_c_uuid ] = { &drbd_nl_new_c_uuid, 0 },
2225};
2226
Philipp Reisner9f5180e2009-10-06 09:30:14 +02002227static void drbd_connector_callback(struct cn_msg *req, struct netlink_skb_parms *nsp)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002228{
2229 struct drbd_nl_cfg_req *nlp = (struct drbd_nl_cfg_req *)req->data;
2230 struct cn_handler_struct *cm;
2231 struct cn_msg *cn_reply;
2232 struct drbd_nl_cfg_reply *reply;
2233 struct drbd_conf *mdev;
2234 int retcode, rr;
2235 int reply_size = sizeof(struct cn_msg)
2236 + sizeof(struct drbd_nl_cfg_reply)
2237 + sizeof(short int);
2238
2239 if (!try_module_get(THIS_MODULE)) {
2240 printk(KERN_ERR "drbd: try_module_get() failed!\n");
2241 return;
2242 }
2243
Patrick McHardy01a16b22011-03-03 13:32:07 -08002244 if (!cap_raised(current_cap(), CAP_SYS_ADMIN)) {
Philipp Reisner9f5180e2009-10-06 09:30:14 +02002245 retcode = ERR_PERM;
2246 goto fail;
2247 }
2248
Lars Ellenbergef50a3e2010-09-01 14:39:30 +02002249 mdev = ensure_mdev(nlp->drbd_minor,
2250 (nlp->flags & DRBD_NL_CREATE_DEVICE));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002251 if (!mdev) {
2252 retcode = ERR_MINOR_INVALID;
2253 goto fail;
2254 }
2255
Lars Ellenberg42ff2692010-11-24 10:11:14 +01002256 if (nlp->packet_type >= P_nl_after_last_packet ||
2257 nlp->packet_type == P_return_code_only) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002258 retcode = ERR_PACKET_NR;
2259 goto fail;
2260 }
2261
2262 cm = cnd_table + nlp->packet_type;
2263
2264 /* This may happen if packet number is 0: */
2265 if (cm->function == NULL) {
2266 retcode = ERR_PACKET_NR;
2267 goto fail;
2268 }
2269
2270 reply_size += cm->reply_body_size;
2271
2272 /* allocation not in the IO path, cqueue thread context */
Lars Ellenberg3e3a7762010-11-24 10:41:45 +01002273 cn_reply = kzalloc(reply_size, GFP_KERNEL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002274 if (!cn_reply) {
2275 retcode = ERR_NOMEM;
2276 goto fail;
2277 }
2278 reply = (struct drbd_nl_cfg_reply *) cn_reply->data;
2279
2280 reply->packet_type =
Lars Ellenberg42ff2692010-11-24 10:11:14 +01002281 cm->reply_body_size ? nlp->packet_type : P_return_code_only;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002282 reply->minor = nlp->drbd_minor;
2283 reply->ret_code = NO_ERROR; /* Might by modified by cm->function. */
2284 /* reply->tag_list; might be modified by cm->function. */
2285
2286 rr = cm->function(mdev, nlp, reply);
2287
2288 cn_reply->id = req->id;
2289 cn_reply->seq = req->seq;
2290 cn_reply->ack = req->ack + 1;
2291 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) + rr;
2292 cn_reply->flags = 0;
2293
Philipp Reisnerb411b362009-09-25 16:07:19 -07002294 rr = cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_KERNEL);
2295 if (rr && rr != -ESRCH)
2296 printk(KERN_INFO "drbd: cn_netlink_send()=%d\n", rr);
2297
2298 kfree(cn_reply);
2299 module_put(THIS_MODULE);
2300 return;
2301 fail:
2302 drbd_nl_send_reply(req, retcode);
2303 module_put(THIS_MODULE);
2304}
2305
2306static atomic_t drbd_nl_seq = ATOMIC_INIT(2); /* two. */
2307
2308static unsigned short *
2309__tl_add_blob(unsigned short *tl, enum drbd_tags tag, const void *data,
2310 unsigned short len, int nul_terminated)
2311{
2312 unsigned short l = tag_descriptions[tag_number(tag)].max_len;
2313 len = (len < l) ? len : l;
2314 put_unaligned(tag, tl++);
2315 put_unaligned(len, tl++);
2316 memcpy(tl, data, len);
2317 tl = (unsigned short*)((char*)tl + len);
2318 if (nul_terminated)
2319 *((char*)tl - 1) = 0;
2320 return tl;
2321}
2322
2323static unsigned short *
2324tl_add_blob(unsigned short *tl, enum drbd_tags tag, const void *data, int len)
2325{
2326 return __tl_add_blob(tl, tag, data, len, 0);
2327}
2328
2329static unsigned short *
2330tl_add_str(unsigned short *tl, enum drbd_tags tag, const char *str)
2331{
2332 return __tl_add_blob(tl, tag, str, strlen(str)+1, 0);
2333}
2334
2335static unsigned short *
2336tl_add_int(unsigned short *tl, enum drbd_tags tag, const void *val)
2337{
2338 put_unaligned(tag, tl++);
2339 switch(tag_type(tag)) {
2340 case TT_INTEGER:
2341 put_unaligned(sizeof(int), tl++);
2342 put_unaligned(*(int *)val, (int *)tl);
2343 tl = (unsigned short*)((char*)tl+sizeof(int));
2344 break;
2345 case TT_INT64:
2346 put_unaligned(sizeof(u64), tl++);
2347 put_unaligned(*(u64 *)val, (u64 *)tl);
2348 tl = (unsigned short*)((char*)tl+sizeof(u64));
2349 break;
2350 default:
2351 /* someone did something stupid. */
2352 ;
2353 }
2354 return tl;
2355}
2356
2357void drbd_bcast_state(struct drbd_conf *mdev, union drbd_state state)
2358{
2359 char buffer[sizeof(struct cn_msg)+
2360 sizeof(struct drbd_nl_cfg_reply)+
2361 sizeof(struct get_state_tag_len_struct)+
2362 sizeof(short int)];
2363 struct cn_msg *cn_reply = (struct cn_msg *) buffer;
2364 struct drbd_nl_cfg_reply *reply =
2365 (struct drbd_nl_cfg_reply *)cn_reply->data;
2366 unsigned short *tl = reply->tag_list;
2367
2368 /* dev_warn(DEV, "drbd_bcast_state() got called\n"); */
2369
2370 tl = get_state_to_tags(mdev, (struct get_state *)&state, tl);
2371
2372 put_unaligned(TT_END, tl++); /* Close the tag list */
2373
2374 cn_reply->id.idx = CN_IDX_DRBD;
2375 cn_reply->id.val = CN_VAL_DRBD;
2376
2377 cn_reply->seq = atomic_add_return(1, &drbd_nl_seq);
2378 cn_reply->ack = 0; /* not used here. */
2379 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
2380 (int)((char *)tl - (char *)reply->tag_list);
2381 cn_reply->flags = 0;
2382
2383 reply->packet_type = P_get_state;
2384 reply->minor = mdev_to_minor(mdev);
2385 reply->ret_code = NO_ERROR;
2386
Philipp Reisnerb411b362009-09-25 16:07:19 -07002387 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
2388}
2389
2390void drbd_bcast_ev_helper(struct drbd_conf *mdev, char *helper_name)
2391{
2392 char buffer[sizeof(struct cn_msg)+
2393 sizeof(struct drbd_nl_cfg_reply)+
2394 sizeof(struct call_helper_tag_len_struct)+
2395 sizeof(short int)];
2396 struct cn_msg *cn_reply = (struct cn_msg *) buffer;
2397 struct drbd_nl_cfg_reply *reply =
2398 (struct drbd_nl_cfg_reply *)cn_reply->data;
2399 unsigned short *tl = reply->tag_list;
2400
2401 /* dev_warn(DEV, "drbd_bcast_state() got called\n"); */
2402
2403 tl = tl_add_str(tl, T_helper, helper_name);
2404 put_unaligned(TT_END, tl++); /* Close the tag list */
2405
2406 cn_reply->id.idx = CN_IDX_DRBD;
2407 cn_reply->id.val = CN_VAL_DRBD;
2408
2409 cn_reply->seq = atomic_add_return(1, &drbd_nl_seq);
2410 cn_reply->ack = 0; /* not used here. */
2411 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
2412 (int)((char *)tl - (char *)reply->tag_list);
2413 cn_reply->flags = 0;
2414
2415 reply->packet_type = P_call_helper;
2416 reply->minor = mdev_to_minor(mdev);
2417 reply->ret_code = NO_ERROR;
2418
Philipp Reisnerb411b362009-09-25 16:07:19 -07002419 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
2420}
2421
Andreas Gruenbacherf6ffca92011-02-04 15:30:34 +01002422void drbd_bcast_ee(struct drbd_conf *mdev, const char *reason, const int dgs,
2423 const char *seen_hash, const char *calc_hash,
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002424 const struct drbd_peer_request *peer_req)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002425{
2426 struct cn_msg *cn_reply;
2427 struct drbd_nl_cfg_reply *reply;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002428 unsigned short *tl;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02002429 struct page *page;
2430 unsigned len;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002431
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002432 if (!peer_req)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002433 return;
2434 if (!reason || !reason[0])
2435 return;
2436
2437 /* apparently we have to memcpy twice, first to prepare the data for the
2438 * struct cn_msg, then within cn_netlink_send from the cn_msg to the
2439 * netlink skb. */
2440 /* receiver thread context, which is not in the writeout path (of this node),
2441 * but may be in the writeout path of the _other_ node.
2442 * GFP_NOIO to avoid potential "distributed deadlock". */
Lars Ellenberg3e3a7762010-11-24 10:41:45 +01002443 cn_reply = kzalloc(
Philipp Reisnerb411b362009-09-25 16:07:19 -07002444 sizeof(struct cn_msg)+
2445 sizeof(struct drbd_nl_cfg_reply)+
2446 sizeof(struct dump_ee_tag_len_struct)+
2447 sizeof(short int),
2448 GFP_NOIO);
2449
2450 if (!cn_reply) {
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002451 dev_err(DEV, "could not kmalloc buffer for drbd_bcast_ee, "
2452 "sector %llu, size %u\n",
2453 (unsigned long long)peer_req->i.sector,
2454 peer_req->i.size);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002455 return;
2456 }
2457
2458 reply = (struct drbd_nl_cfg_reply*)cn_reply->data;
2459 tl = reply->tag_list;
2460
2461 tl = tl_add_str(tl, T_dump_ee_reason, reason);
2462 tl = tl_add_blob(tl, T_seen_digest, seen_hash, dgs);
2463 tl = tl_add_blob(tl, T_calc_digest, calc_hash, dgs);
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002464 tl = tl_add_int(tl, T_ee_sector, &peer_req->i.sector);
2465 tl = tl_add_int(tl, T_ee_block_id, &peer_req->block_id);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002466
Lars Ellenberg3129b1b2010-11-11 10:47:05 +01002467 /* dump the first 32k */
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002468 len = min_t(unsigned, peer_req->i.size, 32 << 10);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002469 put_unaligned(T_ee_data, tl++);
Lars Ellenberg3129b1b2010-11-11 10:47:05 +01002470 put_unaligned(len, tl++);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002471
Andreas Gruenbacherdb830c42011-02-04 15:57:48 +01002472 page = peer_req->pages;
Lars Ellenberg45bb9122010-05-14 17:10:48 +02002473 page_chain_for_each(page) {
2474 void *d = kmap_atomic(page, KM_USER0);
2475 unsigned l = min_t(unsigned, len, PAGE_SIZE);
2476 memcpy(tl, d, l);
2477 kunmap_atomic(d, KM_USER0);
2478 tl = (unsigned short*)((char*)tl + l);
2479 len -= l;
Lars Ellenberg3129b1b2010-11-11 10:47:05 +01002480 if (len == 0)
2481 break;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002482 }
2483 put_unaligned(TT_END, tl++); /* Close the tag list */
2484
2485 cn_reply->id.idx = CN_IDX_DRBD;
2486 cn_reply->id.val = CN_VAL_DRBD;
2487
2488 cn_reply->seq = atomic_add_return(1,&drbd_nl_seq);
2489 cn_reply->ack = 0; // not used here.
2490 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
2491 (int)((char*)tl - (char*)reply->tag_list);
2492 cn_reply->flags = 0;
2493
2494 reply->packet_type = P_dump_ee;
2495 reply->minor = mdev_to_minor(mdev);
2496 reply->ret_code = NO_ERROR;
2497
Philipp Reisnerb411b362009-09-25 16:07:19 -07002498 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
2499 kfree(cn_reply);
2500}
2501
2502void drbd_bcast_sync_progress(struct drbd_conf *mdev)
2503{
2504 char buffer[sizeof(struct cn_msg)+
2505 sizeof(struct drbd_nl_cfg_reply)+
2506 sizeof(struct sync_progress_tag_len_struct)+
2507 sizeof(short int)];
2508 struct cn_msg *cn_reply = (struct cn_msg *) buffer;
2509 struct drbd_nl_cfg_reply *reply =
2510 (struct drbd_nl_cfg_reply *)cn_reply->data;
2511 unsigned short *tl = reply->tag_list;
2512 unsigned long rs_left;
2513 unsigned int res;
2514
2515 /* no local ref, no bitmap, no syncer progress, no broadcast. */
2516 if (!get_ldev(mdev))
2517 return;
2518 drbd_get_syncer_progress(mdev, &rs_left, &res);
2519 put_ldev(mdev);
2520
2521 tl = tl_add_int(tl, T_sync_progress, &res);
2522 put_unaligned(TT_END, tl++); /* Close the tag list */
2523
2524 cn_reply->id.idx = CN_IDX_DRBD;
2525 cn_reply->id.val = CN_VAL_DRBD;
2526
2527 cn_reply->seq = atomic_add_return(1, &drbd_nl_seq);
2528 cn_reply->ack = 0; /* not used here. */
2529 cn_reply->len = sizeof(struct drbd_nl_cfg_reply) +
2530 (int)((char *)tl - (char *)reply->tag_list);
2531 cn_reply->flags = 0;
2532
2533 reply->packet_type = P_sync_progress;
2534 reply->minor = mdev_to_minor(mdev);
2535 reply->ret_code = NO_ERROR;
2536
Philipp Reisnerb411b362009-09-25 16:07:19 -07002537 cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
2538}
2539
2540int __init drbd_nl_init(void)
2541{
2542 static struct cb_id cn_id_drbd;
2543 int err, try=10;
2544
2545 cn_id_drbd.val = CN_VAL_DRBD;
2546 do {
2547 cn_id_drbd.idx = cn_idx;
2548 err = cn_add_callback(&cn_id_drbd, "cn_drbd", &drbd_connector_callback);
2549 if (!err)
2550 break;
2551 cn_idx = (cn_idx + CN_IDX_STEP);
2552 } while (try--);
2553
2554 if (err) {
2555 printk(KERN_ERR "drbd: cn_drbd failed to register\n");
2556 return err;
2557 }
2558
2559 return 0;
2560}
2561
2562void drbd_nl_cleanup(void)
2563{
2564 static struct cb_id cn_id_drbd;
2565
2566 cn_id_drbd.idx = cn_idx;
2567 cn_id_drbd.val = CN_VAL_DRBD;
2568
2569 cn_del_callback(&cn_id_drbd);
2570}
2571
2572void drbd_nl_send_reply(struct cn_msg *req, int ret_code)
2573{
2574 char buffer[sizeof(struct cn_msg)+sizeof(struct drbd_nl_cfg_reply)];
2575 struct cn_msg *cn_reply = (struct cn_msg *) buffer;
2576 struct drbd_nl_cfg_reply *reply =
2577 (struct drbd_nl_cfg_reply *)cn_reply->data;
2578 int rr;
2579
Lars Ellenberg3e3a7762010-11-24 10:41:45 +01002580 memset(buffer, 0, sizeof(buffer));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002581 cn_reply->id = req->id;
2582
2583 cn_reply->seq = req->seq;
2584 cn_reply->ack = req->ack + 1;
2585 cn_reply->len = sizeof(struct drbd_nl_cfg_reply);
2586 cn_reply->flags = 0;
2587
Lars Ellenberg42ff2692010-11-24 10:11:14 +01002588 reply->packet_type = P_return_code_only;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002589 reply->minor = ((struct drbd_nl_cfg_req *)req->data)->drbd_minor;
2590 reply->ret_code = ret_code;
2591
Philipp Reisnerb411b362009-09-25 16:07:19 -07002592 rr = cn_netlink_send(cn_reply, CN_IDX_DRBD, GFP_NOIO);
2593 if (rr && rr != -ESRCH)
2594 printk(KERN_INFO "drbd: cn_netlink_send()=%d\n", rr);
2595}
2596