blob: b39f5dc0f47bfcdec0cc1d6ade87c52d468481b8 [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>
Philipp Reisnerb411b362009-09-25 16:07:19 -070032#include <linux/blkpg.h>
33#include <linux/cpumask.h>
34#include "drbd_int.h"
Philipp Reisner265be2d2010-05-31 10:14:17 +020035#include "drbd_req.h"
Philipp Reisnerb411b362009-09-25 16:07:19 -070036#include "drbd_wrappers.h"
37#include <asm/unaligned.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070038#include <linux/drbd_limits.h>
Philipp Reisner87f7be42010-06-11 13:56:33 +020039#include <linux/kthread.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070040
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010041#include <net/genetlink.h>
Philipp Reisnerb411b362009-09-25 16:07:19 -070042
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010043/* .doit */
44// int drbd_adm_create_resource(struct sk_buff *skb, struct genl_info *info);
45// int drbd_adm_delete_resource(struct sk_buff *skb, struct genl_info *info);
46
47int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info);
48int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info);
49
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +020050int drbd_adm_new_resource(struct sk_buff *skb, struct genl_info *info);
51int drbd_adm_del_resource(struct sk_buff *skb, struct genl_info *info);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +010052int drbd_adm_down(struct sk_buff *skb, struct genl_info *info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010053
54int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info);
55int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info);
Lars Ellenbergf3990022011-03-23 14:31:09 +010056int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010057int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info);
58int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info);
Lars Ellenbergf3990022011-03-23 14:31:09 +010059int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010060int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info);
61int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info);
62int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info);
63int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info);
64int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info);
65int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info);
66int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info);
67int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info);
68int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info);
69int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info);
70int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info);
Lars Ellenbergf3990022011-03-23 14:31:09 +010071int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010072int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info);
73int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info);
74/* .dumpit */
75int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb);
76
77#include <linux/drbd_genl_api.h>
Andreas Gruenbacher01b39b52011-06-10 12:57:26 +020078#include "drbd_nla.h"
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010079#include <linux/genl_magic_func.h>
80
81/* used blkdev_get_by_path, to claim our meta data device(s) */
Philipp Reisnerb411b362009-09-25 16:07:19 -070082static char *drbd_m_holder = "Hands off! this is DRBD's meta data device.";
83
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +010084/* Configuration is strictly serialized, because generic netlink message
85 * processing is strictly serialized by the genl_lock().
86 * Which means we can use one static global drbd_config_context struct.
87 */
88static struct drbd_config_context {
89 /* assigned from drbd_genlmsghdr */
90 unsigned int minor;
91 /* assigned from request attributes, if present */
92 unsigned int volume;
93#define VOLUME_UNSPECIFIED (-1U)
94 /* pointer into the request skb,
95 * limited lifetime! */
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +020096 char *resource_name;
Andreas Gruenbacher089c0752011-06-14 18:28:09 +020097 struct nlattr *my_addr;
98 struct nlattr *peer_addr;
Philipp Reisnerb411b362009-09-25 16:07:19 -070099
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100100 /* reply buffer */
101 struct sk_buff *reply_skb;
102 /* pointer into reply buffer */
103 struct drbd_genlmsghdr *reply_dh;
104 /* resolved from attributes, if possible */
105 struct drbd_conf *mdev;
106 struct drbd_tconn *tconn;
107} adm_ctx;
108
109static void drbd_adm_send_reply(struct sk_buff *skb, struct genl_info *info)
110{
111 genlmsg_end(skb, genlmsg_data(nlmsg_data(nlmsg_hdr(skb))));
112 if (genlmsg_reply(skb, info))
113 printk(KERN_ERR "drbd: error sending genl reply\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700114}
115
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100116/* Used on a fresh "drbd_adm_prepare"d reply_skb, this cannot fail: The only
117 * reason it could fail was no space in skb, and there are 4k available. */
Lars Ellenberg8432b312011-03-08 16:11:16 +0100118int drbd_msg_put_info(const char *info)
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100119{
120 struct sk_buff *skb = adm_ctx.reply_skb;
121 struct nlattr *nla;
122 int err = -EMSGSIZE;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700123
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100124 if (!info || !info[0])
125 return 0;
126
127 nla = nla_nest_start(skb, DRBD_NLA_CFG_REPLY);
128 if (!nla)
129 return err;
130
131 err = nla_put_string(skb, T_info_text, info);
132 if (err) {
133 nla_nest_cancel(skb, nla);
134 return err;
135 } else
136 nla_nest_end(skb, nla);
137 return 0;
138}
139
140/* This would be a good candidate for a "pre_doit" hook,
141 * and per-family private info->pointers.
142 * But we need to stay compatible with older kernels.
143 * If it returns successfully, adm_ctx members are valid.
144 */
145#define DRBD_ADM_NEED_MINOR 1
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +0200146#define DRBD_ADM_NEED_RESOURCE 2
Andreas Gruenbacher089c0752011-06-14 18:28:09 +0200147#define DRBD_ADM_NEED_CONNECTION 4
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100148static int drbd_adm_prepare(struct sk_buff *skb, struct genl_info *info,
149 unsigned flags)
150{
151 struct drbd_genlmsghdr *d_in = info->userhdr;
152 const u8 cmd = info->genlhdr->cmd;
153 int err;
154
155 memset(&adm_ctx, 0, sizeof(adm_ctx));
156
157 /* genl_rcv_msg only checks for CAP_NET_ADMIN on "GENL_ADMIN_PERM" :( */
158 if (cmd != DRBD_ADM_GET_STATUS
159 && security_netlink_recv(skb, CAP_SYS_ADMIN))
160 return -EPERM;
161
162 adm_ctx.reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
Andreas Gruenbacher1e2a2552011-05-24 14:17:08 +0200163 if (!adm_ctx.reply_skb) {
164 err = -ENOMEM;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100165 goto fail;
Andreas Gruenbacher1e2a2552011-05-24 14:17:08 +0200166 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100167
168 adm_ctx.reply_dh = genlmsg_put_reply(adm_ctx.reply_skb,
169 info, &drbd_genl_family, 0, cmd);
170 /* put of a few bytes into a fresh skb of >= 4k will always succeed.
171 * but anyways */
Andreas Gruenbacher1e2a2552011-05-24 14:17:08 +0200172 if (!adm_ctx.reply_dh) {
173 err = -ENOMEM;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100174 goto fail;
Andreas Gruenbacher1e2a2552011-05-24 14:17:08 +0200175 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100176
177 adm_ctx.reply_dh->minor = d_in->minor;
178 adm_ctx.reply_dh->ret_code = NO_ERROR;
179
Andreas Gruenbacher089c0752011-06-14 18:28:09 +0200180 adm_ctx.volume = VOLUME_UNSPECIFIED;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100181 if (info->attrs[DRBD_NLA_CFG_CONTEXT]) {
182 struct nlattr *nla;
183 /* parse and validate only */
Lars Ellenbergf3990022011-03-23 14:31:09 +0100184 err = drbd_cfg_context_from_attrs(NULL, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100185 if (err)
186 goto fail;
187
188 /* It was present, and valid,
189 * copy it over to the reply skb. */
190 err = nla_put_nohdr(adm_ctx.reply_skb,
191 info->attrs[DRBD_NLA_CFG_CONTEXT]->nla_len,
192 info->attrs[DRBD_NLA_CFG_CONTEXT]);
193 if (err)
194 goto fail;
195
196 /* and assign stuff to the global adm_ctx */
197 nla = nested_attr_tb[__nla_type(T_ctx_volume)];
Andreas Gruenbacher089c0752011-06-14 18:28:09 +0200198 if (nla)
199 adm_ctx.volume = nla_get_u32(nla);
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +0200200 nla = nested_attr_tb[__nla_type(T_ctx_resource_name)];
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100201 if (nla)
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +0200202 adm_ctx.resource_name = nla_data(nla);
Andreas Gruenbacher089c0752011-06-14 18:28:09 +0200203 adm_ctx.my_addr = nested_attr_tb[__nla_type(T_ctx_my_addr)];
204 adm_ctx.peer_addr = nested_attr_tb[__nla_type(T_ctx_peer_addr)];
205 if ((adm_ctx.my_addr &&
206 nla_len(adm_ctx.my_addr) > sizeof(adm_ctx.tconn->my_addr)) ||
207 (adm_ctx.peer_addr &&
208 nla_len(adm_ctx.peer_addr) > sizeof(adm_ctx.tconn->peer_addr))) {
209 err = -EINVAL;
210 goto fail;
211 }
212 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100213
214 adm_ctx.minor = d_in->minor;
215 adm_ctx.mdev = minor_to_mdev(d_in->minor);
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +0200216 adm_ctx.tconn = conn_get_by_name(adm_ctx.resource_name);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100217
218 if (!adm_ctx.mdev && (flags & DRBD_ADM_NEED_MINOR)) {
219 drbd_msg_put_info("unknown minor");
220 return ERR_MINOR_INVALID;
221 }
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +0200222 if (!adm_ctx.tconn && (flags & DRBD_ADM_NEED_RESOURCE)) {
223 drbd_msg_put_info("unknown resource");
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100224 return ERR_INVALID_REQUEST;
225 }
226
Andreas Gruenbacher089c0752011-06-14 18:28:09 +0200227 if (flags & DRBD_ADM_NEED_CONNECTION) {
228 if (adm_ctx.tconn && !(flags & DRBD_ADM_NEED_RESOURCE)) {
229 drbd_msg_put_info("no resource name expected");
230 return ERR_INVALID_REQUEST;
231 }
232 if (adm_ctx.mdev) {
233 drbd_msg_put_info("no minor number expected");
234 return ERR_INVALID_REQUEST;
235 }
236 if (adm_ctx.my_addr && adm_ctx.peer_addr)
237 adm_ctx.tconn = conn_get_by_addrs(nla_data(adm_ctx.my_addr),
238 nla_len(adm_ctx.my_addr),
239 nla_data(adm_ctx.peer_addr),
240 nla_len(adm_ctx.peer_addr));
241 if (!adm_ctx.tconn) {
242 drbd_msg_put_info("unknown connection");
243 return ERR_INVALID_REQUEST;
244 }
245 }
246
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100247 /* some more paranoia, if the request was over-determined */
Lars Ellenberg527f4b22011-03-14 13:58:03 +0100248 if (adm_ctx.mdev && adm_ctx.tconn &&
249 adm_ctx.mdev->tconn != adm_ctx.tconn) {
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +0200250 pr_warning("request: minor=%u, resource=%s; but that minor belongs to connection %s\n",
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +0200251 adm_ctx.minor, adm_ctx.resource_name,
252 adm_ctx.mdev->tconn->name);
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +0200253 drbd_msg_put_info("minor exists in different resource");
Lars Ellenberg527f4b22011-03-14 13:58:03 +0100254 return ERR_INVALID_REQUEST;
255 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100256 if (adm_ctx.mdev &&
257 adm_ctx.volume != VOLUME_UNSPECIFIED &&
258 adm_ctx.volume != adm_ctx.mdev->vnr) {
259 pr_warning("request: minor=%u, volume=%u; but that minor is volume %u in %s\n",
260 adm_ctx.minor, adm_ctx.volume,
261 adm_ctx.mdev->vnr, adm_ctx.mdev->tconn->name);
Lars Ellenberg527f4b22011-03-14 13:58:03 +0100262 drbd_msg_put_info("minor exists as different volume");
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100263 return ERR_INVALID_REQUEST;
264 }
Philipp Reisner0ace9df2011-04-24 10:53:19 +0200265
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100266 return NO_ERROR;
267
268fail:
269 nlmsg_free(adm_ctx.reply_skb);
270 adm_ctx.reply_skb = NULL;
Andreas Gruenbacher1e2a2552011-05-24 14:17:08 +0200271 return err;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100272}
273
274static int drbd_adm_finish(struct genl_info *info, int retcode)
275{
Philipp Reisner0ace9df2011-04-24 10:53:19 +0200276 if (adm_ctx.tconn) {
277 kref_put(&adm_ctx.tconn->kref, &conn_destroy);
278 adm_ctx.tconn = NULL;
279 }
280
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100281 if (!adm_ctx.reply_skb)
282 return -ENOMEM;
283
284 adm_ctx.reply_dh->ret_code = retcode;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100285 drbd_adm_send_reply(adm_ctx.reply_skb, info);
286 return 0;
287}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700288
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100289static void setup_khelper_env(struct drbd_tconn *tconn, char **envp)
290{
291 char *afs;
292
Andreas Gruenbacher089c0752011-06-14 18:28:09 +0200293 /* FIXME: A future version will not allow this case. */
294 if (tconn->my_addr_len == 0 || tconn->peer_addr_len == 0)
295 return;
296
297 switch (((struct sockaddr *)&tconn->peer_addr)->sa_family) {
298 case AF_INET6:
299 afs = "ipv6";
300 snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI6",
301 &((struct sockaddr_in6 *)&tconn->peer_addr)->sin6_addr);
302 break;
303 case AF_INET:
304 afs = "ipv4";
305 snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
306 &((struct sockaddr_in *)&tconn->peer_addr)->sin_addr);
307 break;
308 default:
309 afs = "ssocks";
310 snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
311 &((struct sockaddr_in *)&tconn->peer_addr)->sin_addr);
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100312 }
Andreas Gruenbacher089c0752011-06-14 18:28:09 +0200313 snprintf(envp[3], 20, "DRBD_PEER_AF=%s", afs);
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100314}
315
Philipp Reisnerb411b362009-09-25 16:07:19 -0700316int drbd_khelper(struct drbd_conf *mdev, char *cmd)
317{
318 char *envp[] = { "HOME=/",
319 "TERM=linux",
320 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100321 (char[20]) { }, /* address family */
322 (char[60]) { }, /* address */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700323 NULL };
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100324 char mb[12];
Philipp Reisnerb411b362009-09-25 16:07:19 -0700325 char *argv[] = {usermode_helper, cmd, mb, NULL };
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100326 struct sib_info sib;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700327 int ret;
328
329 snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev));
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100330 setup_khelper_env(mdev->tconn, envp);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700331
Lars Ellenberg1090c052010-07-19 17:41:04 +0200332 /* The helper may take some time.
333 * write out any unsynced meta data changes now */
334 drbd_md_sync(mdev);
335
Philipp Reisnerb411b362009-09-25 16:07:19 -0700336 dev_info(DEV, "helper command: %s %s %s\n", usermode_helper, cmd, mb);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100337 sib.sib_reason = SIB_HELPER_PRE;
338 sib.helper_name = cmd;
339 drbd_bcast_event(mdev, &sib);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700340 ret = call_usermodehelper(usermode_helper, argv, envp, 1);
341 if (ret)
342 dev_warn(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
343 usermode_helper, cmd, mb,
344 (ret >> 8) & 0xff, ret);
345 else
346 dev_info(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
347 usermode_helper, cmd, mb,
348 (ret >> 8) & 0xff, ret);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100349 sib.sib_reason = SIB_HELPER_POST;
350 sib.helper_exit_code = ret;
351 drbd_bcast_event(mdev, &sib);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700352
353 if (ret < 0) /* Ignore any ERRNOs we got. */
354 ret = 0;
355
356 return ret;
357}
358
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100359static void conn_md_sync(struct drbd_tconn *tconn)
360{
361 struct drbd_conf *mdev;
Philipp Reisnere90285e2011-03-22 12:51:21 +0100362 int vnr;
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100363
Philipp Reisnerc141ebd2011-05-05 16:13:10 +0200364 rcu_read_lock();
365 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
366 kref_get(&mdev->kref);
367 rcu_read_unlock();
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100368 drbd_md_sync(mdev);
Philipp Reisnerc141ebd2011-05-05 16:13:10 +0200369 kref_put(&mdev->kref, &drbd_minor_destroy);
370 rcu_read_lock();
371 }
372 rcu_read_unlock();
Philipp Reisner6b75dce2011-03-16 17:39:12 +0100373}
374
375int conn_khelper(struct drbd_tconn *tconn, char *cmd)
376{
377 char *envp[] = { "HOME=/",
378 "TERM=linux",
379 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
380 (char[20]) { }, /* address family */
381 (char[60]) { }, /* address */
382 NULL };
383 char *argv[] = {usermode_helper, cmd, tconn->name, NULL };
384 int ret;
385
386 setup_khelper_env(tconn, envp);
387 conn_md_sync(tconn);
388
389 conn_info(tconn, "helper command: %s %s %s\n", usermode_helper, cmd, tconn->name);
390 /* TODO: conn_bcast_event() ?? */
391
392 ret = call_usermodehelper(usermode_helper, argv, envp, 1);
393 if (ret)
394 conn_warn(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
395 usermode_helper, cmd, tconn->name,
396 (ret >> 8) & 0xff, ret);
397 else
398 conn_info(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
399 usermode_helper, cmd, tconn->name,
400 (ret >> 8) & 0xff, ret);
401 /* TODO: conn_bcast_event() ?? */
402
403 if (ret < 0) /* Ignore any ERRNOs we got. */
404 ret = 0;
405
406 return ret;
407}
408
Philipp Reisnercb703452011-03-24 11:03:07 +0100409static enum drbd_fencing_p highest_fencing_policy(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700410{
Philipp Reisnercb703452011-03-24 11:03:07 +0100411 enum drbd_fencing_p fp = FP_NOT_AVAIL;
412 struct drbd_conf *mdev;
413 int vnr;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700414
Philipp Reisner695d08f2011-04-11 22:53:32 -0700415 rcu_read_lock();
Philipp Reisnercb703452011-03-24 11:03:07 +0100416 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
417 if (get_ldev_if_state(mdev, D_CONSISTENT)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200418 fp = max_t(enum drbd_fencing_p, fp,
419 rcu_dereference(mdev->ldev->disk_conf)->fencing);
Philipp Reisnercb703452011-03-24 11:03:07 +0100420 put_ldev(mdev);
421 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700422 }
Philipp Reisner695d08f2011-04-11 22:53:32 -0700423 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700424
Philipp Reisnercb703452011-03-24 11:03:07 +0100425 return fp;
426}
427
428bool conn_try_outdate_peer(struct drbd_tconn *tconn)
429{
430 union drbd_state mask = { };
431 union drbd_state val = { };
432 enum drbd_fencing_p fp;
433 char *ex_to_string;
434 int r;
435
436 if (tconn->cstate >= C_WF_REPORT_PARAMS) {
437 conn_err(tconn, "Expected cstate < C_WF_REPORT_PARAMS\n");
438 return false;
439 }
440
441 fp = highest_fencing_policy(tconn);
442 switch (fp) {
443 case FP_NOT_AVAIL:
444 conn_warn(tconn, "Not fencing peer, I'm not even Consistent myself.\n");
445 goto out;
446 case FP_DONT_CARE:
447 return true;
448 default: ;
449 }
450
451 r = conn_khelper(tconn, "fence-peer");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700452
453 switch ((r>>8) & 0xff) {
454 case 3: /* peer is inconsistent */
455 ex_to_string = "peer is inconsistent or worse";
Philipp Reisnercb703452011-03-24 11:03:07 +0100456 mask.pdsk = D_MASK;
457 val.pdsk = D_INCONSISTENT;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700458 break;
459 case 4: /* peer got outdated, or was already outdated */
460 ex_to_string = "peer was fenced";
Philipp Reisnercb703452011-03-24 11:03:07 +0100461 mask.pdsk = D_MASK;
462 val.pdsk = D_OUTDATED;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700463 break;
464 case 5: /* peer was down */
Philipp Reisnercb703452011-03-24 11:03:07 +0100465 if (conn_highest_disk(tconn) == D_UP_TO_DATE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700466 /* we will(have) create(d) a new UUID anyways... */
467 ex_to_string = "peer is unreachable, assumed to be dead";
Philipp Reisnercb703452011-03-24 11:03:07 +0100468 mask.pdsk = D_MASK;
469 val.pdsk = D_OUTDATED;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700470 } else {
471 ex_to_string = "peer unreachable, doing nothing since disk != UpToDate";
Philipp Reisnerb411b362009-09-25 16:07:19 -0700472 }
473 break;
474 case 6: /* Peer is primary, voluntarily outdate myself.
475 * This is useful when an unconnected R_SECONDARY is asked to
476 * become R_PRIMARY, but finds the other peer being active. */
477 ex_to_string = "peer is active";
Philipp Reisnercb703452011-03-24 11:03:07 +0100478 conn_warn(tconn, "Peer is primary, outdating myself.\n");
479 mask.disk = D_MASK;
480 val.disk = D_OUTDATED;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700481 break;
482 case 7:
483 if (fp != FP_STONITH)
Philipp Reisnercb703452011-03-24 11:03:07 +0100484 conn_err(tconn, "fence-peer() = 7 && fencing != Stonith !!!\n");
Philipp Reisnerb411b362009-09-25 16:07:19 -0700485 ex_to_string = "peer was stonithed";
Philipp Reisnercb703452011-03-24 11:03:07 +0100486 mask.pdsk = D_MASK;
487 val.pdsk = D_OUTDATED;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700488 break;
489 default:
490 /* The script is broken ... */
Philipp Reisnercb703452011-03-24 11:03:07 +0100491 conn_err(tconn, "fence-peer helper broken, returned %d\n", (r>>8)&0xff);
492 return false; /* Eventually leave IO frozen */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700493 }
494
Philipp Reisnercb703452011-03-24 11:03:07 +0100495 conn_info(tconn, "fence-peer helper returned %d (%s)\n",
496 (r>>8) & 0xff, ex_to_string);
Philipp Reisnerfb22c402010-09-08 23:20:21 +0200497
Philipp Reisnercb703452011-03-24 11:03:07 +0100498 out:
Philipp Reisnerfb22c402010-09-08 23:20:21 +0200499
Philipp Reisnercb703452011-03-24 11:03:07 +0100500 /* Not using
501 conn_request_state(tconn, mask, val, CS_VERBOSE);
502 here, because we might were able to re-establish the connection in the
503 meantime. */
504 spin_lock_irq(&tconn->req_lock);
505 if (tconn->cstate < C_WF_REPORT_PARAMS)
506 _conn_request_state(tconn, mask, val, CS_VERBOSE);
507 spin_unlock_irq(&tconn->req_lock);
508
509 return conn_highest_pdsk(tconn) <= D_OUTDATED;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700510}
511
Philipp Reisner87f7be42010-06-11 13:56:33 +0200512static int _try_outdate_peer_async(void *data)
513{
Philipp Reisnercb703452011-03-24 11:03:07 +0100514 struct drbd_tconn *tconn = (struct drbd_tconn *)data;
Philipp Reisner87f7be42010-06-11 13:56:33 +0200515
Philipp Reisnercb703452011-03-24 11:03:07 +0100516 conn_try_outdate_peer(tconn);
Philipp Reisner87f7be42010-06-11 13:56:33 +0200517
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200518 kref_put(&tconn->kref, &conn_destroy);
Philipp Reisner87f7be42010-06-11 13:56:33 +0200519 return 0;
520}
521
Philipp Reisnercb703452011-03-24 11:03:07 +0100522void conn_try_outdate_peer_async(struct drbd_tconn *tconn)
Philipp Reisner87f7be42010-06-11 13:56:33 +0200523{
524 struct task_struct *opa;
525
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200526 kref_get(&tconn->kref);
Philipp Reisnercb703452011-03-24 11:03:07 +0100527 opa = kthread_run(_try_outdate_peer_async, tconn, "drbd_async_h");
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200528 if (IS_ERR(opa)) {
Philipp Reisnercb703452011-03-24 11:03:07 +0100529 conn_err(tconn, "out of mem, failed to invoke fence-peer helper\n");
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +0200530 kref_put(&tconn->kref, &conn_destroy);
531 }
Philipp Reisner87f7be42010-06-11 13:56:33 +0200532}
Philipp Reisnerb411b362009-09-25 16:07:19 -0700533
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100534enum drbd_state_rv
535drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700536{
537 const int max_tries = 4;
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100538 enum drbd_state_rv rv = SS_UNKNOWN_ERROR;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200539 struct net_conf *nc;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700540 int try = 0;
541 int forced = 0;
542 union drbd_state mask, val;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700543
544 if (new_role == R_PRIMARY)
Philipp Reisner0625ac12011-02-07 14:49:19 +0100545 request_ping(mdev->tconn); /* Detect a dead peer ASAP */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700546
Philipp Reisner8410da82011-02-11 20:11:10 +0100547 mutex_lock(mdev->state_mutex);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700548
549 mask.i = 0; mask.role = R_MASK;
550 val.i = 0; val.role = new_role;
551
552 while (try++ < max_tries) {
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100553 rv = _drbd_request_state(mdev, mask, val, CS_WAIT_COMPLETE);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700554
555 /* in case we first succeeded to outdate,
556 * but now suddenly could establish a connection */
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100557 if (rv == SS_CW_FAILED_BY_PEER && mask.pdsk != 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700558 val.pdsk = 0;
559 mask.pdsk = 0;
560 continue;
561 }
562
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100563 if (rv == SS_NO_UP_TO_DATE_DISK && force &&
Philipp Reisnerd10a33c2010-03-04 15:11:39 +0100564 (mdev->state.disk < D_UP_TO_DATE &&
565 mdev->state.disk >= D_INCONSISTENT)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700566 mask.disk = D_MASK;
567 val.disk = D_UP_TO_DATE;
568 forced = 1;
569 continue;
570 }
571
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100572 if (rv == SS_NO_UP_TO_DATE_DISK &&
Philipp Reisnerb411b362009-09-25 16:07:19 -0700573 mdev->state.disk == D_CONSISTENT && mask.pdsk == 0) {
574 D_ASSERT(mdev->state.pdsk == D_UNKNOWN);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700575
Philipp Reisnercb703452011-03-24 11:03:07 +0100576 if (conn_try_outdate_peer(mdev->tconn)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700577 val.disk = D_UP_TO_DATE;
578 mask.disk = D_MASK;
579 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700580 continue;
581 }
582
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100583 if (rv == SS_NOTHING_TO_DO)
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100584 goto out;
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100585 if (rv == SS_PRIMARY_NOP && mask.pdsk == 0) {
Philipp Reisnercb703452011-03-24 11:03:07 +0100586 if (!conn_try_outdate_peer(mdev->tconn) && force) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700587 dev_warn(DEV, "Forced into split brain situation!\n");
Philipp Reisnercb703452011-03-24 11:03:07 +0100588 mask.pdsk = D_MASK;
589 val.pdsk = D_OUTDATED;
590
Philipp Reisnerb411b362009-09-25 16:07:19 -0700591 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700592 continue;
593 }
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100594 if (rv == SS_TWO_PRIMARIES) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700595 /* Maybe the peer is detected as dead very soon...
596 retry at most once more in this case. */
Philipp Reisner44ed1672011-04-19 17:10:19 +0200597 int timeo;
598 rcu_read_lock();
599 nc = rcu_dereference(mdev->tconn->net_conf);
600 timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
601 rcu_read_unlock();
602 schedule_timeout_interruptible(timeo);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700603 if (try < max_tries)
604 try = max_tries - 1;
605 continue;
606 }
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100607 if (rv < SS_SUCCESS) {
608 rv = _drbd_request_state(mdev, mask, val,
Philipp Reisnerb411b362009-09-25 16:07:19 -0700609 CS_VERBOSE + CS_WAIT_COMPLETE);
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100610 if (rv < SS_SUCCESS)
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100611 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700612 }
613 break;
614 }
615
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100616 if (rv < SS_SUCCESS)
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100617 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700618
619 if (forced)
620 dev_warn(DEV, "Forced to consider local data as UpToDate!\n");
621
622 /* Wait until nothing is on the fly :) */
623 wait_event(mdev->misc_wait, atomic_read(&mdev->ap_pending_cnt) == 0);
624
625 if (new_role == R_SECONDARY) {
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100626 set_disk_ro(mdev->vdisk, true);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700627 if (get_ldev(mdev)) {
628 mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
629 put_ldev(mdev);
630 }
631 } else {
Philipp Reisnera0095502011-05-03 13:14:15 +0200632 mutex_lock(&mdev->tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +0200633 nc = mdev->tconn->net_conf;
Philipp Reisner44ed1672011-04-19 17:10:19 +0200634 if (nc)
Andreas Gruenbacher6139f602011-05-06 20:00:02 +0200635 nc->discard_my_data = 0; /* without copy; single bit op is atomic */
Philipp Reisnera0095502011-05-03 13:14:15 +0200636 mutex_unlock(&mdev->tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +0200637
Andreas Gruenbacher81e84652010-12-09 15:03:57 +0100638 set_disk_ro(mdev->vdisk, false);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700639 if (get_ldev(mdev)) {
640 if (((mdev->state.conn < C_CONNECTED ||
641 mdev->state.pdsk <= D_FAILED)
642 && mdev->ldev->md.uuid[UI_BITMAP] == 0) || forced)
643 drbd_uuid_new_current(mdev);
644
645 mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1;
646 put_ldev(mdev);
647 }
648 }
649
Lars Ellenberg19f843a2010-12-15 08:59:11 +0100650 /* writeout of activity log covered areas of the bitmap
651 * to stable storage done in after state change already */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700652
653 if (mdev->state.conn >= C_WF_REPORT_PARAMS) {
654 /* if this was forced, we should consider sync */
655 if (forced)
656 drbd_send_uuids(mdev);
657 drbd_send_state(mdev);
658 }
659
660 drbd_md_sync(mdev);
661
662 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100663out:
Philipp Reisner8410da82011-02-11 20:11:10 +0100664 mutex_unlock(mdev->state_mutex);
Andreas Gruenbacherbf885f82010-12-08 00:39:32 +0100665 return rv;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700666}
667
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100668static const char *from_attrs_err_to_txt(int err)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700669{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100670 return err == -ENOMSG ? "required attribute missing" :
671 err == -EOPNOTSUPP ? "unknown mandatory attribute" :
Lars Ellenbergf3990022011-03-23 14:31:09 +0100672 err == -EEXIST ? "can not change invariant setting" :
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100673 "invalid attribute value";
Philipp Reisnerb411b362009-09-25 16:07:19 -0700674}
675
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100676int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700677{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100678 struct set_role_parms parms;
679 int err;
680 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700681
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100682 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
683 if (!adm_ctx.reply_skb)
684 return retcode;
685 if (retcode != NO_ERROR)
686 goto out;
687
688 memset(&parms, 0, sizeof(parms));
689 if (info->attrs[DRBD_NLA_SET_ROLE_PARMS]) {
Lars Ellenbergf3990022011-03-23 14:31:09 +0100690 err = set_role_parms_from_attrs(&parms, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100691 if (err) {
692 retcode = ERR_MANDATORY_TAG;
693 drbd_msg_put_info(from_attrs_err_to_txt(err));
694 goto out;
695 }
696 }
697
698 if (info->genlhdr->cmd == DRBD_ADM_PRIMARY)
699 retcode = drbd_set_role(adm_ctx.mdev, R_PRIMARY, parms.assume_uptodate);
700 else
701 retcode = drbd_set_role(adm_ctx.mdev, R_SECONDARY, 0);
702out:
703 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700704 return 0;
705}
706
707/* initializes the md.*_offset members, so we are able to find
708 * the on disk meta data */
709static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
710 struct drbd_backing_dev *bdev)
711{
712 sector_t md_size_sect = 0;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200713 int meta_dev_idx;
714
715 rcu_read_lock();
716 meta_dev_idx = rcu_dereference(bdev->disk_conf)->meta_dev_idx;
717
718 switch (meta_dev_idx) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700719 default:
720 /* v07 style fixed size indexed meta data */
721 bdev->md.md_size_sect = MD_RESERVED_SECT;
722 bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
723 bdev->md.al_offset = MD_AL_OFFSET;
724 bdev->md.bm_offset = MD_BM_OFFSET;
725 break;
726 case DRBD_MD_INDEX_FLEX_EXT:
727 /* just occupy the full device; unit: sectors */
728 bdev->md.md_size_sect = drbd_get_capacity(bdev->md_bdev);
729 bdev->md.md_offset = 0;
730 bdev->md.al_offset = MD_AL_OFFSET;
731 bdev->md.bm_offset = MD_BM_OFFSET;
732 break;
733 case DRBD_MD_INDEX_INTERNAL:
734 case DRBD_MD_INDEX_FLEX_INT:
735 bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
736 /* al size is still fixed */
Lars Ellenberg7ad651b2011-02-21 13:21:03 +0100737 bdev->md.al_offset = -MD_AL_SECTORS;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700738 /* we need (slightly less than) ~ this much bitmap sectors: */
739 md_size_sect = drbd_get_capacity(bdev->backing_bdev);
740 md_size_sect = ALIGN(md_size_sect, BM_SECT_PER_EXT);
741 md_size_sect = BM_SECT_TO_EXT(md_size_sect);
742 md_size_sect = ALIGN(md_size_sect, 8);
743
744 /* plus the "drbd meta data super block",
745 * and the activity log; */
746 md_size_sect += MD_BM_OFFSET;
747
748 bdev->md.md_size_sect = md_size_sect;
749 /* bitmap offset is adjusted by 'super' block size */
750 bdev->md.bm_offset = -md_size_sect + MD_AL_OFFSET;
751 break;
752 }
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200753 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -0700754}
755
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100756/* input size is expected to be in KB */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700757char *ppsize(char *buf, unsigned long long size)
758{
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100759 /* Needs 9 bytes at max including trailing NUL:
760 * -1ULL ==> "16384 EB" */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700761 static char units[] = { 'K', 'M', 'G', 'T', 'P', 'E' };
762 int base = 0;
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100763 while (size >= 10000 && base < sizeof(units)-1) {
Philipp Reisnerb411b362009-09-25 16:07:19 -0700764 /* shift + round */
765 size = (size >> 10) + !!(size & (1<<9));
766 base++;
767 }
Lars Ellenberg4b0715f2010-12-14 15:13:04 +0100768 sprintf(buf, "%u %cB", (unsigned)size, units[base]);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700769
770 return buf;
771}
772
773/* there is still a theoretical deadlock when called from receiver
774 * on an D_INCONSISTENT R_PRIMARY:
775 * remote READ does inc_ap_bio, receiver would need to receive answer
776 * packet from remote to dec_ap_bio again.
777 * receiver receive_sizes(), comes here,
778 * waits for ap_bio_cnt == 0. -> deadlock.
779 * but this cannot happen, actually, because:
780 * R_PRIMARY D_INCONSISTENT, and peer's disk is unreachable
781 * (not connected, or bad/no disk on peer):
782 * see drbd_fail_request_early, ap_bio_cnt is zero.
783 * R_PRIMARY D_INCONSISTENT, and C_SYNC_TARGET:
784 * peer may not initiate a resize.
785 */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +0100786/* Note these are not to be confused with
787 * drbd_adm_suspend_io/drbd_adm_resume_io,
788 * which are (sub) state changes triggered by admin (drbdsetup),
789 * and can be long lived.
790 * This changes an mdev->flag, is triggered by drbd internals,
791 * and should be short-lived. */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700792void drbd_suspend_io(struct drbd_conf *mdev)
793{
794 set_bit(SUSPEND_IO, &mdev->flags);
Philipp Reisner2aebfab2011-03-28 16:48:11 +0200795 if (drbd_suspended(mdev))
Philipp Reisner265be2d2010-05-31 10:14:17 +0200796 return;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700797 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
798}
799
800void drbd_resume_io(struct drbd_conf *mdev)
801{
802 clear_bit(SUSPEND_IO, &mdev->flags);
803 wake_up(&mdev->misc_wait);
804}
805
806/**
807 * drbd_determine_dev_size() - Sets the right device size obeying all constraints
808 * @mdev: DRBD device.
809 *
810 * Returns 0 on success, negative return values indicate errors.
811 * You should call drbd_md_sync() after calling this function.
812 */
Bart Van Assche24c48302011-05-21 18:32:29 +0200813enum 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 -0700814{
815 sector_t prev_first_sect, prev_size; /* previous meta location */
Philipp Reisneref5e44a2011-05-03 13:27:43 +0200816 sector_t la_size, u_size;
Philipp Reisnerb411b362009-09-25 16:07:19 -0700817 sector_t size;
818 char ppb[10];
819
820 int md_moved, la_size_changed;
821 enum determine_dev_size rv = unchanged;
822
823 /* race:
824 * application request passes inc_ap_bio,
825 * but then cannot get an AL-reference.
826 * this function later may wait on ap_bio_cnt == 0. -> deadlock.
827 *
828 * to avoid that:
829 * Suspend IO right here.
830 * still lock the act_log to not trigger ASSERTs there.
831 */
832 drbd_suspend_io(mdev);
833
834 /* no wait necessary anymore, actually we could assert that */
835 wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
836
837 prev_first_sect = drbd_md_first_sector(mdev->ldev);
838 prev_size = mdev->ldev->md.md_size_sect;
839 la_size = mdev->ldev->md.la_size_sect;
840
841 /* TODO: should only be some assert here, not (re)init... */
842 drbd_md_set_sector_offsets(mdev, mdev->ldev);
843
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +0200844 rcu_read_lock();
845 u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
846 rcu_read_unlock();
Philipp Reisneref5e44a2011-05-03 13:27:43 +0200847 size = drbd_new_dev_size(mdev, mdev->ldev, u_size, flags & DDSF_FORCED);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700848
849 if (drbd_get_capacity(mdev->this_bdev) != size ||
850 drbd_bm_capacity(mdev) != size) {
851 int err;
Philipp Reisner02d9a942010-03-24 16:23:03 +0100852 err = drbd_bm_resize(mdev, size, !(flags & DDSF_NO_RESYNC));
Philipp Reisnerb411b362009-09-25 16:07:19 -0700853 if (unlikely(err)) {
854 /* currently there is only one error: ENOMEM! */
855 size = drbd_bm_capacity(mdev)>>1;
856 if (size == 0) {
857 dev_err(DEV, "OUT OF MEMORY! "
858 "Could not allocate bitmap!\n");
859 } else {
860 dev_err(DEV, "BM resizing failed. "
861 "Leaving size unchanged at size = %lu KB\n",
862 (unsigned long)size);
863 }
864 rv = dev_size_error;
865 }
866 /* racy, see comments above. */
867 drbd_set_my_capacity(mdev, size);
868 mdev->ldev->md.la_size_sect = size;
869 dev_info(DEV, "size = %s (%llu KB)\n", ppsize(ppb, size>>1),
870 (unsigned long long)size>>1);
871 }
872 if (rv == dev_size_error)
873 goto out;
874
875 la_size_changed = (la_size != mdev->ldev->md.la_size_sect);
876
877 md_moved = prev_first_sect != drbd_md_first_sector(mdev->ldev)
878 || prev_size != mdev->ldev->md.md_size_sect;
879
880 if (la_size_changed || md_moved) {
Andreas Gruenbacher24dccab2010-12-12 17:45:41 +0100881 int err;
882
Philipp Reisnerb411b362009-09-25 16:07:19 -0700883 drbd_al_shrink(mdev); /* All extents inactive. */
884 dev_info(DEV, "Writing the whole bitmap, %s\n",
885 la_size_changed && md_moved ? "size changed and md moved" :
886 la_size_changed ? "size changed" : "md moved");
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +0100887 /* next line implicitly does drbd_suspend_io()+drbd_resume_io() */
888 err = drbd_bitmap_io(mdev, &drbd_bm_write,
889 "size changed", BM_LOCKED_MASK);
Andreas Gruenbacher24dccab2010-12-12 17:45:41 +0100890 if (err) {
891 rv = dev_size_error;
892 goto out;
893 }
Philipp Reisnerb411b362009-09-25 16:07:19 -0700894 drbd_md_mark_dirty(mdev);
895 }
896
897 if (size > la_size)
898 rv = grew;
899 if (size < la_size)
900 rv = shrunk;
901out:
902 lc_unlock(mdev->act_log);
903 wake_up(&mdev->al_wait);
904 drbd_resume_io(mdev);
905
906 return rv;
907}
908
909sector_t
Philipp Reisneref5e44a2011-05-03 13:27:43 +0200910drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev,
911 sector_t u_size, int assume_peer_has_space)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700912{
913 sector_t p_size = mdev->p_size; /* partner's disk size. */
914 sector_t la_size = bdev->md.la_size_sect; /* last agreed size. */
915 sector_t m_size; /* my size */
Philipp Reisnerb411b362009-09-25 16:07:19 -0700916 sector_t size = 0;
917
918 m_size = drbd_get_max_capacity(bdev);
919
Philipp Reisnera393db62009-12-22 13:35:52 +0100920 if (mdev->state.conn < C_CONNECTED && assume_peer_has_space) {
921 dev_warn(DEV, "Resize while not connected was forced by the user!\n");
922 p_size = m_size;
923 }
924
Philipp Reisnerb411b362009-09-25 16:07:19 -0700925 if (p_size && m_size) {
926 size = min_t(sector_t, p_size, m_size);
927 } else {
928 if (la_size) {
929 size = la_size;
930 if (m_size && m_size < size)
931 size = m_size;
932 if (p_size && p_size < size)
933 size = p_size;
934 } else {
935 if (m_size)
936 size = m_size;
937 if (p_size)
938 size = p_size;
939 }
940 }
941
942 if (size == 0)
943 dev_err(DEV, "Both nodes diskless!\n");
944
945 if (u_size) {
946 if (u_size > size)
947 dev_err(DEV, "Requested disk size is too big (%lu > %lu)\n",
948 (unsigned long)u_size>>1, (unsigned long)size>>1);
949 else
950 size = u_size;
951 }
952
953 return size;
954}
955
956/**
957 * drbd_check_al_size() - Ensures that the AL is of the right size
958 * @mdev: DRBD device.
959 *
960 * Returns -EBUSY if current al lru is still used, -ENOMEM when allocation
961 * failed, and 0 on success. You should call drbd_md_sync() after you called
962 * this function.
963 */
Lars Ellenbergf3990022011-03-23 14:31:09 +0100964static int drbd_check_al_size(struct drbd_conf *mdev, struct disk_conf *dc)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700965{
966 struct lru_cache *n, *t;
967 struct lc_element *e;
968 unsigned int in_use;
969 int i;
970
Philipp Reisnerb411b362009-09-25 16:07:19 -0700971 if (mdev->act_log &&
Lars Ellenbergf3990022011-03-23 14:31:09 +0100972 mdev->act_log->nr_elements == dc->al_extents)
Philipp Reisnerb411b362009-09-25 16:07:19 -0700973 return 0;
974
975 in_use = 0;
976 t = mdev->act_log;
Lars Ellenberg7ad651b2011-02-21 13:21:03 +0100977 n = lc_create("act_log", drbd_al_ext_cache, AL_UPDATES_PER_TRANSACTION,
Lars Ellenbergf3990022011-03-23 14:31:09 +0100978 dc->al_extents, sizeof(struct lc_element), 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -0700979
980 if (n == NULL) {
981 dev_err(DEV, "Cannot allocate act_log lru!\n");
982 return -ENOMEM;
983 }
984 spin_lock_irq(&mdev->al_lock);
985 if (t) {
986 for (i = 0; i < t->nr_elements; i++) {
987 e = lc_element_by_index(t, i);
988 if (e->refcnt)
989 dev_err(DEV, "refcnt(%d)==%d\n",
990 e->lc_number, e->refcnt);
991 in_use += e->refcnt;
992 }
993 }
994 if (!in_use)
995 mdev->act_log = n;
996 spin_unlock_irq(&mdev->al_lock);
997 if (in_use) {
998 dev_err(DEV, "Activity log still in use!\n");
999 lc_destroy(n);
1000 return -EBUSY;
1001 } else {
1002 if (t)
1003 lc_destroy(t);
1004 }
1005 drbd_md_mark_dirty(mdev); /* we changed mdev->act_log->nr_elemens */
1006 return 0;
1007}
1008
Philipp Reisner99432fc2011-05-20 16:39:13 +02001009static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_size)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001010{
1011 struct request_queue * const q = mdev->rq_queue;
Philipp Reisner99432fc2011-05-20 16:39:13 +02001012 int max_hw_sectors = max_bio_size >> 9;
1013 int max_segments = 0;
1014
1015 if (get_ldev_if_state(mdev, D_ATTACHING)) {
1016 struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
1017
1018 max_hw_sectors = min(queue_max_hw_sectors(b), max_bio_size >> 9);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001019 rcu_read_lock();
1020 max_segments = rcu_dereference(mdev->ldev->disk_conf)->max_bio_bvecs;
1021 rcu_read_unlock();
Philipp Reisner99432fc2011-05-20 16:39:13 +02001022 put_ldev(mdev);
1023 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001024
Philipp Reisnerb411b362009-09-25 16:07:19 -07001025 blk_queue_logical_block_size(q, 512);
Lars Ellenberg1816a2b2010-11-11 15:19:07 +01001026 blk_queue_max_hw_sectors(q, max_hw_sectors);
1027 /* This is the workaround for "bio would need to, but cannot, be split" */
1028 blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
1029 blk_queue_segment_boundary(q, PAGE_CACHE_SIZE-1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001030
Philipp Reisner99432fc2011-05-20 16:39:13 +02001031 if (get_ldev_if_state(mdev, D_ATTACHING)) {
1032 struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001033
Philipp Reisner99432fc2011-05-20 16:39:13 +02001034 blk_queue_stack_limits(q, b);
1035
1036 if (q->backing_dev_info.ra_pages != b->backing_dev_info.ra_pages) {
1037 dev_info(DEV, "Adjusting my ra_pages to backing device's (%lu -> %lu)\n",
1038 q->backing_dev_info.ra_pages,
1039 b->backing_dev_info.ra_pages);
1040 q->backing_dev_info.ra_pages = b->backing_dev_info.ra_pages;
1041 }
1042 put_ldev(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001043 }
1044}
1045
Philipp Reisner99432fc2011-05-20 16:39:13 +02001046void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
1047{
1048 int now, new, local, peer;
1049
1050 now = queue_max_hw_sectors(mdev->rq_queue) << 9;
1051 local = mdev->local_max_bio_size; /* Eventually last known value, from volatile memory */
1052 peer = mdev->peer_max_bio_size; /* Eventually last known value, from meta data */
1053
1054 if (get_ldev_if_state(mdev, D_ATTACHING)) {
1055 local = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
1056 mdev->local_max_bio_size = local;
1057 put_ldev(mdev);
1058 }
1059
1060 /* We may ignore peer limits if the peer is modern enough.
1061 Because new from 8.3.8 onwards the peer can use multiple
1062 BIOs for a single peer_request */
1063 if (mdev->state.conn >= C_CONNECTED) {
Philipp Reisner31890f42011-01-19 14:12:51 +01001064 if (mdev->tconn->agreed_pro_version < 94)
Philipp Reisner2ffca4f2011-06-30 15:43:06 +02001065 peer = min_t(int, mdev->peer_max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
1066 /* Correct old drbd (up to 8.3.7) if it believes it can do more than 32KiB */
Philipp Reisner31890f42011-01-19 14:12:51 +01001067 else if (mdev->tconn->agreed_pro_version == 94)
Philipp Reisner99432fc2011-05-20 16:39:13 +02001068 peer = DRBD_MAX_SIZE_H80_PACKET;
Philipp Reisner2ffca4f2011-06-30 15:43:06 +02001069 else if (mdev->tconn->agreed_pro_version < 100)
1070 peer = DRBD_MAX_BIO_SIZE_P95; /* drbd 8.3.8 onwards, before 8.4.0 */
1071 else
Philipp Reisner99432fc2011-05-20 16:39:13 +02001072 peer = DRBD_MAX_BIO_SIZE;
1073 }
1074
1075 new = min_t(int, local, peer);
1076
1077 if (mdev->state.role == R_PRIMARY && new < now)
1078 dev_err(DEV, "ASSERT FAILED new < now; (%d < %d)\n", new, now);
1079
1080 if (new != now)
1081 dev_info(DEV, "max BIO size = %u\n", new);
1082
1083 drbd_setup_queue_param(mdev, new);
1084}
1085
Philipp Reisnera18e9d12011-04-24 11:09:55 +02001086/* Starts the worker thread */
Philipp Reisner0e29d162011-02-18 14:23:11 +01001087static void conn_reconfig_start(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001088{
Philipp Reisner0e29d162011-02-18 14:23:11 +01001089 drbd_thread_start(&tconn->worker);
1090 conn_flush_workqueue(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001091}
1092
Philipp Reisnera18e9d12011-04-24 11:09:55 +02001093/* if still unconfigured, stops worker again. */
Philipp Reisner0e29d162011-02-18 14:23:11 +01001094static void conn_reconfig_done(struct drbd_tconn *tconn)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001095{
Lars Ellenberg992d6e92011-05-02 11:47:18 +02001096 bool stop_threads;
Philipp Reisner0e29d162011-02-18 14:23:11 +01001097 spin_lock_irq(&tconn->req_lock);
Lars Ellenberg992d6e92011-05-02 11:47:18 +02001098 stop_threads = conn_all_vols_unconf(tconn);
Philipp Reisner0e29d162011-02-18 14:23:11 +01001099 spin_unlock_irq(&tconn->req_lock);
Lars Ellenberg992d6e92011-05-02 11:47:18 +02001100 if (stop_threads) {
1101 /* asender is implicitly stopped by receiver
Philipp Reisner81fa2e62011-05-04 15:10:30 +02001102 * in conn_disconnect() */
Lars Ellenberg992d6e92011-05-02 11:47:18 +02001103 drbd_thread_stop(&tconn->receiver);
1104 drbd_thread_stop(&tconn->worker);
1105 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001106}
1107
Philipp Reisner07782862010-08-31 12:00:50 +02001108/* Make sure IO is suspended before calling this function(). */
1109static void drbd_suspend_al(struct drbd_conf *mdev)
1110{
1111 int s = 0;
1112
Lars Ellenberg61610422011-02-21 13:20:54 +01001113 if (!lc_try_lock(mdev->act_log)) {
Philipp Reisner07782862010-08-31 12:00:50 +02001114 dev_warn(DEV, "Failed to lock al in drbd_suspend_al()\n");
1115 return;
1116 }
1117
Lars Ellenberg61610422011-02-21 13:20:54 +01001118 drbd_al_shrink(mdev);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001119 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner07782862010-08-31 12:00:50 +02001120 if (mdev->state.conn < C_CONNECTED)
1121 s = !test_and_set_bit(AL_SUSPENDED, &mdev->flags);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001122 spin_unlock_irq(&mdev->tconn->req_lock);
Lars Ellenberg61610422011-02-21 13:20:54 +01001123 lc_unlock(mdev->act_log);
Philipp Reisner07782862010-08-31 12:00:50 +02001124
1125 if (s)
1126 dev_info(DEV, "Suspended AL updates\n");
1127}
1128
Lars Ellenberg5979e362011-04-27 21:09:55 +02001129
1130static bool should_set_defaults(struct genl_info *info)
1131{
1132 unsigned flags = ((struct drbd_genlmsghdr*)info->userhdr)->flags;
1133 return 0 != (flags & DRBD_GENL_F_SET_DEFAULTS);
1134}
1135
Philipp Reisnerd589a212011-05-04 10:06:52 +02001136static void enforce_disk_conf_limits(struct disk_conf *dc)
1137{
1138 if (dc->al_extents < DRBD_AL_EXTENTS_MIN)
1139 dc->al_extents = DRBD_AL_EXTENTS_MIN;
1140 if (dc->al_extents > DRBD_AL_EXTENTS_MAX)
1141 dc->al_extents = DRBD_AL_EXTENTS_MAX;
1142
1143 if (dc->c_plan_ahead > DRBD_C_PLAN_AHEAD_MAX)
1144 dc->c_plan_ahead = DRBD_C_PLAN_AHEAD_MAX;
1145}
1146
Lars Ellenbergf3990022011-03-23 14:31:09 +01001147int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)
1148{
1149 enum drbd_ret_code retcode;
1150 struct drbd_conf *mdev;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001151 struct disk_conf *new_disk_conf, *old_disk_conf;
Philipp Reisner813472c2011-05-03 16:47:02 +02001152 struct fifo_buffer *old_plan = NULL, *new_plan = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001153 int err, fifo_size;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001154
1155 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1156 if (!adm_ctx.reply_skb)
1157 return retcode;
1158 if (retcode != NO_ERROR)
1159 goto out;
1160
1161 mdev = adm_ctx.mdev;
1162
1163 /* we also need a disk
1164 * to change the options on */
1165 if (!get_ldev(mdev)) {
1166 retcode = ERR_NO_DISK;
1167 goto out;
1168 }
1169
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001170 new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001171 if (!new_disk_conf) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001172 retcode = ERR_NOMEM;
1173 goto fail;
1174 }
1175
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001176 mutex_lock(&mdev->tconn->conf_update);
1177 old_disk_conf = mdev->ldev->disk_conf;
1178 *new_disk_conf = *old_disk_conf;
Lars Ellenberg5979e362011-04-27 21:09:55 +02001179 if (should_set_defaults(info))
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02001180 set_disk_conf_defaults(new_disk_conf);
Lars Ellenberg5979e362011-04-27 21:09:55 +02001181
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001182 err = disk_conf_from_attrs_for_change(new_disk_conf, info);
Andreas Gruenbacherc75b9b12011-05-24 14:18:31 +02001183 if (err && err != -ENOMSG) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001184 retcode = ERR_MANDATORY_TAG;
1185 drbd_msg_put_info(from_attrs_err_to_txt(err));
1186 }
1187
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001188 if (!expect(new_disk_conf->resync_rate >= 1))
1189 new_disk_conf->resync_rate = 1;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001190
Philipp Reisnerd589a212011-05-04 10:06:52 +02001191 enforce_disk_conf_limits(new_disk_conf);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001192
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001193 fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ;
Philipp Reisner9958c852011-05-03 16:19:31 +02001194 if (fifo_size != mdev->rs_plan_s->size) {
Philipp Reisner813472c2011-05-03 16:47:02 +02001195 new_plan = fifo_alloc(fifo_size);
1196 if (!new_plan) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001197 dev_err(DEV, "kmalloc of fifo_buffer failed");
1198 retcode = ERR_NOMEM;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001199 goto fail_unlock;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001200 }
1201 }
1202
Lars Ellenbergf3990022011-03-23 14:31:09 +01001203 wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
1204 drbd_al_shrink(mdev);
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001205 err = drbd_check_al_size(mdev, new_disk_conf);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001206 lc_unlock(mdev->act_log);
1207 wake_up(&mdev->al_wait);
1208
1209 if (err) {
1210 retcode = ERR_NOMEM;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001211 goto fail_unlock;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001212 }
1213
Philipp Reisnerdc97b702011-05-03 14:27:15 +02001214 write_lock_irq(&global_state_lock);
Andreas Gruenbacher95f8efd2011-05-12 11:15:34 +02001215 retcode = drbd_resync_after_valid(mdev, new_disk_conf->resync_after);
Philipp Reisnerdc97b702011-05-03 14:27:15 +02001216 if (retcode == NO_ERROR) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001217 rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
Andreas Gruenbacher95f8efd2011-05-12 11:15:34 +02001218 drbd_resync_after_changed(mdev);
Philipp Reisnerdc97b702011-05-03 14:27:15 +02001219 }
1220 write_unlock_irq(&global_state_lock);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001221
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001222 if (retcode != NO_ERROR)
1223 goto fail_unlock;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001224
Philipp Reisner813472c2011-05-03 16:47:02 +02001225 if (new_plan) {
1226 old_plan = mdev->rs_plan_s;
1227 rcu_assign_pointer(mdev->rs_plan_s, new_plan);
Philipp Reisner9958c852011-05-03 16:19:31 +02001228 }
Philipp Reisner9958c852011-05-03 16:19:31 +02001229
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02001230 mutex_unlock(&mdev->tconn->conf_update);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001231 drbd_md_sync(mdev);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001232
1233 if (mdev->state.conn >= C_CONNECTED)
1234 drbd_send_sync_param(mdev);
1235
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001236 synchronize_rcu();
1237 kfree(old_disk_conf);
Philipp Reisner813472c2011-05-03 16:47:02 +02001238 kfree(old_plan);
Philipp Reisnercdfda632011-07-05 15:38:59 +02001239 mod_timer(&mdev->request_timer, jiffies + HZ);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001240 goto success;
1241
1242fail_unlock:
1243 mutex_unlock(&mdev->tconn->conf_update);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001244 fail:
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001245 kfree(new_disk_conf);
Philipp Reisner813472c2011-05-03 16:47:02 +02001246 kfree(new_plan);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001247success:
1248 put_ldev(mdev);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001249 out:
1250 drbd_adm_finish(info, retcode);
1251 return 0;
1252}
1253
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001254int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001255{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001256 struct drbd_conf *mdev;
1257 int err;
Andreas Gruenbacher116676c2010-12-08 13:33:11 +01001258 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001259 enum determine_dev_size dd;
1260 sector_t max_possible_sectors;
1261 sector_t min_md_device_sectors;
1262 struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001263 struct disk_conf *new_disk_conf = NULL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001264 struct block_device *bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001265 struct lru_cache *resync_lru = NULL;
Philipp Reisner9958c852011-05-03 16:19:31 +02001266 struct fifo_buffer *new_plan = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001267 union drbd_state ns, os;
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001268 enum drbd_state_rv rv;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001269 struct net_conf *nc;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001270
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001271 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1272 if (!adm_ctx.reply_skb)
1273 return retcode;
1274 if (retcode != NO_ERROR)
Lars Ellenberg40cbf082011-03-16 16:52:10 +01001275 goto finish;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001276
1277 mdev = adm_ctx.mdev;
Philipp Reisner0e29d162011-02-18 14:23:11 +01001278 conn_reconfig_start(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001279
1280 /* if you want to reconfigure, please tear down first */
1281 if (mdev->state.disk > D_DISKLESS) {
1282 retcode = ERR_DISK_CONFIGURED;
1283 goto fail;
1284 }
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001285 /* It may just now have detached because of IO error. Make sure
1286 * drbd_ldev_destroy is done already, we may end up here very fast,
1287 * e.g. if someone calls attach from the on-io-error handler,
1288 * to realize a "hot spare" feature (not that I'd recommend that) */
1289 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001290
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001291 /* allocation not in the IO path, drbdsetup context */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001292 nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
1293 if (!nbc) {
1294 retcode = ERR_NOMEM;
1295 goto fail;
1296 }
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001297 new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL);
1298 if (!new_disk_conf) {
1299 retcode = ERR_NOMEM;
1300 goto fail;
1301 }
1302 nbc->disk_conf = new_disk_conf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001303
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001304 set_disk_conf_defaults(new_disk_conf);
1305 err = disk_conf_from_attrs(new_disk_conf, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001306 if (err) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001307 retcode = ERR_MANDATORY_TAG;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001308 drbd_msg_put_info(from_attrs_err_to_txt(err));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001309 goto fail;
1310 }
1311
Philipp Reisnerd589a212011-05-04 10:06:52 +02001312 enforce_disk_conf_limits(new_disk_conf);
1313
Philipp Reisner9958c852011-05-03 16:19:31 +02001314 new_plan = fifo_alloc((new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ);
1315 if (!new_plan) {
1316 retcode = ERR_NOMEM;
1317 goto fail;
1318 }
1319
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001320 if (new_disk_conf->meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001321 retcode = ERR_MD_IDX_INVALID;
1322 goto fail;
1323 }
1324
Philipp Reisner44ed1672011-04-19 17:10:19 +02001325 rcu_read_lock();
1326 nc = rcu_dereference(mdev->tconn->net_conf);
1327 if (nc) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001328 if (new_disk_conf->fencing == FP_STONITH && nc->wire_protocol == DRBD_PROT_A) {
Philipp Reisner44ed1672011-04-19 17:10:19 +02001329 rcu_read_unlock();
Philipp Reisner47ff2d02010-06-18 13:56:57 +02001330 retcode = ERR_STONITH_AND_PROT_A;
1331 goto fail;
1332 }
1333 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02001334 rcu_read_unlock();
Philipp Reisner47ff2d02010-06-18 13:56:57 +02001335
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001336 bdev = blkdev_get_by_path(new_disk_conf->backing_dev,
Tejun Heod4d77622010-11-13 11:55:18 +01001337 FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
Tejun Heoe525fd82010-11-13 11:55:17 +01001338 if (IS_ERR(bdev)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001339 dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->backing_dev,
Tejun Heoe525fd82010-11-13 11:55:17 +01001340 PTR_ERR(bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001341 retcode = ERR_OPEN_DISK;
1342 goto fail;
1343 }
Tejun Heoe525fd82010-11-13 11:55:17 +01001344 nbc->backing_bdev = bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001345
Tejun Heoe525fd82010-11-13 11:55:17 +01001346 /*
1347 * meta_dev_idx >= 0: external fixed size, possibly multiple
1348 * drbd sharing one meta device. TODO in that case, paranoia
1349 * check that [md_bdev, meta_dev_idx] is not yet used by some
1350 * other drbd minor! (if you use drbd.conf + drbdadm, that
1351 * should check it for you already; but if you don't, or
1352 * someone fooled it, we need to double check here)
1353 */
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001354 bdev = blkdev_get_by_path(new_disk_conf->meta_dev,
Tejun Heod4d77622010-11-13 11:55:18 +01001355 FMODE_READ | FMODE_WRITE | FMODE_EXCL,
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001356 (new_disk_conf->meta_dev_idx < 0) ?
Tejun Heod4d77622010-11-13 11:55:18 +01001357 (void *)mdev : (void *)drbd_m_holder);
Tejun Heoe525fd82010-11-13 11:55:17 +01001358 if (IS_ERR(bdev)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001359 dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->meta_dev,
Tejun Heoe525fd82010-11-13 11:55:17 +01001360 PTR_ERR(bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001361 retcode = ERR_OPEN_MD_DISK;
1362 goto fail;
1363 }
Tejun Heoe525fd82010-11-13 11:55:17 +01001364 nbc->md_bdev = bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001365
Tejun Heoe525fd82010-11-13 11:55:17 +01001366 if ((nbc->backing_bdev == nbc->md_bdev) !=
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001367 (new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
1368 new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
Tejun Heoe525fd82010-11-13 11:55:17 +01001369 retcode = ERR_MD_IDX_INVALID;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001370 goto fail;
1371 }
1372
1373 resync_lru = lc_create("resync", drbd_bm_ext_cache,
Lars Ellenberg46a15bc2011-02-21 13:21:01 +01001374 1, 61, sizeof(struct bm_extent),
Philipp Reisnerb411b362009-09-25 16:07:19 -07001375 offsetof(struct bm_extent, lce));
1376 if (!resync_lru) {
1377 retcode = ERR_NOMEM;
Tejun Heoe525fd82010-11-13 11:55:17 +01001378 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001379 }
1380
1381 /* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */
1382 drbd_md_set_sector_offsets(mdev, nbc);
1383
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001384 if (drbd_get_max_capacity(nbc) < new_disk_conf->disk_size) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001385 dev_err(DEV, "max capacity %llu smaller than disk size %llu\n",
1386 (unsigned long long) drbd_get_max_capacity(nbc),
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001387 (unsigned long long) new_disk_conf->disk_size);
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001388 retcode = ERR_DISK_TOO_SMALL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001389 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001390 }
1391
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001392 if (new_disk_conf->meta_dev_idx < 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001393 max_possible_sectors = DRBD_MAX_SECTORS_FLEX;
1394 /* at least one MB, otherwise it does not make sense */
1395 min_md_device_sectors = (2<<10);
1396 } else {
1397 max_possible_sectors = DRBD_MAX_SECTORS;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001398 min_md_device_sectors = MD_RESERVED_SECT * (new_disk_conf->meta_dev_idx + 1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001399 }
1400
Philipp Reisnerb411b362009-09-25 16:07:19 -07001401 if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) {
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001402 retcode = ERR_MD_DISK_TOO_SMALL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001403 dev_warn(DEV, "refusing attach: md-device too small, "
1404 "at least %llu sectors needed for this meta-disk type\n",
1405 (unsigned long long) min_md_device_sectors);
Tejun Heoe525fd82010-11-13 11:55:17 +01001406 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001407 }
1408
1409 /* Make sure the new disk is big enough
1410 * (we may currently be R_PRIMARY with no local disk...) */
1411 if (drbd_get_max_capacity(nbc) <
1412 drbd_get_capacity(mdev->this_bdev)) {
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001413 retcode = ERR_DISK_TOO_SMALL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001414 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001415 }
1416
1417 nbc->known_size = drbd_get_capacity(nbc->backing_bdev);
1418
Lars Ellenberg13529942009-10-12 19:07:49 +02001419 if (nbc->known_size > max_possible_sectors) {
1420 dev_warn(DEV, "==> truncating very big lower level device "
1421 "to currently maximum possible %llu sectors <==\n",
1422 (unsigned long long) max_possible_sectors);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001423 if (new_disk_conf->meta_dev_idx >= 0)
Lars Ellenberg13529942009-10-12 19:07:49 +02001424 dev_warn(DEV, "==>> using internal or flexible "
1425 "meta data may help <<==\n");
1426 }
1427
Philipp Reisnerb411b362009-09-25 16:07:19 -07001428 drbd_suspend_io(mdev);
1429 /* also wait for the last barrier ack. */
Philipp Reisner2aebfab2011-03-28 16:48:11 +02001430 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || drbd_suspended(mdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001431 /* and for any other previously queued work */
Philipp Reisnera21e9292011-02-08 15:08:49 +01001432 drbd_flush_workqueue(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001433
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001434 rv = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE);
1435 retcode = rv; /* FIXME: Type mismatch. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001436 drbd_resume_io(mdev);
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001437 if (rv < SS_SUCCESS)
Tejun Heoe525fd82010-11-13 11:55:17 +01001438 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001439
1440 if (!get_ldev_if_state(mdev, D_ATTACHING))
1441 goto force_diskless;
1442
1443 drbd_md_set_sector_offsets(mdev, nbc);
1444
1445 if (!mdev->bitmap) {
1446 if (drbd_bm_init(mdev)) {
1447 retcode = ERR_NOMEM;
1448 goto force_diskless_dec;
1449 }
1450 }
1451
1452 retcode = drbd_md_read(mdev, nbc);
1453 if (retcode != NO_ERROR)
1454 goto force_diskless_dec;
1455
1456 if (mdev->state.conn < C_CONNECTED &&
1457 mdev->state.role == R_PRIMARY &&
1458 (mdev->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
1459 dev_err(DEV, "Can only attach to data with current UUID=%016llX\n",
1460 (unsigned long long)mdev->ed_uuid);
1461 retcode = ERR_DATA_NOT_CURRENT;
1462 goto force_diskless_dec;
1463 }
1464
1465 /* Since we are diskless, fix the activity log first... */
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001466 if (drbd_check_al_size(mdev, new_disk_conf)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001467 retcode = ERR_NOMEM;
1468 goto force_diskless_dec;
1469 }
1470
1471 /* Prevent shrinking of consistent devices ! */
1472 if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001473 drbd_new_dev_size(mdev, nbc, nbc->disk_conf->disk_size, 0) < nbc->md.la_size_sect) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001474 dev_warn(DEV, "refusing to truncate a consistent device\n");
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001475 retcode = ERR_DISK_TOO_SMALL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001476 goto force_diskless_dec;
1477 }
1478
Philipp Reisnerb411b362009-09-25 16:07:19 -07001479 /* Reset the "barriers don't work" bits here, then force meta data to
1480 * be written, to ensure we determine if barriers are supported. */
Andreas Gruenbachere5440462011-05-04 15:25:35 +02001481 if (new_disk_conf->md_flushes)
Philipp Reisnera8a4e512010-08-25 10:21:04 +02001482 clear_bit(MD_NO_FUA, &mdev->flags);
Andreas Gruenbachere5440462011-05-04 15:25:35 +02001483 else
1484 set_bit(MD_NO_FUA, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001485
1486 /* Point of no return reached.
1487 * Devices and memory are no longer released by error cleanup below.
1488 * now mdev takes over responsibility, and the state engine should
1489 * clean it up somewhere. */
1490 D_ASSERT(mdev->ldev == NULL);
1491 mdev->ldev = nbc;
1492 mdev->resync = resync_lru;
Philipp Reisner9958c852011-05-03 16:19:31 +02001493 mdev->rs_plan_s = new_plan;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001494 nbc = NULL;
1495 resync_lru = NULL;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001496 new_disk_conf = NULL;
Philipp Reisner9958c852011-05-03 16:19:31 +02001497 new_plan = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001498
Philipp Reisner2451fc32010-08-24 13:43:11 +02001499 mdev->write_ordering = WO_bdev_flush;
1500 drbd_bump_write_ordering(mdev, WO_bdev_flush);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001501
1502 if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
1503 set_bit(CRASHED_PRIMARY, &mdev->flags);
1504 else
1505 clear_bit(CRASHED_PRIMARY, &mdev->flags);
1506
Philipp Reisner894c6a92010-06-18 16:03:20 +02001507 if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
Lars Ellenbergd5d7ebd2011-07-05 20:59:26 +02001508 !(mdev->state.role == R_PRIMARY && mdev->tconn->susp_nod))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001509 set_bit(CRASHED_PRIMARY, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001510
1511 mdev->send_cnt = 0;
1512 mdev->recv_cnt = 0;
1513 mdev->read_cnt = 0;
1514 mdev->writ_cnt = 0;
1515
Philipp Reisner99432fc2011-05-20 16:39:13 +02001516 drbd_reconsider_max_bio_size(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001517
1518 /* If I am currently not R_PRIMARY,
1519 * but meta data primary indicator is set,
1520 * I just now recover from a hard crash,
1521 * and have been R_PRIMARY before that crash.
1522 *
1523 * Now, if I had no connection before that crash
1524 * (have been degraded R_PRIMARY), chances are that
1525 * I won't find my peer now either.
1526 *
1527 * In that case, and _only_ in that case,
1528 * we use the degr-wfc-timeout instead of the default,
1529 * so we can automatically recover from a crash of a
1530 * degraded but active "cluster" after a certain timeout.
1531 */
1532 clear_bit(USE_DEGR_WFC_T, &mdev->flags);
1533 if (mdev->state.role != R_PRIMARY &&
1534 drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
1535 !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND))
1536 set_bit(USE_DEGR_WFC_T, &mdev->flags);
1537
Bart Van Assche24c48302011-05-21 18:32:29 +02001538 dd = drbd_determine_dev_size(mdev, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001539 if (dd == dev_size_error) {
1540 retcode = ERR_NOMEM_BITMAP;
1541 goto force_diskless_dec;
1542 } else if (dd == grew)
1543 set_bit(RESYNC_AFTER_NEG, &mdev->flags);
1544
1545 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
1546 dev_info(DEV, "Assuming that all blocks are out of sync "
1547 "(aka FullSync)\n");
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001548 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
1549 "set_n_write from attaching", BM_LOCKED_MASK)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001550 retcode = ERR_IO_MD_DISK;
1551 goto force_diskless_dec;
1552 }
1553 } else {
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001554 if (drbd_bitmap_io(mdev, &drbd_bm_read,
Andreas Gruenbacher22ab6a32010-12-13 01:44:11 +01001555 "read from attaching", BM_LOCKED_MASK)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001556 retcode = ERR_IO_MD_DISK;
1557 goto force_diskless_dec;
1558 }
1559 }
1560
Philipp Reisner07782862010-08-31 12:00:50 +02001561 if (_drbd_bm_total_weight(mdev) == drbd_bm_bits(mdev))
1562 drbd_suspend_al(mdev); /* IO is still suspended here... */
1563
Philipp Reisner87eeee42011-01-19 14:16:30 +01001564 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner78bae592011-03-28 15:40:12 +02001565 os = drbd_read_state(mdev);
1566 ns = os;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001567 /* If MDF_CONSISTENT is not set go into inconsistent state,
1568 otherwise investigate MDF_WasUpToDate...
1569 If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state,
1570 otherwise into D_CONSISTENT state.
1571 */
1572 if (drbd_md_test_flag(mdev->ldev, MDF_CONSISTENT)) {
1573 if (drbd_md_test_flag(mdev->ldev, MDF_WAS_UP_TO_DATE))
1574 ns.disk = D_CONSISTENT;
1575 else
1576 ns.disk = D_OUTDATED;
1577 } else {
1578 ns.disk = D_INCONSISTENT;
1579 }
1580
1581 if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED))
1582 ns.pdsk = D_OUTDATED;
1583
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001584 rcu_read_lock();
1585 if (ns.disk == D_CONSISTENT &&
1586 (ns.pdsk == D_OUTDATED || rcu_dereference(mdev->ldev->disk_conf)->fencing == FP_DONT_CARE))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001587 ns.disk = D_UP_TO_DATE;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001588 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -07001589
1590 /* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND,
1591 MDF_CONSISTENT and MDF_WAS_UP_TO_DATE must happen before
1592 this point, because drbd_request_state() modifies these
1593 flags. */
1594
1595 /* In case we are C_CONNECTED postpone any decision on the new disk
1596 state after the negotiation phase. */
1597 if (mdev->state.conn == C_CONNECTED) {
1598 mdev->new_state_tmp.i = ns.i;
1599 ns.i = os.i;
1600 ns.disk = D_NEGOTIATING;
Philipp Reisnerdc66c742010-06-02 14:31:29 +02001601
1602 /* We expect to receive up-to-date UUIDs soon.
1603 To avoid a race in receive_state, free p_uuid while
1604 holding req_lock. I.e. atomic with the state change */
1605 kfree(mdev->p_uuid);
1606 mdev->p_uuid = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001607 }
1608
1609 rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001610 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001611
1612 if (rv < SS_SUCCESS)
1613 goto force_diskless_dec;
1614
Philipp Reisnercdfda632011-07-05 15:38:59 +02001615 mod_timer(&mdev->request_timer, jiffies + HZ);
1616
Philipp Reisnerb411b362009-09-25 16:07:19 -07001617 if (mdev->state.role == R_PRIMARY)
1618 mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1;
1619 else
1620 mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
1621
1622 drbd_md_mark_dirty(mdev);
1623 drbd_md_sync(mdev);
1624
1625 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
1626 put_ldev(mdev);
Philipp Reisner0e29d162011-02-18 14:23:11 +01001627 conn_reconfig_done(mdev->tconn);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001628 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001629 return 0;
1630
1631 force_diskless_dec:
1632 put_ldev(mdev);
1633 force_diskless:
Philipp Reisner9510b242011-07-01 17:00:57 +02001634 drbd_force_state(mdev, NS(disk, D_DISKLESS));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001635 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001636 fail:
Lars Ellenberg40cbf082011-03-16 16:52:10 +01001637 conn_reconfig_done(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001638 if (nbc) {
Tejun Heoe525fd82010-11-13 11:55:17 +01001639 if (nbc->backing_bdev)
1640 blkdev_put(nbc->backing_bdev,
1641 FMODE_READ | FMODE_WRITE | FMODE_EXCL);
1642 if (nbc->md_bdev)
1643 blkdev_put(nbc->md_bdev,
1644 FMODE_READ | FMODE_WRITE | FMODE_EXCL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001645 kfree(nbc);
1646 }
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001647 kfree(new_disk_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001648 lc_destroy(resync_lru);
Philipp Reisner9958c852011-05-03 16:19:31 +02001649 kfree(new_plan);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001650
Lars Ellenberg40cbf082011-03-16 16:52:10 +01001651 finish:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001652 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001653 return 0;
1654}
1655
Philipp Reisnercdfda632011-07-05 15:38:59 +02001656static int adm_detach(struct drbd_conf *mdev, int force)
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001657{
Philipp Reisner19f83c72011-03-29 14:21:03 +02001658 enum drbd_state_rv retcode;
Lars Ellenberg009ba892011-05-02 11:51:31 +02001659 int ret;
Philipp Reisnercdfda632011-07-05 15:38:59 +02001660
1661 if (force) {
1662 drbd_force_state(mdev, NS(disk, D_FAILED));
1663 retcode = SS_SUCCESS;
1664 goto out;
1665 }
1666
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001667 drbd_suspend_io(mdev); /* so no-one is stuck in drbd_al_begin_io */
Lars Ellenberg009ba892011-05-02 11:51:31 +02001668 retcode = drbd_request_state(mdev, NS(disk, D_FAILED));
1669 /* D_FAILED will transition to DISKLESS. */
1670 ret = wait_event_interruptible(mdev->misc_wait,
1671 mdev->state.disk != D_FAILED);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001672 drbd_resume_io(mdev);
Lars Ellenberg009ba892011-05-02 11:51:31 +02001673 if ((int)retcode == (int)SS_IS_DISKLESS)
1674 retcode = SS_NOTHING_TO_DO;
1675 if (ret)
1676 retcode = ERR_INTR;
Philipp Reisnercdfda632011-07-05 15:38:59 +02001677out:
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001678 return retcode;
1679}
1680
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001681/* Detaching the disk is a process in multiple stages. First we need to lock
1682 * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
1683 * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
1684 * internal references as well.
1685 * Only then we have finally detached. */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001686int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001687{
Lars Ellenberg9a0d9d02011-05-02 11:51:31 +02001688 enum drbd_ret_code retcode;
Philipp Reisnercdfda632011-07-05 15:38:59 +02001689 struct detach_parms parms = { };
1690 int err;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001691
1692 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1693 if (!adm_ctx.reply_skb)
1694 return retcode;
1695 if (retcode != NO_ERROR)
1696 goto out;
1697
Philipp Reisnercdfda632011-07-05 15:38:59 +02001698 if (info->attrs[DRBD_NLA_DETACH_PARMS]) {
1699 err = detach_parms_from_attrs(&parms, info);
1700 if (err) {
1701 retcode = ERR_MANDATORY_TAG;
1702 drbd_msg_put_info(from_attrs_err_to_txt(err));
1703 goto out;
1704 }
1705 }
1706
1707 retcode = adm_detach(adm_ctx.mdev, parms.force_detach);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001708out:
1709 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001710 return 0;
1711}
1712
Lars Ellenbergf3990022011-03-23 14:31:09 +01001713static bool conn_resync_running(struct drbd_tconn *tconn)
1714{
1715 struct drbd_conf *mdev;
Philipp Reisner695d08f2011-04-11 22:53:32 -07001716 bool rv = false;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001717 int vnr;
1718
Philipp Reisner695d08f2011-04-11 22:53:32 -07001719 rcu_read_lock();
Lars Ellenbergf3990022011-03-23 14:31:09 +01001720 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
1721 if (mdev->state.conn == C_SYNC_SOURCE ||
1722 mdev->state.conn == C_SYNC_TARGET ||
1723 mdev->state.conn == C_PAUSED_SYNC_S ||
Philipp Reisner695d08f2011-04-11 22:53:32 -07001724 mdev->state.conn == C_PAUSED_SYNC_T) {
1725 rv = true;
1726 break;
1727 }
Lars Ellenbergf3990022011-03-23 14:31:09 +01001728 }
Philipp Reisner695d08f2011-04-11 22:53:32 -07001729 rcu_read_unlock();
1730
1731 return rv;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001732}
1733
1734static bool conn_ov_running(struct drbd_tconn *tconn)
1735{
1736 struct drbd_conf *mdev;
Philipp Reisner695d08f2011-04-11 22:53:32 -07001737 bool rv = false;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001738 int vnr;
1739
Philipp Reisner695d08f2011-04-11 22:53:32 -07001740 rcu_read_lock();
Lars Ellenbergf3990022011-03-23 14:31:09 +01001741 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
1742 if (mdev->state.conn == C_VERIFY_S ||
Philipp Reisner695d08f2011-04-11 22:53:32 -07001743 mdev->state.conn == C_VERIFY_T) {
1744 rv = true;
1745 break;
1746 }
Lars Ellenbergf3990022011-03-23 14:31:09 +01001747 }
Philipp Reisner695d08f2011-04-11 22:53:32 -07001748 rcu_read_unlock();
1749
1750 return rv;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001751}
1752
Philipp Reisnercd643972011-04-13 18:00:59 -07001753static enum drbd_ret_code
Philipp Reisner44ed1672011-04-19 17:10:19 +02001754_check_net_options(struct drbd_tconn *tconn, struct net_conf *old_conf, struct net_conf *new_conf)
Philipp Reisnercd643972011-04-13 18:00:59 -07001755{
1756 struct drbd_conf *mdev;
1757 int i;
1758
Philipp Reisnerdcb20d12011-05-16 14:30:24 +02001759 if (old_conf && tconn->cstate == C_WF_REPORT_PARAMS && tconn->agreed_pro_version < 100) {
1760 if (new_conf->wire_protocol != old_conf->wire_protocol)
1761 return ERR_NEED_APV_100;
1762
1763 if (new_conf->two_primaries != old_conf->two_primaries)
1764 return ERR_NEED_APV_100;
1765
1766 if (!new_conf->integrity_alg != !old_conf->integrity_alg)
1767 return ERR_NEED_APV_100;
1768
1769 if (strcmp(new_conf->integrity_alg, old_conf->integrity_alg))
1770 return ERR_NEED_APV_100;
1771 }
1772
1773 if (!new_conf->two_primaries &&
1774 conn_highest_role(tconn) == R_PRIMARY &&
1775 conn_highest_peer(tconn) == R_PRIMARY)
1776 return ERR_NEED_ALLOW_TWO_PRI;
Philipp Reisnerb032b6f2011-04-13 18:16:10 -07001777
Philipp Reisnercd643972011-04-13 18:00:59 -07001778 if (new_conf->two_primaries &&
1779 (new_conf->wire_protocol != DRBD_PROT_C))
1780 return ERR_NOT_PROTO_C;
1781
Philipp Reisnercd643972011-04-13 18:00:59 -07001782 idr_for_each_entry(&tconn->volumes, mdev, i) {
1783 if (get_ldev(mdev)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001784 enum drbd_fencing_p fp = rcu_dereference(mdev->ldev->disk_conf)->fencing;
Philipp Reisnercd643972011-04-13 18:00:59 -07001785 put_ldev(mdev);
Philipp Reisner44ed1672011-04-19 17:10:19 +02001786 if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH)
Philipp Reisnercd643972011-04-13 18:00:59 -07001787 return ERR_STONITH_AND_PROT_A;
Philipp Reisnercd643972011-04-13 18:00:59 -07001788 }
Andreas Gruenbacher6139f602011-05-06 20:00:02 +02001789 if (mdev->state.role == R_PRIMARY && new_conf->discard_my_data)
Philipp Reisnercd643972011-04-13 18:00:59 -07001790 return ERR_DISCARD;
Philipp Reisnercd643972011-04-13 18:00:59 -07001791 }
Philipp Reisnercd643972011-04-13 18:00:59 -07001792
1793 if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A)
1794 return ERR_CONG_NOT_PROTO_A;
1795
1796 return NO_ERROR;
1797}
1798
Philipp Reisner44ed1672011-04-19 17:10:19 +02001799static enum drbd_ret_code
1800check_net_options(struct drbd_tconn *tconn, struct net_conf *new_conf)
1801{
1802 static enum drbd_ret_code rv;
1803 struct drbd_conf *mdev;
1804 int i;
1805
1806 rcu_read_lock();
1807 rv = _check_net_options(tconn, rcu_dereference(tconn->net_conf), new_conf);
1808 rcu_read_unlock();
1809
1810 /* tconn->volumes protected by genl_lock() here */
1811 idr_for_each_entry(&tconn->volumes, mdev, i) {
1812 if (!mdev->bitmap) {
1813 if(drbd_bm_init(mdev))
1814 return ERR_NOMEM;
1815 }
1816 }
1817
1818 return rv;
1819}
1820
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001821struct crypto {
1822 struct crypto_hash *verify_tfm;
1823 struct crypto_hash *csums_tfm;
1824 struct crypto_hash *cram_hmac_tfm;
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001825 struct crypto_hash *integrity_tfm;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001826 void *int_dig_in;
1827 void *int_dig_vv;
1828};
1829
1830static int
Andreas Gruenbacher4b6ad6d2011-04-29 10:20:08 +02001831alloc_hash(struct crypto_hash **tfm, char *tfm_name, int err_alg)
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001832{
1833 if (!tfm_name[0])
1834 return NO_ERROR;
1835
1836 *tfm = crypto_alloc_hash(tfm_name, 0, CRYPTO_ALG_ASYNC);
1837 if (IS_ERR(*tfm)) {
1838 *tfm = NULL;
1839 return err_alg;
1840 }
1841
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001842 return NO_ERROR;
1843}
1844
1845static enum drbd_ret_code
1846alloc_crypto(struct crypto *crypto, struct net_conf *new_conf)
1847{
1848 char hmac_name[CRYPTO_MAX_ALG_NAME];
1849 enum drbd_ret_code rv;
1850 int hash_size;
1851
Andreas Gruenbacher4b6ad6d2011-04-29 10:20:08 +02001852 rv = alloc_hash(&crypto->csums_tfm, new_conf->csums_alg,
1853 ERR_CSUMS_ALG);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001854 if (rv != NO_ERROR)
1855 return rv;
Andreas Gruenbacher4b6ad6d2011-04-29 10:20:08 +02001856 rv = alloc_hash(&crypto->verify_tfm, new_conf->verify_alg,
1857 ERR_VERIFY_ALG);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001858 if (rv != NO_ERROR)
1859 return rv;
Andreas Gruenbacher4b6ad6d2011-04-29 10:20:08 +02001860 rv = alloc_hash(&crypto->integrity_tfm, new_conf->integrity_alg,
1861 ERR_INTEGRITY_ALG);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001862 if (rv != NO_ERROR)
1863 return rv;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001864 if (new_conf->cram_hmac_alg[0] != 0) {
1865 snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
1866 new_conf->cram_hmac_alg);
1867
Andreas Gruenbacher4b6ad6d2011-04-29 10:20:08 +02001868 rv = alloc_hash(&crypto->cram_hmac_tfm, hmac_name,
1869 ERR_AUTH_ALG);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001870 }
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001871 if (crypto->integrity_tfm) {
1872 hash_size = crypto_hash_digestsize(crypto->integrity_tfm);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001873 crypto->int_dig_in = kmalloc(hash_size, GFP_KERNEL);
1874 if (!crypto->int_dig_in)
1875 return ERR_NOMEM;
1876 crypto->int_dig_vv = kmalloc(hash_size, GFP_KERNEL);
1877 if (!crypto->int_dig_vv)
1878 return ERR_NOMEM;
1879 }
1880
1881 return rv;
1882}
1883
1884static void free_crypto(struct crypto *crypto)
1885{
1886 kfree(crypto->int_dig_in);
1887 kfree(crypto->int_dig_vv);
1888 crypto_free_hash(crypto->cram_hmac_tfm);
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001889 crypto_free_hash(crypto->integrity_tfm);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001890 crypto_free_hash(crypto->csums_tfm);
1891 crypto_free_hash(crypto->verify_tfm);
1892}
1893
Lars Ellenbergf3990022011-03-23 14:31:09 +01001894int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info)
1895{
1896 enum drbd_ret_code retcode;
1897 struct drbd_tconn *tconn;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001898 struct net_conf *old_conf, *new_conf = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001899 int err;
1900 int ovr; /* online verify running */
1901 int rsr; /* re-sync running */
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001902 struct crypto crypto = { };
Lars Ellenbergf3990022011-03-23 14:31:09 +01001903
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02001904 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001905 if (!adm_ctx.reply_skb)
1906 return retcode;
1907 if (retcode != NO_ERROR)
1908 goto out;
1909
1910 tconn = adm_ctx.tconn;
1911
1912 new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
1913 if (!new_conf) {
1914 retcode = ERR_NOMEM;
1915 goto out;
1916 }
1917
Lars Ellenbergf3990022011-03-23 14:31:09 +01001918 conn_reconfig_start(tconn);
1919
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001920 mutex_lock(&tconn->data.mutex);
Philipp Reisnera0095502011-05-03 13:14:15 +02001921 mutex_lock(&tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001922 old_conf = tconn->net_conf;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001923
1924 if (!old_conf) {
1925 drbd_msg_put_info("net conf missing, try connect");
1926 retcode = ERR_INVALID_REQUEST;
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001927 goto fail;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001928 }
1929
1930 *new_conf = *old_conf;
Lars Ellenberg5979e362011-04-27 21:09:55 +02001931 if (should_set_defaults(info))
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02001932 set_net_conf_defaults(new_conf);
Philipp Reisner44ed1672011-04-19 17:10:19 +02001933
Lars Ellenbergf3990022011-03-23 14:31:09 +01001934 err = net_conf_from_attrs_for_change(new_conf, info);
Andreas Gruenbacherc75b9b12011-05-24 14:18:31 +02001935 if (err && err != -ENOMSG) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001936 retcode = ERR_MANDATORY_TAG;
1937 drbd_msg_put_info(from_attrs_err_to_txt(err));
1938 goto fail;
1939 }
1940
Philipp Reisnercd643972011-04-13 18:00:59 -07001941 retcode = check_net_options(tconn, new_conf);
1942 if (retcode != NO_ERROR)
1943 goto fail;
1944
Lars Ellenbergf3990022011-03-23 14:31:09 +01001945 /* re-sync running */
1946 rsr = conn_resync_running(tconn);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001947 if (rsr && strcmp(new_conf->csums_alg, old_conf->csums_alg)) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001948 retcode = ERR_CSUMS_RESYNC_RUNNING;
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001949 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001950 }
1951
Lars Ellenbergf3990022011-03-23 14:31:09 +01001952 /* online verify running */
1953 ovr = conn_ov_running(tconn);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001954 if (ovr && strcmp(new_conf->verify_alg, old_conf->verify_alg)) {
1955 retcode = ERR_VERIFY_RUNNING;
1956 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001957 }
1958
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001959 retcode = alloc_crypto(&crypto, new_conf);
1960 if (retcode != NO_ERROR)
1961 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001962
Philipp Reisner44ed1672011-04-19 17:10:19 +02001963 rcu_assign_pointer(tconn->net_conf, new_conf);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001964
1965 if (!rsr) {
1966 crypto_free_hash(tconn->csums_tfm);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001967 tconn->csums_tfm = crypto.csums_tfm;
1968 crypto.csums_tfm = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001969 }
1970 if (!ovr) {
1971 crypto_free_hash(tconn->verify_tfm);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001972 tconn->verify_tfm = crypto.verify_tfm;
1973 crypto.verify_tfm = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001974 }
1975
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001976 kfree(tconn->int_dig_in);
1977 tconn->int_dig_in = crypto.int_dig_in;
1978 kfree(tconn->int_dig_vv);
1979 tconn->int_dig_vv = crypto.int_dig_vv;
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001980 crypto_free_hash(tconn->integrity_tfm);
1981 tconn->integrity_tfm = crypto.integrity_tfm;
Philipp Reisnerd659f2a2011-05-16 17:38:45 +02001982 if (tconn->cstate >= C_WF_REPORT_PARAMS && tconn->agreed_pro_version >= 100)
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001983 /* Do this without trying to take tconn->data.mutex again. */
Philipp Reisnerd659f2a2011-05-16 17:38:45 +02001984 __drbd_send_protocol(tconn, P_PROTOCOL_UPDATE);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001985
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001986 crypto_free_hash(tconn->cram_hmac_tfm);
1987 tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
1988
Philipp Reisnera0095502011-05-03 13:14:15 +02001989 mutex_unlock(&tconn->conf_update);
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001990 mutex_unlock(&tconn->data.mutex);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001991 synchronize_rcu();
1992 kfree(old_conf);
1993
Lars Ellenbergf3990022011-03-23 14:31:09 +01001994 if (tconn->cstate >= C_WF_REPORT_PARAMS)
1995 drbd_send_sync_param(minor_to_mdev(conn_lowest_minor(tconn)));
1996
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001997 goto done;
1998
Lars Ellenbergf3990022011-03-23 14:31:09 +01001999 fail:
Philipp Reisnera0095502011-05-03 13:14:15 +02002000 mutex_unlock(&tconn->conf_update);
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02002001 mutex_unlock(&tconn->data.mutex);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002002 free_crypto(&crypto);
Lars Ellenbergf3990022011-03-23 14:31:09 +01002003 kfree(new_conf);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002004 done:
Lars Ellenbergf3990022011-03-23 14:31:09 +01002005 conn_reconfig_done(tconn);
2006 out:
2007 drbd_adm_finish(info, retcode);
2008 return 0;
2009}
2010
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002011int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002012{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002013 struct drbd_conf *mdev;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002014 struct net_conf *old_conf, *new_conf = NULL;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002015 struct crypto crypto = { };
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002016 struct drbd_tconn *tconn;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002017 enum drbd_ret_code retcode;
2018 int i;
2019 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002020
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02002021 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002022
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002023 if (!adm_ctx.reply_skb)
2024 return retcode;
2025 if (retcode != NO_ERROR)
2026 goto out;
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002027 if (!(adm_ctx.my_addr && adm_ctx.peer_addr)) {
2028 drbd_msg_put_info("connection endpoint(s) missing");
2029 retcode = ERR_INVALID_REQUEST;
2030 goto out;
2031 }
2032
2033 /* No need for _rcu here. All reconfiguration is
2034 * strictly serialized on genl_lock(). We are protected against
2035 * concurrent reconfiguration/addition/deletion */
2036 list_for_each_entry(tconn, &drbd_tconns, all_tconn) {
2037 if (nla_len(adm_ctx.my_addr) == tconn->my_addr_len &&
2038 !memcmp(nla_data(adm_ctx.my_addr), &tconn->my_addr, tconn->my_addr_len)) {
2039 retcode = ERR_LOCAL_ADDR;
2040 goto out;
2041 }
2042
2043 if (nla_len(adm_ctx.peer_addr) == tconn->peer_addr_len &&
2044 !memcmp(nla_data(adm_ctx.peer_addr), &tconn->peer_addr, tconn->peer_addr_len)) {
2045 retcode = ERR_PEER_ADDR;
2046 goto out;
2047 }
2048 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002049
2050 tconn = adm_ctx.tconn;
Philipp Reisner80883192011-02-18 14:56:45 +01002051 conn_reconfig_start(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002052
Philipp Reisner80883192011-02-18 14:56:45 +01002053 if (tconn->cstate > C_STANDALONE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002054 retcode = ERR_NET_CONFIGURED;
2055 goto fail;
2056 }
2057
2058 /* allocation not in the IO path, cqueue thread context */
Lars Ellenberg5979e362011-04-27 21:09:55 +02002059 new_conf = kzalloc(sizeof(*new_conf), GFP_KERNEL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002060 if (!new_conf) {
2061 retcode = ERR_NOMEM;
2062 goto fail;
2063 }
2064
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02002065 set_net_conf_defaults(new_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002066
Lars Ellenbergf3990022011-03-23 14:31:09 +01002067 err = net_conf_from_attrs(new_conf, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002068 if (err) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002069 retcode = ERR_MANDATORY_TAG;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002070 drbd_msg_put_info(from_attrs_err_to_txt(err));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002071 goto fail;
2072 }
2073
Philipp Reisnercd643972011-04-13 18:00:59 -07002074 retcode = check_net_options(tconn, new_conf);
2075 if (retcode != NO_ERROR)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002076 goto fail;
Philipp Reisner422028b2010-10-27 11:12:07 +02002077
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002078 retcode = alloc_crypto(&crypto, new_conf);
2079 if (retcode != NO_ERROR)
2080 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002081
Philipp Reisnerb411b362009-09-25 16:07:19 -07002082 ((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;
2083
Philipp Reisner80883192011-02-18 14:56:45 +01002084 conn_flush_workqueue(tconn);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002085
Philipp Reisnera0095502011-05-03 13:14:15 +02002086 mutex_lock(&tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002087 old_conf = tconn->net_conf;
2088 if (old_conf) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002089 retcode = ERR_NET_CONFIGURED;
Philipp Reisnera0095502011-05-03 13:14:15 +02002090 mutex_unlock(&tconn->conf_update);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002091 goto fail;
2092 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02002093 rcu_assign_pointer(tconn->net_conf, new_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002094
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002095 conn_free_crypto(tconn);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002096 tconn->int_dig_in = crypto.int_dig_in;
2097 tconn->int_dig_vv = crypto.int_dig_vv;
2098 tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02002099 tconn->integrity_tfm = crypto.integrity_tfm;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002100 tconn->csums_tfm = crypto.csums_tfm;
2101 tconn->verify_tfm = crypto.verify_tfm;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002102
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002103 tconn->my_addr_len = nla_len(adm_ctx.my_addr);
2104 memcpy(&tconn->my_addr, nla_data(adm_ctx.my_addr), tconn->my_addr_len);
2105 tconn->peer_addr_len = nla_len(adm_ctx.peer_addr);
2106 memcpy(&tconn->peer_addr, nla_data(adm_ctx.peer_addr), tconn->peer_addr_len);
2107
Philipp Reisnera0095502011-05-03 13:14:15 +02002108 mutex_unlock(&tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002109
Philipp Reisner695d08f2011-04-11 22:53:32 -07002110 rcu_read_lock();
Philipp Reisner80883192011-02-18 14:56:45 +01002111 idr_for_each_entry(&tconn->volumes, mdev, i) {
2112 mdev->send_cnt = 0;
2113 mdev->recv_cnt = 0;
Philipp Reisner80883192011-02-18 14:56:45 +01002114 }
Philipp Reisner695d08f2011-04-11 22:53:32 -07002115 rcu_read_unlock();
Lars Ellenberg5ee743e2011-04-26 16:22:25 +02002116
2117 retcode = conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
2118
Philipp Reisner80883192011-02-18 14:56:45 +01002119 conn_reconfig_done(tconn);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002120 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002121 return 0;
2122
2123fail:
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002124 free_crypto(&crypto);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002125 kfree(new_conf);
2126
Philipp Reisner80883192011-02-18 14:56:45 +01002127 conn_reconfig_done(tconn);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002128out:
2129 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002130 return 0;
2131}
2132
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002133static enum drbd_state_rv conn_try_disconnect(struct drbd_tconn *tconn, bool force)
2134{
2135 enum drbd_state_rv rv;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002136
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002137 rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
2138 force ? CS_HARD : 0);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002139
2140 switch (rv) {
2141 case SS_NOTHING_TO_DO:
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002142 break;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002143 case SS_ALREADY_STANDALONE:
2144 return SS_SUCCESS;
2145 case SS_PRIMARY_NOP:
2146 /* Our state checking code wants to see the peer outdated. */
2147 rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002148 pdsk, D_OUTDATED), CS_VERBOSE);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002149 break;
2150 case SS_CW_FAILED_BY_PEER:
2151 /* The peer probably wants to see us outdated. */
2152 rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
2153 disk, D_OUTDATED), 0);
2154 if (rv == SS_IS_DISKLESS || rv == SS_LOWER_THAN_OUTDATED) {
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002155 rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
2156 CS_HARD);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002157 }
2158 break;
2159 default:;
2160 /* no special handling necessary */
2161 }
2162
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002163 if (rv >= SS_SUCCESS) {
2164 enum drbd_state_rv rv2;
2165 /* No one else can reconfigure the network while I am here.
2166 * The state handling only uses drbd_thread_stop_nowait(),
2167 * we want to really wait here until the receiver is no more.
2168 */
2169 drbd_thread_stop(&adm_ctx.tconn->receiver);
2170
2171 /* Race breaker. This additional state change request may be
2172 * necessary, if this was a forced disconnect during a receiver
2173 * restart. We may have "killed" the receiver thread just
2174 * after drbdd_init() returned. Typically, we should be
2175 * C_STANDALONE already, now, and this becomes a no-op.
2176 */
2177 rv2 = conn_request_state(tconn, NS(conn, C_STANDALONE),
2178 CS_VERBOSE | CS_HARD);
2179 if (rv2 < SS_SUCCESS)
2180 conn_err(tconn,
2181 "unexpected rv2=%d in conn_try_disconnect()\n",
2182 rv2);
2183 }
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002184 return rv;
2185}
2186
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002187int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002188{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002189 struct disconnect_parms parms;
2190 struct drbd_tconn *tconn;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002191 enum drbd_state_rv rv;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002192 enum drbd_ret_code retcode;
2193 int err;
Philipp Reisner2561b9c2010-12-03 15:22:48 +01002194
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002195 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002196 if (!adm_ctx.reply_skb)
2197 return retcode;
2198 if (retcode != NO_ERROR)
Philipp Reisner2561b9c2010-12-03 15:22:48 +01002199 goto fail;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002200
2201 tconn = adm_ctx.tconn;
2202 memset(&parms, 0, sizeof(parms));
2203 if (info->attrs[DRBD_NLA_DISCONNECT_PARMS]) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01002204 err = disconnect_parms_from_attrs(&parms, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002205 if (err) {
2206 retcode = ERR_MANDATORY_TAG;
2207 drbd_msg_put_info(from_attrs_err_to_txt(err));
2208 goto fail;
2209 }
Philipp Reisner2561b9c2010-12-03 15:22:48 +01002210 }
2211
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002212 rv = conn_try_disconnect(tconn, parms.force_disconnect);
2213 if (rv < SS_SUCCESS)
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002214 retcode = rv; /* FIXME: Type mismatch. */
2215 else
2216 retcode = NO_ERROR;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002217 fail:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002218 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002219 return 0;
2220}
2221
2222void resync_after_online_grow(struct drbd_conf *mdev)
2223{
2224 int iass; /* I am sync source */
2225
2226 dev_info(DEV, "Resync of new storage after online grow\n");
2227 if (mdev->state.role != mdev->state.peer)
2228 iass = (mdev->state.role == R_PRIMARY);
2229 else
Philipp Reisner25703f82011-02-07 14:35:25 +01002230 iass = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002231
2232 if (iass)
2233 drbd_start_resync(mdev, C_SYNC_SOURCE);
2234 else
2235 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE);
2236}
2237
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002238int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002239{
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002240 struct disk_conf *old_disk_conf, *new_disk_conf = NULL;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002241 struct resize_parms rs;
2242 struct drbd_conf *mdev;
2243 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002244 enum determine_dev_size dd;
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002245 enum dds_flags ddsf;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002246 sector_t u_size;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002247 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002248
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002249 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2250 if (!adm_ctx.reply_skb)
2251 return retcode;
2252 if (retcode != NO_ERROR)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002253 goto fail;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002254
2255 memset(&rs, 0, sizeof(struct resize_parms));
2256 if (info->attrs[DRBD_NLA_RESIZE_PARMS]) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01002257 err = resize_parms_from_attrs(&rs, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002258 if (err) {
2259 retcode = ERR_MANDATORY_TAG;
2260 drbd_msg_put_info(from_attrs_err_to_txt(err));
2261 goto fail;
2262 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002263 }
2264
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002265 mdev = adm_ctx.mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002266 if (mdev->state.conn > C_CONNECTED) {
2267 retcode = ERR_RESIZE_RESYNC;
2268 goto fail;
2269 }
2270
2271 if (mdev->state.role == R_SECONDARY &&
2272 mdev->state.peer == R_SECONDARY) {
2273 retcode = ERR_NO_PRIMARY;
2274 goto fail;
2275 }
2276
2277 if (!get_ldev(mdev)) {
2278 retcode = ERR_NO_DISK;
2279 goto fail;
2280 }
2281
Philipp Reisner31890f42011-01-19 14:12:51 +01002282 if (rs.no_resync && mdev->tconn->agreed_pro_version < 93) {
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002283 retcode = ERR_NEED_APV_93;
2284 goto fail;
2285 }
2286
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002287 rcu_read_lock();
2288 u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
2289 rcu_read_unlock();
2290 if (u_size != (sector_t)rs.resize_size) {
2291 new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
2292 if (!new_disk_conf) {
2293 retcode = ERR_NOMEM;
2294 goto fail;
2295 }
2296 }
2297
Philipp Reisner087c2492010-03-26 13:49:56 +01002298 if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002299 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002300
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002301 if (new_disk_conf) {
2302 mutex_lock(&mdev->tconn->conf_update);
2303 old_disk_conf = mdev->ldev->disk_conf;
2304 *new_disk_conf = *old_disk_conf;
2305 new_disk_conf->disk_size = (sector_t)rs.resize_size;
2306 rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
2307 mutex_unlock(&mdev->tconn->conf_update);
2308 synchronize_rcu();
2309 kfree(old_disk_conf);
2310 }
2311
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002312 ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0);
Bart Van Assche24c48302011-05-21 18:32:29 +02002313 dd = drbd_determine_dev_size(mdev, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002314 drbd_md_sync(mdev);
2315 put_ldev(mdev);
2316 if (dd == dev_size_error) {
2317 retcode = ERR_NOMEM_BITMAP;
2318 goto fail;
2319 }
2320
Philipp Reisner087c2492010-03-26 13:49:56 +01002321 if (mdev->state.conn == C_CONNECTED) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002322 if (dd == grew)
2323 set_bit(RESIZE_PENDING, &mdev->flags);
2324
2325 drbd_send_uuids(mdev);
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002326 drbd_send_sizes(mdev, 1, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002327 }
2328
2329 fail:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002330 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002331 return 0;
2332}
2333
Lars Ellenbergf3990022011-03-23 14:31:09 +01002334int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002335{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002336 enum drbd_ret_code retcode;
Lars Ellenbergf3990022011-03-23 14:31:09 +01002337 struct drbd_tconn *tconn;
Lars Ellenbergb57a1e22011-04-27 21:17:33 +02002338 struct res_opts res_opts;
Lars Ellenbergf3990022011-03-23 14:31:09 +01002339 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002340
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02002341 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002342 if (!adm_ctx.reply_skb)
2343 return retcode;
2344 if (retcode != NO_ERROR)
2345 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01002346 tconn = adm_ctx.tconn;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002347
Lars Ellenbergb57a1e22011-04-27 21:17:33 +02002348 res_opts = tconn->res_opts;
Lars Ellenberg5979e362011-04-27 21:09:55 +02002349 if (should_set_defaults(info))
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02002350 set_res_opts_defaults(&res_opts);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002351
Lars Ellenbergb57a1e22011-04-27 21:17:33 +02002352 err = res_opts_from_attrs(&res_opts, info);
Andreas Gruenbacherc75b9b12011-05-24 14:18:31 +02002353 if (err && err != -ENOMSG) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002354 retcode = ERR_MANDATORY_TAG;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002355 drbd_msg_put_info(from_attrs_err_to_txt(err));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002356 goto fail;
2357 }
2358
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002359 err = set_resource_options(tconn, &res_opts);
2360 if (err) {
2361 retcode = ERR_INVALID_REQUEST;
2362 if (err == -ENOMEM)
2363 retcode = ERR_NOMEM;
Philipp Reisner778f2712010-07-06 11:14:00 +02002364 }
2365
Philipp Reisnerb411b362009-09-25 16:07:19 -07002366fail:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002367 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002368 return 0;
2369}
2370
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002371int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002372{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002373 struct drbd_conf *mdev;
2374 int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
2375
2376 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2377 if (!adm_ctx.reply_skb)
2378 return retcode;
2379 if (retcode != NO_ERROR)
2380 goto out;
2381
2382 mdev = adm_ctx.mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002383
Lars Ellenberg194bfb32011-01-18 10:38:01 +01002384 /* If there is still bitmap IO pending, probably because of a previous
2385 * resync just being finished, wait for it before requesting a new resync. */
2386 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
2387
Philipp Reisnerb411b362009-09-25 16:07:19 -07002388 retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED);
2389
2390 if (retcode < SS_SUCCESS && retcode != SS_NEED_CONNECTION)
2391 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
2392
2393 while (retcode == SS_NEED_CONNECTION) {
Philipp Reisner87eeee42011-01-19 14:16:30 +01002394 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002395 if (mdev->state.conn < C_CONNECTED)
2396 retcode = _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002397 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002398
2399 if (retcode != SS_NEED_CONNECTION)
2400 break;
2401
2402 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
2403 }
2404
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002405out:
2406 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002407 return 0;
2408}
2409
Philipp Reisner07782862010-08-31 12:00:50 +02002410static int drbd_bmio_set_susp_al(struct drbd_conf *mdev)
2411{
2412 int rv;
2413
2414 rv = drbd_bmio_set_n_write(mdev);
2415 drbd_suspend_al(mdev);
2416 return rv;
2417}
2418
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002419static int drbd_adm_simple_request_state(struct sk_buff *skb, struct genl_info *info,
2420 union drbd_state mask, union drbd_state val)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002421{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002422 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002423
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002424 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2425 if (!adm_ctx.reply_skb)
2426 return retcode;
2427 if (retcode != NO_ERROR)
2428 goto out;
Lars Ellenberg194bfb32011-01-18 10:38:01 +01002429
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002430 retcode = drbd_request_state(adm_ctx.mdev, mask, val);
2431out:
2432 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002433 return 0;
2434}
2435
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002436int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002437{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002438 return drbd_adm_simple_request_state(skb, info, NS(conn, C_STARTING_SYNC_S));
2439}
Philipp Reisnerb411b362009-09-25 16:07:19 -07002440
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002441int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info)
2442{
2443 enum drbd_ret_code retcode;
2444
2445 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2446 if (!adm_ctx.reply_skb)
2447 return retcode;
2448 if (retcode != NO_ERROR)
2449 goto out;
2450
2451 if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002452 retcode = ERR_PAUSE_IS_SET;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002453out:
2454 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002455 return 0;
2456}
2457
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002458int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002459{
Philipp Reisnerda9fbc22011-03-29 10:52:01 +02002460 union drbd_dev_state s;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002461 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002462
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002463 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2464 if (!adm_ctx.reply_skb)
2465 return retcode;
2466 if (retcode != NO_ERROR)
2467 goto out;
2468
2469 if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
2470 s = adm_ctx.mdev->state;
Philipp Reisnercd88d032011-01-20 11:46:41 +01002471 if (s.conn == C_PAUSED_SYNC_S || s.conn == C_PAUSED_SYNC_T) {
2472 retcode = s.aftr_isp ? ERR_PIC_AFTER_DEP :
2473 s.peer_isp ? ERR_PIC_PEER_DEP : ERR_PAUSE_IS_CLEAR;
2474 } else {
2475 retcode = ERR_PAUSE_IS_CLEAR;
2476 }
2477 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002478
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002479out:
2480 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002481 return 0;
2482}
2483
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002484int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002485{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002486 return drbd_adm_simple_request_state(skb, info, NS(susp, 1));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002487}
2488
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002489int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002490{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002491 struct drbd_conf *mdev;
2492 int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
2493
2494 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2495 if (!adm_ctx.reply_skb)
2496 return retcode;
2497 if (retcode != NO_ERROR)
2498 goto out;
2499
2500 mdev = adm_ctx.mdev;
Philipp Reisner43a51822010-06-11 11:26:34 +02002501 if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
2502 drbd_uuid_new_current(mdev);
2503 clear_bit(NEW_CUR_UUID, &mdev->flags);
Philipp Reisner43a51822010-06-11 11:26:34 +02002504 }
Philipp Reisner265be2d2010-05-31 10:14:17 +02002505 drbd_suspend_io(mdev);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002506 retcode = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
2507 if (retcode == SS_SUCCESS) {
Philipp Reisner265be2d2010-05-31 10:14:17 +02002508 if (mdev->state.conn < C_CONNECTED)
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01002509 tl_clear(mdev->tconn);
Philipp Reisner265be2d2010-05-31 10:14:17 +02002510 if (mdev->state.disk == D_DISKLESS || mdev->state.disk == D_FAILED)
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01002511 tl_restart(mdev->tconn, FAIL_FROZEN_DISK_IO);
Philipp Reisner265be2d2010-05-31 10:14:17 +02002512 }
2513 drbd_resume_io(mdev);
2514
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002515out:
2516 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002517 return 0;
2518}
2519
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002520int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002521{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002522 return drbd_adm_simple_request_state(skb, info, NS(disk, D_OUTDATED));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002523}
2524
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002525int nla_put_drbd_cfg_context(struct sk_buff *skb, struct drbd_tconn *tconn, unsigned vnr)
Lars Ellenberg543cc102011-03-10 22:18:18 +01002526{
2527 struct nlattr *nla;
2528 nla = nla_nest_start(skb, DRBD_NLA_CFG_CONTEXT);
2529 if (!nla)
2530 goto nla_put_failure;
2531 if (vnr != VOLUME_UNSPECIFIED)
2532 NLA_PUT_U32(skb, T_ctx_volume, vnr);
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002533 NLA_PUT_STRING(skb, T_ctx_resource_name, tconn->name);
2534 if (tconn->my_addr_len)
2535 NLA_PUT(skb, T_ctx_my_addr, tconn->my_addr_len, &tconn->my_addr);
2536 if (tconn->peer_addr_len)
2537 NLA_PUT(skb, T_ctx_peer_addr, tconn->peer_addr_len, &tconn->peer_addr);
Lars Ellenberg543cc102011-03-10 22:18:18 +01002538 nla_nest_end(skb, nla);
2539 return 0;
2540
2541nla_put_failure:
2542 if (nla)
2543 nla_nest_cancel(skb, nla);
2544 return -EMSGSIZE;
2545}
2546
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002547int nla_put_status_info(struct sk_buff *skb, struct drbd_conf *mdev,
2548 const struct sib_info *sib)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002549{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002550 struct state_info *si = NULL; /* for sizeof(si->member); */
Philipp Reisner44ed1672011-04-19 17:10:19 +02002551 struct net_conf *nc;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002552 struct nlattr *nla;
2553 int got_ldev;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002554 int err = 0;
2555 int exclude_sensitive;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002556
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002557 /* If sib != NULL, this is drbd_bcast_event, which anyone can listen
2558 * to. So we better exclude_sensitive information.
2559 *
2560 * If sib == NULL, this is drbd_adm_get_status, executed synchronously
2561 * in the context of the requesting user process. Exclude sensitive
2562 * information, unless current has superuser.
2563 *
2564 * NOTE: for drbd_adm_get_status_all(), this is a netlink dump, and
2565 * relies on the current implementation of netlink_dump(), which
2566 * executes the dump callback successively from netlink_recvmsg(),
2567 * always in the context of the receiving process */
2568 exclude_sensitive = sib || !capable(CAP_SYS_ADMIN);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002569
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002570 got_ldev = get_ldev(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002571
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002572 /* We need to add connection name and volume number information still.
2573 * Minor number is in drbd_genlmsghdr. */
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002574 if (nla_put_drbd_cfg_context(skb, mdev->tconn, mdev->vnr))
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002575 goto nla_put_failure;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002576
Lars Ellenbergf3990022011-03-23 14:31:09 +01002577 if (res_opts_to_skb(skb, &mdev->tconn->res_opts, exclude_sensitive))
2578 goto nla_put_failure;
2579
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002580 rcu_read_lock();
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002581 if (got_ldev)
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002582 if (disk_conf_to_skb(skb, rcu_dereference(mdev->ldev->disk_conf), exclude_sensitive))
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002583 goto nla_put_failure;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002584
Philipp Reisner44ed1672011-04-19 17:10:19 +02002585 nc = rcu_dereference(mdev->tconn->net_conf);
2586 if (nc)
2587 err = net_conf_to_skb(skb, nc, exclude_sensitive);
2588 rcu_read_unlock();
2589 if (err)
2590 goto nla_put_failure;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002591
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002592 nla = nla_nest_start(skb, DRBD_NLA_STATE_INFO);
2593 if (!nla)
2594 goto nla_put_failure;
2595 NLA_PUT_U32(skb, T_sib_reason, sib ? sib->sib_reason : SIB_GET_STATUS_REPLY);
2596 NLA_PUT_U32(skb, T_current_state, mdev->state.i);
2597 NLA_PUT_U64(skb, T_ed_uuid, mdev->ed_uuid);
2598 NLA_PUT_U64(skb, T_capacity, drbd_get_capacity(mdev->this_bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002599
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002600 if (got_ldev) {
2601 NLA_PUT_U32(skb, T_disk_flags, mdev->ldev->md.flags);
2602 NLA_PUT(skb, T_uuids, sizeof(si->uuids), mdev->ldev->md.uuid);
2603 NLA_PUT_U64(skb, T_bits_total, drbd_bm_bits(mdev));
2604 NLA_PUT_U64(skb, T_bits_oos, drbd_bm_total_weight(mdev));
2605 if (C_SYNC_SOURCE <= mdev->state.conn &&
2606 C_PAUSED_SYNC_T >= mdev->state.conn) {
2607 NLA_PUT_U64(skb, T_bits_rs_total, mdev->rs_total);
2608 NLA_PUT_U64(skb, T_bits_rs_failed, mdev->rs_failed);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002609 }
2610 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002611
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002612 if (sib) {
2613 switch(sib->sib_reason) {
2614 case SIB_SYNC_PROGRESS:
2615 case SIB_GET_STATUS_REPLY:
2616 break;
2617 case SIB_STATE_CHANGE:
2618 NLA_PUT_U32(skb, T_prev_state, sib->os.i);
2619 NLA_PUT_U32(skb, T_new_state, sib->ns.i);
2620 break;
2621 case SIB_HELPER_POST:
2622 NLA_PUT_U32(skb,
2623 T_helper_exit_code, sib->helper_exit_code);
2624 /* fall through */
2625 case SIB_HELPER_PRE:
2626 NLA_PUT_STRING(skb, T_helper, sib->helper_name);
2627 break;
2628 }
2629 }
2630 nla_nest_end(skb, nla);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002631
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002632 if (0)
2633nla_put_failure:
2634 err = -EMSGSIZE;
2635 if (got_ldev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002636 put_ldev(mdev);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002637 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002638}
2639
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002640int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002641{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002642 enum drbd_ret_code retcode;
2643 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002644
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002645 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2646 if (!adm_ctx.reply_skb)
2647 return retcode;
2648 if (retcode != NO_ERROR)
2649 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002650
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002651 err = nla_put_status_info(adm_ctx.reply_skb, adm_ctx.mdev, NULL);
2652 if (err) {
2653 nlmsg_free(adm_ctx.reply_skb);
2654 return err;
2655 }
2656out:
2657 drbd_adm_finish(info, retcode);
2658 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002659}
2660
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002661int get_one_status(struct sk_buff *skb, struct netlink_callback *cb)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002662{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002663 struct drbd_conf *mdev;
2664 struct drbd_genlmsghdr *dh;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002665 struct drbd_tconn *pos = (struct drbd_tconn*)cb->args[0];
2666 struct drbd_tconn *tconn = NULL;
2667 struct drbd_tconn *tmp;
2668 unsigned volume = cb->args[1];
Philipp Reisnerb411b362009-09-25 16:07:19 -07002669
Lars Ellenberg543cc102011-03-10 22:18:18 +01002670 /* Open coded, deferred, iteration:
2671 * list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
2672 * idr_for_each_entry(&tconn->volumes, mdev, i) {
2673 * ...
2674 * }
2675 * }
2676 * where tconn is cb->args[0];
2677 * and i is cb->args[1];
2678 *
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002679 * cb->args[2] indicates if we shall loop over all resources,
2680 * or just dump all volumes of a single resource.
2681 *
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002682 * This may miss entries inserted after this dump started,
2683 * or entries deleted before they are reached.
Lars Ellenberg543cc102011-03-10 22:18:18 +01002684 *
2685 * We need to make sure the mdev won't disappear while
2686 * we are looking at it, and revalidate our iterators
2687 * on each iteration.
2688 */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002689
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002690 /* synchronize with conn_create()/conn_destroy() */
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002691 rcu_read_lock();
Lars Ellenberg543cc102011-03-10 22:18:18 +01002692 /* revalidate iterator position */
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02002693 list_for_each_entry_rcu(tmp, &drbd_tconns, all_tconn) {
Lars Ellenberg543cc102011-03-10 22:18:18 +01002694 if (pos == NULL) {
2695 /* first iteration */
2696 pos = tmp;
2697 tconn = pos;
2698 break;
2699 }
2700 if (tmp == pos) {
2701 tconn = pos;
2702 break;
2703 }
2704 }
2705 if (tconn) {
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002706next_tconn:
Lars Ellenberg543cc102011-03-10 22:18:18 +01002707 mdev = idr_get_next(&tconn->volumes, &volume);
2708 if (!mdev) {
2709 /* No more volumes to dump on this tconn.
2710 * Advance tconn iterator. */
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02002711 pos = list_entry_rcu(tconn->all_tconn.next,
2712 struct drbd_tconn, all_tconn);
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002713 /* Did we dump any volume on this tconn yet? */
Lars Ellenberg543cc102011-03-10 22:18:18 +01002714 if (volume != 0) {
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002715 /* If we reached the end of the list,
2716 * or only a single resource dump was requested,
2717 * we are done. */
2718 if (&pos->all_tconn == &drbd_tconns || cb->args[2])
2719 goto out;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002720 volume = 0;
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002721 tconn = pos;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002722 goto next_tconn;
2723 }
2724 }
2725
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002726 dh = genlmsg_put(skb, NETLINK_CB(cb->skb).pid,
2727 cb->nlh->nlmsg_seq, &drbd_genl_family,
2728 NLM_F_MULTI, DRBD_ADM_GET_STATUS);
2729 if (!dh)
Lars Ellenberg543cc102011-03-10 22:18:18 +01002730 goto out;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002731
Lars Ellenberg543cc102011-03-10 22:18:18 +01002732 if (!mdev) {
2733 /* this is a tconn without a single volume */
2734 dh->minor = -1U;
2735 dh->ret_code = NO_ERROR;
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002736 if (nla_put_drbd_cfg_context(skb, tconn, VOLUME_UNSPECIFIED))
Lars Ellenberg543cc102011-03-10 22:18:18 +01002737 genlmsg_cancel(skb, dh);
2738 else
2739 genlmsg_end(skb, dh);
2740 goto out;
2741 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002742
Lars Ellenberg543cc102011-03-10 22:18:18 +01002743 D_ASSERT(mdev->vnr == volume);
2744 D_ASSERT(mdev->tconn == tconn);
2745
2746 dh->minor = mdev_to_minor(mdev);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002747 dh->ret_code = NO_ERROR;
2748
2749 if (nla_put_status_info(skb, mdev, NULL)) {
2750 genlmsg_cancel(skb, dh);
Lars Ellenberg543cc102011-03-10 22:18:18 +01002751 goto out;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002752 }
2753 genlmsg_end(skb, dh);
2754 }
2755
Lars Ellenberg543cc102011-03-10 22:18:18 +01002756out:
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002757 rcu_read_unlock();
Lars Ellenberg543cc102011-03-10 22:18:18 +01002758 /* where to start the next iteration */
2759 cb->args[0] = (long)pos;
2760 cb->args[1] = (pos == tconn) ? volume + 1 : 0;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002761
Lars Ellenberg543cc102011-03-10 22:18:18 +01002762 /* No more tconns/volumes/minors found results in an empty skb.
2763 * Which will terminate the dump. */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002764 return skb->len;
2765}
2766
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002767/*
2768 * Request status of all resources, or of all volumes within a single resource.
2769 *
2770 * This is a dump, as the answer may not fit in a single reply skb otherwise.
2771 * Which means we cannot use the family->attrbuf or other such members, because
2772 * dump is NOT protected by the genl_lock(). During dump, we only have access
2773 * to the incoming skb, and need to opencode "parsing" of the nlattr payload.
2774 *
2775 * Once things are setup properly, we call into get_one_status().
2776 */
2777int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb)
2778{
2779 const unsigned hdrlen = GENL_HDRLEN + GENL_MAGIC_FAMILY_HDRSZ;
2780 struct nlattr *nla;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002781 const char *resource_name;
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002782 struct drbd_tconn *tconn;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002783 int maxtype;
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002784
2785 /* Is this a followup call? */
2786 if (cb->args[0]) {
2787 /* ... of a single resource dump,
2788 * and the resource iterator has been advanced already? */
2789 if (cb->args[2] && cb->args[2] != cb->args[0])
2790 return 0; /* DONE. */
2791 goto dump;
2792 }
2793
2794 /* First call (from netlink_dump_start). We need to figure out
2795 * which resource(s) the user wants us to dump. */
2796 nla = nla_find(nlmsg_attrdata(cb->nlh, hdrlen),
2797 nlmsg_attrlen(cb->nlh, hdrlen),
2798 DRBD_NLA_CFG_CONTEXT);
2799
2800 /* No explicit context given. Dump all. */
2801 if (!nla)
2802 goto dump;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002803 maxtype = ARRAY_SIZE(drbd_cfg_context_nl_policy) - 1;
2804 nla = drbd_nla_find_nested(maxtype, nla, __nla_type(T_ctx_resource_name));
2805 if (IS_ERR(nla))
2806 return PTR_ERR(nla);
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002807 /* context given, but no name present? */
2808 if (!nla)
2809 return -EINVAL;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002810 resource_name = nla_data(nla);
2811 tconn = conn_get_by_name(resource_name);
Philipp Reisner0ace9df2011-04-24 10:53:19 +02002812
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002813 if (!tconn)
2814 return -ENODEV;
2815
Philipp Reisner0ace9df2011-04-24 10:53:19 +02002816 kref_put(&tconn->kref, &conn_destroy); /* get_one_status() (re)validates tconn by itself */
2817
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002818 /* prime iterators, and set "filter" mode mark:
2819 * only dump this tconn. */
2820 cb->args[0] = (long)tconn;
2821 /* cb->args[1] = 0; passed in this way. */
2822 cb->args[2] = (long)tconn;
2823
2824dump:
2825 return get_one_status(skb, cb);
2826}
2827
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002828int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info)
2829{
2830 enum drbd_ret_code retcode;
2831 struct timeout_parms tp;
2832 int err;
2833
2834 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2835 if (!adm_ctx.reply_skb)
2836 return retcode;
2837 if (retcode != NO_ERROR)
2838 goto out;
2839
2840 tp.timeout_type =
2841 adm_ctx.mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED :
2842 test_bit(USE_DEGR_WFC_T, &adm_ctx.mdev->flags) ? UT_DEGRADED :
2843 UT_DEFAULT;
2844
2845 err = timeout_parms_to_priv_skb(adm_ctx.reply_skb, &tp);
2846 if (err) {
2847 nlmsg_free(adm_ctx.reply_skb);
2848 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002849 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002850out:
2851 drbd_adm_finish(info, retcode);
2852 return 0;
2853}
Lars Ellenberg873b0d52011-01-21 22:53:48 +01002854
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002855int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info)
2856{
2857 struct drbd_conf *mdev;
2858 enum drbd_ret_code retcode;
2859
2860 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2861 if (!adm_ctx.reply_skb)
2862 return retcode;
2863 if (retcode != NO_ERROR)
2864 goto out;
2865
2866 mdev = adm_ctx.mdev;
2867 if (info->attrs[DRBD_NLA_START_OV_PARMS]) {
2868 /* resume from last known position, if possible */
2869 struct start_ov_parms parms =
2870 { .ov_start_sector = mdev->ov_start_sector };
Lars Ellenbergf3990022011-03-23 14:31:09 +01002871 int err = start_ov_parms_from_attrs(&parms, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002872 if (err) {
2873 retcode = ERR_MANDATORY_TAG;
2874 drbd_msg_put_info(from_attrs_err_to_txt(err));
2875 goto out;
2876 }
2877 /* w_make_ov_request expects position to be aligned */
2878 mdev->ov_start_sector = parms.ov_start_sector & ~BM_SECT_PER_BIT;
2879 }
Lars Ellenberg873b0d52011-01-21 22:53:48 +01002880 /* If there is still bitmap IO pending, e.g. previous resync or verify
2881 * just being finished, wait for it before requesting a new resync. */
2882 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002883 retcode = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
2884out:
2885 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002886 return 0;
2887}
2888
2889
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002890int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002891{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002892 struct drbd_conf *mdev;
2893 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002894 int skip_initial_sync = 0;
2895 int err;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002896 struct new_c_uuid_parms args;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002897
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002898 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2899 if (!adm_ctx.reply_skb)
2900 return retcode;
2901 if (retcode != NO_ERROR)
2902 goto out_nolock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002903
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002904 mdev = adm_ctx.mdev;
2905 memset(&args, 0, sizeof(args));
2906 if (info->attrs[DRBD_NLA_NEW_C_UUID_PARMS]) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01002907 err = new_c_uuid_parms_from_attrs(&args, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002908 if (err) {
2909 retcode = ERR_MANDATORY_TAG;
2910 drbd_msg_put_info(from_attrs_err_to_txt(err));
2911 goto out_nolock;
2912 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002913 }
2914
Philipp Reisner8410da82011-02-11 20:11:10 +01002915 mutex_lock(mdev->state_mutex); /* Protects us against serialized state changes. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002916
2917 if (!get_ldev(mdev)) {
2918 retcode = ERR_NO_DISK;
2919 goto out;
2920 }
2921
2922 /* this is "skip initial sync", assume to be clean */
Philipp Reisner31890f42011-01-19 14:12:51 +01002923 if (mdev->state.conn == C_CONNECTED && mdev->tconn->agreed_pro_version >= 90 &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07002924 mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) {
2925 dev_info(DEV, "Preparing to skip initial sync\n");
2926 skip_initial_sync = 1;
2927 } else if (mdev->state.conn != C_STANDALONE) {
2928 retcode = ERR_CONNECTED;
2929 goto out_dec;
2930 }
2931
2932 drbd_uuid_set(mdev, UI_BITMAP, 0); /* Rotate UI_BITMAP to History 1, etc... */
2933 drbd_uuid_new_current(mdev); /* New current, previous to UI_BITMAP */
2934
2935 if (args.clear_bm) {
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01002936 err = drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
2937 "clear_n_write from new_c_uuid", BM_LOCKED_MASK);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002938 if (err) {
2939 dev_err(DEV, "Writing bitmap failed with %d\n",err);
2940 retcode = ERR_IO_MD_DISK;
2941 }
2942 if (skip_initial_sync) {
2943 drbd_send_uuids_skip_initial_sync(mdev);
2944 _drbd_uuid_set(mdev, UI_BITMAP, 0);
Lars Ellenberg62b0da32011-01-20 13:25:21 +01002945 drbd_print_uuids(mdev, "cleared bitmap UUID");
Philipp Reisner87eeee42011-01-19 14:16:30 +01002946 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002947 _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
2948 CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002949 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002950 }
2951 }
2952
2953 drbd_md_sync(mdev);
2954out_dec:
2955 put_ldev(mdev);
2956out:
Philipp Reisner8410da82011-02-11 20:11:10 +01002957 mutex_unlock(mdev->state_mutex);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002958out_nolock:
2959 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002960 return 0;
2961}
2962
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002963static enum drbd_ret_code
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002964drbd_check_resource_name(const char *name)
Philipp Reisner774b3052011-02-22 02:07:03 -05002965{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002966 if (!name || !name[0]) {
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002967 drbd_msg_put_info("resource name missing");
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002968 return ERR_MANDATORY_TAG;
2969 }
2970 /* if we want to use these in sysfs/configfs/debugfs some day,
2971 * we must not allow slashes */
2972 if (strchr(name, '/')) {
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002973 drbd_msg_put_info("invalid resource name");
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002974 return ERR_INVALID_REQUEST;
2975 }
2976 return NO_ERROR;
2977}
Philipp Reisner774b3052011-02-22 02:07:03 -05002978
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02002979int drbd_adm_new_resource(struct sk_buff *skb, struct genl_info *info)
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002980{
2981 enum drbd_ret_code retcode;
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002982 struct res_opts res_opts;
2983 int err;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002984
2985 retcode = drbd_adm_prepare(skb, info, 0);
2986 if (!adm_ctx.reply_skb)
2987 return retcode;
2988 if (retcode != NO_ERROR)
2989 goto out;
2990
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002991 set_res_opts_defaults(&res_opts);
2992 err = res_opts_from_attrs(&res_opts, info);
2993 if (err && err != -ENOMSG) {
2994 retcode = ERR_MANDATORY_TAG;
2995 drbd_msg_put_info(from_attrs_err_to_txt(err));
2996 goto out;
2997 }
2998
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002999 retcode = drbd_check_resource_name(adm_ctx.resource_name);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003000 if (retcode != NO_ERROR)
3001 goto out;
3002
3003 if (adm_ctx.tconn) {
Lars Ellenberg38f19612011-03-14 13:22:35 +01003004 if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) {
3005 retcode = ERR_INVALID_REQUEST;
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003006 drbd_msg_put_info("resource exists");
Lars Ellenberg38f19612011-03-14 13:22:35 +01003007 }
3008 /* else: still NO_ERROR */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003009 goto out;
Philipp Reisner774b3052011-02-22 02:07:03 -05003010 }
3011
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02003012 if (!conn_create(adm_ctx.resource_name, &res_opts))
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003013 retcode = ERR_NOMEM;
3014out:
3015 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003016 return 0;
3017}
3018
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003019int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info)
Philipp Reisner774b3052011-02-22 02:07:03 -05003020{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003021 struct drbd_genlmsghdr *dh = info->userhdr;
3022 enum drbd_ret_code retcode;
Philipp Reisner774b3052011-02-22 02:07:03 -05003023
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02003024 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003025 if (!adm_ctx.reply_skb)
3026 return retcode;
3027 if (retcode != NO_ERROR)
3028 goto out;
Philipp Reisner774b3052011-02-22 02:07:03 -05003029
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003030 /* FIXME drop minor_count parameter, limit to MINORMASK */
3031 if (dh->minor >= minor_count) {
3032 drbd_msg_put_info("requested minor out of range");
3033 retcode = ERR_INVALID_REQUEST;
3034 goto out;
3035 }
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +02003036 if (adm_ctx.volume > DRBD_VOLUME_MAX) {
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003037 drbd_msg_put_info("requested volume id out of range");
3038 retcode = ERR_INVALID_REQUEST;
3039 goto out;
Philipp Reisner774b3052011-02-22 02:07:03 -05003040 }
3041
Lars Ellenberg38f19612011-03-14 13:22:35 +01003042 /* drbd_adm_prepare made sure already
3043 * that mdev->tconn and mdev->vnr match the request. */
3044 if (adm_ctx.mdev) {
3045 if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
3046 retcode = ERR_MINOR_EXISTS;
3047 /* else: still NO_ERROR */
3048 goto out;
3049 }
3050
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003051 retcode = conn_new_minor(adm_ctx.tconn, dh->minor, adm_ctx.volume);
3052out:
3053 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003054 return 0;
3055}
3056
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003057static enum drbd_ret_code adm_delete_minor(struct drbd_conf *mdev)
3058{
3059 if (mdev->state.disk == D_DISKLESS &&
3060 /* no need to be mdev->state.conn == C_STANDALONE &&
3061 * we may want to delete a minor from a live replication group.
3062 */
3063 mdev->state.role == R_SECONDARY) {
Philipp Reisner81fa2e62011-05-04 15:10:30 +02003064 idr_remove(&mdev->tconn->volumes, mdev->vnr);
3065 idr_remove(&minors, mdev_to_minor(mdev));
3066 del_gendisk(mdev->vdisk);
3067 synchronize_rcu();
3068 kref_put(&mdev->kref, &drbd_minor_destroy);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003069 return NO_ERROR;
3070 } else
3071 return ERR_MINOR_CONFIGURED;
3072}
3073
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003074int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info)
Philipp Reisner774b3052011-02-22 02:07:03 -05003075{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003076 enum drbd_ret_code retcode;
3077
3078 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
3079 if (!adm_ctx.reply_skb)
3080 return retcode;
3081 if (retcode != NO_ERROR)
3082 goto out;
3083
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003084 retcode = adm_delete_minor(adm_ctx.mdev);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003085out:
3086 drbd_adm_finish(info, retcode);
3087 return 0;
3088}
3089
3090int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
3091{
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003092 int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003093 struct drbd_conf *mdev;
3094 unsigned i;
3095
3096 retcode = drbd_adm_prepare(skb, info, 0);
3097 if (!adm_ctx.reply_skb)
3098 return retcode;
3099 if (retcode != NO_ERROR)
3100 goto out;
3101
3102 if (!adm_ctx.tconn) {
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003103 retcode = ERR_RES_NOT_KNOWN;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003104 goto out;
3105 }
3106
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003107 /* demote */
3108 idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
3109 retcode = drbd_set_role(mdev, R_SECONDARY, 0);
3110 if (retcode < SS_SUCCESS) {
3111 drbd_msg_put_info("failed to demote");
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02003112 goto out;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003113 }
3114 }
3115
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003116 retcode = conn_try_disconnect(adm_ctx.tconn, 0);
3117 if (retcode < SS_SUCCESS) {
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003118 drbd_msg_put_info("failed to disconnect");
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003119 goto out;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003120 }
3121
3122 /* detach */
3123 idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
Philipp Reisnercdfda632011-07-05 15:38:59 +02003124 retcode = adm_detach(mdev, 0);
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003125 if (retcode < SS_SUCCESS) {
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003126 drbd_msg_put_info("failed to detach");
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02003127 goto out;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003128 }
3129 }
3130
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003131 /* If we reach this, all volumes (of this tconn) are Secondary,
3132 * Disconnected, Diskless, aka Unconfigured. Make sure all threads have
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02003133 * actually stopped, state handling only does drbd_thread_stop_nowait(). */
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003134 drbd_thread_stop(&adm_ctx.tconn->worker);
3135
3136 /* Now, nothing can fail anymore */
3137
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003138 /* delete volumes */
3139 idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
3140 retcode = adm_delete_minor(mdev);
3141 if (retcode != NO_ERROR) {
3142 /* "can not happen" */
3143 drbd_msg_put_info("failed to delete volume");
Philipp Reisneref356262011-04-13 14:21:29 -07003144 goto out;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003145 }
3146 }
3147
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003148 /* delete connection */
3149 if (conn_lowest_minor(adm_ctx.tconn) < 0) {
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02003150 list_del_rcu(&adm_ctx.tconn->all_tconn);
3151 synchronize_rcu();
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02003152 kref_put(&adm_ctx.tconn->kref, &conn_destroy);
3153
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003154 retcode = NO_ERROR;
3155 } else {
3156 /* "can not happen" */
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003157 retcode = ERR_RES_IN_USE;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003158 drbd_msg_put_info("failed to delete connection");
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003159 }
Philipp Reisneref356262011-04-13 14:21:29 -07003160 goto out;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003161out:
3162 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003163 return 0;
3164}
3165
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003166int drbd_adm_del_resource(struct sk_buff *skb, struct genl_info *info)
Philipp Reisner774b3052011-02-22 02:07:03 -05003167{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003168 enum drbd_ret_code retcode;
3169
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02003170 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003171 if (!adm_ctx.reply_skb)
3172 return retcode;
3173 if (retcode != NO_ERROR)
3174 goto out;
3175
3176 if (conn_lowest_minor(adm_ctx.tconn) < 0) {
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02003177 list_del_rcu(&adm_ctx.tconn->all_tconn);
3178 synchronize_rcu();
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02003179 kref_put(&adm_ctx.tconn->kref, &conn_destroy);
3180
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003181 retcode = NO_ERROR;
Philipp Reisner774b3052011-02-22 02:07:03 -05003182 } else {
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003183 retcode = ERR_RES_IN_USE;
Philipp Reisner774b3052011-02-22 02:07:03 -05003184 }
3185
Lars Ellenberg992d6e92011-05-02 11:47:18 +02003186 if (retcode == NO_ERROR)
3187 drbd_thread_stop(&adm_ctx.tconn->worker);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003188out:
3189 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003190 return 0;
3191}
3192
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003193void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003194{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003195 static atomic_t drbd_genl_seq = ATOMIC_INIT(2); /* two. */
3196 struct sk_buff *msg;
3197 struct drbd_genlmsghdr *d_out;
3198 unsigned seq;
3199 int err = -ENOMEM;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003200
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003201 seq = atomic_inc_return(&drbd_genl_seq);
3202 msg = genlmsg_new(NLMSG_GOODSIZE, GFP_NOIO);
3203 if (!msg)
3204 goto failed;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003205
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003206 err = -EMSGSIZE;
3207 d_out = genlmsg_put(msg, 0, seq, &drbd_genl_family, 0, DRBD_EVENT);
3208 if (!d_out) /* cannot happen, but anyways. */
3209 goto nla_put_failure;
3210 d_out->minor = mdev_to_minor(mdev);
Andreas Gruenbacher6f9b5f82011-05-06 01:03:32 +02003211 d_out->ret_code = NO_ERROR;
Philipp Reisner9f5180e2009-10-06 09:30:14 +02003212
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003213 if (nla_put_status_info(msg, mdev, sib))
3214 goto nla_put_failure;
3215 genlmsg_end(msg, d_out);
3216 err = drbd_genl_multicast_events(msg, 0);
3217 /* msg has been consumed or freed in netlink_broadcast() */
3218 if (err && err != -ESRCH)
3219 goto failed;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003220
Philipp Reisnerb411b362009-09-25 16:07:19 -07003221 return;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003222
3223nla_put_failure:
3224 nlmsg_free(msg);
3225failed:
3226 dev_err(DEV, "Error %d while broadcasting event. "
3227 "Event seq:%u sib_reason:%u\n",
3228 err, seq, sib->sib_reason);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003229}