blob: c50c1753aa9a0abce0465d5246e4d629fed6cbcf [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 Reisner8410da8f02011-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 Reisner8410da8f02011-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);
Philipp Reisnere0e16652011-07-11 17:04:23 +02001098 stop_threads = conn_all_vols_unconf(tconn) &&
1099 tconn->cstate == C_STANDALONE;
Philipp Reisner0e29d162011-02-18 14:23:11 +01001100 spin_unlock_irq(&tconn->req_lock);
Lars Ellenberg992d6e92011-05-02 11:47:18 +02001101 if (stop_threads) {
1102 /* asender is implicitly stopped by receiver
Philipp Reisner81fa2e62011-05-04 15:10:30 +02001103 * in conn_disconnect() */
Lars Ellenberg992d6e92011-05-02 11:47:18 +02001104 drbd_thread_stop(&tconn->receiver);
1105 drbd_thread_stop(&tconn->worker);
1106 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07001107}
1108
Philipp Reisner07782862010-08-31 12:00:50 +02001109/* Make sure IO is suspended before calling this function(). */
1110static void drbd_suspend_al(struct drbd_conf *mdev)
1111{
1112 int s = 0;
1113
Lars Ellenberg61610422011-02-21 13:20:54 +01001114 if (!lc_try_lock(mdev->act_log)) {
Philipp Reisner07782862010-08-31 12:00:50 +02001115 dev_warn(DEV, "Failed to lock al in drbd_suspend_al()\n");
1116 return;
1117 }
1118
Lars Ellenberg61610422011-02-21 13:20:54 +01001119 drbd_al_shrink(mdev);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001120 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner07782862010-08-31 12:00:50 +02001121 if (mdev->state.conn < C_CONNECTED)
1122 s = !test_and_set_bit(AL_SUSPENDED, &mdev->flags);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001123 spin_unlock_irq(&mdev->tconn->req_lock);
Lars Ellenberg61610422011-02-21 13:20:54 +01001124 lc_unlock(mdev->act_log);
Philipp Reisner07782862010-08-31 12:00:50 +02001125
1126 if (s)
1127 dev_info(DEV, "Suspended AL updates\n");
1128}
1129
Lars Ellenberg5979e362011-04-27 21:09:55 +02001130
1131static bool should_set_defaults(struct genl_info *info)
1132{
1133 unsigned flags = ((struct drbd_genlmsghdr*)info->userhdr)->flags;
1134 return 0 != (flags & DRBD_GENL_F_SET_DEFAULTS);
1135}
1136
Philipp Reisnerd589a212011-05-04 10:06:52 +02001137static void enforce_disk_conf_limits(struct disk_conf *dc)
1138{
1139 if (dc->al_extents < DRBD_AL_EXTENTS_MIN)
1140 dc->al_extents = DRBD_AL_EXTENTS_MIN;
1141 if (dc->al_extents > DRBD_AL_EXTENTS_MAX)
1142 dc->al_extents = DRBD_AL_EXTENTS_MAX;
1143
1144 if (dc->c_plan_ahead > DRBD_C_PLAN_AHEAD_MAX)
1145 dc->c_plan_ahead = DRBD_C_PLAN_AHEAD_MAX;
1146}
1147
Lars Ellenbergf3990022011-03-23 14:31:09 +01001148int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)
1149{
1150 enum drbd_ret_code retcode;
1151 struct drbd_conf *mdev;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001152 struct disk_conf *new_disk_conf, *old_disk_conf;
Philipp Reisner813472c2011-05-03 16:47:02 +02001153 struct fifo_buffer *old_plan = NULL, *new_plan = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001154 int err, fifo_size;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001155
1156 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1157 if (!adm_ctx.reply_skb)
1158 return retcode;
1159 if (retcode != NO_ERROR)
1160 goto out;
1161
1162 mdev = adm_ctx.mdev;
1163
1164 /* we also need a disk
1165 * to change the options on */
1166 if (!get_ldev(mdev)) {
1167 retcode = ERR_NO_DISK;
1168 goto out;
1169 }
1170
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001171 new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001172 if (!new_disk_conf) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001173 retcode = ERR_NOMEM;
1174 goto fail;
1175 }
1176
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001177 mutex_lock(&mdev->tconn->conf_update);
1178 old_disk_conf = mdev->ldev->disk_conf;
1179 *new_disk_conf = *old_disk_conf;
Lars Ellenberg5979e362011-04-27 21:09:55 +02001180 if (should_set_defaults(info))
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02001181 set_disk_conf_defaults(new_disk_conf);
Lars Ellenberg5979e362011-04-27 21:09:55 +02001182
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001183 err = disk_conf_from_attrs_for_change(new_disk_conf, info);
Andreas Gruenbacherc75b9b12011-05-24 14:18:31 +02001184 if (err && err != -ENOMSG) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001185 retcode = ERR_MANDATORY_TAG;
1186 drbd_msg_put_info(from_attrs_err_to_txt(err));
1187 }
1188
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001189 if (!expect(new_disk_conf->resync_rate >= 1))
1190 new_disk_conf->resync_rate = 1;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001191
Philipp Reisnerd589a212011-05-04 10:06:52 +02001192 enforce_disk_conf_limits(new_disk_conf);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001193
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001194 fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ;
Philipp Reisner9958c852011-05-03 16:19:31 +02001195 if (fifo_size != mdev->rs_plan_s->size) {
Philipp Reisner813472c2011-05-03 16:47:02 +02001196 new_plan = fifo_alloc(fifo_size);
1197 if (!new_plan) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001198 dev_err(DEV, "kmalloc of fifo_buffer failed");
1199 retcode = ERR_NOMEM;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001200 goto fail_unlock;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001201 }
1202 }
1203
Lars Ellenbergf3990022011-03-23 14:31:09 +01001204 wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
1205 drbd_al_shrink(mdev);
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001206 err = drbd_check_al_size(mdev, new_disk_conf);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001207 lc_unlock(mdev->act_log);
1208 wake_up(&mdev->al_wait);
1209
1210 if (err) {
1211 retcode = ERR_NOMEM;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001212 goto fail_unlock;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001213 }
1214
Philipp Reisnerdc97b702011-05-03 14:27:15 +02001215 write_lock_irq(&global_state_lock);
Andreas Gruenbacher95f8efd2011-05-12 11:15:34 +02001216 retcode = drbd_resync_after_valid(mdev, new_disk_conf->resync_after);
Philipp Reisnerdc97b702011-05-03 14:27:15 +02001217 if (retcode == NO_ERROR) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001218 rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
Andreas Gruenbacher95f8efd2011-05-12 11:15:34 +02001219 drbd_resync_after_changed(mdev);
Philipp Reisnerdc97b702011-05-03 14:27:15 +02001220 }
1221 write_unlock_irq(&global_state_lock);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001222
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001223 if (retcode != NO_ERROR)
1224 goto fail_unlock;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001225
Philipp Reisner813472c2011-05-03 16:47:02 +02001226 if (new_plan) {
1227 old_plan = mdev->rs_plan_s;
1228 rcu_assign_pointer(mdev->rs_plan_s, new_plan);
Philipp Reisner9958c852011-05-03 16:19:31 +02001229 }
Philipp Reisner9958c852011-05-03 16:19:31 +02001230
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02001231 mutex_unlock(&mdev->tconn->conf_update);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001232 drbd_md_sync(mdev);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001233
1234 if (mdev->state.conn >= C_CONNECTED)
1235 drbd_send_sync_param(mdev);
1236
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001237 synchronize_rcu();
1238 kfree(old_disk_conf);
Philipp Reisner813472c2011-05-03 16:47:02 +02001239 kfree(old_plan);
Philipp Reisnercdfda632011-07-05 15:38:59 +02001240 mod_timer(&mdev->request_timer, jiffies + HZ);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001241 goto success;
1242
1243fail_unlock:
1244 mutex_unlock(&mdev->tconn->conf_update);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001245 fail:
Lars Ellenberg5ecc72c2011-04-27 21:14:57 +02001246 kfree(new_disk_conf);
Philipp Reisner813472c2011-05-03 16:47:02 +02001247 kfree(new_plan);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001248success:
1249 put_ldev(mdev);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001250 out:
1251 drbd_adm_finish(info, retcode);
1252 return 0;
1253}
1254
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001255int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001256{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001257 struct drbd_conf *mdev;
1258 int err;
Andreas Gruenbacher116676c2010-12-08 13:33:11 +01001259 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001260 enum determine_dev_size dd;
1261 sector_t max_possible_sectors;
1262 sector_t min_md_device_sectors;
1263 struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001264 struct disk_conf *new_disk_conf = NULL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001265 struct block_device *bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001266 struct lru_cache *resync_lru = NULL;
Philipp Reisner9958c852011-05-03 16:19:31 +02001267 struct fifo_buffer *new_plan = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001268 union drbd_state ns, os;
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001269 enum drbd_state_rv rv;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001270 struct net_conf *nc;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001271
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001272 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1273 if (!adm_ctx.reply_skb)
1274 return retcode;
1275 if (retcode != NO_ERROR)
Lars Ellenberg40cbf082011-03-16 16:52:10 +01001276 goto finish;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001277
1278 mdev = adm_ctx.mdev;
Philipp Reisner0e29d162011-02-18 14:23:11 +01001279 conn_reconfig_start(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001280
1281 /* if you want to reconfigure, please tear down first */
1282 if (mdev->state.disk > D_DISKLESS) {
1283 retcode = ERR_DISK_CONFIGURED;
1284 goto fail;
1285 }
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001286 /* It may just now have detached because of IO error. Make sure
1287 * drbd_ldev_destroy is done already, we may end up here very fast,
1288 * e.g. if someone calls attach from the on-io-error handler,
1289 * to realize a "hot spare" feature (not that I'd recommend that) */
1290 wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001291
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001292 /* allocation not in the IO path, drbdsetup context */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001293 nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
1294 if (!nbc) {
1295 retcode = ERR_NOMEM;
1296 goto fail;
1297 }
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001298 new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL);
1299 if (!new_disk_conf) {
1300 retcode = ERR_NOMEM;
1301 goto fail;
1302 }
1303 nbc->disk_conf = new_disk_conf;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001304
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001305 set_disk_conf_defaults(new_disk_conf);
1306 err = disk_conf_from_attrs(new_disk_conf, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001307 if (err) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001308 retcode = ERR_MANDATORY_TAG;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001309 drbd_msg_put_info(from_attrs_err_to_txt(err));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001310 goto fail;
1311 }
1312
Philipp Reisnerd589a212011-05-04 10:06:52 +02001313 enforce_disk_conf_limits(new_disk_conf);
1314
Philipp Reisner9958c852011-05-03 16:19:31 +02001315 new_plan = fifo_alloc((new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ);
1316 if (!new_plan) {
1317 retcode = ERR_NOMEM;
1318 goto fail;
1319 }
1320
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001321 if (new_disk_conf->meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001322 retcode = ERR_MD_IDX_INVALID;
1323 goto fail;
1324 }
1325
Philipp Reisner44ed1672011-04-19 17:10:19 +02001326 rcu_read_lock();
1327 nc = rcu_dereference(mdev->tconn->net_conf);
1328 if (nc) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001329 if (new_disk_conf->fencing == FP_STONITH && nc->wire_protocol == DRBD_PROT_A) {
Philipp Reisner44ed1672011-04-19 17:10:19 +02001330 rcu_read_unlock();
Philipp Reisner47ff2d02010-06-18 13:56:57 +02001331 retcode = ERR_STONITH_AND_PROT_A;
1332 goto fail;
1333 }
1334 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02001335 rcu_read_unlock();
Philipp Reisner47ff2d02010-06-18 13:56:57 +02001336
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001337 bdev = blkdev_get_by_path(new_disk_conf->backing_dev,
Tejun Heod4d77622010-11-13 11:55:18 +01001338 FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
Tejun Heoe525fd82010-11-13 11:55:17 +01001339 if (IS_ERR(bdev)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001340 dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->backing_dev,
Tejun Heoe525fd82010-11-13 11:55:17 +01001341 PTR_ERR(bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001342 retcode = ERR_OPEN_DISK;
1343 goto fail;
1344 }
Tejun Heoe525fd82010-11-13 11:55:17 +01001345 nbc->backing_bdev = bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001346
Tejun Heoe525fd82010-11-13 11:55:17 +01001347 /*
1348 * meta_dev_idx >= 0: external fixed size, possibly multiple
1349 * drbd sharing one meta device. TODO in that case, paranoia
1350 * check that [md_bdev, meta_dev_idx] is not yet used by some
1351 * other drbd minor! (if you use drbd.conf + drbdadm, that
1352 * should check it for you already; but if you don't, or
1353 * someone fooled it, we need to double check here)
1354 */
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001355 bdev = blkdev_get_by_path(new_disk_conf->meta_dev,
Tejun Heod4d77622010-11-13 11:55:18 +01001356 FMODE_READ | FMODE_WRITE | FMODE_EXCL,
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001357 (new_disk_conf->meta_dev_idx < 0) ?
Tejun Heod4d77622010-11-13 11:55:18 +01001358 (void *)mdev : (void *)drbd_m_holder);
Tejun Heoe525fd82010-11-13 11:55:17 +01001359 if (IS_ERR(bdev)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001360 dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->meta_dev,
Tejun Heoe525fd82010-11-13 11:55:17 +01001361 PTR_ERR(bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001362 retcode = ERR_OPEN_MD_DISK;
1363 goto fail;
1364 }
Tejun Heoe525fd82010-11-13 11:55:17 +01001365 nbc->md_bdev = bdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001366
Tejun Heoe525fd82010-11-13 11:55:17 +01001367 if ((nbc->backing_bdev == nbc->md_bdev) !=
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001368 (new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
1369 new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
Tejun Heoe525fd82010-11-13 11:55:17 +01001370 retcode = ERR_MD_IDX_INVALID;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001371 goto fail;
1372 }
1373
1374 resync_lru = lc_create("resync", drbd_bm_ext_cache,
Lars Ellenberg46a15bc2011-02-21 13:21:01 +01001375 1, 61, sizeof(struct bm_extent),
Philipp Reisnerb411b362009-09-25 16:07:19 -07001376 offsetof(struct bm_extent, lce));
1377 if (!resync_lru) {
1378 retcode = ERR_NOMEM;
Tejun Heoe525fd82010-11-13 11:55:17 +01001379 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001380 }
1381
1382 /* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */
1383 drbd_md_set_sector_offsets(mdev, nbc);
1384
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001385 if (drbd_get_max_capacity(nbc) < new_disk_conf->disk_size) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001386 dev_err(DEV, "max capacity %llu smaller than disk size %llu\n",
1387 (unsigned long long) drbd_get_max_capacity(nbc),
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001388 (unsigned long long) new_disk_conf->disk_size);
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001389 retcode = ERR_DISK_TOO_SMALL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001390 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001391 }
1392
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001393 if (new_disk_conf->meta_dev_idx < 0) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001394 max_possible_sectors = DRBD_MAX_SECTORS_FLEX;
1395 /* at least one MB, otherwise it does not make sense */
1396 min_md_device_sectors = (2<<10);
1397 } else {
1398 max_possible_sectors = DRBD_MAX_SECTORS;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001399 min_md_device_sectors = MD_RESERVED_SECT * (new_disk_conf->meta_dev_idx + 1);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001400 }
1401
Philipp Reisnerb411b362009-09-25 16:07:19 -07001402 if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) {
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001403 retcode = ERR_MD_DISK_TOO_SMALL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001404 dev_warn(DEV, "refusing attach: md-device too small, "
1405 "at least %llu sectors needed for this meta-disk type\n",
1406 (unsigned long long) min_md_device_sectors);
Tejun Heoe525fd82010-11-13 11:55:17 +01001407 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001408 }
1409
1410 /* Make sure the new disk is big enough
1411 * (we may currently be R_PRIMARY with no local disk...) */
1412 if (drbd_get_max_capacity(nbc) <
1413 drbd_get_capacity(mdev->this_bdev)) {
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001414 retcode = ERR_DISK_TOO_SMALL;
Tejun Heoe525fd82010-11-13 11:55:17 +01001415 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001416 }
1417
1418 nbc->known_size = drbd_get_capacity(nbc->backing_bdev);
1419
Lars Ellenberg13529942009-10-12 19:07:49 +02001420 if (nbc->known_size > max_possible_sectors) {
1421 dev_warn(DEV, "==> truncating very big lower level device "
1422 "to currently maximum possible %llu sectors <==\n",
1423 (unsigned long long) max_possible_sectors);
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001424 if (new_disk_conf->meta_dev_idx >= 0)
Lars Ellenberg13529942009-10-12 19:07:49 +02001425 dev_warn(DEV, "==>> using internal or flexible "
1426 "meta data may help <<==\n");
1427 }
1428
Philipp Reisnerb411b362009-09-25 16:07:19 -07001429 drbd_suspend_io(mdev);
1430 /* also wait for the last barrier ack. */
Philipp Reisner2aebfab2011-03-28 16:48:11 +02001431 wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || drbd_suspended(mdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001432 /* and for any other previously queued work */
Philipp Reisnera21e9292011-02-08 15:08:49 +01001433 drbd_flush_workqueue(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001434
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001435 rv = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE);
1436 retcode = rv; /* FIXME: Type mismatch. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07001437 drbd_resume_io(mdev);
Andreas Gruenbacherf2024e72010-12-10 13:44:05 +01001438 if (rv < SS_SUCCESS)
Tejun Heoe525fd82010-11-13 11:55:17 +01001439 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001440
1441 if (!get_ldev_if_state(mdev, D_ATTACHING))
1442 goto force_diskless;
1443
1444 drbd_md_set_sector_offsets(mdev, nbc);
1445
1446 if (!mdev->bitmap) {
1447 if (drbd_bm_init(mdev)) {
1448 retcode = ERR_NOMEM;
1449 goto force_diskless_dec;
1450 }
1451 }
1452
1453 retcode = drbd_md_read(mdev, nbc);
1454 if (retcode != NO_ERROR)
1455 goto force_diskless_dec;
1456
1457 if (mdev->state.conn < C_CONNECTED &&
1458 mdev->state.role == R_PRIMARY &&
1459 (mdev->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
1460 dev_err(DEV, "Can only attach to data with current UUID=%016llX\n",
1461 (unsigned long long)mdev->ed_uuid);
1462 retcode = ERR_DATA_NOT_CURRENT;
1463 goto force_diskless_dec;
1464 }
1465
1466 /* Since we are diskless, fix the activity log first... */
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001467 if (drbd_check_al_size(mdev, new_disk_conf)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001468 retcode = ERR_NOMEM;
1469 goto force_diskless_dec;
1470 }
1471
1472 /* Prevent shrinking of consistent devices ! */
1473 if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001474 drbd_new_dev_size(mdev, nbc, nbc->disk_conf->disk_size, 0) < nbc->md.la_size_sect) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001475 dev_warn(DEV, "refusing to truncate a consistent device\n");
Lars Ellenberg67b58bf2011-06-06 15:36:04 +02001476 retcode = ERR_DISK_TOO_SMALL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001477 goto force_diskless_dec;
1478 }
1479
Philipp Reisnerb411b362009-09-25 16:07:19 -07001480 /* Reset the "barriers don't work" bits here, then force meta data to
1481 * be written, to ensure we determine if barriers are supported. */
Andreas Gruenbachere5440462011-05-04 15:25:35 +02001482 if (new_disk_conf->md_flushes)
Philipp Reisnera8a4e512010-08-25 10:21:04 +02001483 clear_bit(MD_NO_FUA, &mdev->flags);
Andreas Gruenbachere5440462011-05-04 15:25:35 +02001484 else
1485 set_bit(MD_NO_FUA, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001486
1487 /* Point of no return reached.
1488 * Devices and memory are no longer released by error cleanup below.
1489 * now mdev takes over responsibility, and the state engine should
1490 * clean it up somewhere. */
1491 D_ASSERT(mdev->ldev == NULL);
1492 mdev->ldev = nbc;
1493 mdev->resync = resync_lru;
Philipp Reisner9958c852011-05-03 16:19:31 +02001494 mdev->rs_plan_s = new_plan;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001495 nbc = NULL;
1496 resync_lru = NULL;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001497 new_disk_conf = NULL;
Philipp Reisner9958c852011-05-03 16:19:31 +02001498 new_plan = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001499
Philipp Reisner2451fc32010-08-24 13:43:11 +02001500 mdev->write_ordering = WO_bdev_flush;
1501 drbd_bump_write_ordering(mdev, WO_bdev_flush);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001502
1503 if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
1504 set_bit(CRASHED_PRIMARY, &mdev->flags);
1505 else
1506 clear_bit(CRASHED_PRIMARY, &mdev->flags);
1507
Philipp Reisner894c6a92010-06-18 16:03:20 +02001508 if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
Lars Ellenbergd5d7ebd2011-07-05 20:59:26 +02001509 !(mdev->state.role == R_PRIMARY && mdev->tconn->susp_nod))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001510 set_bit(CRASHED_PRIMARY, &mdev->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001511
1512 mdev->send_cnt = 0;
1513 mdev->recv_cnt = 0;
1514 mdev->read_cnt = 0;
1515 mdev->writ_cnt = 0;
1516
Philipp Reisner99432fc2011-05-20 16:39:13 +02001517 drbd_reconsider_max_bio_size(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001518
1519 /* If I am currently not R_PRIMARY,
1520 * but meta data primary indicator is set,
1521 * I just now recover from a hard crash,
1522 * and have been R_PRIMARY before that crash.
1523 *
1524 * Now, if I had no connection before that crash
1525 * (have been degraded R_PRIMARY), chances are that
1526 * I won't find my peer now either.
1527 *
1528 * In that case, and _only_ in that case,
1529 * we use the degr-wfc-timeout instead of the default,
1530 * so we can automatically recover from a crash of a
1531 * degraded but active "cluster" after a certain timeout.
1532 */
1533 clear_bit(USE_DEGR_WFC_T, &mdev->flags);
1534 if (mdev->state.role != R_PRIMARY &&
1535 drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
1536 !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND))
1537 set_bit(USE_DEGR_WFC_T, &mdev->flags);
1538
Bart Van Assche24c48302011-05-21 18:32:29 +02001539 dd = drbd_determine_dev_size(mdev, 0);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001540 if (dd == dev_size_error) {
1541 retcode = ERR_NOMEM_BITMAP;
1542 goto force_diskless_dec;
1543 } else if (dd == grew)
1544 set_bit(RESYNC_AFTER_NEG, &mdev->flags);
1545
1546 if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
1547 dev_info(DEV, "Assuming that all blocks are out of sync "
1548 "(aka FullSync)\n");
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001549 if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
1550 "set_n_write from attaching", BM_LOCKED_MASK)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001551 retcode = ERR_IO_MD_DISK;
1552 goto force_diskless_dec;
1553 }
1554 } else {
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01001555 if (drbd_bitmap_io(mdev, &drbd_bm_read,
Andreas Gruenbacher22ab6a32010-12-13 01:44:11 +01001556 "read from attaching", BM_LOCKED_MASK)) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07001557 retcode = ERR_IO_MD_DISK;
1558 goto force_diskless_dec;
1559 }
1560 }
1561
Philipp Reisner07782862010-08-31 12:00:50 +02001562 if (_drbd_bm_total_weight(mdev) == drbd_bm_bits(mdev))
1563 drbd_suspend_al(mdev); /* IO is still suspended here... */
1564
Philipp Reisner87eeee42011-01-19 14:16:30 +01001565 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisner78bae592011-03-28 15:40:12 +02001566 os = drbd_read_state(mdev);
1567 ns = os;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001568 /* If MDF_CONSISTENT is not set go into inconsistent state,
1569 otherwise investigate MDF_WasUpToDate...
1570 If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state,
1571 otherwise into D_CONSISTENT state.
1572 */
1573 if (drbd_md_test_flag(mdev->ldev, MDF_CONSISTENT)) {
1574 if (drbd_md_test_flag(mdev->ldev, MDF_WAS_UP_TO_DATE))
1575 ns.disk = D_CONSISTENT;
1576 else
1577 ns.disk = D_OUTDATED;
1578 } else {
1579 ns.disk = D_INCONSISTENT;
1580 }
1581
1582 if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED))
1583 ns.pdsk = D_OUTDATED;
1584
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001585 rcu_read_lock();
1586 if (ns.disk == D_CONSISTENT &&
1587 (ns.pdsk == D_OUTDATED || rcu_dereference(mdev->ldev->disk_conf)->fencing == FP_DONT_CARE))
Philipp Reisnerb411b362009-09-25 16:07:19 -07001588 ns.disk = D_UP_TO_DATE;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001589 rcu_read_unlock();
Philipp Reisnerb411b362009-09-25 16:07:19 -07001590
1591 /* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND,
1592 MDF_CONSISTENT and MDF_WAS_UP_TO_DATE must happen before
1593 this point, because drbd_request_state() modifies these
1594 flags. */
1595
1596 /* In case we are C_CONNECTED postpone any decision on the new disk
1597 state after the negotiation phase. */
1598 if (mdev->state.conn == C_CONNECTED) {
1599 mdev->new_state_tmp.i = ns.i;
1600 ns.i = os.i;
1601 ns.disk = D_NEGOTIATING;
Philipp Reisnerdc66c742010-06-02 14:31:29 +02001602
1603 /* We expect to receive up-to-date UUIDs soon.
1604 To avoid a race in receive_state, free p_uuid while
1605 holding req_lock. I.e. atomic with the state change */
1606 kfree(mdev->p_uuid);
1607 mdev->p_uuid = NULL;
Philipp Reisnerb411b362009-09-25 16:07:19 -07001608 }
1609
1610 rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01001611 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001612
1613 if (rv < SS_SUCCESS)
1614 goto force_diskless_dec;
1615
Philipp Reisnercdfda632011-07-05 15:38:59 +02001616 mod_timer(&mdev->request_timer, jiffies + HZ);
1617
Philipp Reisnerb411b362009-09-25 16:07:19 -07001618 if (mdev->state.role == R_PRIMARY)
1619 mdev->ldev->md.uuid[UI_CURRENT] |= (u64)1;
1620 else
1621 mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
1622
1623 drbd_md_mark_dirty(mdev);
1624 drbd_md_sync(mdev);
1625
1626 kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
1627 put_ldev(mdev);
Philipp Reisner0e29d162011-02-18 14:23:11 +01001628 conn_reconfig_done(mdev->tconn);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001629 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001630 return 0;
1631
1632 force_diskless_dec:
1633 put_ldev(mdev);
1634 force_diskless:
Philipp Reisner9510b242011-07-01 17:00:57 +02001635 drbd_force_state(mdev, NS(disk, D_DISKLESS));
Philipp Reisnerb411b362009-09-25 16:07:19 -07001636 drbd_md_sync(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001637 fail:
Lars Ellenberg40cbf082011-03-16 16:52:10 +01001638 conn_reconfig_done(mdev->tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001639 if (nbc) {
Tejun Heoe525fd82010-11-13 11:55:17 +01001640 if (nbc->backing_bdev)
1641 blkdev_put(nbc->backing_bdev,
1642 FMODE_READ | FMODE_WRITE | FMODE_EXCL);
1643 if (nbc->md_bdev)
1644 blkdev_put(nbc->md_bdev,
1645 FMODE_READ | FMODE_WRITE | FMODE_EXCL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001646 kfree(nbc);
1647 }
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001648 kfree(new_disk_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001649 lc_destroy(resync_lru);
Philipp Reisner9958c852011-05-03 16:19:31 +02001650 kfree(new_plan);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001651
Lars Ellenberg40cbf082011-03-16 16:52:10 +01001652 finish:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001653 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001654 return 0;
1655}
1656
Philipp Reisnercdfda632011-07-05 15:38:59 +02001657static int adm_detach(struct drbd_conf *mdev, int force)
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001658{
Philipp Reisner19f83c72011-03-29 14:21:03 +02001659 enum drbd_state_rv retcode;
Lars Ellenberg009ba892011-05-02 11:51:31 +02001660 int ret;
Philipp Reisnercdfda632011-07-05 15:38:59 +02001661
1662 if (force) {
1663 drbd_force_state(mdev, NS(disk, D_FAILED));
1664 retcode = SS_SUCCESS;
1665 goto out;
1666 }
1667
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001668 drbd_suspend_io(mdev); /* so no-one is stuck in drbd_al_begin_io */
Philipp Reisner0cfac5d2011-11-10 12:12:52 +01001669 drbd_md_get_buffer(mdev); /* make sure there is no in-flight meta-data IO */
Lars Ellenberg009ba892011-05-02 11:51:31 +02001670 retcode = drbd_request_state(mdev, NS(disk, D_FAILED));
Philipp Reisner0cfac5d2011-11-10 12:12:52 +01001671 drbd_md_put_buffer(mdev);
Lars Ellenberg009ba892011-05-02 11:51:31 +02001672 /* D_FAILED will transition to DISKLESS. */
1673 ret = wait_event_interruptible(mdev->misc_wait,
1674 mdev->state.disk != D_FAILED);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001675 drbd_resume_io(mdev);
Lars Ellenberg009ba892011-05-02 11:51:31 +02001676 if ((int)retcode == (int)SS_IS_DISKLESS)
1677 retcode = SS_NOTHING_TO_DO;
1678 if (ret)
1679 retcode = ERR_INTR;
Philipp Reisnercdfda632011-07-05 15:38:59 +02001680out:
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01001681 return retcode;
1682}
1683
Lars Ellenberg82f59cc2010-10-16 12:13:47 +02001684/* Detaching the disk is a process in multiple stages. First we need to lock
1685 * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
1686 * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
1687 * internal references as well.
1688 * Only then we have finally detached. */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001689int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001690{
Lars Ellenberg9a0d9d02011-05-02 11:51:31 +02001691 enum drbd_ret_code retcode;
Philipp Reisnercdfda632011-07-05 15:38:59 +02001692 struct detach_parms parms = { };
1693 int err;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001694
1695 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1696 if (!adm_ctx.reply_skb)
1697 return retcode;
1698 if (retcode != NO_ERROR)
1699 goto out;
1700
Philipp Reisnercdfda632011-07-05 15:38:59 +02001701 if (info->attrs[DRBD_NLA_DETACH_PARMS]) {
1702 err = detach_parms_from_attrs(&parms, info);
1703 if (err) {
1704 retcode = ERR_MANDATORY_TAG;
1705 drbd_msg_put_info(from_attrs_err_to_txt(err));
1706 goto out;
1707 }
1708 }
1709
1710 retcode = adm_detach(adm_ctx.mdev, parms.force_detach);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001711out:
1712 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07001713 return 0;
1714}
1715
Lars Ellenbergf3990022011-03-23 14:31:09 +01001716static bool conn_resync_running(struct drbd_tconn *tconn)
1717{
1718 struct drbd_conf *mdev;
Philipp Reisner695d08f2011-04-11 22:53:32 -07001719 bool rv = false;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001720 int vnr;
1721
Philipp Reisner695d08f2011-04-11 22:53:32 -07001722 rcu_read_lock();
Lars Ellenbergf3990022011-03-23 14:31:09 +01001723 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
1724 if (mdev->state.conn == C_SYNC_SOURCE ||
1725 mdev->state.conn == C_SYNC_TARGET ||
1726 mdev->state.conn == C_PAUSED_SYNC_S ||
Philipp Reisner695d08f2011-04-11 22:53:32 -07001727 mdev->state.conn == C_PAUSED_SYNC_T) {
1728 rv = true;
1729 break;
1730 }
Lars Ellenbergf3990022011-03-23 14:31:09 +01001731 }
Philipp Reisner695d08f2011-04-11 22:53:32 -07001732 rcu_read_unlock();
1733
1734 return rv;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001735}
1736
1737static bool conn_ov_running(struct drbd_tconn *tconn)
1738{
1739 struct drbd_conf *mdev;
Philipp Reisner695d08f2011-04-11 22:53:32 -07001740 bool rv = false;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001741 int vnr;
1742
Philipp Reisner695d08f2011-04-11 22:53:32 -07001743 rcu_read_lock();
Lars Ellenbergf3990022011-03-23 14:31:09 +01001744 idr_for_each_entry(&tconn->volumes, mdev, vnr) {
1745 if (mdev->state.conn == C_VERIFY_S ||
Philipp Reisner695d08f2011-04-11 22:53:32 -07001746 mdev->state.conn == C_VERIFY_T) {
1747 rv = true;
1748 break;
1749 }
Lars Ellenbergf3990022011-03-23 14:31:09 +01001750 }
Philipp Reisner695d08f2011-04-11 22:53:32 -07001751 rcu_read_unlock();
1752
1753 return rv;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001754}
1755
Philipp Reisnercd643972011-04-13 18:00:59 -07001756static enum drbd_ret_code
Philipp Reisner44ed1672011-04-19 17:10:19 +02001757_check_net_options(struct drbd_tconn *tconn, struct net_conf *old_conf, struct net_conf *new_conf)
Philipp Reisnercd643972011-04-13 18:00:59 -07001758{
1759 struct drbd_conf *mdev;
1760 int i;
1761
Philipp Reisnerdcb20d12011-05-16 14:30:24 +02001762 if (old_conf && tconn->cstate == C_WF_REPORT_PARAMS && tconn->agreed_pro_version < 100) {
1763 if (new_conf->wire_protocol != old_conf->wire_protocol)
1764 return ERR_NEED_APV_100;
1765
1766 if (new_conf->two_primaries != old_conf->two_primaries)
1767 return ERR_NEED_APV_100;
1768
1769 if (!new_conf->integrity_alg != !old_conf->integrity_alg)
1770 return ERR_NEED_APV_100;
1771
1772 if (strcmp(new_conf->integrity_alg, old_conf->integrity_alg))
1773 return ERR_NEED_APV_100;
1774 }
1775
1776 if (!new_conf->two_primaries &&
1777 conn_highest_role(tconn) == R_PRIMARY &&
1778 conn_highest_peer(tconn) == R_PRIMARY)
1779 return ERR_NEED_ALLOW_TWO_PRI;
Philipp Reisnerb032b6f2011-04-13 18:16:10 -07001780
Philipp Reisnercd643972011-04-13 18:00:59 -07001781 if (new_conf->two_primaries &&
1782 (new_conf->wire_protocol != DRBD_PROT_C))
1783 return ERR_NOT_PROTO_C;
1784
Philipp Reisnercd643972011-04-13 18:00:59 -07001785 idr_for_each_entry(&tconn->volumes, mdev, i) {
1786 if (get_ldev(mdev)) {
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02001787 enum drbd_fencing_p fp = rcu_dereference(mdev->ldev->disk_conf)->fencing;
Philipp Reisnercd643972011-04-13 18:00:59 -07001788 put_ldev(mdev);
Philipp Reisner44ed1672011-04-19 17:10:19 +02001789 if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH)
Philipp Reisnercd643972011-04-13 18:00:59 -07001790 return ERR_STONITH_AND_PROT_A;
Philipp Reisnercd643972011-04-13 18:00:59 -07001791 }
Andreas Gruenbacher6139f602011-05-06 20:00:02 +02001792 if (mdev->state.role == R_PRIMARY && new_conf->discard_my_data)
Philipp Reisnercd643972011-04-13 18:00:59 -07001793 return ERR_DISCARD;
Philipp Reisnercd643972011-04-13 18:00:59 -07001794 }
Philipp Reisnercd643972011-04-13 18:00:59 -07001795
1796 if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A)
1797 return ERR_CONG_NOT_PROTO_A;
1798
1799 return NO_ERROR;
1800}
1801
Philipp Reisner44ed1672011-04-19 17:10:19 +02001802static enum drbd_ret_code
1803check_net_options(struct drbd_tconn *tconn, struct net_conf *new_conf)
1804{
1805 static enum drbd_ret_code rv;
1806 struct drbd_conf *mdev;
1807 int i;
1808
1809 rcu_read_lock();
1810 rv = _check_net_options(tconn, rcu_dereference(tconn->net_conf), new_conf);
1811 rcu_read_unlock();
1812
1813 /* tconn->volumes protected by genl_lock() here */
1814 idr_for_each_entry(&tconn->volumes, mdev, i) {
1815 if (!mdev->bitmap) {
1816 if(drbd_bm_init(mdev))
1817 return ERR_NOMEM;
1818 }
1819 }
1820
1821 return rv;
1822}
1823
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001824struct crypto {
1825 struct crypto_hash *verify_tfm;
1826 struct crypto_hash *csums_tfm;
1827 struct crypto_hash *cram_hmac_tfm;
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001828 struct crypto_hash *integrity_tfm;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001829};
1830
1831static int
Andreas Gruenbacher4b6ad6d2011-04-29 10:20:08 +02001832alloc_hash(struct crypto_hash **tfm, char *tfm_name, int err_alg)
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001833{
1834 if (!tfm_name[0])
1835 return NO_ERROR;
1836
1837 *tfm = crypto_alloc_hash(tfm_name, 0, CRYPTO_ALG_ASYNC);
1838 if (IS_ERR(*tfm)) {
1839 *tfm = NULL;
1840 return err_alg;
1841 }
1842
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001843 return NO_ERROR;
1844}
1845
1846static enum drbd_ret_code
1847alloc_crypto(struct crypto *crypto, struct net_conf *new_conf)
1848{
1849 char hmac_name[CRYPTO_MAX_ALG_NAME];
1850 enum drbd_ret_code rv;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001851
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 }
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001871
1872 return rv;
1873}
1874
1875static void free_crypto(struct crypto *crypto)
1876{
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001877 crypto_free_hash(crypto->cram_hmac_tfm);
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001878 crypto_free_hash(crypto->integrity_tfm);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001879 crypto_free_hash(crypto->csums_tfm);
1880 crypto_free_hash(crypto->verify_tfm);
1881}
1882
Lars Ellenbergf3990022011-03-23 14:31:09 +01001883int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info)
1884{
1885 enum drbd_ret_code retcode;
1886 struct drbd_tconn *tconn;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001887 struct net_conf *old_conf, *new_conf = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001888 int err;
1889 int ovr; /* online verify running */
1890 int rsr; /* re-sync running */
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001891 struct crypto crypto = { };
Lars Ellenbergf3990022011-03-23 14:31:09 +01001892
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02001893 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001894 if (!adm_ctx.reply_skb)
1895 return retcode;
1896 if (retcode != NO_ERROR)
1897 goto out;
1898
1899 tconn = adm_ctx.tconn;
1900
1901 new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
1902 if (!new_conf) {
1903 retcode = ERR_NOMEM;
1904 goto out;
1905 }
1906
Lars Ellenbergf3990022011-03-23 14:31:09 +01001907 conn_reconfig_start(tconn);
1908
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001909 mutex_lock(&tconn->data.mutex);
Philipp Reisnera0095502011-05-03 13:14:15 +02001910 mutex_lock(&tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001911 old_conf = tconn->net_conf;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001912
1913 if (!old_conf) {
1914 drbd_msg_put_info("net conf missing, try connect");
1915 retcode = ERR_INVALID_REQUEST;
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001916 goto fail;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001917 }
1918
1919 *new_conf = *old_conf;
Lars Ellenberg5979e362011-04-27 21:09:55 +02001920 if (should_set_defaults(info))
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02001921 set_net_conf_defaults(new_conf);
Philipp Reisner44ed1672011-04-19 17:10:19 +02001922
Lars Ellenbergf3990022011-03-23 14:31:09 +01001923 err = net_conf_from_attrs_for_change(new_conf, info);
Andreas Gruenbacherc75b9b12011-05-24 14:18:31 +02001924 if (err && err != -ENOMSG) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001925 retcode = ERR_MANDATORY_TAG;
1926 drbd_msg_put_info(from_attrs_err_to_txt(err));
1927 goto fail;
1928 }
1929
Philipp Reisnercd643972011-04-13 18:00:59 -07001930 retcode = check_net_options(tconn, new_conf);
1931 if (retcode != NO_ERROR)
1932 goto fail;
1933
Lars Ellenbergf3990022011-03-23 14:31:09 +01001934 /* re-sync running */
1935 rsr = conn_resync_running(tconn);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001936 if (rsr && strcmp(new_conf->csums_alg, old_conf->csums_alg)) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01001937 retcode = ERR_CSUMS_RESYNC_RUNNING;
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001938 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001939 }
1940
Lars Ellenbergf3990022011-03-23 14:31:09 +01001941 /* online verify running */
1942 ovr = conn_ov_running(tconn);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001943 if (ovr && strcmp(new_conf->verify_alg, old_conf->verify_alg)) {
1944 retcode = ERR_VERIFY_RUNNING;
1945 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001946 }
1947
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001948 retcode = alloc_crypto(&crypto, new_conf);
1949 if (retcode != NO_ERROR)
1950 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001951
Philipp Reisner44ed1672011-04-19 17:10:19 +02001952 rcu_assign_pointer(tconn->net_conf, new_conf);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001953
1954 if (!rsr) {
1955 crypto_free_hash(tconn->csums_tfm);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001956 tconn->csums_tfm = crypto.csums_tfm;
1957 crypto.csums_tfm = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001958 }
1959 if (!ovr) {
1960 crypto_free_hash(tconn->verify_tfm);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001961 tconn->verify_tfm = crypto.verify_tfm;
1962 crypto.verify_tfm = NULL;
Lars Ellenbergf3990022011-03-23 14:31:09 +01001963 }
1964
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02001965 crypto_free_hash(tconn->integrity_tfm);
1966 tconn->integrity_tfm = crypto.integrity_tfm;
Philipp Reisnerd659f2a2011-05-16 17:38:45 +02001967 if (tconn->cstate >= C_WF_REPORT_PARAMS && tconn->agreed_pro_version >= 100)
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001968 /* Do this without trying to take tconn->data.mutex again. */
Philipp Reisnerd659f2a2011-05-16 17:38:45 +02001969 __drbd_send_protocol(tconn, P_PROTOCOL_UPDATE);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001970
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001971 crypto_free_hash(tconn->cram_hmac_tfm);
1972 tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
1973
Philipp Reisnera0095502011-05-03 13:14:15 +02001974 mutex_unlock(&tconn->conf_update);
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001975 mutex_unlock(&tconn->data.mutex);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001976 synchronize_rcu();
1977 kfree(old_conf);
1978
Lars Ellenbergf3990022011-03-23 14:31:09 +01001979 if (tconn->cstate >= C_WF_REPORT_PARAMS)
1980 drbd_send_sync_param(minor_to_mdev(conn_lowest_minor(tconn)));
1981
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001982 goto done;
1983
Lars Ellenbergf3990022011-03-23 14:31:09 +01001984 fail:
Philipp Reisnera0095502011-05-03 13:14:15 +02001985 mutex_unlock(&tconn->conf_update);
Andreas Gruenbacher88104ca2011-04-28 21:47:21 +02001986 mutex_unlock(&tconn->data.mutex);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02001987 free_crypto(&crypto);
Lars Ellenbergf3990022011-03-23 14:31:09 +01001988 kfree(new_conf);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02001989 done:
Lars Ellenbergf3990022011-03-23 14:31:09 +01001990 conn_reconfig_done(tconn);
1991 out:
1992 drbd_adm_finish(info, retcode);
1993 return 0;
1994}
1995
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001996int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07001997{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01001998 struct drbd_conf *mdev;
Philipp Reisner44ed1672011-04-19 17:10:19 +02001999 struct net_conf *old_conf, *new_conf = NULL;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002000 struct crypto crypto = { };
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002001 struct drbd_tconn *tconn;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002002 enum drbd_ret_code retcode;
2003 int i;
2004 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002005
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02002006 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002007
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002008 if (!adm_ctx.reply_skb)
2009 return retcode;
2010 if (retcode != NO_ERROR)
2011 goto out;
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002012 if (!(adm_ctx.my_addr && adm_ctx.peer_addr)) {
2013 drbd_msg_put_info("connection endpoint(s) missing");
2014 retcode = ERR_INVALID_REQUEST;
2015 goto out;
2016 }
2017
2018 /* No need for _rcu here. All reconfiguration is
2019 * strictly serialized on genl_lock(). We are protected against
2020 * concurrent reconfiguration/addition/deletion */
2021 list_for_each_entry(tconn, &drbd_tconns, all_tconn) {
2022 if (nla_len(adm_ctx.my_addr) == tconn->my_addr_len &&
2023 !memcmp(nla_data(adm_ctx.my_addr), &tconn->my_addr, tconn->my_addr_len)) {
2024 retcode = ERR_LOCAL_ADDR;
2025 goto out;
2026 }
2027
2028 if (nla_len(adm_ctx.peer_addr) == tconn->peer_addr_len &&
2029 !memcmp(nla_data(adm_ctx.peer_addr), &tconn->peer_addr, tconn->peer_addr_len)) {
2030 retcode = ERR_PEER_ADDR;
2031 goto out;
2032 }
2033 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002034
2035 tconn = adm_ctx.tconn;
Philipp Reisner80883192011-02-18 14:56:45 +01002036 conn_reconfig_start(tconn);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002037
Philipp Reisner80883192011-02-18 14:56:45 +01002038 if (tconn->cstate > C_STANDALONE) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002039 retcode = ERR_NET_CONFIGURED;
2040 goto fail;
2041 }
2042
Andreas Gruenbachera209b4a2011-08-17 12:43:25 +02002043 /* allocation not in the IO path, drbdsetup / netlink process context */
Lars Ellenberg5979e362011-04-27 21:09:55 +02002044 new_conf = kzalloc(sizeof(*new_conf), GFP_KERNEL);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002045 if (!new_conf) {
2046 retcode = ERR_NOMEM;
2047 goto fail;
2048 }
2049
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02002050 set_net_conf_defaults(new_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002051
Lars Ellenbergf3990022011-03-23 14:31:09 +01002052 err = net_conf_from_attrs(new_conf, info);
Lars Ellenberg25e40932011-08-19 10:39:00 +02002053 if (err && err != -ENOMSG) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002054 retcode = ERR_MANDATORY_TAG;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002055 drbd_msg_put_info(from_attrs_err_to_txt(err));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002056 goto fail;
2057 }
2058
Philipp Reisnercd643972011-04-13 18:00:59 -07002059 retcode = check_net_options(tconn, new_conf);
2060 if (retcode != NO_ERROR)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002061 goto fail;
Philipp Reisner422028b2010-10-27 11:12:07 +02002062
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002063 retcode = alloc_crypto(&crypto, new_conf);
2064 if (retcode != NO_ERROR)
2065 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002066
Philipp Reisnerb411b362009-09-25 16:07:19 -07002067 ((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;
2068
Philipp Reisner80883192011-02-18 14:56:45 +01002069 conn_flush_workqueue(tconn);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002070
Philipp Reisnera0095502011-05-03 13:14:15 +02002071 mutex_lock(&tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002072 old_conf = tconn->net_conf;
2073 if (old_conf) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002074 retcode = ERR_NET_CONFIGURED;
Philipp Reisnera0095502011-05-03 13:14:15 +02002075 mutex_unlock(&tconn->conf_update);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002076 goto fail;
2077 }
Philipp Reisner44ed1672011-04-19 17:10:19 +02002078 rcu_assign_pointer(tconn->net_conf, new_conf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002079
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002080 conn_free_crypto(tconn);
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002081 tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
Andreas Gruenbacher8d412fc2011-04-27 20:59:18 +02002082 tconn->integrity_tfm = crypto.integrity_tfm;
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002083 tconn->csums_tfm = crypto.csums_tfm;
2084 tconn->verify_tfm = crypto.verify_tfm;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002085
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002086 tconn->my_addr_len = nla_len(adm_ctx.my_addr);
2087 memcpy(&tconn->my_addr, nla_data(adm_ctx.my_addr), tconn->my_addr_len);
2088 tconn->peer_addr_len = nla_len(adm_ctx.peer_addr);
2089 memcpy(&tconn->peer_addr, nla_data(adm_ctx.peer_addr), tconn->peer_addr_len);
2090
Philipp Reisnera0095502011-05-03 13:14:15 +02002091 mutex_unlock(&tconn->conf_update);
Philipp Reisner91fd4da2011-04-20 17:47:29 +02002092
Philipp Reisner695d08f2011-04-11 22:53:32 -07002093 rcu_read_lock();
Philipp Reisner80883192011-02-18 14:56:45 +01002094 idr_for_each_entry(&tconn->volumes, mdev, i) {
2095 mdev->send_cnt = 0;
2096 mdev->recv_cnt = 0;
Philipp Reisner80883192011-02-18 14:56:45 +01002097 }
Philipp Reisner695d08f2011-04-11 22:53:32 -07002098 rcu_read_unlock();
Lars Ellenberg5ee743e2011-04-26 16:22:25 +02002099
2100 retcode = conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
2101
Philipp Reisner80883192011-02-18 14:56:45 +01002102 conn_reconfig_done(tconn);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002103 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002104 return 0;
2105
2106fail:
Philipp Reisner0fd0ea02011-04-27 11:27:47 +02002107 free_crypto(&crypto);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002108 kfree(new_conf);
2109
Philipp Reisner80883192011-02-18 14:56:45 +01002110 conn_reconfig_done(tconn);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002111out:
2112 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002113 return 0;
2114}
2115
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002116static enum drbd_state_rv conn_try_disconnect(struct drbd_tconn *tconn, bool force)
2117{
2118 enum drbd_state_rv rv;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002119
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002120 rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
2121 force ? CS_HARD : 0);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002122
2123 switch (rv) {
2124 case SS_NOTHING_TO_DO:
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002125 break;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002126 case SS_ALREADY_STANDALONE:
2127 return SS_SUCCESS;
2128 case SS_PRIMARY_NOP:
2129 /* Our state checking code wants to see the peer outdated. */
2130 rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002131 pdsk, D_OUTDATED), CS_VERBOSE);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002132 break;
2133 case SS_CW_FAILED_BY_PEER:
2134 /* The peer probably wants to see us outdated. */
2135 rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
2136 disk, D_OUTDATED), 0);
2137 if (rv == SS_IS_DISKLESS || rv == SS_LOWER_THAN_OUTDATED) {
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002138 rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
2139 CS_HARD);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002140 }
2141 break;
2142 default:;
2143 /* no special handling necessary */
2144 }
2145
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002146 if (rv >= SS_SUCCESS) {
2147 enum drbd_state_rv rv2;
2148 /* No one else can reconfigure the network while I am here.
2149 * The state handling only uses drbd_thread_stop_nowait(),
2150 * we want to really wait here until the receiver is no more.
2151 */
2152 drbd_thread_stop(&adm_ctx.tconn->receiver);
2153
2154 /* Race breaker. This additional state change request may be
2155 * necessary, if this was a forced disconnect during a receiver
2156 * restart. We may have "killed" the receiver thread just
2157 * after drbdd_init() returned. Typically, we should be
2158 * C_STANDALONE already, now, and this becomes a no-op.
2159 */
2160 rv2 = conn_request_state(tconn, NS(conn, C_STANDALONE),
2161 CS_VERBOSE | CS_HARD);
2162 if (rv2 < SS_SUCCESS)
2163 conn_err(tconn,
2164 "unexpected rv2=%d in conn_try_disconnect()\n",
2165 rv2);
2166 }
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002167 return rv;
2168}
2169
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002170int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002171{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002172 struct disconnect_parms parms;
2173 struct drbd_tconn *tconn;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002174 enum drbd_state_rv rv;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002175 enum drbd_ret_code retcode;
2176 int err;
Philipp Reisner2561b9c2010-12-03 15:22:48 +01002177
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002178 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002179 if (!adm_ctx.reply_skb)
2180 return retcode;
2181 if (retcode != NO_ERROR)
Philipp Reisner2561b9c2010-12-03 15:22:48 +01002182 goto fail;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002183
2184 tconn = adm_ctx.tconn;
2185 memset(&parms, 0, sizeof(parms));
2186 if (info->attrs[DRBD_NLA_DISCONNECT_PARMS]) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01002187 err = disconnect_parms_from_attrs(&parms, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002188 if (err) {
2189 retcode = ERR_MANDATORY_TAG;
2190 drbd_msg_put_info(from_attrs_err_to_txt(err));
2191 goto fail;
2192 }
Philipp Reisner2561b9c2010-12-03 15:22:48 +01002193 }
2194
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01002195 rv = conn_try_disconnect(tconn, parms.force_disconnect);
2196 if (rv < SS_SUCCESS)
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02002197 retcode = rv; /* FIXME: Type mismatch. */
2198 else
2199 retcode = NO_ERROR;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002200 fail:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002201 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002202 return 0;
2203}
2204
2205void resync_after_online_grow(struct drbd_conf *mdev)
2206{
2207 int iass; /* I am sync source */
2208
2209 dev_info(DEV, "Resync of new storage after online grow\n");
2210 if (mdev->state.role != mdev->state.peer)
2211 iass = (mdev->state.role == R_PRIMARY);
2212 else
Philipp Reisner25703f82011-02-07 14:35:25 +01002213 iass = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002214
2215 if (iass)
2216 drbd_start_resync(mdev, C_SYNC_SOURCE);
2217 else
2218 _drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE);
2219}
2220
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002221int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002222{
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002223 struct disk_conf *old_disk_conf, *new_disk_conf = NULL;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002224 struct resize_parms rs;
2225 struct drbd_conf *mdev;
2226 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002227 enum determine_dev_size dd;
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002228 enum dds_flags ddsf;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002229 sector_t u_size;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002230 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002231
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002232 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2233 if (!adm_ctx.reply_skb)
2234 return retcode;
2235 if (retcode != NO_ERROR)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002236 goto fail;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002237
2238 memset(&rs, 0, sizeof(struct resize_parms));
2239 if (info->attrs[DRBD_NLA_RESIZE_PARMS]) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01002240 err = resize_parms_from_attrs(&rs, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002241 if (err) {
2242 retcode = ERR_MANDATORY_TAG;
2243 drbd_msg_put_info(from_attrs_err_to_txt(err));
2244 goto fail;
2245 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002246 }
2247
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002248 mdev = adm_ctx.mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002249 if (mdev->state.conn > C_CONNECTED) {
2250 retcode = ERR_RESIZE_RESYNC;
2251 goto fail;
2252 }
2253
2254 if (mdev->state.role == R_SECONDARY &&
2255 mdev->state.peer == R_SECONDARY) {
2256 retcode = ERR_NO_PRIMARY;
2257 goto fail;
2258 }
2259
2260 if (!get_ldev(mdev)) {
2261 retcode = ERR_NO_DISK;
2262 goto fail;
2263 }
2264
Philipp Reisner31890f42011-01-19 14:12:51 +01002265 if (rs.no_resync && mdev->tconn->agreed_pro_version < 93) {
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002266 retcode = ERR_NEED_APV_93;
Philipp Reisner9bcd2522011-09-29 13:00:14 +02002267 goto fail_ldev;
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002268 }
2269
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002270 rcu_read_lock();
2271 u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
2272 rcu_read_unlock();
2273 if (u_size != (sector_t)rs.resize_size) {
2274 new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
2275 if (!new_disk_conf) {
2276 retcode = ERR_NOMEM;
Philipp Reisner9bcd2522011-09-29 13:00:14 +02002277 goto fail_ldev;
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002278 }
2279 }
2280
Philipp Reisner087c2492010-03-26 13:49:56 +01002281 if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev))
Philipp Reisnerb411b362009-09-25 16:07:19 -07002282 mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002283
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002284 if (new_disk_conf) {
2285 mutex_lock(&mdev->tconn->conf_update);
2286 old_disk_conf = mdev->ldev->disk_conf;
2287 *new_disk_conf = *old_disk_conf;
2288 new_disk_conf->disk_size = (sector_t)rs.resize_size;
2289 rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
2290 mutex_unlock(&mdev->tconn->conf_update);
2291 synchronize_rcu();
2292 kfree(old_disk_conf);
2293 }
2294
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002295 ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0);
Bart Van Assche24c48302011-05-21 18:32:29 +02002296 dd = drbd_determine_dev_size(mdev, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002297 drbd_md_sync(mdev);
2298 put_ldev(mdev);
2299 if (dd == dev_size_error) {
2300 retcode = ERR_NOMEM_BITMAP;
2301 goto fail;
2302 }
2303
Philipp Reisner087c2492010-03-26 13:49:56 +01002304 if (mdev->state.conn == C_CONNECTED) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002305 if (dd == grew)
2306 set_bit(RESIZE_PENDING, &mdev->flags);
2307
2308 drbd_send_uuids(mdev);
Philipp Reisner6495d2c2010-03-24 16:07:04 +01002309 drbd_send_sizes(mdev, 1, ddsf);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002310 }
2311
2312 fail:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002313 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002314 return 0;
Philipp Reisner9bcd2522011-09-29 13:00:14 +02002315
2316 fail_ldev:
2317 put_ldev(mdev);
2318 goto fail;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002319}
2320
Lars Ellenbergf3990022011-03-23 14:31:09 +01002321int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002322{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002323 enum drbd_ret_code retcode;
Lars Ellenbergf3990022011-03-23 14:31:09 +01002324 struct drbd_tconn *tconn;
Lars Ellenbergb57a1e22011-04-27 21:17:33 +02002325 struct res_opts res_opts;
Lars Ellenbergf3990022011-03-23 14:31:09 +01002326 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002327
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02002328 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002329 if (!adm_ctx.reply_skb)
2330 return retcode;
2331 if (retcode != NO_ERROR)
2332 goto fail;
Lars Ellenbergf3990022011-03-23 14:31:09 +01002333 tconn = adm_ctx.tconn;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002334
Lars Ellenbergb57a1e22011-04-27 21:17:33 +02002335 res_opts = tconn->res_opts;
Lars Ellenberg5979e362011-04-27 21:09:55 +02002336 if (should_set_defaults(info))
Andreas Gruenbacherb966b5d2011-05-03 14:56:09 +02002337 set_res_opts_defaults(&res_opts);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002338
Lars Ellenbergb57a1e22011-04-27 21:17:33 +02002339 err = res_opts_from_attrs(&res_opts, info);
Andreas Gruenbacherc75b9b12011-05-24 14:18:31 +02002340 if (err && err != -ENOMSG) {
Philipp Reisnerb411b362009-09-25 16:07:19 -07002341 retcode = ERR_MANDATORY_TAG;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002342 drbd_msg_put_info(from_attrs_err_to_txt(err));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002343 goto fail;
2344 }
2345
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002346 err = set_resource_options(tconn, &res_opts);
2347 if (err) {
2348 retcode = ERR_INVALID_REQUEST;
2349 if (err == -ENOMEM)
2350 retcode = ERR_NOMEM;
Philipp Reisner778f2712010-07-06 11:14:00 +02002351 }
2352
Philipp Reisnerb411b362009-09-25 16:07:19 -07002353fail:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002354 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002355 return 0;
2356}
2357
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002358int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002359{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002360 struct drbd_conf *mdev;
2361 int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
2362
2363 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2364 if (!adm_ctx.reply_skb)
2365 return retcode;
2366 if (retcode != NO_ERROR)
2367 goto out;
2368
2369 mdev = adm_ctx.mdev;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002370
Lars Ellenberg194bfb32011-01-18 10:38:01 +01002371 /* If there is still bitmap IO pending, probably because of a previous
2372 * resync just being finished, wait for it before requesting a new resync. */
2373 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
2374
Philipp Reisnerb411b362009-09-25 16:07:19 -07002375 retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED);
2376
2377 if (retcode < SS_SUCCESS && retcode != SS_NEED_CONNECTION)
2378 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
2379
2380 while (retcode == SS_NEED_CONNECTION) {
Philipp Reisner87eeee42011-01-19 14:16:30 +01002381 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002382 if (mdev->state.conn < C_CONNECTED)
2383 retcode = _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002384 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002385
2386 if (retcode != SS_NEED_CONNECTION)
2387 break;
2388
2389 retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
2390 }
2391
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002392out:
2393 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002394 return 0;
2395}
2396
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002397static int drbd_adm_simple_request_state(struct sk_buff *skb, struct genl_info *info,
2398 union drbd_state mask, union drbd_state val)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002399{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002400 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002401
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002402 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2403 if (!adm_ctx.reply_skb)
2404 return retcode;
2405 if (retcode != NO_ERROR)
2406 goto out;
Lars Ellenberg194bfb32011-01-18 10:38:01 +01002407
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002408 retcode = drbd_request_state(adm_ctx.mdev, mask, val);
2409out:
2410 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002411 return 0;
2412}
2413
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002414int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002415{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002416 return drbd_adm_simple_request_state(skb, info, NS(conn, C_STARTING_SYNC_S));
2417}
Philipp Reisnerb411b362009-09-25 16:07:19 -07002418
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002419int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info)
2420{
2421 enum drbd_ret_code retcode;
2422
2423 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2424 if (!adm_ctx.reply_skb)
2425 return retcode;
2426 if (retcode != NO_ERROR)
2427 goto out;
2428
2429 if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002430 retcode = ERR_PAUSE_IS_SET;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002431out:
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_resume_sync(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002437{
Philipp Reisnerda9fbc22011-03-29 10:52:01 +02002438 union drbd_dev_state s;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002439 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002440
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002441 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2442 if (!adm_ctx.reply_skb)
2443 return retcode;
2444 if (retcode != NO_ERROR)
2445 goto out;
2446
2447 if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
2448 s = adm_ctx.mdev->state;
Philipp Reisnercd88d032011-01-20 11:46:41 +01002449 if (s.conn == C_PAUSED_SYNC_S || s.conn == C_PAUSED_SYNC_T) {
2450 retcode = s.aftr_isp ? ERR_PIC_AFTER_DEP :
2451 s.peer_isp ? ERR_PIC_PEER_DEP : ERR_PAUSE_IS_CLEAR;
2452 } else {
2453 retcode = ERR_PAUSE_IS_CLEAR;
2454 }
2455 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002456
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002457out:
2458 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002459 return 0;
2460}
2461
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002462int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002463{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002464 return drbd_adm_simple_request_state(skb, info, NS(susp, 1));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002465}
2466
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002467int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002468{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002469 struct drbd_conf *mdev;
2470 int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
2471
2472 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2473 if (!adm_ctx.reply_skb)
2474 return retcode;
2475 if (retcode != NO_ERROR)
2476 goto out;
2477
2478 mdev = adm_ctx.mdev;
Philipp Reisner43a51822010-06-11 11:26:34 +02002479 if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
2480 drbd_uuid_new_current(mdev);
2481 clear_bit(NEW_CUR_UUID, &mdev->flags);
Philipp Reisner43a51822010-06-11 11:26:34 +02002482 }
Philipp Reisner265be2d2010-05-31 10:14:17 +02002483 drbd_suspend_io(mdev);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002484 retcode = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
2485 if (retcode == SS_SUCCESS) {
Philipp Reisner265be2d2010-05-31 10:14:17 +02002486 if (mdev->state.conn < C_CONNECTED)
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01002487 tl_clear(mdev->tconn);
Philipp Reisner265be2d2010-05-31 10:14:17 +02002488 if (mdev->state.disk == D_DISKLESS || mdev->state.disk == D_FAILED)
Philipp Reisner2f5cdd02011-02-21 14:29:27 +01002489 tl_restart(mdev->tconn, FAIL_FROZEN_DISK_IO);
Philipp Reisner265be2d2010-05-31 10:14:17 +02002490 }
2491 drbd_resume_io(mdev);
2492
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002493out:
2494 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002495 return 0;
2496}
2497
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002498int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002499{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002500 return drbd_adm_simple_request_state(skb, info, NS(disk, D_OUTDATED));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002501}
2502
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002503int nla_put_drbd_cfg_context(struct sk_buff *skb, struct drbd_tconn *tconn, unsigned vnr)
Lars Ellenberg543cc102011-03-10 22:18:18 +01002504{
2505 struct nlattr *nla;
2506 nla = nla_nest_start(skb, DRBD_NLA_CFG_CONTEXT);
2507 if (!nla)
2508 goto nla_put_failure;
2509 if (vnr != VOLUME_UNSPECIFIED)
2510 NLA_PUT_U32(skb, T_ctx_volume, vnr);
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002511 NLA_PUT_STRING(skb, T_ctx_resource_name, tconn->name);
2512 if (tconn->my_addr_len)
2513 NLA_PUT(skb, T_ctx_my_addr, tconn->my_addr_len, &tconn->my_addr);
2514 if (tconn->peer_addr_len)
2515 NLA_PUT(skb, T_ctx_peer_addr, tconn->peer_addr_len, &tconn->peer_addr);
Lars Ellenberg543cc102011-03-10 22:18:18 +01002516 nla_nest_end(skb, nla);
2517 return 0;
2518
2519nla_put_failure:
2520 if (nla)
2521 nla_nest_cancel(skb, nla);
2522 return -EMSGSIZE;
2523}
2524
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002525int nla_put_status_info(struct sk_buff *skb, struct drbd_conf *mdev,
2526 const struct sib_info *sib)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002527{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002528 struct state_info *si = NULL; /* for sizeof(si->member); */
Philipp Reisner44ed1672011-04-19 17:10:19 +02002529 struct net_conf *nc;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002530 struct nlattr *nla;
2531 int got_ldev;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002532 int err = 0;
2533 int exclude_sensitive;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002534
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002535 /* If sib != NULL, this is drbd_bcast_event, which anyone can listen
2536 * to. So we better exclude_sensitive information.
2537 *
2538 * If sib == NULL, this is drbd_adm_get_status, executed synchronously
2539 * in the context of the requesting user process. Exclude sensitive
2540 * information, unless current has superuser.
2541 *
2542 * NOTE: for drbd_adm_get_status_all(), this is a netlink dump, and
2543 * relies on the current implementation of netlink_dump(), which
2544 * executes the dump callback successively from netlink_recvmsg(),
2545 * always in the context of the receiving process */
2546 exclude_sensitive = sib || !capable(CAP_SYS_ADMIN);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002547
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002548 got_ldev = get_ldev(mdev);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002549
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002550 /* We need to add connection name and volume number information still.
2551 * Minor number is in drbd_genlmsghdr. */
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002552 if (nla_put_drbd_cfg_context(skb, mdev->tconn, mdev->vnr))
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002553 goto nla_put_failure;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002554
Lars Ellenbergf3990022011-03-23 14:31:09 +01002555 if (res_opts_to_skb(skb, &mdev->tconn->res_opts, exclude_sensitive))
2556 goto nla_put_failure;
2557
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002558 rcu_read_lock();
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002559 if (got_ldev)
Philipp Reisnerdaeda1c2011-05-03 15:00:55 +02002560 if (disk_conf_to_skb(skb, rcu_dereference(mdev->ldev->disk_conf), exclude_sensitive))
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002561 goto nla_put_failure;
Philipp Reisner44ed1672011-04-19 17:10:19 +02002562
Philipp Reisner44ed1672011-04-19 17:10:19 +02002563 nc = rcu_dereference(mdev->tconn->net_conf);
2564 if (nc)
2565 err = net_conf_to_skb(skb, nc, exclude_sensitive);
2566 rcu_read_unlock();
2567 if (err)
2568 goto nla_put_failure;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002569
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002570 nla = nla_nest_start(skb, DRBD_NLA_STATE_INFO);
2571 if (!nla)
2572 goto nla_put_failure;
2573 NLA_PUT_U32(skb, T_sib_reason, sib ? sib->sib_reason : SIB_GET_STATUS_REPLY);
2574 NLA_PUT_U32(skb, T_current_state, mdev->state.i);
2575 NLA_PUT_U64(skb, T_ed_uuid, mdev->ed_uuid);
2576 NLA_PUT_U64(skb, T_capacity, drbd_get_capacity(mdev->this_bdev));
Philipp Reisnerb411b362009-09-25 16:07:19 -07002577
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002578 if (got_ldev) {
2579 NLA_PUT_U32(skb, T_disk_flags, mdev->ldev->md.flags);
2580 NLA_PUT(skb, T_uuids, sizeof(si->uuids), mdev->ldev->md.uuid);
2581 NLA_PUT_U64(skb, T_bits_total, drbd_bm_bits(mdev));
2582 NLA_PUT_U64(skb, T_bits_oos, drbd_bm_total_weight(mdev));
2583 if (C_SYNC_SOURCE <= mdev->state.conn &&
2584 C_PAUSED_SYNC_T >= mdev->state.conn) {
2585 NLA_PUT_U64(skb, T_bits_rs_total, mdev->rs_total);
2586 NLA_PUT_U64(skb, T_bits_rs_failed, mdev->rs_failed);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002587 }
2588 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002589
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002590 if (sib) {
2591 switch(sib->sib_reason) {
2592 case SIB_SYNC_PROGRESS:
2593 case SIB_GET_STATUS_REPLY:
2594 break;
2595 case SIB_STATE_CHANGE:
2596 NLA_PUT_U32(skb, T_prev_state, sib->os.i);
2597 NLA_PUT_U32(skb, T_new_state, sib->ns.i);
2598 break;
2599 case SIB_HELPER_POST:
2600 NLA_PUT_U32(skb,
2601 T_helper_exit_code, sib->helper_exit_code);
2602 /* fall through */
2603 case SIB_HELPER_PRE:
2604 NLA_PUT_STRING(skb, T_helper, sib->helper_name);
2605 break;
2606 }
2607 }
2608 nla_nest_end(skb, nla);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002609
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002610 if (0)
2611nla_put_failure:
2612 err = -EMSGSIZE;
2613 if (got_ldev)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002614 put_ldev(mdev);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002615 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002616}
2617
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002618int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002619{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002620 enum drbd_ret_code retcode;
2621 int err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002622
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002623 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2624 if (!adm_ctx.reply_skb)
2625 return retcode;
2626 if (retcode != NO_ERROR)
2627 goto out;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002628
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002629 err = nla_put_status_info(adm_ctx.reply_skb, adm_ctx.mdev, NULL);
2630 if (err) {
2631 nlmsg_free(adm_ctx.reply_skb);
2632 return err;
2633 }
2634out:
2635 drbd_adm_finish(info, retcode);
2636 return 0;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002637}
2638
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002639int get_one_status(struct sk_buff *skb, struct netlink_callback *cb)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002640{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002641 struct drbd_conf *mdev;
2642 struct drbd_genlmsghdr *dh;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002643 struct drbd_tconn *pos = (struct drbd_tconn*)cb->args[0];
2644 struct drbd_tconn *tconn = NULL;
2645 struct drbd_tconn *tmp;
2646 unsigned volume = cb->args[1];
Philipp Reisnerb411b362009-09-25 16:07:19 -07002647
Lars Ellenberg543cc102011-03-10 22:18:18 +01002648 /* Open coded, deferred, iteration:
2649 * list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
2650 * idr_for_each_entry(&tconn->volumes, mdev, i) {
2651 * ...
2652 * }
2653 * }
2654 * where tconn is cb->args[0];
2655 * and i is cb->args[1];
2656 *
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002657 * cb->args[2] indicates if we shall loop over all resources,
2658 * or just dump all volumes of a single resource.
2659 *
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002660 * This may miss entries inserted after this dump started,
2661 * or entries deleted before they are reached.
Lars Ellenberg543cc102011-03-10 22:18:18 +01002662 *
2663 * We need to make sure the mdev won't disappear while
2664 * we are looking at it, and revalidate our iterators
2665 * on each iteration.
2666 */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002667
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02002668 /* synchronize with conn_create()/conn_destroy() */
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002669 rcu_read_lock();
Lars Ellenberg543cc102011-03-10 22:18:18 +01002670 /* revalidate iterator position */
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02002671 list_for_each_entry_rcu(tmp, &drbd_tconns, all_tconn) {
Lars Ellenberg543cc102011-03-10 22:18:18 +01002672 if (pos == NULL) {
2673 /* first iteration */
2674 pos = tmp;
2675 tconn = pos;
2676 break;
2677 }
2678 if (tmp == pos) {
2679 tconn = pos;
2680 break;
2681 }
2682 }
2683 if (tconn) {
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002684next_tconn:
Lars Ellenberg543cc102011-03-10 22:18:18 +01002685 mdev = idr_get_next(&tconn->volumes, &volume);
2686 if (!mdev) {
2687 /* No more volumes to dump on this tconn.
2688 * Advance tconn iterator. */
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02002689 pos = list_entry_rcu(tconn->all_tconn.next,
2690 struct drbd_tconn, all_tconn);
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002691 /* Did we dump any volume on this tconn yet? */
Lars Ellenberg543cc102011-03-10 22:18:18 +01002692 if (volume != 0) {
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002693 /* If we reached the end of the list,
2694 * or only a single resource dump was requested,
2695 * we are done. */
2696 if (&pos->all_tconn == &drbd_tconns || cb->args[2])
2697 goto out;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002698 volume = 0;
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002699 tconn = pos;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002700 goto next_tconn;
2701 }
2702 }
2703
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002704 dh = genlmsg_put(skb, NETLINK_CB(cb->skb).pid,
2705 cb->nlh->nlmsg_seq, &drbd_genl_family,
2706 NLM_F_MULTI, DRBD_ADM_GET_STATUS);
2707 if (!dh)
Lars Ellenberg543cc102011-03-10 22:18:18 +01002708 goto out;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002709
Lars Ellenberg543cc102011-03-10 22:18:18 +01002710 if (!mdev) {
Lars Ellenberg367d675d2011-07-11 23:49:55 +02002711 /* This is a tconn without a single volume.
2712 * Suprisingly enough, it may have a network
2713 * configuration. */
2714 struct net_conf *nc;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002715 dh->minor = -1U;
2716 dh->ret_code = NO_ERROR;
Andreas Gruenbacher089c0752011-06-14 18:28:09 +02002717 if (nla_put_drbd_cfg_context(skb, tconn, VOLUME_UNSPECIFIED))
Lars Ellenberg367d675d2011-07-11 23:49:55 +02002718 goto cancel;
2719 nc = rcu_dereference(tconn->net_conf);
2720 if (nc && net_conf_to_skb(skb, nc, 1) != 0)
2721 goto cancel;
2722 goto done;
Lars Ellenberg543cc102011-03-10 22:18:18 +01002723 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002724
Lars Ellenberg543cc102011-03-10 22:18:18 +01002725 D_ASSERT(mdev->vnr == volume);
2726 D_ASSERT(mdev->tconn == tconn);
2727
2728 dh->minor = mdev_to_minor(mdev);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002729 dh->ret_code = NO_ERROR;
2730
2731 if (nla_put_status_info(skb, mdev, NULL)) {
Lars Ellenberg367d675d2011-07-11 23:49:55 +02002732cancel:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002733 genlmsg_cancel(skb, dh);
Lars Ellenberg543cc102011-03-10 22:18:18 +01002734 goto out;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002735 }
Lars Ellenberg367d675d2011-07-11 23:49:55 +02002736done:
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002737 genlmsg_end(skb, dh);
2738 }
2739
Lars Ellenberg543cc102011-03-10 22:18:18 +01002740out:
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02002741 rcu_read_unlock();
Lars Ellenberg543cc102011-03-10 22:18:18 +01002742 /* where to start the next iteration */
2743 cb->args[0] = (long)pos;
2744 cb->args[1] = (pos == tconn) ? volume + 1 : 0;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002745
Lars Ellenberg543cc102011-03-10 22:18:18 +01002746 /* No more tconns/volumes/minors found results in an empty skb.
2747 * Which will terminate the dump. */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002748 return skb->len;
2749}
2750
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002751/*
2752 * Request status of all resources, or of all volumes within a single resource.
2753 *
2754 * This is a dump, as the answer may not fit in a single reply skb otherwise.
2755 * Which means we cannot use the family->attrbuf or other such members, because
2756 * dump is NOT protected by the genl_lock(). During dump, we only have access
2757 * to the incoming skb, and need to opencode "parsing" of the nlattr payload.
2758 *
2759 * Once things are setup properly, we call into get_one_status().
2760 */
2761int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb)
2762{
2763 const unsigned hdrlen = GENL_HDRLEN + GENL_MAGIC_FAMILY_HDRSZ;
2764 struct nlattr *nla;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002765 const char *resource_name;
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002766 struct drbd_tconn *tconn;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002767 int maxtype;
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002768
2769 /* Is this a followup call? */
2770 if (cb->args[0]) {
2771 /* ... of a single resource dump,
2772 * and the resource iterator has been advanced already? */
2773 if (cb->args[2] && cb->args[2] != cb->args[0])
2774 return 0; /* DONE. */
2775 goto dump;
2776 }
2777
2778 /* First call (from netlink_dump_start). We need to figure out
2779 * which resource(s) the user wants us to dump. */
2780 nla = nla_find(nlmsg_attrdata(cb->nlh, hdrlen),
2781 nlmsg_attrlen(cb->nlh, hdrlen),
2782 DRBD_NLA_CFG_CONTEXT);
2783
2784 /* No explicit context given. Dump all. */
2785 if (!nla)
2786 goto dump;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002787 maxtype = ARRAY_SIZE(drbd_cfg_context_nl_policy) - 1;
2788 nla = drbd_nla_find_nested(maxtype, nla, __nla_type(T_ctx_resource_name));
2789 if (IS_ERR(nla))
2790 return PTR_ERR(nla);
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002791 /* context given, but no name present? */
2792 if (!nla)
2793 return -EINVAL;
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002794 resource_name = nla_data(nla);
2795 tconn = conn_get_by_name(resource_name);
Philipp Reisner0ace9df2011-04-24 10:53:19 +02002796
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002797 if (!tconn)
2798 return -ENODEV;
2799
Philipp Reisner0ace9df2011-04-24 10:53:19 +02002800 kref_put(&tconn->kref, &conn_destroy); /* get_one_status() (re)validates tconn by itself */
2801
Lars Ellenberg71932ef2011-04-18 09:43:25 +02002802 /* prime iterators, and set "filter" mode mark:
2803 * only dump this tconn. */
2804 cb->args[0] = (long)tconn;
2805 /* cb->args[1] = 0; passed in this way. */
2806 cb->args[2] = (long)tconn;
2807
2808dump:
2809 return get_one_status(skb, cb);
2810}
2811
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002812int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info)
2813{
2814 enum drbd_ret_code retcode;
2815 struct timeout_parms tp;
2816 int err;
2817
2818 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2819 if (!adm_ctx.reply_skb)
2820 return retcode;
2821 if (retcode != NO_ERROR)
2822 goto out;
2823
2824 tp.timeout_type =
2825 adm_ctx.mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED :
2826 test_bit(USE_DEGR_WFC_T, &adm_ctx.mdev->flags) ? UT_DEGRADED :
2827 UT_DEFAULT;
2828
2829 err = timeout_parms_to_priv_skb(adm_ctx.reply_skb, &tp);
2830 if (err) {
2831 nlmsg_free(adm_ctx.reply_skb);
2832 return err;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002833 }
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002834out:
2835 drbd_adm_finish(info, retcode);
2836 return 0;
2837}
Lars Ellenberg873b0d52011-01-21 22:53:48 +01002838
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002839int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info)
2840{
2841 struct drbd_conf *mdev;
2842 enum drbd_ret_code retcode;
2843
2844 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2845 if (!adm_ctx.reply_skb)
2846 return retcode;
2847 if (retcode != NO_ERROR)
2848 goto out;
2849
2850 mdev = adm_ctx.mdev;
2851 if (info->attrs[DRBD_NLA_START_OV_PARMS]) {
2852 /* resume from last known position, if possible */
2853 struct start_ov_parms parms =
2854 { .ov_start_sector = mdev->ov_start_sector };
Lars Ellenbergf3990022011-03-23 14:31:09 +01002855 int err = start_ov_parms_from_attrs(&parms, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002856 if (err) {
2857 retcode = ERR_MANDATORY_TAG;
2858 drbd_msg_put_info(from_attrs_err_to_txt(err));
2859 goto out;
2860 }
2861 /* w_make_ov_request expects position to be aligned */
2862 mdev->ov_start_sector = parms.ov_start_sector & ~BM_SECT_PER_BIT;
2863 }
Lars Ellenberg873b0d52011-01-21 22:53:48 +01002864 /* If there is still bitmap IO pending, e.g. previous resync or verify
2865 * just being finished, wait for it before requesting a new resync. */
2866 wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002867 retcode = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
2868out:
2869 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002870 return 0;
2871}
2872
2873
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002874int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
Philipp Reisnerb411b362009-09-25 16:07:19 -07002875{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002876 struct drbd_conf *mdev;
2877 enum drbd_ret_code retcode;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002878 int skip_initial_sync = 0;
2879 int err;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002880 struct new_c_uuid_parms args;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002881
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002882 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2883 if (!adm_ctx.reply_skb)
2884 return retcode;
2885 if (retcode != NO_ERROR)
2886 goto out_nolock;
Philipp Reisnerb411b362009-09-25 16:07:19 -07002887
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002888 mdev = adm_ctx.mdev;
2889 memset(&args, 0, sizeof(args));
2890 if (info->attrs[DRBD_NLA_NEW_C_UUID_PARMS]) {
Lars Ellenbergf3990022011-03-23 14:31:09 +01002891 err = new_c_uuid_parms_from_attrs(&args, info);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002892 if (err) {
2893 retcode = ERR_MANDATORY_TAG;
2894 drbd_msg_put_info(from_attrs_err_to_txt(err));
2895 goto out_nolock;
2896 }
Philipp Reisnerb411b362009-09-25 16:07:19 -07002897 }
2898
Philipp Reisner8410da8f02011-02-11 20:11:10 +01002899 mutex_lock(mdev->state_mutex); /* Protects us against serialized state changes. */
Philipp Reisnerb411b362009-09-25 16:07:19 -07002900
2901 if (!get_ldev(mdev)) {
2902 retcode = ERR_NO_DISK;
2903 goto out;
2904 }
2905
2906 /* this is "skip initial sync", assume to be clean */
Philipp Reisner31890f42011-01-19 14:12:51 +01002907 if (mdev->state.conn == C_CONNECTED && mdev->tconn->agreed_pro_version >= 90 &&
Philipp Reisnerb411b362009-09-25 16:07:19 -07002908 mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) {
2909 dev_info(DEV, "Preparing to skip initial sync\n");
2910 skip_initial_sync = 1;
2911 } else if (mdev->state.conn != C_STANDALONE) {
2912 retcode = ERR_CONNECTED;
2913 goto out_dec;
2914 }
2915
2916 drbd_uuid_set(mdev, UI_BITMAP, 0); /* Rotate UI_BITMAP to History 1, etc... */
2917 drbd_uuid_new_current(mdev); /* New current, previous to UI_BITMAP */
2918
2919 if (args.clear_bm) {
Lars Ellenberg20ceb2b2011-01-21 10:56:44 +01002920 err = drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
2921 "clear_n_write from new_c_uuid", BM_LOCKED_MASK);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002922 if (err) {
2923 dev_err(DEV, "Writing bitmap failed with %d\n",err);
2924 retcode = ERR_IO_MD_DISK;
2925 }
2926 if (skip_initial_sync) {
2927 drbd_send_uuids_skip_initial_sync(mdev);
2928 _drbd_uuid_set(mdev, UI_BITMAP, 0);
Lars Ellenberg62b0da32011-01-20 13:25:21 +01002929 drbd_print_uuids(mdev, "cleared bitmap UUID");
Philipp Reisner87eeee42011-01-19 14:16:30 +01002930 spin_lock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002931 _drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
2932 CS_VERBOSE, NULL);
Philipp Reisner87eeee42011-01-19 14:16:30 +01002933 spin_unlock_irq(&mdev->tconn->req_lock);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002934 }
2935 }
2936
2937 drbd_md_sync(mdev);
2938out_dec:
2939 put_ldev(mdev);
2940out:
Philipp Reisner8410da8f02011-02-11 20:11:10 +01002941 mutex_unlock(mdev->state_mutex);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002942out_nolock:
2943 drbd_adm_finish(info, retcode);
Philipp Reisnerb411b362009-09-25 16:07:19 -07002944 return 0;
2945}
2946
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002947static enum drbd_ret_code
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002948drbd_check_resource_name(const char *name)
Philipp Reisner774b3052011-02-22 02:07:03 -05002949{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002950 if (!name || !name[0]) {
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002951 drbd_msg_put_info("resource name missing");
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002952 return ERR_MANDATORY_TAG;
2953 }
2954 /* if we want to use these in sysfs/configfs/debugfs some day,
2955 * we must not allow slashes */
2956 if (strchr(name, '/')) {
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002957 drbd_msg_put_info("invalid resource name");
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002958 return ERR_INVALID_REQUEST;
2959 }
2960 return NO_ERROR;
2961}
Philipp Reisner774b3052011-02-22 02:07:03 -05002962
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02002963int drbd_adm_new_resource(struct sk_buff *skb, struct genl_info *info)
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002964{
2965 enum drbd_ret_code retcode;
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002966 struct res_opts res_opts;
2967 int err;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002968
2969 retcode = drbd_adm_prepare(skb, info, 0);
2970 if (!adm_ctx.reply_skb)
2971 return retcode;
2972 if (retcode != NO_ERROR)
2973 goto out;
2974
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002975 set_res_opts_defaults(&res_opts);
2976 err = res_opts_from_attrs(&res_opts, info);
2977 if (err && err != -ENOMSG) {
2978 retcode = ERR_MANDATORY_TAG;
2979 drbd_msg_put_info(from_attrs_err_to_txt(err));
2980 goto out;
2981 }
2982
Andreas Gruenbacher7c3063c2011-06-09 17:52:12 +02002983 retcode = drbd_check_resource_name(adm_ctx.resource_name);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002984 if (retcode != NO_ERROR)
2985 goto out;
2986
2987 if (adm_ctx.tconn) {
Lars Ellenberg38f19612011-03-14 13:22:35 +01002988 if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) {
2989 retcode = ERR_INVALID_REQUEST;
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02002990 drbd_msg_put_info("resource exists");
Lars Ellenberg38f19612011-03-14 13:22:35 +01002991 }
2992 /* else: still NO_ERROR */
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002993 goto out;
Philipp Reisner774b3052011-02-22 02:07:03 -05002994 }
2995
Andreas Gruenbacherafbbfa82011-06-16 17:58:02 +02002996 if (!conn_create(adm_ctx.resource_name, &res_opts))
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01002997 retcode = ERR_NOMEM;
2998out:
2999 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003000 return 0;
3001}
3002
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003003int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info)
Philipp Reisner774b3052011-02-22 02:07:03 -05003004{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003005 struct drbd_genlmsghdr *dh = info->userhdr;
3006 enum drbd_ret_code retcode;
Philipp Reisner774b3052011-02-22 02:07:03 -05003007
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02003008 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003009 if (!adm_ctx.reply_skb)
3010 return retcode;
3011 if (retcode != NO_ERROR)
3012 goto out;
Philipp Reisner774b3052011-02-22 02:07:03 -05003013
Andreas Gruenbacherf2257a52011-07-14 16:00:40 +02003014 if (dh->minor > MINORMASK) {
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003015 drbd_msg_put_info("requested minor out of range");
3016 retcode = ERR_INVALID_REQUEST;
3017 goto out;
3018 }
Andreas Gruenbacher0c8e36d2011-03-30 16:00:17 +02003019 if (adm_ctx.volume > DRBD_VOLUME_MAX) {
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003020 drbd_msg_put_info("requested volume id out of range");
3021 retcode = ERR_INVALID_REQUEST;
3022 goto out;
Philipp Reisner774b3052011-02-22 02:07:03 -05003023 }
3024
Lars Ellenberg38f19612011-03-14 13:22:35 +01003025 /* drbd_adm_prepare made sure already
3026 * that mdev->tconn and mdev->vnr match the request. */
3027 if (adm_ctx.mdev) {
3028 if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
3029 retcode = ERR_MINOR_EXISTS;
3030 /* else: still NO_ERROR */
3031 goto out;
3032 }
3033
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003034 retcode = conn_new_minor(adm_ctx.tconn, dh->minor, adm_ctx.volume);
3035out:
3036 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003037 return 0;
3038}
3039
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003040static enum drbd_ret_code adm_delete_minor(struct drbd_conf *mdev)
3041{
3042 if (mdev->state.disk == D_DISKLESS &&
3043 /* no need to be mdev->state.conn == C_STANDALONE &&
3044 * we may want to delete a minor from a live replication group.
3045 */
3046 mdev->state.role == R_SECONDARY) {
Philipp Reisner369bea62011-07-06 23:04:44 +02003047 _drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS),
3048 CS_VERBOSE + CS_WAIT_COMPLETE);
Philipp Reisner81fa2e62011-05-04 15:10:30 +02003049 idr_remove(&mdev->tconn->volumes, mdev->vnr);
3050 idr_remove(&minors, mdev_to_minor(mdev));
3051 del_gendisk(mdev->vdisk);
3052 synchronize_rcu();
3053 kref_put(&mdev->kref, &drbd_minor_destroy);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003054 return NO_ERROR;
3055 } else
3056 return ERR_MINOR_CONFIGURED;
3057}
3058
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003059int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info)
Philipp Reisner774b3052011-02-22 02:07:03 -05003060{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003061 enum drbd_ret_code retcode;
3062
3063 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
3064 if (!adm_ctx.reply_skb)
3065 return retcode;
3066 if (retcode != NO_ERROR)
3067 goto out;
3068
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003069 retcode = adm_delete_minor(adm_ctx.mdev);
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003070out:
3071 drbd_adm_finish(info, retcode);
3072 return 0;
3073}
3074
3075int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
3076{
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003077 int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003078 struct drbd_conf *mdev;
3079 unsigned i;
3080
3081 retcode = drbd_adm_prepare(skb, info, 0);
3082 if (!adm_ctx.reply_skb)
3083 return retcode;
3084 if (retcode != NO_ERROR)
3085 goto out;
3086
3087 if (!adm_ctx.tconn) {
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003088 retcode = ERR_RES_NOT_KNOWN;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003089 goto out;
3090 }
3091
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003092 /* demote */
3093 idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
3094 retcode = drbd_set_role(mdev, R_SECONDARY, 0);
3095 if (retcode < SS_SUCCESS) {
3096 drbd_msg_put_info("failed to demote");
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02003097 goto out;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003098 }
3099 }
3100
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003101 retcode = conn_try_disconnect(adm_ctx.tconn, 0);
3102 if (retcode < SS_SUCCESS) {
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003103 drbd_msg_put_info("failed to disconnect");
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003104 goto out;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003105 }
3106
3107 /* detach */
3108 idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
Philipp Reisnercdfda632011-07-05 15:38:59 +02003109 retcode = adm_detach(mdev, 0);
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003110 if (retcode < SS_SUCCESS) {
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003111 drbd_msg_put_info("failed to detach");
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 /* If we reach this, all volumes (of this tconn) are Secondary,
3117 * Disconnected, Diskless, aka Unconfigured. Make sure all threads have
Philipp Reisnerc141ebd2011-05-05 16:13:10 +02003118 * actually stopped, state handling only does drbd_thread_stop_nowait(). */
Lars Ellenbergf3dfa402011-05-02 10:45:05 +02003119 drbd_thread_stop(&adm_ctx.tconn->worker);
3120
3121 /* Now, nothing can fail anymore */
3122
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003123 /* delete volumes */
3124 idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
3125 retcode = adm_delete_minor(mdev);
3126 if (retcode != NO_ERROR) {
3127 /* "can not happen" */
3128 drbd_msg_put_info("failed to delete volume");
Philipp Reisneref356262011-04-13 14:21:29 -07003129 goto out;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003130 }
3131 }
3132
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003133 /* delete connection */
3134 if (conn_lowest_minor(adm_ctx.tconn) < 0) {
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02003135 list_del_rcu(&adm_ctx.tconn->all_tconn);
3136 synchronize_rcu();
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02003137 kref_put(&adm_ctx.tconn->kref, &conn_destroy);
3138
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003139 retcode = NO_ERROR;
3140 } else {
3141 /* "can not happen" */
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003142 retcode = ERR_RES_IN_USE;
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003143 drbd_msg_put_info("failed to delete connection");
Lars Ellenberg85f75dd72011-03-15 16:26:37 +01003144 }
Philipp Reisneref356262011-04-13 14:21:29 -07003145 goto out;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003146out:
3147 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003148 return 0;
3149}
3150
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003151int drbd_adm_del_resource(struct sk_buff *skb, struct genl_info *info)
Philipp Reisner774b3052011-02-22 02:07:03 -05003152{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003153 enum drbd_ret_code retcode;
3154
Andreas Gruenbacher44e52cf2011-06-14 16:07:32 +02003155 retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003156 if (!adm_ctx.reply_skb)
3157 return retcode;
3158 if (retcode != NO_ERROR)
3159 goto out;
3160
3161 if (conn_lowest_minor(adm_ctx.tconn) < 0) {
Philipp Reisnerec0bddb2011-05-04 15:47:01 +02003162 list_del_rcu(&adm_ctx.tconn->all_tconn);
3163 synchronize_rcu();
Philipp Reisner9dc9fbb2011-04-22 15:23:32 +02003164 kref_put(&adm_ctx.tconn->kref, &conn_destroy);
3165
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003166 retcode = NO_ERROR;
Philipp Reisner774b3052011-02-22 02:07:03 -05003167 } else {
Andreas Gruenbacher789c1b62011-06-06 16:16:44 +02003168 retcode = ERR_RES_IN_USE;
Philipp Reisner774b3052011-02-22 02:07:03 -05003169 }
3170
Lars Ellenberg992d6e92011-05-02 11:47:18 +02003171 if (retcode == NO_ERROR)
3172 drbd_thread_stop(&adm_ctx.tconn->worker);
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003173out:
3174 drbd_adm_finish(info, retcode);
Philipp Reisner774b3052011-02-22 02:07:03 -05003175 return 0;
3176}
3177
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003178void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib)
Philipp Reisnerb411b362009-09-25 16:07:19 -07003179{
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003180 static atomic_t drbd_genl_seq = ATOMIC_INIT(2); /* two. */
3181 struct sk_buff *msg;
3182 struct drbd_genlmsghdr *d_out;
3183 unsigned seq;
3184 int err = -ENOMEM;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003185
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003186 seq = atomic_inc_return(&drbd_genl_seq);
3187 msg = genlmsg_new(NLMSG_GOODSIZE, GFP_NOIO);
3188 if (!msg)
3189 goto failed;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003190
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003191 err = -EMSGSIZE;
3192 d_out = genlmsg_put(msg, 0, seq, &drbd_genl_family, 0, DRBD_EVENT);
3193 if (!d_out) /* cannot happen, but anyways. */
3194 goto nla_put_failure;
3195 d_out->minor = mdev_to_minor(mdev);
Andreas Gruenbacher6f9b5f82011-05-06 01:03:32 +02003196 d_out->ret_code = NO_ERROR;
Philipp Reisner9f5180e2009-10-06 09:30:14 +02003197
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003198 if (nla_put_status_info(msg, mdev, sib))
3199 goto nla_put_failure;
3200 genlmsg_end(msg, d_out);
3201 err = drbd_genl_multicast_events(msg, 0);
3202 /* msg has been consumed or freed in netlink_broadcast() */
3203 if (err && err != -ESRCH)
3204 goto failed;
Philipp Reisnerb411b362009-09-25 16:07:19 -07003205
Philipp Reisnerb411b362009-09-25 16:07:19 -07003206 return;
Lars Ellenberg3b98c0c2011-03-07 12:49:34 +01003207
3208nla_put_failure:
3209 nlmsg_free(msg);
3210failed:
3211 dev_err(DEV, "Error %d while broadcasting event. "
3212 "Event seq:%u sib_reason:%u\n",
3213 err, seq, sib->sib_reason);
Philipp Reisnerb411b362009-09-25 16:07:19 -07003214}