xref: /openbmc/linux/drivers/block/drbd/drbd_nl.c (revision e23feb16)
1 /*
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 
26 #include <linux/module.h>
27 #include <linux/drbd.h>
28 #include <linux/in.h>
29 #include <linux/fs.h>
30 #include <linux/file.h>
31 #include <linux/slab.h>
32 #include <linux/blkpg.h>
33 #include <linux/cpumask.h>
34 #include "drbd_int.h"
35 #include "drbd_req.h"
36 #include "drbd_wrappers.h"
37 #include <asm/unaligned.h>
38 #include <linux/drbd_limits.h>
39 #include <linux/kthread.h>
40 
41 #include <net/genetlink.h>
42 
43 /* .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 
47 int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info);
48 int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info);
49 
50 int drbd_adm_new_resource(struct sk_buff *skb, struct genl_info *info);
51 int drbd_adm_del_resource(struct sk_buff *skb, struct genl_info *info);
52 int drbd_adm_down(struct sk_buff *skb, struct genl_info *info);
53 
54 int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info);
55 int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info);
56 int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info);
57 int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info);
58 int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info);
59 int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info);
60 int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info);
61 int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info);
62 int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info);
63 int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info);
64 int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info);
65 int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info);
66 int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info);
67 int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info);
68 int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info);
69 int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info);
70 int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info);
71 int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info);
72 int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info);
73 int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info);
74 /* .dumpit */
75 int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb);
76 
77 #include <linux/drbd_genl_api.h>
78 #include "drbd_nla.h"
79 #include <linux/genl_magic_func.h>
80 
81 /* used blkdev_get_by_path, to claim our meta data device(s) */
82 static char *drbd_m_holder = "Hands off! this is DRBD's meta data device.";
83 
84 /* 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  */
88 static 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! */
96 	char *resource_name;
97 	struct nlattr *my_addr;
98 	struct nlattr *peer_addr;
99 
100 	/* 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 
109 static 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");
114 }
115 
116 /* 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. */
118 int drbd_msg_put_info(const char *info)
119 {
120 	struct sk_buff *skb = adm_ctx.reply_skb;
121 	struct nlattr *nla;
122 	int err = -EMSGSIZE;
123 
124 	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
146 #define DRBD_ADM_NEED_RESOURCE	2
147 #define DRBD_ADM_NEED_CONNECTION 4
148 static 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 && !capable(CAP_NET_ADMIN))
159 	       return -EPERM;
160 
161 	adm_ctx.reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
162 	if (!adm_ctx.reply_skb) {
163 		err = -ENOMEM;
164 		goto fail;
165 	}
166 
167 	adm_ctx.reply_dh = genlmsg_put_reply(adm_ctx.reply_skb,
168 					info, &drbd_genl_family, 0, cmd);
169 	/* put of a few bytes into a fresh skb of >= 4k will always succeed.
170 	 * but anyways */
171 	if (!adm_ctx.reply_dh) {
172 		err = -ENOMEM;
173 		goto fail;
174 	}
175 
176 	adm_ctx.reply_dh->minor = d_in->minor;
177 	adm_ctx.reply_dh->ret_code = NO_ERROR;
178 
179 	adm_ctx.volume = VOLUME_UNSPECIFIED;
180 	if (info->attrs[DRBD_NLA_CFG_CONTEXT]) {
181 		struct nlattr *nla;
182 		/* parse and validate only */
183 		err = drbd_cfg_context_from_attrs(NULL, info);
184 		if (err)
185 			goto fail;
186 
187 		/* It was present, and valid,
188 		 * copy it over to the reply skb. */
189 		err = nla_put_nohdr(adm_ctx.reply_skb,
190 				info->attrs[DRBD_NLA_CFG_CONTEXT]->nla_len,
191 				info->attrs[DRBD_NLA_CFG_CONTEXT]);
192 		if (err)
193 			goto fail;
194 
195 		/* and assign stuff to the global adm_ctx */
196 		nla = nested_attr_tb[__nla_type(T_ctx_volume)];
197 		if (nla)
198 			adm_ctx.volume = nla_get_u32(nla);
199 		nla = nested_attr_tb[__nla_type(T_ctx_resource_name)];
200 		if (nla)
201 			adm_ctx.resource_name = nla_data(nla);
202 		adm_ctx.my_addr = nested_attr_tb[__nla_type(T_ctx_my_addr)];
203 		adm_ctx.peer_addr = nested_attr_tb[__nla_type(T_ctx_peer_addr)];
204 		if ((adm_ctx.my_addr &&
205 		     nla_len(adm_ctx.my_addr) > sizeof(adm_ctx.tconn->my_addr)) ||
206 		    (adm_ctx.peer_addr &&
207 		     nla_len(adm_ctx.peer_addr) > sizeof(adm_ctx.tconn->peer_addr))) {
208 			err = -EINVAL;
209 			goto fail;
210 		}
211 	}
212 
213 	adm_ctx.minor = d_in->minor;
214 	adm_ctx.mdev = minor_to_mdev(d_in->minor);
215 	adm_ctx.tconn = conn_get_by_name(adm_ctx.resource_name);
216 
217 	if (!adm_ctx.mdev && (flags & DRBD_ADM_NEED_MINOR)) {
218 		drbd_msg_put_info("unknown minor");
219 		return ERR_MINOR_INVALID;
220 	}
221 	if (!adm_ctx.tconn && (flags & DRBD_ADM_NEED_RESOURCE)) {
222 		drbd_msg_put_info("unknown resource");
223 		return ERR_INVALID_REQUEST;
224 	}
225 
226 	if (flags & DRBD_ADM_NEED_CONNECTION) {
227 		if (adm_ctx.tconn && !(flags & DRBD_ADM_NEED_RESOURCE)) {
228 			drbd_msg_put_info("no resource name expected");
229 			return ERR_INVALID_REQUEST;
230 		}
231 		if (adm_ctx.mdev) {
232 			drbd_msg_put_info("no minor number expected");
233 			return ERR_INVALID_REQUEST;
234 		}
235 		if (adm_ctx.my_addr && adm_ctx.peer_addr)
236 			adm_ctx.tconn = conn_get_by_addrs(nla_data(adm_ctx.my_addr),
237 							  nla_len(adm_ctx.my_addr),
238 							  nla_data(adm_ctx.peer_addr),
239 							  nla_len(adm_ctx.peer_addr));
240 		if (!adm_ctx.tconn) {
241 			drbd_msg_put_info("unknown connection");
242 			return ERR_INVALID_REQUEST;
243 		}
244 	}
245 
246 	/* some more paranoia, if the request was over-determined */
247 	if (adm_ctx.mdev && adm_ctx.tconn &&
248 	    adm_ctx.mdev->tconn != adm_ctx.tconn) {
249 		pr_warning("request: minor=%u, resource=%s; but that minor belongs to connection %s\n",
250 				adm_ctx.minor, adm_ctx.resource_name,
251 				adm_ctx.mdev->tconn->name);
252 		drbd_msg_put_info("minor exists in different resource");
253 		return ERR_INVALID_REQUEST;
254 	}
255 	if (adm_ctx.mdev &&
256 	    adm_ctx.volume != VOLUME_UNSPECIFIED &&
257 	    adm_ctx.volume != adm_ctx.mdev->vnr) {
258 		pr_warning("request: minor=%u, volume=%u; but that minor is volume %u in %s\n",
259 				adm_ctx.minor, adm_ctx.volume,
260 				adm_ctx.mdev->vnr, adm_ctx.mdev->tconn->name);
261 		drbd_msg_put_info("minor exists as different volume");
262 		return ERR_INVALID_REQUEST;
263 	}
264 
265 	return NO_ERROR;
266 
267 fail:
268 	nlmsg_free(adm_ctx.reply_skb);
269 	adm_ctx.reply_skb = NULL;
270 	return err;
271 }
272 
273 static int drbd_adm_finish(struct genl_info *info, int retcode)
274 {
275 	if (adm_ctx.tconn) {
276 		kref_put(&adm_ctx.tconn->kref, &conn_destroy);
277 		adm_ctx.tconn = NULL;
278 	}
279 
280 	if (!adm_ctx.reply_skb)
281 		return -ENOMEM;
282 
283 	adm_ctx.reply_dh->ret_code = retcode;
284 	drbd_adm_send_reply(adm_ctx.reply_skb, info);
285 	return 0;
286 }
287 
288 static void setup_khelper_env(struct drbd_tconn *tconn, char **envp)
289 {
290 	char *afs;
291 
292 	/* FIXME: A future version will not allow this case. */
293 	if (tconn->my_addr_len == 0 || tconn->peer_addr_len == 0)
294 		return;
295 
296 	switch (((struct sockaddr *)&tconn->peer_addr)->sa_family) {
297 	case AF_INET6:
298 		afs = "ipv6";
299 		snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI6",
300 			 &((struct sockaddr_in6 *)&tconn->peer_addr)->sin6_addr);
301 		break;
302 	case AF_INET:
303 		afs = "ipv4";
304 		snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
305 			 &((struct sockaddr_in *)&tconn->peer_addr)->sin_addr);
306 		break;
307 	default:
308 		afs = "ssocks";
309 		snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
310 			 &((struct sockaddr_in *)&tconn->peer_addr)->sin_addr);
311 	}
312 	snprintf(envp[3], 20, "DRBD_PEER_AF=%s", afs);
313 }
314 
315 int drbd_khelper(struct drbd_conf *mdev, char *cmd)
316 {
317 	char *envp[] = { "HOME=/",
318 			"TERM=linux",
319 			"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
320 			 (char[20]) { }, /* address family */
321 			 (char[60]) { }, /* address */
322 			NULL };
323 	char mb[12];
324 	char *argv[] = {usermode_helper, cmd, mb, NULL };
325 	struct drbd_tconn *tconn = mdev->tconn;
326 	struct sib_info sib;
327 	int ret;
328 
329 	if (current == tconn->worker.task)
330 		set_bit(CALLBACK_PENDING, &tconn->flags);
331 
332 	snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev));
333 	setup_khelper_env(tconn, envp);
334 
335 	/* The helper may take some time.
336 	 * write out any unsynced meta data changes now */
337 	drbd_md_sync(mdev);
338 
339 	dev_info(DEV, "helper command: %s %s %s\n", usermode_helper, cmd, mb);
340 	sib.sib_reason = SIB_HELPER_PRE;
341 	sib.helper_name = cmd;
342 	drbd_bcast_event(mdev, &sib);
343 	ret = call_usermodehelper(usermode_helper, argv, envp, UMH_WAIT_PROC);
344 	if (ret)
345 		dev_warn(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
346 				usermode_helper, cmd, mb,
347 				(ret >> 8) & 0xff, ret);
348 	else
349 		dev_info(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
350 				usermode_helper, cmd, mb,
351 				(ret >> 8) & 0xff, ret);
352 	sib.sib_reason = SIB_HELPER_POST;
353 	sib.helper_exit_code = ret;
354 	drbd_bcast_event(mdev, &sib);
355 
356 	if (current == tconn->worker.task)
357 		clear_bit(CALLBACK_PENDING, &tconn->flags);
358 
359 	if (ret < 0) /* Ignore any ERRNOs we got. */
360 		ret = 0;
361 
362 	return ret;
363 }
364 
365 int conn_khelper(struct drbd_tconn *tconn, char *cmd)
366 {
367 	char *envp[] = { "HOME=/",
368 			"TERM=linux",
369 			"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
370 			 (char[20]) { }, /* address family */
371 			 (char[60]) { }, /* address */
372 			NULL };
373 	char *argv[] = {usermode_helper, cmd, tconn->name, NULL };
374 	int ret;
375 
376 	setup_khelper_env(tconn, envp);
377 	conn_md_sync(tconn);
378 
379 	conn_info(tconn, "helper command: %s %s %s\n", usermode_helper, cmd, tconn->name);
380 	/* TODO: conn_bcast_event() ?? */
381 
382 	ret = call_usermodehelper(usermode_helper, argv, envp, UMH_WAIT_PROC);
383 	if (ret)
384 		conn_warn(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
385 			  usermode_helper, cmd, tconn->name,
386 			  (ret >> 8) & 0xff, ret);
387 	else
388 		conn_info(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
389 			  usermode_helper, cmd, tconn->name,
390 			  (ret >> 8) & 0xff, ret);
391 	/* TODO: conn_bcast_event() ?? */
392 
393 	if (ret < 0) /* Ignore any ERRNOs we got. */
394 		ret = 0;
395 
396 	return ret;
397 }
398 
399 static enum drbd_fencing_p highest_fencing_policy(struct drbd_tconn *tconn)
400 {
401 	enum drbd_fencing_p fp = FP_NOT_AVAIL;
402 	struct drbd_conf *mdev;
403 	int vnr;
404 
405 	rcu_read_lock();
406 	idr_for_each_entry(&tconn->volumes, mdev, vnr) {
407 		if (get_ldev_if_state(mdev, D_CONSISTENT)) {
408 			fp = max_t(enum drbd_fencing_p, fp,
409 				   rcu_dereference(mdev->ldev->disk_conf)->fencing);
410 			put_ldev(mdev);
411 		}
412 	}
413 	rcu_read_unlock();
414 
415 	return fp;
416 }
417 
418 bool conn_try_outdate_peer(struct drbd_tconn *tconn)
419 {
420 	unsigned int connect_cnt;
421 	union drbd_state mask = { };
422 	union drbd_state val = { };
423 	enum drbd_fencing_p fp;
424 	char *ex_to_string;
425 	int r;
426 
427 	if (tconn->cstate >= C_WF_REPORT_PARAMS) {
428 		conn_err(tconn, "Expected cstate < C_WF_REPORT_PARAMS\n");
429 		return false;
430 	}
431 
432 	spin_lock_irq(&tconn->req_lock);
433 	connect_cnt = tconn->connect_cnt;
434 	spin_unlock_irq(&tconn->req_lock);
435 
436 	fp = highest_fencing_policy(tconn);
437 	switch (fp) {
438 	case FP_NOT_AVAIL:
439 		conn_warn(tconn, "Not fencing peer, I'm not even Consistent myself.\n");
440 		goto out;
441 	case FP_DONT_CARE:
442 		return true;
443 	default: ;
444 	}
445 
446 	r = conn_khelper(tconn, "fence-peer");
447 
448 	switch ((r>>8) & 0xff) {
449 	case 3: /* peer is inconsistent */
450 		ex_to_string = "peer is inconsistent or worse";
451 		mask.pdsk = D_MASK;
452 		val.pdsk = D_INCONSISTENT;
453 		break;
454 	case 4: /* peer got outdated, or was already outdated */
455 		ex_to_string = "peer was fenced";
456 		mask.pdsk = D_MASK;
457 		val.pdsk = D_OUTDATED;
458 		break;
459 	case 5: /* peer was down */
460 		if (conn_highest_disk(tconn) == D_UP_TO_DATE) {
461 			/* we will(have) create(d) a new UUID anyways... */
462 			ex_to_string = "peer is unreachable, assumed to be dead";
463 			mask.pdsk = D_MASK;
464 			val.pdsk = D_OUTDATED;
465 		} else {
466 			ex_to_string = "peer unreachable, doing nothing since disk != UpToDate";
467 		}
468 		break;
469 	case 6: /* Peer is primary, voluntarily outdate myself.
470 		 * This is useful when an unconnected R_SECONDARY is asked to
471 		 * become R_PRIMARY, but finds the other peer being active. */
472 		ex_to_string = "peer is active";
473 		conn_warn(tconn, "Peer is primary, outdating myself.\n");
474 		mask.disk = D_MASK;
475 		val.disk = D_OUTDATED;
476 		break;
477 	case 7:
478 		if (fp != FP_STONITH)
479 			conn_err(tconn, "fence-peer() = 7 && fencing != Stonith !!!\n");
480 		ex_to_string = "peer was stonithed";
481 		mask.pdsk = D_MASK;
482 		val.pdsk = D_OUTDATED;
483 		break;
484 	default:
485 		/* The script is broken ... */
486 		conn_err(tconn, "fence-peer helper broken, returned %d\n", (r>>8)&0xff);
487 		return false; /* Eventually leave IO frozen */
488 	}
489 
490 	conn_info(tconn, "fence-peer helper returned %d (%s)\n",
491 		  (r>>8) & 0xff, ex_to_string);
492 
493  out:
494 
495 	/* Not using
496 	   conn_request_state(tconn, mask, val, CS_VERBOSE);
497 	   here, because we might were able to re-establish the connection in the
498 	   meantime. */
499 	spin_lock_irq(&tconn->req_lock);
500 	if (tconn->cstate < C_WF_REPORT_PARAMS && !test_bit(STATE_SENT, &tconn->flags)) {
501 		if (tconn->connect_cnt != connect_cnt)
502 			/* In case the connection was established and droped
503 			   while the fence-peer handler was running, ignore it */
504 			conn_info(tconn, "Ignoring fence-peer exit code\n");
505 		else
506 			_conn_request_state(tconn, mask, val, CS_VERBOSE);
507 	}
508 	spin_unlock_irq(&tconn->req_lock);
509 
510 	return conn_highest_pdsk(tconn) <= D_OUTDATED;
511 }
512 
513 static int _try_outdate_peer_async(void *data)
514 {
515 	struct drbd_tconn *tconn = (struct drbd_tconn *)data;
516 
517 	conn_try_outdate_peer(tconn);
518 
519 	kref_put(&tconn->kref, &conn_destroy);
520 	return 0;
521 }
522 
523 void conn_try_outdate_peer_async(struct drbd_tconn *tconn)
524 {
525 	struct task_struct *opa;
526 
527 	kref_get(&tconn->kref);
528 	opa = kthread_run(_try_outdate_peer_async, tconn, "drbd_async_h");
529 	if (IS_ERR(opa)) {
530 		conn_err(tconn, "out of mem, failed to invoke fence-peer helper\n");
531 		kref_put(&tconn->kref, &conn_destroy);
532 	}
533 }
534 
535 enum drbd_state_rv
536 drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
537 {
538 	const int max_tries = 4;
539 	enum drbd_state_rv rv = SS_UNKNOWN_ERROR;
540 	struct net_conf *nc;
541 	int try = 0;
542 	int forced = 0;
543 	union drbd_state mask, val;
544 
545 	if (new_role == R_PRIMARY)
546 		request_ping(mdev->tconn); /* Detect a dead peer ASAP */
547 
548 	mutex_lock(mdev->state_mutex);
549 
550 	mask.i = 0; mask.role = R_MASK;
551 	val.i  = 0; val.role  = new_role;
552 
553 	while (try++ < max_tries) {
554 		rv = _drbd_request_state(mdev, mask, val, CS_WAIT_COMPLETE);
555 
556 		/* in case we first succeeded to outdate,
557 		 * but now suddenly could establish a connection */
558 		if (rv == SS_CW_FAILED_BY_PEER && mask.pdsk != 0) {
559 			val.pdsk = 0;
560 			mask.pdsk = 0;
561 			continue;
562 		}
563 
564 		if (rv == SS_NO_UP_TO_DATE_DISK && force &&
565 		    (mdev->state.disk < D_UP_TO_DATE &&
566 		     mdev->state.disk >= D_INCONSISTENT)) {
567 			mask.disk = D_MASK;
568 			val.disk  = D_UP_TO_DATE;
569 			forced = 1;
570 			continue;
571 		}
572 
573 		if (rv == SS_NO_UP_TO_DATE_DISK &&
574 		    mdev->state.disk == D_CONSISTENT && mask.pdsk == 0) {
575 			D_ASSERT(mdev->state.pdsk == D_UNKNOWN);
576 
577 			if (conn_try_outdate_peer(mdev->tconn)) {
578 				val.disk = D_UP_TO_DATE;
579 				mask.disk = D_MASK;
580 			}
581 			continue;
582 		}
583 
584 		if (rv == SS_NOTHING_TO_DO)
585 			goto out;
586 		if (rv == SS_PRIMARY_NOP && mask.pdsk == 0) {
587 			if (!conn_try_outdate_peer(mdev->tconn) && force) {
588 				dev_warn(DEV, "Forced into split brain situation!\n");
589 				mask.pdsk = D_MASK;
590 				val.pdsk  = D_OUTDATED;
591 
592 			}
593 			continue;
594 		}
595 		if (rv == SS_TWO_PRIMARIES) {
596 			/* Maybe the peer is detected as dead very soon...
597 			   retry at most once more in this case. */
598 			int timeo;
599 			rcu_read_lock();
600 			nc = rcu_dereference(mdev->tconn->net_conf);
601 			timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
602 			rcu_read_unlock();
603 			schedule_timeout_interruptible(timeo);
604 			if (try < max_tries)
605 				try = max_tries - 1;
606 			continue;
607 		}
608 		if (rv < SS_SUCCESS) {
609 			rv = _drbd_request_state(mdev, mask, val,
610 						CS_VERBOSE + CS_WAIT_COMPLETE);
611 			if (rv < SS_SUCCESS)
612 				goto out;
613 		}
614 		break;
615 	}
616 
617 	if (rv < SS_SUCCESS)
618 		goto out;
619 
620 	if (forced)
621 		dev_warn(DEV, "Forced to consider local data as UpToDate!\n");
622 
623 	/* Wait until nothing is on the fly :) */
624 	wait_event(mdev->misc_wait, atomic_read(&mdev->ap_pending_cnt) == 0);
625 
626 	/* FIXME also wait for all pending P_BARRIER_ACK? */
627 
628 	if (new_role == R_SECONDARY) {
629 		set_disk_ro(mdev->vdisk, true);
630 		if (get_ldev(mdev)) {
631 			mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
632 			put_ldev(mdev);
633 		}
634 	} else {
635 		mutex_lock(&mdev->tconn->conf_update);
636 		nc = mdev->tconn->net_conf;
637 		if (nc)
638 			nc->discard_my_data = 0; /* without copy; single bit op is atomic */
639 		mutex_unlock(&mdev->tconn->conf_update);
640 
641 		set_disk_ro(mdev->vdisk, false);
642 		if (get_ldev(mdev)) {
643 			if (((mdev->state.conn < C_CONNECTED ||
644 			       mdev->state.pdsk <= D_FAILED)
645 			      && mdev->ldev->md.uuid[UI_BITMAP] == 0) || forced)
646 				drbd_uuid_new_current(mdev);
647 
648 			mdev->ldev->md.uuid[UI_CURRENT] |=  (u64)1;
649 			put_ldev(mdev);
650 		}
651 	}
652 
653 	/* writeout of activity log covered areas of the bitmap
654 	 * to stable storage done in after state change already */
655 
656 	if (mdev->state.conn >= C_WF_REPORT_PARAMS) {
657 		/* if this was forced, we should consider sync */
658 		if (forced)
659 			drbd_send_uuids(mdev);
660 		drbd_send_current_state(mdev);
661 	}
662 
663 	drbd_md_sync(mdev);
664 
665 	kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
666 out:
667 	mutex_unlock(mdev->state_mutex);
668 	return rv;
669 }
670 
671 static const char *from_attrs_err_to_txt(int err)
672 {
673 	return	err == -ENOMSG ? "required attribute missing" :
674 		err == -EOPNOTSUPP ? "unknown mandatory attribute" :
675 		err == -EEXIST ? "can not change invariant setting" :
676 		"invalid attribute value";
677 }
678 
679 int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info)
680 {
681 	struct set_role_parms parms;
682 	int err;
683 	enum drbd_ret_code retcode;
684 
685 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
686 	if (!adm_ctx.reply_skb)
687 		return retcode;
688 	if (retcode != NO_ERROR)
689 		goto out;
690 
691 	memset(&parms, 0, sizeof(parms));
692 	if (info->attrs[DRBD_NLA_SET_ROLE_PARMS]) {
693 		err = set_role_parms_from_attrs(&parms, info);
694 		if (err) {
695 			retcode = ERR_MANDATORY_TAG;
696 			drbd_msg_put_info(from_attrs_err_to_txt(err));
697 			goto out;
698 		}
699 	}
700 
701 	if (info->genlhdr->cmd == DRBD_ADM_PRIMARY)
702 		retcode = drbd_set_role(adm_ctx.mdev, R_PRIMARY, parms.assume_uptodate);
703 	else
704 		retcode = drbd_set_role(adm_ctx.mdev, R_SECONDARY, 0);
705 out:
706 	drbd_adm_finish(info, retcode);
707 	return 0;
708 }
709 
710 /* Initializes the md.*_offset members, so we are able to find
711  * the on disk meta data.
712  *
713  * We currently have two possible layouts:
714  * external:
715  *   |----------- md_size_sect ------------------|
716  *   [ 4k superblock ][ activity log ][  Bitmap  ]
717  *   | al_offset == 8 |
718  *   | bm_offset = al_offset + X      |
719  *  ==> bitmap sectors = md_size_sect - bm_offset
720  *
721  * internal:
722  *            |----------- md_size_sect ------------------|
723  * [data.....][  Bitmap  ][ activity log ][ 4k superblock ]
724  *                        | al_offset < 0 |
725  *            | bm_offset = al_offset - Y |
726  *  ==> bitmap sectors = Y = al_offset - bm_offset
727  *
728  *  Activity log size used to be fixed 32kB,
729  *  but is about to become configurable.
730  */
731 static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
732 				       struct drbd_backing_dev *bdev)
733 {
734 	sector_t md_size_sect = 0;
735 	unsigned int al_size_sect = bdev->md.al_size_4k * 8;
736 
737 	bdev->md.md_offset = drbd_md_ss(bdev);
738 
739 	switch (bdev->md.meta_dev_idx) {
740 	default:
741 		/* v07 style fixed size indexed meta data */
742 		bdev->md.md_size_sect = MD_128MB_SECT;
743 		bdev->md.al_offset = MD_4kB_SECT;
744 		bdev->md.bm_offset = MD_4kB_SECT + al_size_sect;
745 		break;
746 	case DRBD_MD_INDEX_FLEX_EXT:
747 		/* just occupy the full device; unit: sectors */
748 		bdev->md.md_size_sect = drbd_get_capacity(bdev->md_bdev);
749 		bdev->md.al_offset = MD_4kB_SECT;
750 		bdev->md.bm_offset = MD_4kB_SECT + al_size_sect;
751 		break;
752 	case DRBD_MD_INDEX_INTERNAL:
753 	case DRBD_MD_INDEX_FLEX_INT:
754 		/* al size is still fixed */
755 		bdev->md.al_offset = -al_size_sect;
756 		/* we need (slightly less than) ~ this much bitmap sectors: */
757 		md_size_sect = drbd_get_capacity(bdev->backing_bdev);
758 		md_size_sect = ALIGN(md_size_sect, BM_SECT_PER_EXT);
759 		md_size_sect = BM_SECT_TO_EXT(md_size_sect);
760 		md_size_sect = ALIGN(md_size_sect, 8);
761 
762 		/* plus the "drbd meta data super block",
763 		 * and the activity log; */
764 		md_size_sect += MD_4kB_SECT + al_size_sect;
765 
766 		bdev->md.md_size_sect = md_size_sect;
767 		/* bitmap offset is adjusted by 'super' block size */
768 		bdev->md.bm_offset   = -md_size_sect + MD_4kB_SECT;
769 		break;
770 	}
771 }
772 
773 /* input size is expected to be in KB */
774 char *ppsize(char *buf, unsigned long long size)
775 {
776 	/* Needs 9 bytes at max including trailing NUL:
777 	 * -1ULL ==> "16384 EB" */
778 	static char units[] = { 'K', 'M', 'G', 'T', 'P', 'E' };
779 	int base = 0;
780 	while (size >= 10000 && base < sizeof(units)-1) {
781 		/* shift + round */
782 		size = (size >> 10) + !!(size & (1<<9));
783 		base++;
784 	}
785 	sprintf(buf, "%u %cB", (unsigned)size, units[base]);
786 
787 	return buf;
788 }
789 
790 /* there is still a theoretical deadlock when called from receiver
791  * on an D_INCONSISTENT R_PRIMARY:
792  *  remote READ does inc_ap_bio, receiver would need to receive answer
793  *  packet from remote to dec_ap_bio again.
794  *  receiver receive_sizes(), comes here,
795  *  waits for ap_bio_cnt == 0. -> deadlock.
796  * but this cannot happen, actually, because:
797  *  R_PRIMARY D_INCONSISTENT, and peer's disk is unreachable
798  *  (not connected, or bad/no disk on peer):
799  *  see drbd_fail_request_early, ap_bio_cnt is zero.
800  *  R_PRIMARY D_INCONSISTENT, and C_SYNC_TARGET:
801  *  peer may not initiate a resize.
802  */
803 /* Note these are not to be confused with
804  * drbd_adm_suspend_io/drbd_adm_resume_io,
805  * which are (sub) state changes triggered by admin (drbdsetup),
806  * and can be long lived.
807  * This changes an mdev->flag, is triggered by drbd internals,
808  * and should be short-lived. */
809 void drbd_suspend_io(struct drbd_conf *mdev)
810 {
811 	set_bit(SUSPEND_IO, &mdev->flags);
812 	if (drbd_suspended(mdev))
813 		return;
814 	wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
815 }
816 
817 void drbd_resume_io(struct drbd_conf *mdev)
818 {
819 	clear_bit(SUSPEND_IO, &mdev->flags);
820 	wake_up(&mdev->misc_wait);
821 }
822 
823 /**
824  * drbd_determine_dev_size() -  Sets the right device size obeying all constraints
825  * @mdev:	DRBD device.
826  *
827  * Returns 0 on success, negative return values indicate errors.
828  * You should call drbd_md_sync() after calling this function.
829  */
830 enum determine_dev_size
831 drbd_determine_dev_size(struct drbd_conf *mdev, enum dds_flags flags, struct resize_parms *rs) __must_hold(local)
832 {
833 	sector_t prev_first_sect, prev_size; /* previous meta location */
834 	sector_t la_size_sect, u_size;
835 	struct drbd_md *md = &mdev->ldev->md;
836 	u32 prev_al_stripe_size_4k;
837 	u32 prev_al_stripes;
838 	sector_t size;
839 	char ppb[10];
840 	void *buffer;
841 
842 	int md_moved, la_size_changed;
843 	enum determine_dev_size rv = DS_UNCHANGED;
844 
845 	/* race:
846 	 * application request passes inc_ap_bio,
847 	 * but then cannot get an AL-reference.
848 	 * this function later may wait on ap_bio_cnt == 0. -> deadlock.
849 	 *
850 	 * to avoid that:
851 	 * Suspend IO right here.
852 	 * still lock the act_log to not trigger ASSERTs there.
853 	 */
854 	drbd_suspend_io(mdev);
855 	buffer = drbd_md_get_buffer(mdev); /* Lock meta-data IO */
856 	if (!buffer) {
857 		drbd_resume_io(mdev);
858 		return DS_ERROR;
859 	}
860 
861 	/* no wait necessary anymore, actually we could assert that */
862 	wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
863 
864 	prev_first_sect = drbd_md_first_sector(mdev->ldev);
865 	prev_size = mdev->ldev->md.md_size_sect;
866 	la_size_sect = mdev->ldev->md.la_size_sect;
867 
868 	if (rs) {
869 		/* rs is non NULL if we should change the AL layout only */
870 
871 		prev_al_stripes = md->al_stripes;
872 		prev_al_stripe_size_4k = md->al_stripe_size_4k;
873 
874 		md->al_stripes = rs->al_stripes;
875 		md->al_stripe_size_4k = rs->al_stripe_size / 4;
876 		md->al_size_4k = (u64)rs->al_stripes * rs->al_stripe_size / 4;
877 	}
878 
879 	drbd_md_set_sector_offsets(mdev, mdev->ldev);
880 
881 	rcu_read_lock();
882 	u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
883 	rcu_read_unlock();
884 	size = drbd_new_dev_size(mdev, mdev->ldev, u_size, flags & DDSF_FORCED);
885 
886 	if (size < la_size_sect) {
887 		if (rs && u_size == 0) {
888 			/* Remove "rs &&" later. This check should always be active, but
889 			   right now the receiver expects the permissive behavior */
890 			dev_warn(DEV, "Implicit shrink not allowed. "
891 				 "Use --size=%llus for explicit shrink.\n",
892 				 (unsigned long long)size);
893 			rv = DS_ERROR_SHRINK;
894 		}
895 		if (u_size > size)
896 			rv = DS_ERROR_SPACE_MD;
897 		if (rv != DS_UNCHANGED)
898 			goto err_out;
899 	}
900 
901 	if (drbd_get_capacity(mdev->this_bdev) != size ||
902 	    drbd_bm_capacity(mdev) != size) {
903 		int err;
904 		err = drbd_bm_resize(mdev, size, !(flags & DDSF_NO_RESYNC));
905 		if (unlikely(err)) {
906 			/* currently there is only one error: ENOMEM! */
907 			size = drbd_bm_capacity(mdev)>>1;
908 			if (size == 0) {
909 				dev_err(DEV, "OUT OF MEMORY! "
910 				    "Could not allocate bitmap!\n");
911 			} else {
912 				dev_err(DEV, "BM resizing failed. "
913 				    "Leaving size unchanged at size = %lu KB\n",
914 				    (unsigned long)size);
915 			}
916 			rv = DS_ERROR;
917 		}
918 		/* racy, see comments above. */
919 		drbd_set_my_capacity(mdev, size);
920 		mdev->ldev->md.la_size_sect = size;
921 		dev_info(DEV, "size = %s (%llu KB)\n", ppsize(ppb, size>>1),
922 		     (unsigned long long)size>>1);
923 	}
924 	if (rv <= DS_ERROR)
925 		goto err_out;
926 
927 	la_size_changed = (la_size_sect != mdev->ldev->md.la_size_sect);
928 
929 	md_moved = prev_first_sect != drbd_md_first_sector(mdev->ldev)
930 		|| prev_size	   != mdev->ldev->md.md_size_sect;
931 
932 	if (la_size_changed || md_moved || rs) {
933 		u32 prev_flags;
934 
935 		drbd_al_shrink(mdev); /* All extents inactive. */
936 
937 		prev_flags = md->flags;
938 		md->flags &= ~MDF_PRIMARY_IND;
939 		drbd_md_write(mdev, buffer);
940 
941 		dev_info(DEV, "Writing the whole bitmap, %s\n",
942 			 la_size_changed && md_moved ? "size changed and md moved" :
943 			 la_size_changed ? "size changed" : "md moved");
944 		/* next line implicitly does drbd_suspend_io()+drbd_resume_io() */
945 		drbd_bitmap_io(mdev, md_moved ? &drbd_bm_write_all : &drbd_bm_write,
946 			       "size changed", BM_LOCKED_MASK);
947 		drbd_initialize_al(mdev, buffer);
948 
949 		md->flags = prev_flags;
950 		drbd_md_write(mdev, buffer);
951 
952 		if (rs)
953 			dev_info(DEV, "Changed AL layout to al-stripes = %d, al-stripe-size-kB = %d\n",
954 				 md->al_stripes, md->al_stripe_size_4k * 4);
955 	}
956 
957 	if (size > la_size_sect)
958 		rv = DS_GREW;
959 	if (size < la_size_sect)
960 		rv = DS_SHRUNK;
961 
962 	if (0) {
963 	err_out:
964 		if (rs) {
965 			md->al_stripes = prev_al_stripes;
966 			md->al_stripe_size_4k = prev_al_stripe_size_4k;
967 			md->al_size_4k = (u64)prev_al_stripes * prev_al_stripe_size_4k;
968 
969 			drbd_md_set_sector_offsets(mdev, mdev->ldev);
970 		}
971 	}
972 	lc_unlock(mdev->act_log);
973 	wake_up(&mdev->al_wait);
974 	drbd_md_put_buffer(mdev);
975 	drbd_resume_io(mdev);
976 
977 	return rv;
978 }
979 
980 sector_t
981 drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev,
982 		  sector_t u_size, int assume_peer_has_space)
983 {
984 	sector_t p_size = mdev->p_size;   /* partner's disk size. */
985 	sector_t la_size_sect = bdev->md.la_size_sect; /* last agreed size. */
986 	sector_t m_size; /* my size */
987 	sector_t size = 0;
988 
989 	m_size = drbd_get_max_capacity(bdev);
990 
991 	if (mdev->state.conn < C_CONNECTED && assume_peer_has_space) {
992 		dev_warn(DEV, "Resize while not connected was forced by the user!\n");
993 		p_size = m_size;
994 	}
995 
996 	if (p_size && m_size) {
997 		size = min_t(sector_t, p_size, m_size);
998 	} else {
999 		if (la_size_sect) {
1000 			size = la_size_sect;
1001 			if (m_size && m_size < size)
1002 				size = m_size;
1003 			if (p_size && p_size < size)
1004 				size = p_size;
1005 		} else {
1006 			if (m_size)
1007 				size = m_size;
1008 			if (p_size)
1009 				size = p_size;
1010 		}
1011 	}
1012 
1013 	if (size == 0)
1014 		dev_err(DEV, "Both nodes diskless!\n");
1015 
1016 	if (u_size) {
1017 		if (u_size > size)
1018 			dev_err(DEV, "Requested disk size is too big (%lu > %lu)\n",
1019 			    (unsigned long)u_size>>1, (unsigned long)size>>1);
1020 		else
1021 			size = u_size;
1022 	}
1023 
1024 	return size;
1025 }
1026 
1027 /**
1028  * drbd_check_al_size() - Ensures that the AL is of the right size
1029  * @mdev:	DRBD device.
1030  *
1031  * Returns -EBUSY if current al lru is still used, -ENOMEM when allocation
1032  * failed, and 0 on success. You should call drbd_md_sync() after you called
1033  * this function.
1034  */
1035 static int drbd_check_al_size(struct drbd_conf *mdev, struct disk_conf *dc)
1036 {
1037 	struct lru_cache *n, *t;
1038 	struct lc_element *e;
1039 	unsigned int in_use;
1040 	int i;
1041 
1042 	if (mdev->act_log &&
1043 	    mdev->act_log->nr_elements == dc->al_extents)
1044 		return 0;
1045 
1046 	in_use = 0;
1047 	t = mdev->act_log;
1048 	n = lc_create("act_log", drbd_al_ext_cache, AL_UPDATES_PER_TRANSACTION,
1049 		dc->al_extents, sizeof(struct lc_element), 0);
1050 
1051 	if (n == NULL) {
1052 		dev_err(DEV, "Cannot allocate act_log lru!\n");
1053 		return -ENOMEM;
1054 	}
1055 	spin_lock_irq(&mdev->al_lock);
1056 	if (t) {
1057 		for (i = 0; i < t->nr_elements; i++) {
1058 			e = lc_element_by_index(t, i);
1059 			if (e->refcnt)
1060 				dev_err(DEV, "refcnt(%d)==%d\n",
1061 				    e->lc_number, e->refcnt);
1062 			in_use += e->refcnt;
1063 		}
1064 	}
1065 	if (!in_use)
1066 		mdev->act_log = n;
1067 	spin_unlock_irq(&mdev->al_lock);
1068 	if (in_use) {
1069 		dev_err(DEV, "Activity log still in use!\n");
1070 		lc_destroy(n);
1071 		return -EBUSY;
1072 	} else {
1073 		if (t)
1074 			lc_destroy(t);
1075 	}
1076 	drbd_md_mark_dirty(mdev); /* we changed mdev->act_log->nr_elemens */
1077 	return 0;
1078 }
1079 
1080 static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_size)
1081 {
1082 	struct request_queue * const q = mdev->rq_queue;
1083 	unsigned int max_hw_sectors = max_bio_size >> 9;
1084 	unsigned int max_segments = 0;
1085 
1086 	if (get_ldev_if_state(mdev, D_ATTACHING)) {
1087 		struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
1088 
1089 		max_hw_sectors = min(queue_max_hw_sectors(b), max_bio_size >> 9);
1090 		rcu_read_lock();
1091 		max_segments = rcu_dereference(mdev->ldev->disk_conf)->max_bio_bvecs;
1092 		rcu_read_unlock();
1093 		put_ldev(mdev);
1094 	}
1095 
1096 	blk_queue_logical_block_size(q, 512);
1097 	blk_queue_max_hw_sectors(q, max_hw_sectors);
1098 	/* This is the workaround for "bio would need to, but cannot, be split" */
1099 	blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
1100 	blk_queue_segment_boundary(q, PAGE_CACHE_SIZE-1);
1101 
1102 	if (get_ldev_if_state(mdev, D_ATTACHING)) {
1103 		struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;
1104 
1105 		blk_queue_stack_limits(q, b);
1106 
1107 		if (q->backing_dev_info.ra_pages != b->backing_dev_info.ra_pages) {
1108 			dev_info(DEV, "Adjusting my ra_pages to backing device's (%lu -> %lu)\n",
1109 				 q->backing_dev_info.ra_pages,
1110 				 b->backing_dev_info.ra_pages);
1111 			q->backing_dev_info.ra_pages = b->backing_dev_info.ra_pages;
1112 		}
1113 		put_ldev(mdev);
1114 	}
1115 }
1116 
1117 void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
1118 {
1119 	unsigned int now, new, local, peer;
1120 
1121 	now = queue_max_hw_sectors(mdev->rq_queue) << 9;
1122 	local = mdev->local_max_bio_size; /* Eventually last known value, from volatile memory */
1123 	peer = mdev->peer_max_bio_size; /* Eventually last known value, from meta data */
1124 
1125 	if (get_ldev_if_state(mdev, D_ATTACHING)) {
1126 		local = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
1127 		mdev->local_max_bio_size = local;
1128 		put_ldev(mdev);
1129 	}
1130 	local = min(local, DRBD_MAX_BIO_SIZE);
1131 
1132 	/* We may ignore peer limits if the peer is modern enough.
1133 	   Because new from 8.3.8 onwards the peer can use multiple
1134 	   BIOs for a single peer_request */
1135 	if (mdev->state.conn >= C_CONNECTED) {
1136 		if (mdev->tconn->agreed_pro_version < 94)
1137 			peer = min( mdev->peer_max_bio_size, DRBD_MAX_SIZE_H80_PACKET);
1138 			/* Correct old drbd (up to 8.3.7) if it believes it can do more than 32KiB */
1139 		else if (mdev->tconn->agreed_pro_version == 94)
1140 			peer = DRBD_MAX_SIZE_H80_PACKET;
1141 		else if (mdev->tconn->agreed_pro_version < 100)
1142 			peer = DRBD_MAX_BIO_SIZE_P95;  /* drbd 8.3.8 onwards, before 8.4.0 */
1143 		else
1144 			peer = DRBD_MAX_BIO_SIZE;
1145 	}
1146 
1147 	new = min(local, peer);
1148 
1149 	if (mdev->state.role == R_PRIMARY && new < now)
1150 		dev_err(DEV, "ASSERT FAILED new < now; (%u < %u)\n", new, now);
1151 
1152 	if (new != now)
1153 		dev_info(DEV, "max BIO size = %u\n", new);
1154 
1155 	drbd_setup_queue_param(mdev, new);
1156 }
1157 
1158 /* Starts the worker thread */
1159 static void conn_reconfig_start(struct drbd_tconn *tconn)
1160 {
1161 	drbd_thread_start(&tconn->worker);
1162 	conn_flush_workqueue(tconn);
1163 }
1164 
1165 /* if still unconfigured, stops worker again. */
1166 static void conn_reconfig_done(struct drbd_tconn *tconn)
1167 {
1168 	bool stop_threads;
1169 	spin_lock_irq(&tconn->req_lock);
1170 	stop_threads = conn_all_vols_unconf(tconn) &&
1171 		tconn->cstate == C_STANDALONE;
1172 	spin_unlock_irq(&tconn->req_lock);
1173 	if (stop_threads) {
1174 		/* asender is implicitly stopped by receiver
1175 		 * in conn_disconnect() */
1176 		drbd_thread_stop(&tconn->receiver);
1177 		drbd_thread_stop(&tconn->worker);
1178 	}
1179 }
1180 
1181 /* Make sure IO is suspended before calling this function(). */
1182 static void drbd_suspend_al(struct drbd_conf *mdev)
1183 {
1184 	int s = 0;
1185 
1186 	if (!lc_try_lock(mdev->act_log)) {
1187 		dev_warn(DEV, "Failed to lock al in drbd_suspend_al()\n");
1188 		return;
1189 	}
1190 
1191 	drbd_al_shrink(mdev);
1192 	spin_lock_irq(&mdev->tconn->req_lock);
1193 	if (mdev->state.conn < C_CONNECTED)
1194 		s = !test_and_set_bit(AL_SUSPENDED, &mdev->flags);
1195 	spin_unlock_irq(&mdev->tconn->req_lock);
1196 	lc_unlock(mdev->act_log);
1197 
1198 	if (s)
1199 		dev_info(DEV, "Suspended AL updates\n");
1200 }
1201 
1202 
1203 static bool should_set_defaults(struct genl_info *info)
1204 {
1205 	unsigned flags = ((struct drbd_genlmsghdr*)info->userhdr)->flags;
1206 	return 0 != (flags & DRBD_GENL_F_SET_DEFAULTS);
1207 }
1208 
1209 static unsigned int drbd_al_extents_max(struct drbd_backing_dev *bdev)
1210 {
1211 	/* This is limited by 16 bit "slot" numbers,
1212 	 * and by available on-disk context storage.
1213 	 *
1214 	 * Also (u16)~0 is special (denotes a "free" extent).
1215 	 *
1216 	 * One transaction occupies one 4kB on-disk block,
1217 	 * we have n such blocks in the on disk ring buffer,
1218 	 * the "current" transaction may fail (n-1),
1219 	 * and there is 919 slot numbers context information per transaction.
1220 	 *
1221 	 * 72 transaction blocks amounts to more than 2**16 context slots,
1222 	 * so cap there first.
1223 	 */
1224 	const unsigned int max_al_nr = DRBD_AL_EXTENTS_MAX;
1225 	const unsigned int sufficient_on_disk =
1226 		(max_al_nr + AL_CONTEXT_PER_TRANSACTION -1)
1227 		/AL_CONTEXT_PER_TRANSACTION;
1228 
1229 	unsigned int al_size_4k = bdev->md.al_size_4k;
1230 
1231 	if (al_size_4k > sufficient_on_disk)
1232 		return max_al_nr;
1233 
1234 	return (al_size_4k - 1) * AL_CONTEXT_PER_TRANSACTION;
1235 }
1236 
1237 int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)
1238 {
1239 	enum drbd_ret_code retcode;
1240 	struct drbd_conf *mdev;
1241 	struct disk_conf *new_disk_conf, *old_disk_conf;
1242 	struct fifo_buffer *old_plan = NULL, *new_plan = NULL;
1243 	int err, fifo_size;
1244 
1245 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1246 	if (!adm_ctx.reply_skb)
1247 		return retcode;
1248 	if (retcode != NO_ERROR)
1249 		goto out;
1250 
1251 	mdev = adm_ctx.mdev;
1252 
1253 	/* we also need a disk
1254 	 * to change the options on */
1255 	if (!get_ldev(mdev)) {
1256 		retcode = ERR_NO_DISK;
1257 		goto out;
1258 	}
1259 
1260 	new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
1261 	if (!new_disk_conf) {
1262 		retcode = ERR_NOMEM;
1263 		goto fail;
1264 	}
1265 
1266 	mutex_lock(&mdev->tconn->conf_update);
1267 	old_disk_conf = mdev->ldev->disk_conf;
1268 	*new_disk_conf = *old_disk_conf;
1269 	if (should_set_defaults(info))
1270 		set_disk_conf_defaults(new_disk_conf);
1271 
1272 	err = disk_conf_from_attrs_for_change(new_disk_conf, info);
1273 	if (err && err != -ENOMSG) {
1274 		retcode = ERR_MANDATORY_TAG;
1275 		drbd_msg_put_info(from_attrs_err_to_txt(err));
1276 	}
1277 
1278 	if (!expect(new_disk_conf->resync_rate >= 1))
1279 		new_disk_conf->resync_rate = 1;
1280 
1281 	if (new_disk_conf->al_extents < DRBD_AL_EXTENTS_MIN)
1282 		new_disk_conf->al_extents = DRBD_AL_EXTENTS_MIN;
1283 	if (new_disk_conf->al_extents > drbd_al_extents_max(mdev->ldev))
1284 		new_disk_conf->al_extents = drbd_al_extents_max(mdev->ldev);
1285 
1286 	if (new_disk_conf->c_plan_ahead > DRBD_C_PLAN_AHEAD_MAX)
1287 		new_disk_conf->c_plan_ahead = DRBD_C_PLAN_AHEAD_MAX;
1288 
1289 	fifo_size = (new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ;
1290 	if (fifo_size != mdev->rs_plan_s->size) {
1291 		new_plan = fifo_alloc(fifo_size);
1292 		if (!new_plan) {
1293 			dev_err(DEV, "kmalloc of fifo_buffer failed");
1294 			retcode = ERR_NOMEM;
1295 			goto fail_unlock;
1296 		}
1297 	}
1298 
1299 	drbd_suspend_io(mdev);
1300 	wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
1301 	drbd_al_shrink(mdev);
1302 	err = drbd_check_al_size(mdev, new_disk_conf);
1303 	lc_unlock(mdev->act_log);
1304 	wake_up(&mdev->al_wait);
1305 	drbd_resume_io(mdev);
1306 
1307 	if (err) {
1308 		retcode = ERR_NOMEM;
1309 		goto fail_unlock;
1310 	}
1311 
1312 	write_lock_irq(&global_state_lock);
1313 	retcode = drbd_resync_after_valid(mdev, new_disk_conf->resync_after);
1314 	if (retcode == NO_ERROR) {
1315 		rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
1316 		drbd_resync_after_changed(mdev);
1317 	}
1318 	write_unlock_irq(&global_state_lock);
1319 
1320 	if (retcode != NO_ERROR)
1321 		goto fail_unlock;
1322 
1323 	if (new_plan) {
1324 		old_plan = mdev->rs_plan_s;
1325 		rcu_assign_pointer(mdev->rs_plan_s, new_plan);
1326 	}
1327 
1328 	mutex_unlock(&mdev->tconn->conf_update);
1329 
1330 	if (new_disk_conf->al_updates)
1331 		mdev->ldev->md.flags &= ~MDF_AL_DISABLED;
1332 	else
1333 		mdev->ldev->md.flags |= MDF_AL_DISABLED;
1334 
1335 	if (new_disk_conf->md_flushes)
1336 		clear_bit(MD_NO_FUA, &mdev->flags);
1337 	else
1338 		set_bit(MD_NO_FUA, &mdev->flags);
1339 
1340 	drbd_bump_write_ordering(mdev->tconn, WO_bdev_flush);
1341 
1342 	drbd_md_sync(mdev);
1343 
1344 	if (mdev->state.conn >= C_CONNECTED)
1345 		drbd_send_sync_param(mdev);
1346 
1347 	synchronize_rcu();
1348 	kfree(old_disk_conf);
1349 	kfree(old_plan);
1350 	mod_timer(&mdev->request_timer, jiffies + HZ);
1351 	goto success;
1352 
1353 fail_unlock:
1354 	mutex_unlock(&mdev->tconn->conf_update);
1355  fail:
1356 	kfree(new_disk_conf);
1357 	kfree(new_plan);
1358 success:
1359 	put_ldev(mdev);
1360  out:
1361 	drbd_adm_finish(info, retcode);
1362 	return 0;
1363 }
1364 
1365 int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
1366 {
1367 	struct drbd_conf *mdev;
1368 	int err;
1369 	enum drbd_ret_code retcode;
1370 	enum determine_dev_size dd;
1371 	sector_t max_possible_sectors;
1372 	sector_t min_md_device_sectors;
1373 	struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
1374 	struct disk_conf *new_disk_conf = NULL;
1375 	struct block_device *bdev;
1376 	struct lru_cache *resync_lru = NULL;
1377 	struct fifo_buffer *new_plan = NULL;
1378 	union drbd_state ns, os;
1379 	enum drbd_state_rv rv;
1380 	struct net_conf *nc;
1381 
1382 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1383 	if (!adm_ctx.reply_skb)
1384 		return retcode;
1385 	if (retcode != NO_ERROR)
1386 		goto finish;
1387 
1388 	mdev = adm_ctx.mdev;
1389 	conn_reconfig_start(mdev->tconn);
1390 
1391 	/* if you want to reconfigure, please tear down first */
1392 	if (mdev->state.disk > D_DISKLESS) {
1393 		retcode = ERR_DISK_CONFIGURED;
1394 		goto fail;
1395 	}
1396 	/* It may just now have detached because of IO error.  Make sure
1397 	 * drbd_ldev_destroy is done already, we may end up here very fast,
1398 	 * e.g. if someone calls attach from the on-io-error handler,
1399 	 * to realize a "hot spare" feature (not that I'd recommend that) */
1400 	wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
1401 
1402 	/* make sure there is no leftover from previous force-detach attempts */
1403 	clear_bit(FORCE_DETACH, &mdev->flags);
1404 	clear_bit(WAS_IO_ERROR, &mdev->flags);
1405 	clear_bit(WAS_READ_ERROR, &mdev->flags);
1406 
1407 	/* and no leftover from previously aborted resync or verify, either */
1408 	mdev->rs_total = 0;
1409 	mdev->rs_failed = 0;
1410 	atomic_set(&mdev->rs_pending_cnt, 0);
1411 
1412 	/* allocation not in the IO path, drbdsetup context */
1413 	nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
1414 	if (!nbc) {
1415 		retcode = ERR_NOMEM;
1416 		goto fail;
1417 	}
1418 	spin_lock_init(&nbc->md.uuid_lock);
1419 
1420 	new_disk_conf = kzalloc(sizeof(struct disk_conf), GFP_KERNEL);
1421 	if (!new_disk_conf) {
1422 		retcode = ERR_NOMEM;
1423 		goto fail;
1424 	}
1425 	nbc->disk_conf = new_disk_conf;
1426 
1427 	set_disk_conf_defaults(new_disk_conf);
1428 	err = disk_conf_from_attrs(new_disk_conf, info);
1429 	if (err) {
1430 		retcode = ERR_MANDATORY_TAG;
1431 		drbd_msg_put_info(from_attrs_err_to_txt(err));
1432 		goto fail;
1433 	}
1434 
1435 	if (new_disk_conf->c_plan_ahead > DRBD_C_PLAN_AHEAD_MAX)
1436 		new_disk_conf->c_plan_ahead = DRBD_C_PLAN_AHEAD_MAX;
1437 
1438 	new_plan = fifo_alloc((new_disk_conf->c_plan_ahead * 10 * SLEEP_TIME) / HZ);
1439 	if (!new_plan) {
1440 		retcode = ERR_NOMEM;
1441 		goto fail;
1442 	}
1443 
1444 	if (new_disk_conf->meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
1445 		retcode = ERR_MD_IDX_INVALID;
1446 		goto fail;
1447 	}
1448 
1449 	write_lock_irq(&global_state_lock);
1450 	retcode = drbd_resync_after_valid(mdev, new_disk_conf->resync_after);
1451 	write_unlock_irq(&global_state_lock);
1452 	if (retcode != NO_ERROR)
1453 		goto fail;
1454 
1455 	rcu_read_lock();
1456 	nc = rcu_dereference(mdev->tconn->net_conf);
1457 	if (nc) {
1458 		if (new_disk_conf->fencing == FP_STONITH && nc->wire_protocol == DRBD_PROT_A) {
1459 			rcu_read_unlock();
1460 			retcode = ERR_STONITH_AND_PROT_A;
1461 			goto fail;
1462 		}
1463 	}
1464 	rcu_read_unlock();
1465 
1466 	bdev = blkdev_get_by_path(new_disk_conf->backing_dev,
1467 				  FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
1468 	if (IS_ERR(bdev)) {
1469 		dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->backing_dev,
1470 			PTR_ERR(bdev));
1471 		retcode = ERR_OPEN_DISK;
1472 		goto fail;
1473 	}
1474 	nbc->backing_bdev = bdev;
1475 
1476 	/*
1477 	 * meta_dev_idx >= 0: external fixed size, possibly multiple
1478 	 * drbd sharing one meta device.  TODO in that case, paranoia
1479 	 * check that [md_bdev, meta_dev_idx] is not yet used by some
1480 	 * other drbd minor!  (if you use drbd.conf + drbdadm, that
1481 	 * should check it for you already; but if you don't, or
1482 	 * someone fooled it, we need to double check here)
1483 	 */
1484 	bdev = blkdev_get_by_path(new_disk_conf->meta_dev,
1485 				  FMODE_READ | FMODE_WRITE | FMODE_EXCL,
1486 				  (new_disk_conf->meta_dev_idx < 0) ?
1487 				  (void *)mdev : (void *)drbd_m_holder);
1488 	if (IS_ERR(bdev)) {
1489 		dev_err(DEV, "open(\"%s\") failed with %ld\n", new_disk_conf->meta_dev,
1490 			PTR_ERR(bdev));
1491 		retcode = ERR_OPEN_MD_DISK;
1492 		goto fail;
1493 	}
1494 	nbc->md_bdev = bdev;
1495 
1496 	if ((nbc->backing_bdev == nbc->md_bdev) !=
1497 	    (new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
1498 	     new_disk_conf->meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
1499 		retcode = ERR_MD_IDX_INVALID;
1500 		goto fail;
1501 	}
1502 
1503 	resync_lru = lc_create("resync", drbd_bm_ext_cache,
1504 			1, 61, sizeof(struct bm_extent),
1505 			offsetof(struct bm_extent, lce));
1506 	if (!resync_lru) {
1507 		retcode = ERR_NOMEM;
1508 		goto fail;
1509 	}
1510 
1511 	/* Read our meta data super block early.
1512 	 * This also sets other on-disk offsets. */
1513 	retcode = drbd_md_read(mdev, nbc);
1514 	if (retcode != NO_ERROR)
1515 		goto fail;
1516 
1517 	if (new_disk_conf->al_extents < DRBD_AL_EXTENTS_MIN)
1518 		new_disk_conf->al_extents = DRBD_AL_EXTENTS_MIN;
1519 	if (new_disk_conf->al_extents > drbd_al_extents_max(nbc))
1520 		new_disk_conf->al_extents = drbd_al_extents_max(nbc);
1521 
1522 	if (drbd_get_max_capacity(nbc) < new_disk_conf->disk_size) {
1523 		dev_err(DEV, "max capacity %llu smaller than disk size %llu\n",
1524 			(unsigned long long) drbd_get_max_capacity(nbc),
1525 			(unsigned long long) new_disk_conf->disk_size);
1526 		retcode = ERR_DISK_TOO_SMALL;
1527 		goto fail;
1528 	}
1529 
1530 	if (new_disk_conf->meta_dev_idx < 0) {
1531 		max_possible_sectors = DRBD_MAX_SECTORS_FLEX;
1532 		/* at least one MB, otherwise it does not make sense */
1533 		min_md_device_sectors = (2<<10);
1534 	} else {
1535 		max_possible_sectors = DRBD_MAX_SECTORS;
1536 		min_md_device_sectors = MD_128MB_SECT * (new_disk_conf->meta_dev_idx + 1);
1537 	}
1538 
1539 	if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) {
1540 		retcode = ERR_MD_DISK_TOO_SMALL;
1541 		dev_warn(DEV, "refusing attach: md-device too small, "
1542 		     "at least %llu sectors needed for this meta-disk type\n",
1543 		     (unsigned long long) min_md_device_sectors);
1544 		goto fail;
1545 	}
1546 
1547 	/* Make sure the new disk is big enough
1548 	 * (we may currently be R_PRIMARY with no local disk...) */
1549 	if (drbd_get_max_capacity(nbc) <
1550 	    drbd_get_capacity(mdev->this_bdev)) {
1551 		retcode = ERR_DISK_TOO_SMALL;
1552 		goto fail;
1553 	}
1554 
1555 	nbc->known_size = drbd_get_capacity(nbc->backing_bdev);
1556 
1557 	if (nbc->known_size > max_possible_sectors) {
1558 		dev_warn(DEV, "==> truncating very big lower level device "
1559 			"to currently maximum possible %llu sectors <==\n",
1560 			(unsigned long long) max_possible_sectors);
1561 		if (new_disk_conf->meta_dev_idx >= 0)
1562 			dev_warn(DEV, "==>> using internal or flexible "
1563 				      "meta data may help <<==\n");
1564 	}
1565 
1566 	drbd_suspend_io(mdev);
1567 	/* also wait for the last barrier ack. */
1568 	/* FIXME see also https://daiquiri.linbit/cgi-bin/bugzilla/show_bug.cgi?id=171
1569 	 * We need a way to either ignore barrier acks for barriers sent before a device
1570 	 * was attached, or a way to wait for all pending barrier acks to come in.
1571 	 * As barriers are counted per resource,
1572 	 * we'd need to suspend io on all devices of a resource.
1573 	 */
1574 	wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || drbd_suspended(mdev));
1575 	/* and for any other previously queued work */
1576 	drbd_flush_workqueue(mdev);
1577 
1578 	rv = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE);
1579 	retcode = rv;  /* FIXME: Type mismatch. */
1580 	drbd_resume_io(mdev);
1581 	if (rv < SS_SUCCESS)
1582 		goto fail;
1583 
1584 	if (!get_ldev_if_state(mdev, D_ATTACHING))
1585 		goto force_diskless;
1586 
1587 	if (!mdev->bitmap) {
1588 		if (drbd_bm_init(mdev)) {
1589 			retcode = ERR_NOMEM;
1590 			goto force_diskless_dec;
1591 		}
1592 	}
1593 
1594 	if (mdev->state.conn < C_CONNECTED &&
1595 	    mdev->state.role == R_PRIMARY &&
1596 	    (mdev->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
1597 		dev_err(DEV, "Can only attach to data with current UUID=%016llX\n",
1598 		    (unsigned long long)mdev->ed_uuid);
1599 		retcode = ERR_DATA_NOT_CURRENT;
1600 		goto force_diskless_dec;
1601 	}
1602 
1603 	/* Since we are diskless, fix the activity log first... */
1604 	if (drbd_check_al_size(mdev, new_disk_conf)) {
1605 		retcode = ERR_NOMEM;
1606 		goto force_diskless_dec;
1607 	}
1608 
1609 	/* Prevent shrinking of consistent devices ! */
1610 	if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
1611 	    drbd_new_dev_size(mdev, nbc, nbc->disk_conf->disk_size, 0) < nbc->md.la_size_sect) {
1612 		dev_warn(DEV, "refusing to truncate a consistent device\n");
1613 		retcode = ERR_DISK_TOO_SMALL;
1614 		goto force_diskless_dec;
1615 	}
1616 
1617 	/* Reset the "barriers don't work" bits here, then force meta data to
1618 	 * be written, to ensure we determine if barriers are supported. */
1619 	if (new_disk_conf->md_flushes)
1620 		clear_bit(MD_NO_FUA, &mdev->flags);
1621 	else
1622 		set_bit(MD_NO_FUA, &mdev->flags);
1623 
1624 	/* Point of no return reached.
1625 	 * Devices and memory are no longer released by error cleanup below.
1626 	 * now mdev takes over responsibility, and the state engine should
1627 	 * clean it up somewhere.  */
1628 	D_ASSERT(mdev->ldev == NULL);
1629 	mdev->ldev = nbc;
1630 	mdev->resync = resync_lru;
1631 	mdev->rs_plan_s = new_plan;
1632 	nbc = NULL;
1633 	resync_lru = NULL;
1634 	new_disk_conf = NULL;
1635 	new_plan = NULL;
1636 
1637 	drbd_bump_write_ordering(mdev->tconn, WO_bdev_flush);
1638 
1639 	if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
1640 		set_bit(CRASHED_PRIMARY, &mdev->flags);
1641 	else
1642 		clear_bit(CRASHED_PRIMARY, &mdev->flags);
1643 
1644 	if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
1645 	    !(mdev->state.role == R_PRIMARY && mdev->tconn->susp_nod))
1646 		set_bit(CRASHED_PRIMARY, &mdev->flags);
1647 
1648 	mdev->send_cnt = 0;
1649 	mdev->recv_cnt = 0;
1650 	mdev->read_cnt = 0;
1651 	mdev->writ_cnt = 0;
1652 
1653 	drbd_reconsider_max_bio_size(mdev);
1654 
1655 	/* If I am currently not R_PRIMARY,
1656 	 * but meta data primary indicator is set,
1657 	 * I just now recover from a hard crash,
1658 	 * and have been R_PRIMARY before that crash.
1659 	 *
1660 	 * Now, if I had no connection before that crash
1661 	 * (have been degraded R_PRIMARY), chances are that
1662 	 * I won't find my peer now either.
1663 	 *
1664 	 * In that case, and _only_ in that case,
1665 	 * we use the degr-wfc-timeout instead of the default,
1666 	 * so we can automatically recover from a crash of a
1667 	 * degraded but active "cluster" after a certain timeout.
1668 	 */
1669 	clear_bit(USE_DEGR_WFC_T, &mdev->flags);
1670 	if (mdev->state.role != R_PRIMARY &&
1671 	     drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
1672 	    !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND))
1673 		set_bit(USE_DEGR_WFC_T, &mdev->flags);
1674 
1675 	dd = drbd_determine_dev_size(mdev, 0, NULL);
1676 	if (dd <= DS_ERROR) {
1677 		retcode = ERR_NOMEM_BITMAP;
1678 		goto force_diskless_dec;
1679 	} else if (dd == DS_GREW)
1680 		set_bit(RESYNC_AFTER_NEG, &mdev->flags);
1681 
1682 	if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC) ||
1683 	    (test_bit(CRASHED_PRIMARY, &mdev->flags) &&
1684 	     drbd_md_test_flag(mdev->ldev, MDF_AL_DISABLED))) {
1685 		dev_info(DEV, "Assuming that all blocks are out of sync "
1686 		     "(aka FullSync)\n");
1687 		if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
1688 			"set_n_write from attaching", BM_LOCKED_MASK)) {
1689 			retcode = ERR_IO_MD_DISK;
1690 			goto force_diskless_dec;
1691 		}
1692 	} else {
1693 		if (drbd_bitmap_io(mdev, &drbd_bm_read,
1694 			"read from attaching", BM_LOCKED_MASK)) {
1695 			retcode = ERR_IO_MD_DISK;
1696 			goto force_diskless_dec;
1697 		}
1698 	}
1699 
1700 	if (_drbd_bm_total_weight(mdev) == drbd_bm_bits(mdev))
1701 		drbd_suspend_al(mdev); /* IO is still suspended here... */
1702 
1703 	spin_lock_irq(&mdev->tconn->req_lock);
1704 	os = drbd_read_state(mdev);
1705 	ns = os;
1706 	/* If MDF_CONSISTENT is not set go into inconsistent state,
1707 	   otherwise investigate MDF_WasUpToDate...
1708 	   If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state,
1709 	   otherwise into D_CONSISTENT state.
1710 	*/
1711 	if (drbd_md_test_flag(mdev->ldev, MDF_CONSISTENT)) {
1712 		if (drbd_md_test_flag(mdev->ldev, MDF_WAS_UP_TO_DATE))
1713 			ns.disk = D_CONSISTENT;
1714 		else
1715 			ns.disk = D_OUTDATED;
1716 	} else {
1717 		ns.disk = D_INCONSISTENT;
1718 	}
1719 
1720 	if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED))
1721 		ns.pdsk = D_OUTDATED;
1722 
1723 	rcu_read_lock();
1724 	if (ns.disk == D_CONSISTENT &&
1725 	    (ns.pdsk == D_OUTDATED || rcu_dereference(mdev->ldev->disk_conf)->fencing == FP_DONT_CARE))
1726 		ns.disk = D_UP_TO_DATE;
1727 
1728 	/* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND,
1729 	   MDF_CONSISTENT and MDF_WAS_UP_TO_DATE must happen before
1730 	   this point, because drbd_request_state() modifies these
1731 	   flags. */
1732 
1733 	if (rcu_dereference(mdev->ldev->disk_conf)->al_updates)
1734 		mdev->ldev->md.flags &= ~MDF_AL_DISABLED;
1735 	else
1736 		mdev->ldev->md.flags |= MDF_AL_DISABLED;
1737 
1738 	rcu_read_unlock();
1739 
1740 	/* In case we are C_CONNECTED postpone any decision on the new disk
1741 	   state after the negotiation phase. */
1742 	if (mdev->state.conn == C_CONNECTED) {
1743 		mdev->new_state_tmp.i = ns.i;
1744 		ns.i = os.i;
1745 		ns.disk = D_NEGOTIATING;
1746 
1747 		/* We expect to receive up-to-date UUIDs soon.
1748 		   To avoid a race in receive_state, free p_uuid while
1749 		   holding req_lock. I.e. atomic with the state change */
1750 		kfree(mdev->p_uuid);
1751 		mdev->p_uuid = NULL;
1752 	}
1753 
1754 	rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
1755 	spin_unlock_irq(&mdev->tconn->req_lock);
1756 
1757 	if (rv < SS_SUCCESS)
1758 		goto force_diskless_dec;
1759 
1760 	mod_timer(&mdev->request_timer, jiffies + HZ);
1761 
1762 	if (mdev->state.role == R_PRIMARY)
1763 		mdev->ldev->md.uuid[UI_CURRENT] |=  (u64)1;
1764 	else
1765 		mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
1766 
1767 	drbd_md_mark_dirty(mdev);
1768 	drbd_md_sync(mdev);
1769 
1770 	kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
1771 	put_ldev(mdev);
1772 	conn_reconfig_done(mdev->tconn);
1773 	drbd_adm_finish(info, retcode);
1774 	return 0;
1775 
1776  force_diskless_dec:
1777 	put_ldev(mdev);
1778  force_diskless:
1779 	drbd_force_state(mdev, NS(disk, D_DISKLESS));
1780 	drbd_md_sync(mdev);
1781  fail:
1782 	conn_reconfig_done(mdev->tconn);
1783 	if (nbc) {
1784 		if (nbc->backing_bdev)
1785 			blkdev_put(nbc->backing_bdev,
1786 				   FMODE_READ | FMODE_WRITE | FMODE_EXCL);
1787 		if (nbc->md_bdev)
1788 			blkdev_put(nbc->md_bdev,
1789 				   FMODE_READ | FMODE_WRITE | FMODE_EXCL);
1790 		kfree(nbc);
1791 	}
1792 	kfree(new_disk_conf);
1793 	lc_destroy(resync_lru);
1794 	kfree(new_plan);
1795 
1796  finish:
1797 	drbd_adm_finish(info, retcode);
1798 	return 0;
1799 }
1800 
1801 static int adm_detach(struct drbd_conf *mdev, int force)
1802 {
1803 	enum drbd_state_rv retcode;
1804 	int ret;
1805 
1806 	if (force) {
1807 		set_bit(FORCE_DETACH, &mdev->flags);
1808 		drbd_force_state(mdev, NS(disk, D_FAILED));
1809 		retcode = SS_SUCCESS;
1810 		goto out;
1811 	}
1812 
1813 	drbd_suspend_io(mdev); /* so no-one is stuck in drbd_al_begin_io */
1814 	drbd_md_get_buffer(mdev); /* make sure there is no in-flight meta-data IO */
1815 	retcode = drbd_request_state(mdev, NS(disk, D_FAILED));
1816 	drbd_md_put_buffer(mdev);
1817 	/* D_FAILED will transition to DISKLESS. */
1818 	ret = wait_event_interruptible(mdev->misc_wait,
1819 			mdev->state.disk != D_FAILED);
1820 	drbd_resume_io(mdev);
1821 	if ((int)retcode == (int)SS_IS_DISKLESS)
1822 		retcode = SS_NOTHING_TO_DO;
1823 	if (ret)
1824 		retcode = ERR_INTR;
1825 out:
1826 	return retcode;
1827 }
1828 
1829 /* Detaching the disk is a process in multiple stages.  First we need to lock
1830  * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
1831  * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
1832  * internal references as well.
1833  * Only then we have finally detached. */
1834 int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info)
1835 {
1836 	enum drbd_ret_code retcode;
1837 	struct detach_parms parms = { };
1838 	int err;
1839 
1840 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
1841 	if (!adm_ctx.reply_skb)
1842 		return retcode;
1843 	if (retcode != NO_ERROR)
1844 		goto out;
1845 
1846 	if (info->attrs[DRBD_NLA_DETACH_PARMS]) {
1847 		err = detach_parms_from_attrs(&parms, info);
1848 		if (err) {
1849 			retcode = ERR_MANDATORY_TAG;
1850 			drbd_msg_put_info(from_attrs_err_to_txt(err));
1851 			goto out;
1852 		}
1853 	}
1854 
1855 	retcode = adm_detach(adm_ctx.mdev, parms.force_detach);
1856 out:
1857 	drbd_adm_finish(info, retcode);
1858 	return 0;
1859 }
1860 
1861 static bool conn_resync_running(struct drbd_tconn *tconn)
1862 {
1863 	struct drbd_conf *mdev;
1864 	bool rv = false;
1865 	int vnr;
1866 
1867 	rcu_read_lock();
1868 	idr_for_each_entry(&tconn->volumes, mdev, vnr) {
1869 		if (mdev->state.conn == C_SYNC_SOURCE ||
1870 		    mdev->state.conn == C_SYNC_TARGET ||
1871 		    mdev->state.conn == C_PAUSED_SYNC_S ||
1872 		    mdev->state.conn == C_PAUSED_SYNC_T) {
1873 			rv = true;
1874 			break;
1875 		}
1876 	}
1877 	rcu_read_unlock();
1878 
1879 	return rv;
1880 }
1881 
1882 static bool conn_ov_running(struct drbd_tconn *tconn)
1883 {
1884 	struct drbd_conf *mdev;
1885 	bool rv = false;
1886 	int vnr;
1887 
1888 	rcu_read_lock();
1889 	idr_for_each_entry(&tconn->volumes, mdev, vnr) {
1890 		if (mdev->state.conn == C_VERIFY_S ||
1891 		    mdev->state.conn == C_VERIFY_T) {
1892 			rv = true;
1893 			break;
1894 		}
1895 	}
1896 	rcu_read_unlock();
1897 
1898 	return rv;
1899 }
1900 
1901 static enum drbd_ret_code
1902 _check_net_options(struct drbd_tconn *tconn, struct net_conf *old_conf, struct net_conf *new_conf)
1903 {
1904 	struct drbd_conf *mdev;
1905 	int i;
1906 
1907 	if (old_conf && tconn->cstate == C_WF_REPORT_PARAMS && tconn->agreed_pro_version < 100) {
1908 		if (new_conf->wire_protocol != old_conf->wire_protocol)
1909 			return ERR_NEED_APV_100;
1910 
1911 		if (new_conf->two_primaries != old_conf->two_primaries)
1912 			return ERR_NEED_APV_100;
1913 
1914 		if (strcmp(new_conf->integrity_alg, old_conf->integrity_alg))
1915 			return ERR_NEED_APV_100;
1916 	}
1917 
1918 	if (!new_conf->two_primaries &&
1919 	    conn_highest_role(tconn) == R_PRIMARY &&
1920 	    conn_highest_peer(tconn) == R_PRIMARY)
1921 		return ERR_NEED_ALLOW_TWO_PRI;
1922 
1923 	if (new_conf->two_primaries &&
1924 	    (new_conf->wire_protocol != DRBD_PROT_C))
1925 		return ERR_NOT_PROTO_C;
1926 
1927 	idr_for_each_entry(&tconn->volumes, mdev, i) {
1928 		if (get_ldev(mdev)) {
1929 			enum drbd_fencing_p fp = rcu_dereference(mdev->ldev->disk_conf)->fencing;
1930 			put_ldev(mdev);
1931 			if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH)
1932 				return ERR_STONITH_AND_PROT_A;
1933 		}
1934 		if (mdev->state.role == R_PRIMARY && new_conf->discard_my_data)
1935 			return ERR_DISCARD_IMPOSSIBLE;
1936 	}
1937 
1938 	if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A)
1939 		return ERR_CONG_NOT_PROTO_A;
1940 
1941 	return NO_ERROR;
1942 }
1943 
1944 static enum drbd_ret_code
1945 check_net_options(struct drbd_tconn *tconn, struct net_conf *new_conf)
1946 {
1947 	static enum drbd_ret_code rv;
1948 	struct drbd_conf *mdev;
1949 	int i;
1950 
1951 	rcu_read_lock();
1952 	rv = _check_net_options(tconn, rcu_dereference(tconn->net_conf), new_conf);
1953 	rcu_read_unlock();
1954 
1955 	/* tconn->volumes protected by genl_lock() here */
1956 	idr_for_each_entry(&tconn->volumes, mdev, i) {
1957 		if (!mdev->bitmap) {
1958 			if(drbd_bm_init(mdev))
1959 				return ERR_NOMEM;
1960 		}
1961 	}
1962 
1963 	return rv;
1964 }
1965 
1966 struct crypto {
1967 	struct crypto_hash *verify_tfm;
1968 	struct crypto_hash *csums_tfm;
1969 	struct crypto_hash *cram_hmac_tfm;
1970 	struct crypto_hash *integrity_tfm;
1971 };
1972 
1973 static int
1974 alloc_hash(struct crypto_hash **tfm, char *tfm_name, int err_alg)
1975 {
1976 	if (!tfm_name[0])
1977 		return NO_ERROR;
1978 
1979 	*tfm = crypto_alloc_hash(tfm_name, 0, CRYPTO_ALG_ASYNC);
1980 	if (IS_ERR(*tfm)) {
1981 		*tfm = NULL;
1982 		return err_alg;
1983 	}
1984 
1985 	return NO_ERROR;
1986 }
1987 
1988 static enum drbd_ret_code
1989 alloc_crypto(struct crypto *crypto, struct net_conf *new_conf)
1990 {
1991 	char hmac_name[CRYPTO_MAX_ALG_NAME];
1992 	enum drbd_ret_code rv;
1993 
1994 	rv = alloc_hash(&crypto->csums_tfm, new_conf->csums_alg,
1995 		       ERR_CSUMS_ALG);
1996 	if (rv != NO_ERROR)
1997 		return rv;
1998 	rv = alloc_hash(&crypto->verify_tfm, new_conf->verify_alg,
1999 		       ERR_VERIFY_ALG);
2000 	if (rv != NO_ERROR)
2001 		return rv;
2002 	rv = alloc_hash(&crypto->integrity_tfm, new_conf->integrity_alg,
2003 		       ERR_INTEGRITY_ALG);
2004 	if (rv != NO_ERROR)
2005 		return rv;
2006 	if (new_conf->cram_hmac_alg[0] != 0) {
2007 		snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
2008 			 new_conf->cram_hmac_alg);
2009 
2010 		rv = alloc_hash(&crypto->cram_hmac_tfm, hmac_name,
2011 			       ERR_AUTH_ALG);
2012 	}
2013 
2014 	return rv;
2015 }
2016 
2017 static void free_crypto(struct crypto *crypto)
2018 {
2019 	crypto_free_hash(crypto->cram_hmac_tfm);
2020 	crypto_free_hash(crypto->integrity_tfm);
2021 	crypto_free_hash(crypto->csums_tfm);
2022 	crypto_free_hash(crypto->verify_tfm);
2023 }
2024 
2025 int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info)
2026 {
2027 	enum drbd_ret_code retcode;
2028 	struct drbd_tconn *tconn;
2029 	struct net_conf *old_conf, *new_conf = NULL;
2030 	int err;
2031 	int ovr; /* online verify running */
2032 	int rsr; /* re-sync running */
2033 	struct crypto crypto = { };
2034 
2035 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
2036 	if (!adm_ctx.reply_skb)
2037 		return retcode;
2038 	if (retcode != NO_ERROR)
2039 		goto out;
2040 
2041 	tconn = adm_ctx.tconn;
2042 
2043 	new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
2044 	if (!new_conf) {
2045 		retcode = ERR_NOMEM;
2046 		goto out;
2047 	}
2048 
2049 	conn_reconfig_start(tconn);
2050 
2051 	mutex_lock(&tconn->data.mutex);
2052 	mutex_lock(&tconn->conf_update);
2053 	old_conf = tconn->net_conf;
2054 
2055 	if (!old_conf) {
2056 		drbd_msg_put_info("net conf missing, try connect");
2057 		retcode = ERR_INVALID_REQUEST;
2058 		goto fail;
2059 	}
2060 
2061 	*new_conf = *old_conf;
2062 	if (should_set_defaults(info))
2063 		set_net_conf_defaults(new_conf);
2064 
2065 	err = net_conf_from_attrs_for_change(new_conf, info);
2066 	if (err && err != -ENOMSG) {
2067 		retcode = ERR_MANDATORY_TAG;
2068 		drbd_msg_put_info(from_attrs_err_to_txt(err));
2069 		goto fail;
2070 	}
2071 
2072 	retcode = check_net_options(tconn, new_conf);
2073 	if (retcode != NO_ERROR)
2074 		goto fail;
2075 
2076 	/* re-sync running */
2077 	rsr = conn_resync_running(tconn);
2078 	if (rsr && strcmp(new_conf->csums_alg, old_conf->csums_alg)) {
2079 		retcode = ERR_CSUMS_RESYNC_RUNNING;
2080 		goto fail;
2081 	}
2082 
2083 	/* online verify running */
2084 	ovr = conn_ov_running(tconn);
2085 	if (ovr && strcmp(new_conf->verify_alg, old_conf->verify_alg)) {
2086 		retcode = ERR_VERIFY_RUNNING;
2087 		goto fail;
2088 	}
2089 
2090 	retcode = alloc_crypto(&crypto, new_conf);
2091 	if (retcode != NO_ERROR)
2092 		goto fail;
2093 
2094 	rcu_assign_pointer(tconn->net_conf, new_conf);
2095 
2096 	if (!rsr) {
2097 		crypto_free_hash(tconn->csums_tfm);
2098 		tconn->csums_tfm = crypto.csums_tfm;
2099 		crypto.csums_tfm = NULL;
2100 	}
2101 	if (!ovr) {
2102 		crypto_free_hash(tconn->verify_tfm);
2103 		tconn->verify_tfm = crypto.verify_tfm;
2104 		crypto.verify_tfm = NULL;
2105 	}
2106 
2107 	crypto_free_hash(tconn->integrity_tfm);
2108 	tconn->integrity_tfm = crypto.integrity_tfm;
2109 	if (tconn->cstate >= C_WF_REPORT_PARAMS && tconn->agreed_pro_version >= 100)
2110 		/* Do this without trying to take tconn->data.mutex again.  */
2111 		__drbd_send_protocol(tconn, P_PROTOCOL_UPDATE);
2112 
2113 	crypto_free_hash(tconn->cram_hmac_tfm);
2114 	tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
2115 
2116 	mutex_unlock(&tconn->conf_update);
2117 	mutex_unlock(&tconn->data.mutex);
2118 	synchronize_rcu();
2119 	kfree(old_conf);
2120 
2121 	if (tconn->cstate >= C_WF_REPORT_PARAMS)
2122 		drbd_send_sync_param(minor_to_mdev(conn_lowest_minor(tconn)));
2123 
2124 	goto done;
2125 
2126  fail:
2127 	mutex_unlock(&tconn->conf_update);
2128 	mutex_unlock(&tconn->data.mutex);
2129 	free_crypto(&crypto);
2130 	kfree(new_conf);
2131  done:
2132 	conn_reconfig_done(tconn);
2133  out:
2134 	drbd_adm_finish(info, retcode);
2135 	return 0;
2136 }
2137 
2138 int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info)
2139 {
2140 	struct drbd_conf *mdev;
2141 	struct net_conf *old_conf, *new_conf = NULL;
2142 	struct crypto crypto = { };
2143 	struct drbd_tconn *tconn;
2144 	enum drbd_ret_code retcode;
2145 	int i;
2146 	int err;
2147 
2148 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
2149 
2150 	if (!adm_ctx.reply_skb)
2151 		return retcode;
2152 	if (retcode != NO_ERROR)
2153 		goto out;
2154 	if (!(adm_ctx.my_addr && adm_ctx.peer_addr)) {
2155 		drbd_msg_put_info("connection endpoint(s) missing");
2156 		retcode = ERR_INVALID_REQUEST;
2157 		goto out;
2158 	}
2159 
2160 	/* No need for _rcu here. All reconfiguration is
2161 	 * strictly serialized on genl_lock(). We are protected against
2162 	 * concurrent reconfiguration/addition/deletion */
2163 	list_for_each_entry(tconn, &drbd_tconns, all_tconn) {
2164 		if (nla_len(adm_ctx.my_addr) == tconn->my_addr_len &&
2165 		    !memcmp(nla_data(adm_ctx.my_addr), &tconn->my_addr, tconn->my_addr_len)) {
2166 			retcode = ERR_LOCAL_ADDR;
2167 			goto out;
2168 		}
2169 
2170 		if (nla_len(adm_ctx.peer_addr) == tconn->peer_addr_len &&
2171 		    !memcmp(nla_data(adm_ctx.peer_addr), &tconn->peer_addr, tconn->peer_addr_len)) {
2172 			retcode = ERR_PEER_ADDR;
2173 			goto out;
2174 		}
2175 	}
2176 
2177 	tconn = adm_ctx.tconn;
2178 	conn_reconfig_start(tconn);
2179 
2180 	if (tconn->cstate > C_STANDALONE) {
2181 		retcode = ERR_NET_CONFIGURED;
2182 		goto fail;
2183 	}
2184 
2185 	/* allocation not in the IO path, drbdsetup / netlink process context */
2186 	new_conf = kzalloc(sizeof(*new_conf), GFP_KERNEL);
2187 	if (!new_conf) {
2188 		retcode = ERR_NOMEM;
2189 		goto fail;
2190 	}
2191 
2192 	set_net_conf_defaults(new_conf);
2193 
2194 	err = net_conf_from_attrs(new_conf, info);
2195 	if (err && err != -ENOMSG) {
2196 		retcode = ERR_MANDATORY_TAG;
2197 		drbd_msg_put_info(from_attrs_err_to_txt(err));
2198 		goto fail;
2199 	}
2200 
2201 	retcode = check_net_options(tconn, new_conf);
2202 	if (retcode != NO_ERROR)
2203 		goto fail;
2204 
2205 	retcode = alloc_crypto(&crypto, new_conf);
2206 	if (retcode != NO_ERROR)
2207 		goto fail;
2208 
2209 	((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;
2210 
2211 	conn_flush_workqueue(tconn);
2212 
2213 	mutex_lock(&tconn->conf_update);
2214 	old_conf = tconn->net_conf;
2215 	if (old_conf) {
2216 		retcode = ERR_NET_CONFIGURED;
2217 		mutex_unlock(&tconn->conf_update);
2218 		goto fail;
2219 	}
2220 	rcu_assign_pointer(tconn->net_conf, new_conf);
2221 
2222 	conn_free_crypto(tconn);
2223 	tconn->cram_hmac_tfm = crypto.cram_hmac_tfm;
2224 	tconn->integrity_tfm = crypto.integrity_tfm;
2225 	tconn->csums_tfm = crypto.csums_tfm;
2226 	tconn->verify_tfm = crypto.verify_tfm;
2227 
2228 	tconn->my_addr_len = nla_len(adm_ctx.my_addr);
2229 	memcpy(&tconn->my_addr, nla_data(adm_ctx.my_addr), tconn->my_addr_len);
2230 	tconn->peer_addr_len = nla_len(adm_ctx.peer_addr);
2231 	memcpy(&tconn->peer_addr, nla_data(adm_ctx.peer_addr), tconn->peer_addr_len);
2232 
2233 	mutex_unlock(&tconn->conf_update);
2234 
2235 	rcu_read_lock();
2236 	idr_for_each_entry(&tconn->volumes, mdev, i) {
2237 		mdev->send_cnt = 0;
2238 		mdev->recv_cnt = 0;
2239 	}
2240 	rcu_read_unlock();
2241 
2242 	retcode = conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
2243 
2244 	conn_reconfig_done(tconn);
2245 	drbd_adm_finish(info, retcode);
2246 	return 0;
2247 
2248 fail:
2249 	free_crypto(&crypto);
2250 	kfree(new_conf);
2251 
2252 	conn_reconfig_done(tconn);
2253 out:
2254 	drbd_adm_finish(info, retcode);
2255 	return 0;
2256 }
2257 
2258 static enum drbd_state_rv conn_try_disconnect(struct drbd_tconn *tconn, bool force)
2259 {
2260 	enum drbd_state_rv rv;
2261 
2262 	rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
2263 			force ? CS_HARD : 0);
2264 
2265 	switch (rv) {
2266 	case SS_NOTHING_TO_DO:
2267 		break;
2268 	case SS_ALREADY_STANDALONE:
2269 		return SS_SUCCESS;
2270 	case SS_PRIMARY_NOP:
2271 		/* Our state checking code wants to see the peer outdated. */
2272 		rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING, pdsk, D_OUTDATED), 0);
2273 
2274 		if (rv == SS_OUTDATE_WO_CONN) /* lost connection before graceful disconnect succeeded */
2275 			rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_VERBOSE);
2276 
2277 		break;
2278 	case SS_CW_FAILED_BY_PEER:
2279 		/* The peer probably wants to see us outdated. */
2280 		rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
2281 							disk, D_OUTDATED), 0);
2282 		if (rv == SS_IS_DISKLESS || rv == SS_LOWER_THAN_OUTDATED) {
2283 			rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING),
2284 					CS_HARD);
2285 		}
2286 		break;
2287 	default:;
2288 		/* no special handling necessary */
2289 	}
2290 
2291 	if (rv >= SS_SUCCESS) {
2292 		enum drbd_state_rv rv2;
2293 		/* No one else can reconfigure the network while I am here.
2294 		 * The state handling only uses drbd_thread_stop_nowait(),
2295 		 * we want to really wait here until the receiver is no more.
2296 		 */
2297 		drbd_thread_stop(&adm_ctx.tconn->receiver);
2298 
2299 		/* Race breaker.  This additional state change request may be
2300 		 * necessary, if this was a forced disconnect during a receiver
2301 		 * restart.  We may have "killed" the receiver thread just
2302 		 * after drbdd_init() returned.  Typically, we should be
2303 		 * C_STANDALONE already, now, and this becomes a no-op.
2304 		 */
2305 		rv2 = conn_request_state(tconn, NS(conn, C_STANDALONE),
2306 				CS_VERBOSE | CS_HARD);
2307 		if (rv2 < SS_SUCCESS)
2308 			conn_err(tconn,
2309 				"unexpected rv2=%d in conn_try_disconnect()\n",
2310 				rv2);
2311 	}
2312 	return rv;
2313 }
2314 
2315 int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info)
2316 {
2317 	struct disconnect_parms parms;
2318 	struct drbd_tconn *tconn;
2319 	enum drbd_state_rv rv;
2320 	enum drbd_ret_code retcode;
2321 	int err;
2322 
2323 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONNECTION);
2324 	if (!adm_ctx.reply_skb)
2325 		return retcode;
2326 	if (retcode != NO_ERROR)
2327 		goto fail;
2328 
2329 	tconn = adm_ctx.tconn;
2330 	memset(&parms, 0, sizeof(parms));
2331 	if (info->attrs[DRBD_NLA_DISCONNECT_PARMS]) {
2332 		err = disconnect_parms_from_attrs(&parms, info);
2333 		if (err) {
2334 			retcode = ERR_MANDATORY_TAG;
2335 			drbd_msg_put_info(from_attrs_err_to_txt(err));
2336 			goto fail;
2337 		}
2338 	}
2339 
2340 	rv = conn_try_disconnect(tconn, parms.force_disconnect);
2341 	if (rv < SS_SUCCESS)
2342 		retcode = rv;  /* FIXME: Type mismatch. */
2343 	else
2344 		retcode = NO_ERROR;
2345  fail:
2346 	drbd_adm_finish(info, retcode);
2347 	return 0;
2348 }
2349 
2350 void resync_after_online_grow(struct drbd_conf *mdev)
2351 {
2352 	int iass; /* I am sync source */
2353 
2354 	dev_info(DEV, "Resync of new storage after online grow\n");
2355 	if (mdev->state.role != mdev->state.peer)
2356 		iass = (mdev->state.role == R_PRIMARY);
2357 	else
2358 		iass = test_bit(RESOLVE_CONFLICTS, &mdev->tconn->flags);
2359 
2360 	if (iass)
2361 		drbd_start_resync(mdev, C_SYNC_SOURCE);
2362 	else
2363 		_drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE);
2364 }
2365 
2366 int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info)
2367 {
2368 	struct disk_conf *old_disk_conf, *new_disk_conf = NULL;
2369 	struct resize_parms rs;
2370 	struct drbd_conf *mdev;
2371 	enum drbd_ret_code retcode;
2372 	enum determine_dev_size dd;
2373 	bool change_al_layout = false;
2374 	enum dds_flags ddsf;
2375 	sector_t u_size;
2376 	int err;
2377 
2378 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2379 	if (!adm_ctx.reply_skb)
2380 		return retcode;
2381 	if (retcode != NO_ERROR)
2382 		goto fail;
2383 
2384 	mdev = adm_ctx.mdev;
2385 	if (!get_ldev(mdev)) {
2386 		retcode = ERR_NO_DISK;
2387 		goto fail;
2388 	}
2389 
2390 	memset(&rs, 0, sizeof(struct resize_parms));
2391 	rs.al_stripes = mdev->ldev->md.al_stripes;
2392 	rs.al_stripe_size = mdev->ldev->md.al_stripe_size_4k * 4;
2393 	if (info->attrs[DRBD_NLA_RESIZE_PARMS]) {
2394 		err = resize_parms_from_attrs(&rs, info);
2395 		if (err) {
2396 			retcode = ERR_MANDATORY_TAG;
2397 			drbd_msg_put_info(from_attrs_err_to_txt(err));
2398 			goto fail_ldev;
2399 		}
2400 	}
2401 
2402 	if (mdev->state.conn > C_CONNECTED) {
2403 		retcode = ERR_RESIZE_RESYNC;
2404 		goto fail_ldev;
2405 	}
2406 
2407 	if (mdev->state.role == R_SECONDARY &&
2408 	    mdev->state.peer == R_SECONDARY) {
2409 		retcode = ERR_NO_PRIMARY;
2410 		goto fail_ldev;
2411 	}
2412 
2413 	if (rs.no_resync && mdev->tconn->agreed_pro_version < 93) {
2414 		retcode = ERR_NEED_APV_93;
2415 		goto fail_ldev;
2416 	}
2417 
2418 	rcu_read_lock();
2419 	u_size = rcu_dereference(mdev->ldev->disk_conf)->disk_size;
2420 	rcu_read_unlock();
2421 	if (u_size != (sector_t)rs.resize_size) {
2422 		new_disk_conf = kmalloc(sizeof(struct disk_conf), GFP_KERNEL);
2423 		if (!new_disk_conf) {
2424 			retcode = ERR_NOMEM;
2425 			goto fail_ldev;
2426 		}
2427 	}
2428 
2429 	if (mdev->ldev->md.al_stripes != rs.al_stripes ||
2430 	    mdev->ldev->md.al_stripe_size_4k != rs.al_stripe_size / 4) {
2431 		u32 al_size_k = rs.al_stripes * rs.al_stripe_size;
2432 
2433 		if (al_size_k > (16 * 1024 * 1024)) {
2434 			retcode = ERR_MD_LAYOUT_TOO_BIG;
2435 			goto fail_ldev;
2436 		}
2437 
2438 		if (al_size_k < MD_32kB_SECT/2) {
2439 			retcode = ERR_MD_LAYOUT_TOO_SMALL;
2440 			goto fail_ldev;
2441 		}
2442 
2443 		if (mdev->state.conn != C_CONNECTED) {
2444 			retcode = ERR_MD_LAYOUT_CONNECTED;
2445 			goto fail_ldev;
2446 		}
2447 
2448 		change_al_layout = true;
2449 	}
2450 
2451 	if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev))
2452 		mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);
2453 
2454 	if (new_disk_conf) {
2455 		mutex_lock(&mdev->tconn->conf_update);
2456 		old_disk_conf = mdev->ldev->disk_conf;
2457 		*new_disk_conf = *old_disk_conf;
2458 		new_disk_conf->disk_size = (sector_t)rs.resize_size;
2459 		rcu_assign_pointer(mdev->ldev->disk_conf, new_disk_conf);
2460 		mutex_unlock(&mdev->tconn->conf_update);
2461 		synchronize_rcu();
2462 		kfree(old_disk_conf);
2463 	}
2464 
2465 	ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0);
2466 	dd = drbd_determine_dev_size(mdev, ddsf, change_al_layout ? &rs : NULL);
2467 	drbd_md_sync(mdev);
2468 	put_ldev(mdev);
2469 	if (dd == DS_ERROR) {
2470 		retcode = ERR_NOMEM_BITMAP;
2471 		goto fail;
2472 	} else if (dd == DS_ERROR_SPACE_MD) {
2473 		retcode = ERR_MD_LAYOUT_NO_FIT;
2474 		goto fail;
2475 	} else if (dd == DS_ERROR_SHRINK) {
2476 		retcode = ERR_IMPLICIT_SHRINK;
2477 		goto fail;
2478 	}
2479 
2480 	if (mdev->state.conn == C_CONNECTED) {
2481 		if (dd == DS_GREW)
2482 			set_bit(RESIZE_PENDING, &mdev->flags);
2483 
2484 		drbd_send_uuids(mdev);
2485 		drbd_send_sizes(mdev, 1, ddsf);
2486 	}
2487 
2488  fail:
2489 	drbd_adm_finish(info, retcode);
2490 	return 0;
2491 
2492  fail_ldev:
2493 	put_ldev(mdev);
2494 	goto fail;
2495 }
2496 
2497 int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info)
2498 {
2499 	enum drbd_ret_code retcode;
2500 	struct drbd_tconn *tconn;
2501 	struct res_opts res_opts;
2502 	int err;
2503 
2504 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
2505 	if (!adm_ctx.reply_skb)
2506 		return retcode;
2507 	if (retcode != NO_ERROR)
2508 		goto fail;
2509 	tconn = adm_ctx.tconn;
2510 
2511 	res_opts = tconn->res_opts;
2512 	if (should_set_defaults(info))
2513 		set_res_opts_defaults(&res_opts);
2514 
2515 	err = res_opts_from_attrs(&res_opts, info);
2516 	if (err && err != -ENOMSG) {
2517 		retcode = ERR_MANDATORY_TAG;
2518 		drbd_msg_put_info(from_attrs_err_to_txt(err));
2519 		goto fail;
2520 	}
2521 
2522 	err = set_resource_options(tconn, &res_opts);
2523 	if (err) {
2524 		retcode = ERR_INVALID_REQUEST;
2525 		if (err == -ENOMEM)
2526 			retcode = ERR_NOMEM;
2527 	}
2528 
2529 fail:
2530 	drbd_adm_finish(info, retcode);
2531 	return 0;
2532 }
2533 
2534 int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
2535 {
2536 	struct drbd_conf *mdev;
2537 	int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
2538 
2539 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2540 	if (!adm_ctx.reply_skb)
2541 		return retcode;
2542 	if (retcode != NO_ERROR)
2543 		goto out;
2544 
2545 	mdev = adm_ctx.mdev;
2546 
2547 	/* If there is still bitmap IO pending, probably because of a previous
2548 	 * resync just being finished, wait for it before requesting a new resync.
2549 	 * Also wait for it's after_state_ch(). */
2550 	drbd_suspend_io(mdev);
2551 	wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
2552 	drbd_flush_workqueue(mdev);
2553 
2554 	/* If we happen to be C_STANDALONE R_SECONDARY, just change to
2555 	 * D_INCONSISTENT, and set all bits in the bitmap.  Otherwise,
2556 	 * try to start a resync handshake as sync target for full sync.
2557 	 */
2558 	if (mdev->state.conn == C_STANDALONE && mdev->state.role == R_SECONDARY) {
2559 		retcode = drbd_request_state(mdev, NS(disk, D_INCONSISTENT));
2560 		if (retcode >= SS_SUCCESS) {
2561 			if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
2562 				"set_n_write from invalidate", BM_LOCKED_MASK))
2563 				retcode = ERR_IO_MD_DISK;
2564 		}
2565 	} else
2566 		retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
2567 	drbd_resume_io(mdev);
2568 
2569 out:
2570 	drbd_adm_finish(info, retcode);
2571 	return 0;
2572 }
2573 
2574 static int drbd_adm_simple_request_state(struct sk_buff *skb, struct genl_info *info,
2575 		union drbd_state mask, union drbd_state val)
2576 {
2577 	enum drbd_ret_code retcode;
2578 
2579 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2580 	if (!adm_ctx.reply_skb)
2581 		return retcode;
2582 	if (retcode != NO_ERROR)
2583 		goto out;
2584 
2585 	retcode = drbd_request_state(adm_ctx.mdev, mask, val);
2586 out:
2587 	drbd_adm_finish(info, retcode);
2588 	return 0;
2589 }
2590 
2591 static int drbd_bmio_set_susp_al(struct drbd_conf *mdev)
2592 {
2593 	int rv;
2594 
2595 	rv = drbd_bmio_set_n_write(mdev);
2596 	drbd_suspend_al(mdev);
2597 	return rv;
2598 }
2599 
2600 int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info)
2601 {
2602 	int retcode; /* drbd_ret_code, drbd_state_rv */
2603 	struct drbd_conf *mdev;
2604 
2605 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2606 	if (!adm_ctx.reply_skb)
2607 		return retcode;
2608 	if (retcode != NO_ERROR)
2609 		goto out;
2610 
2611 	mdev = adm_ctx.mdev;
2612 
2613 	/* If there is still bitmap IO pending, probably because of a previous
2614 	 * resync just being finished, wait for it before requesting a new resync.
2615 	 * Also wait for it's after_state_ch(). */
2616 	drbd_suspend_io(mdev);
2617 	wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
2618 	drbd_flush_workqueue(mdev);
2619 
2620 	/* If we happen to be C_STANDALONE R_PRIMARY, just set all bits
2621 	 * in the bitmap.  Otherwise, try to start a resync handshake
2622 	 * as sync source for full sync.
2623 	 */
2624 	if (mdev->state.conn == C_STANDALONE && mdev->state.role == R_PRIMARY) {
2625 		/* The peer will get a resync upon connect anyways. Just make that
2626 		   into a full resync. */
2627 		retcode = drbd_request_state(mdev, NS(pdsk, D_INCONSISTENT));
2628 		if (retcode >= SS_SUCCESS) {
2629 			if (drbd_bitmap_io(mdev, &drbd_bmio_set_susp_al,
2630 				"set_n_write from invalidate_peer",
2631 				BM_LOCKED_SET_ALLOWED))
2632 				retcode = ERR_IO_MD_DISK;
2633 		}
2634 	} else
2635 		retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_S));
2636 	drbd_resume_io(mdev);
2637 
2638 out:
2639 	drbd_adm_finish(info, retcode);
2640 	return 0;
2641 }
2642 
2643 int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info)
2644 {
2645 	enum drbd_ret_code retcode;
2646 
2647 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2648 	if (!adm_ctx.reply_skb)
2649 		return retcode;
2650 	if (retcode != NO_ERROR)
2651 		goto out;
2652 
2653 	if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
2654 		retcode = ERR_PAUSE_IS_SET;
2655 out:
2656 	drbd_adm_finish(info, retcode);
2657 	return 0;
2658 }
2659 
2660 int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info)
2661 {
2662 	union drbd_dev_state s;
2663 	enum drbd_ret_code retcode;
2664 
2665 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2666 	if (!adm_ctx.reply_skb)
2667 		return retcode;
2668 	if (retcode != NO_ERROR)
2669 		goto out;
2670 
2671 	if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
2672 		s = adm_ctx.mdev->state;
2673 		if (s.conn == C_PAUSED_SYNC_S || s.conn == C_PAUSED_SYNC_T) {
2674 			retcode = s.aftr_isp ? ERR_PIC_AFTER_DEP :
2675 				  s.peer_isp ? ERR_PIC_PEER_DEP : ERR_PAUSE_IS_CLEAR;
2676 		} else {
2677 			retcode = ERR_PAUSE_IS_CLEAR;
2678 		}
2679 	}
2680 
2681 out:
2682 	drbd_adm_finish(info, retcode);
2683 	return 0;
2684 }
2685 
2686 int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info)
2687 {
2688 	return drbd_adm_simple_request_state(skb, info, NS(susp, 1));
2689 }
2690 
2691 int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info)
2692 {
2693 	struct drbd_conf *mdev;
2694 	int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
2695 
2696 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2697 	if (!adm_ctx.reply_skb)
2698 		return retcode;
2699 	if (retcode != NO_ERROR)
2700 		goto out;
2701 
2702 	mdev = adm_ctx.mdev;
2703 	if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
2704 		drbd_uuid_new_current(mdev);
2705 		clear_bit(NEW_CUR_UUID, &mdev->flags);
2706 	}
2707 	drbd_suspend_io(mdev);
2708 	retcode = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
2709 	if (retcode == SS_SUCCESS) {
2710 		if (mdev->state.conn < C_CONNECTED)
2711 			tl_clear(mdev->tconn);
2712 		if (mdev->state.disk == D_DISKLESS || mdev->state.disk == D_FAILED)
2713 			tl_restart(mdev->tconn, FAIL_FROZEN_DISK_IO);
2714 	}
2715 	drbd_resume_io(mdev);
2716 
2717 out:
2718 	drbd_adm_finish(info, retcode);
2719 	return 0;
2720 }
2721 
2722 int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info)
2723 {
2724 	return drbd_adm_simple_request_state(skb, info, NS(disk, D_OUTDATED));
2725 }
2726 
2727 int nla_put_drbd_cfg_context(struct sk_buff *skb, struct drbd_tconn *tconn, unsigned vnr)
2728 {
2729 	struct nlattr *nla;
2730 	nla = nla_nest_start(skb, DRBD_NLA_CFG_CONTEXT);
2731 	if (!nla)
2732 		goto nla_put_failure;
2733 	if (vnr != VOLUME_UNSPECIFIED &&
2734 	    nla_put_u32(skb, T_ctx_volume, vnr))
2735 		goto nla_put_failure;
2736 	if (nla_put_string(skb, T_ctx_resource_name, tconn->name))
2737 		goto nla_put_failure;
2738 	if (tconn->my_addr_len &&
2739 	    nla_put(skb, T_ctx_my_addr, tconn->my_addr_len, &tconn->my_addr))
2740 		goto nla_put_failure;
2741 	if (tconn->peer_addr_len &&
2742 	    nla_put(skb, T_ctx_peer_addr, tconn->peer_addr_len, &tconn->peer_addr))
2743 		goto nla_put_failure;
2744 	nla_nest_end(skb, nla);
2745 	return 0;
2746 
2747 nla_put_failure:
2748 	if (nla)
2749 		nla_nest_cancel(skb, nla);
2750 	return -EMSGSIZE;
2751 }
2752 
2753 int nla_put_status_info(struct sk_buff *skb, struct drbd_conf *mdev,
2754 		const struct sib_info *sib)
2755 {
2756 	struct state_info *si = NULL; /* for sizeof(si->member); */
2757 	struct nlattr *nla;
2758 	int got_ldev;
2759 	int err = 0;
2760 	int exclude_sensitive;
2761 
2762 	/* If sib != NULL, this is drbd_bcast_event, which anyone can listen
2763 	 * to.  So we better exclude_sensitive information.
2764 	 *
2765 	 * If sib == NULL, this is drbd_adm_get_status, executed synchronously
2766 	 * in the context of the requesting user process. Exclude sensitive
2767 	 * information, unless current has superuser.
2768 	 *
2769 	 * NOTE: for drbd_adm_get_status_all(), this is a netlink dump, and
2770 	 * relies on the current implementation of netlink_dump(), which
2771 	 * executes the dump callback successively from netlink_recvmsg(),
2772 	 * always in the context of the receiving process */
2773 	exclude_sensitive = sib || !capable(CAP_SYS_ADMIN);
2774 
2775 	got_ldev = get_ldev(mdev);
2776 
2777 	/* We need to add connection name and volume number information still.
2778 	 * Minor number is in drbd_genlmsghdr. */
2779 	if (nla_put_drbd_cfg_context(skb, mdev->tconn, mdev->vnr))
2780 		goto nla_put_failure;
2781 
2782 	if (res_opts_to_skb(skb, &mdev->tconn->res_opts, exclude_sensitive))
2783 		goto nla_put_failure;
2784 
2785 	rcu_read_lock();
2786 	if (got_ldev) {
2787 		struct disk_conf *disk_conf;
2788 
2789 		disk_conf = rcu_dereference(mdev->ldev->disk_conf);
2790 		err = disk_conf_to_skb(skb, disk_conf, exclude_sensitive);
2791 	}
2792 	if (!err) {
2793 		struct net_conf *nc;
2794 
2795 		nc = rcu_dereference(mdev->tconn->net_conf);
2796 		if (nc)
2797 			err = net_conf_to_skb(skb, nc, exclude_sensitive);
2798 	}
2799 	rcu_read_unlock();
2800 	if (err)
2801 		goto nla_put_failure;
2802 
2803 	nla = nla_nest_start(skb, DRBD_NLA_STATE_INFO);
2804 	if (!nla)
2805 		goto nla_put_failure;
2806 	if (nla_put_u32(skb, T_sib_reason, sib ? sib->sib_reason : SIB_GET_STATUS_REPLY) ||
2807 	    nla_put_u32(skb, T_current_state, mdev->state.i) ||
2808 	    nla_put_u64(skb, T_ed_uuid, mdev->ed_uuid) ||
2809 	    nla_put_u64(skb, T_capacity, drbd_get_capacity(mdev->this_bdev)) ||
2810 	    nla_put_u64(skb, T_send_cnt, mdev->send_cnt) ||
2811 	    nla_put_u64(skb, T_recv_cnt, mdev->recv_cnt) ||
2812 	    nla_put_u64(skb, T_read_cnt, mdev->read_cnt) ||
2813 	    nla_put_u64(skb, T_writ_cnt, mdev->writ_cnt) ||
2814 	    nla_put_u64(skb, T_al_writ_cnt, mdev->al_writ_cnt) ||
2815 	    nla_put_u64(skb, T_bm_writ_cnt, mdev->bm_writ_cnt) ||
2816 	    nla_put_u32(skb, T_ap_bio_cnt, atomic_read(&mdev->ap_bio_cnt)) ||
2817 	    nla_put_u32(skb, T_ap_pending_cnt, atomic_read(&mdev->ap_pending_cnt)) ||
2818 	    nla_put_u32(skb, T_rs_pending_cnt, atomic_read(&mdev->rs_pending_cnt)))
2819 		goto nla_put_failure;
2820 
2821 	if (got_ldev) {
2822 		int err;
2823 
2824 		spin_lock_irq(&mdev->ldev->md.uuid_lock);
2825 		err = nla_put(skb, T_uuids, sizeof(si->uuids), mdev->ldev->md.uuid);
2826 		spin_unlock_irq(&mdev->ldev->md.uuid_lock);
2827 
2828 		if (err)
2829 			goto nla_put_failure;
2830 
2831 		if (nla_put_u32(skb, T_disk_flags, mdev->ldev->md.flags) ||
2832 		    nla_put_u64(skb, T_bits_total, drbd_bm_bits(mdev)) ||
2833 		    nla_put_u64(skb, T_bits_oos, drbd_bm_total_weight(mdev)))
2834 			goto nla_put_failure;
2835 		if (C_SYNC_SOURCE <= mdev->state.conn &&
2836 		    C_PAUSED_SYNC_T >= mdev->state.conn) {
2837 			if (nla_put_u64(skb, T_bits_rs_total, mdev->rs_total) ||
2838 			    nla_put_u64(skb, T_bits_rs_failed, mdev->rs_failed))
2839 				goto nla_put_failure;
2840 		}
2841 	}
2842 
2843 	if (sib) {
2844 		switch(sib->sib_reason) {
2845 		case SIB_SYNC_PROGRESS:
2846 		case SIB_GET_STATUS_REPLY:
2847 			break;
2848 		case SIB_STATE_CHANGE:
2849 			if (nla_put_u32(skb, T_prev_state, sib->os.i) ||
2850 			    nla_put_u32(skb, T_new_state, sib->ns.i))
2851 				goto nla_put_failure;
2852 			break;
2853 		case SIB_HELPER_POST:
2854 			if (nla_put_u32(skb, T_helper_exit_code,
2855 					sib->helper_exit_code))
2856 				goto nla_put_failure;
2857 			/* fall through */
2858 		case SIB_HELPER_PRE:
2859 			if (nla_put_string(skb, T_helper, sib->helper_name))
2860 				goto nla_put_failure;
2861 			break;
2862 		}
2863 	}
2864 	nla_nest_end(skb, nla);
2865 
2866 	if (0)
2867 nla_put_failure:
2868 		err = -EMSGSIZE;
2869 	if (got_ldev)
2870 		put_ldev(mdev);
2871 	return err;
2872 }
2873 
2874 int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info)
2875 {
2876 	enum drbd_ret_code retcode;
2877 	int err;
2878 
2879 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
2880 	if (!adm_ctx.reply_skb)
2881 		return retcode;
2882 	if (retcode != NO_ERROR)
2883 		goto out;
2884 
2885 	err = nla_put_status_info(adm_ctx.reply_skb, adm_ctx.mdev, NULL);
2886 	if (err) {
2887 		nlmsg_free(adm_ctx.reply_skb);
2888 		return err;
2889 	}
2890 out:
2891 	drbd_adm_finish(info, retcode);
2892 	return 0;
2893 }
2894 
2895 int get_one_status(struct sk_buff *skb, struct netlink_callback *cb)
2896 {
2897 	struct drbd_conf *mdev;
2898 	struct drbd_genlmsghdr *dh;
2899 	struct drbd_tconn *pos = (struct drbd_tconn*)cb->args[0];
2900 	struct drbd_tconn *tconn = NULL;
2901 	struct drbd_tconn *tmp;
2902 	unsigned volume = cb->args[1];
2903 
2904 	/* Open coded, deferred, iteration:
2905 	 * list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
2906 	 *	idr_for_each_entry(&tconn->volumes, mdev, i) {
2907 	 *	  ...
2908 	 *	}
2909 	 * }
2910 	 * where tconn is cb->args[0];
2911 	 * and i is cb->args[1];
2912 	 *
2913 	 * cb->args[2] indicates if we shall loop over all resources,
2914 	 * or just dump all volumes of a single resource.
2915 	 *
2916 	 * This may miss entries inserted after this dump started,
2917 	 * or entries deleted before they are reached.
2918 	 *
2919 	 * We need to make sure the mdev won't disappear while
2920 	 * we are looking at it, and revalidate our iterators
2921 	 * on each iteration.
2922 	 */
2923 
2924 	/* synchronize with conn_create()/conn_destroy() */
2925 	rcu_read_lock();
2926 	/* revalidate iterator position */
2927 	list_for_each_entry_rcu(tmp, &drbd_tconns, all_tconn) {
2928 		if (pos == NULL) {
2929 			/* first iteration */
2930 			pos = tmp;
2931 			tconn = pos;
2932 			break;
2933 		}
2934 		if (tmp == pos) {
2935 			tconn = pos;
2936 			break;
2937 		}
2938 	}
2939 	if (tconn) {
2940 next_tconn:
2941 		mdev = idr_get_next(&tconn->volumes, &volume);
2942 		if (!mdev) {
2943 			/* No more volumes to dump on this tconn.
2944 			 * Advance tconn iterator. */
2945 			pos = list_entry_rcu(tconn->all_tconn.next,
2946 					     struct drbd_tconn, all_tconn);
2947 			/* Did we dump any volume on this tconn yet? */
2948 			if (volume != 0) {
2949 				/* If we reached the end of the list,
2950 				 * or only a single resource dump was requested,
2951 				 * we are done. */
2952 				if (&pos->all_tconn == &drbd_tconns || cb->args[2])
2953 					goto out;
2954 				volume = 0;
2955 				tconn = pos;
2956 				goto next_tconn;
2957 			}
2958 		}
2959 
2960 		dh = genlmsg_put(skb, NETLINK_CB(cb->skb).portid,
2961 				cb->nlh->nlmsg_seq, &drbd_genl_family,
2962 				NLM_F_MULTI, DRBD_ADM_GET_STATUS);
2963 		if (!dh)
2964 			goto out;
2965 
2966 		if (!mdev) {
2967 			/* This is a tconn without a single volume.
2968 			 * Suprisingly enough, it may have a network
2969 			 * configuration. */
2970 			struct net_conf *nc;
2971 			dh->minor = -1U;
2972 			dh->ret_code = NO_ERROR;
2973 			if (nla_put_drbd_cfg_context(skb, tconn, VOLUME_UNSPECIFIED))
2974 				goto cancel;
2975 			nc = rcu_dereference(tconn->net_conf);
2976 			if (nc && net_conf_to_skb(skb, nc, 1) != 0)
2977 				goto cancel;
2978 			goto done;
2979 		}
2980 
2981 		D_ASSERT(mdev->vnr == volume);
2982 		D_ASSERT(mdev->tconn == tconn);
2983 
2984 		dh->minor = mdev_to_minor(mdev);
2985 		dh->ret_code = NO_ERROR;
2986 
2987 		if (nla_put_status_info(skb, mdev, NULL)) {
2988 cancel:
2989 			genlmsg_cancel(skb, dh);
2990 			goto out;
2991 		}
2992 done:
2993 		genlmsg_end(skb, dh);
2994         }
2995 
2996 out:
2997 	rcu_read_unlock();
2998 	/* where to start the next iteration */
2999         cb->args[0] = (long)pos;
3000         cb->args[1] = (pos == tconn) ? volume + 1 : 0;
3001 
3002 	/* No more tconns/volumes/minors found results in an empty skb.
3003 	 * Which will terminate the dump. */
3004         return skb->len;
3005 }
3006 
3007 /*
3008  * Request status of all resources, or of all volumes within a single resource.
3009  *
3010  * This is a dump, as the answer may not fit in a single reply skb otherwise.
3011  * Which means we cannot use the family->attrbuf or other such members, because
3012  * dump is NOT protected by the genl_lock().  During dump, we only have access
3013  * to the incoming skb, and need to opencode "parsing" of the nlattr payload.
3014  *
3015  * Once things are setup properly, we call into get_one_status().
3016  */
3017 int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb)
3018 {
3019 	const unsigned hdrlen = GENL_HDRLEN + GENL_MAGIC_FAMILY_HDRSZ;
3020 	struct nlattr *nla;
3021 	const char *resource_name;
3022 	struct drbd_tconn *tconn;
3023 	int maxtype;
3024 
3025 	/* Is this a followup call? */
3026 	if (cb->args[0]) {
3027 		/* ... of a single resource dump,
3028 		 * and the resource iterator has been advanced already? */
3029 		if (cb->args[2] && cb->args[2] != cb->args[0])
3030 			return 0; /* DONE. */
3031 		goto dump;
3032 	}
3033 
3034 	/* First call (from netlink_dump_start).  We need to figure out
3035 	 * which resource(s) the user wants us to dump. */
3036 	nla = nla_find(nlmsg_attrdata(cb->nlh, hdrlen),
3037 			nlmsg_attrlen(cb->nlh, hdrlen),
3038 			DRBD_NLA_CFG_CONTEXT);
3039 
3040 	/* No explicit context given.  Dump all. */
3041 	if (!nla)
3042 		goto dump;
3043 	maxtype = ARRAY_SIZE(drbd_cfg_context_nl_policy) - 1;
3044 	nla = drbd_nla_find_nested(maxtype, nla, __nla_type(T_ctx_resource_name));
3045 	if (IS_ERR(nla))
3046 		return PTR_ERR(nla);
3047 	/* context given, but no name present? */
3048 	if (!nla)
3049 		return -EINVAL;
3050 	resource_name = nla_data(nla);
3051 	tconn = conn_get_by_name(resource_name);
3052 
3053 	if (!tconn)
3054 		return -ENODEV;
3055 
3056 	kref_put(&tconn->kref, &conn_destroy); /* get_one_status() (re)validates tconn by itself */
3057 
3058 	/* prime iterators, and set "filter" mode mark:
3059 	 * only dump this tconn. */
3060 	cb->args[0] = (long)tconn;
3061 	/* cb->args[1] = 0; passed in this way. */
3062 	cb->args[2] = (long)tconn;
3063 
3064 dump:
3065 	return get_one_status(skb, cb);
3066 }
3067 
3068 int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info)
3069 {
3070 	enum drbd_ret_code retcode;
3071 	struct timeout_parms tp;
3072 	int err;
3073 
3074 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
3075 	if (!adm_ctx.reply_skb)
3076 		return retcode;
3077 	if (retcode != NO_ERROR)
3078 		goto out;
3079 
3080 	tp.timeout_type =
3081 		adm_ctx.mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED :
3082 		test_bit(USE_DEGR_WFC_T, &adm_ctx.mdev->flags) ? UT_DEGRADED :
3083 		UT_DEFAULT;
3084 
3085 	err = timeout_parms_to_priv_skb(adm_ctx.reply_skb, &tp);
3086 	if (err) {
3087 		nlmsg_free(adm_ctx.reply_skb);
3088 		return err;
3089 	}
3090 out:
3091 	drbd_adm_finish(info, retcode);
3092 	return 0;
3093 }
3094 
3095 int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info)
3096 {
3097 	struct drbd_conf *mdev;
3098 	enum drbd_ret_code retcode;
3099 	struct start_ov_parms parms;
3100 
3101 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
3102 	if (!adm_ctx.reply_skb)
3103 		return retcode;
3104 	if (retcode != NO_ERROR)
3105 		goto out;
3106 
3107 	mdev = adm_ctx.mdev;
3108 
3109 	/* resume from last known position, if possible */
3110 	parms.ov_start_sector = mdev->ov_start_sector;
3111 	parms.ov_stop_sector = ULLONG_MAX;
3112 	if (info->attrs[DRBD_NLA_START_OV_PARMS]) {
3113 		int err = start_ov_parms_from_attrs(&parms, info);
3114 		if (err) {
3115 			retcode = ERR_MANDATORY_TAG;
3116 			drbd_msg_put_info(from_attrs_err_to_txt(err));
3117 			goto out;
3118 		}
3119 	}
3120 	/* w_make_ov_request expects position to be aligned */
3121 	mdev->ov_start_sector = parms.ov_start_sector & ~(BM_SECT_PER_BIT-1);
3122 	mdev->ov_stop_sector = parms.ov_stop_sector;
3123 
3124 	/* If there is still bitmap IO pending, e.g. previous resync or verify
3125 	 * just being finished, wait for it before requesting a new resync. */
3126 	drbd_suspend_io(mdev);
3127 	wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
3128 	retcode = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
3129 	drbd_resume_io(mdev);
3130 out:
3131 	drbd_adm_finish(info, retcode);
3132 	return 0;
3133 }
3134 
3135 
3136 int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
3137 {
3138 	struct drbd_conf *mdev;
3139 	enum drbd_ret_code retcode;
3140 	int skip_initial_sync = 0;
3141 	int err;
3142 	struct new_c_uuid_parms args;
3143 
3144 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
3145 	if (!adm_ctx.reply_skb)
3146 		return retcode;
3147 	if (retcode != NO_ERROR)
3148 		goto out_nolock;
3149 
3150 	mdev = adm_ctx.mdev;
3151 	memset(&args, 0, sizeof(args));
3152 	if (info->attrs[DRBD_NLA_NEW_C_UUID_PARMS]) {
3153 		err = new_c_uuid_parms_from_attrs(&args, info);
3154 		if (err) {
3155 			retcode = ERR_MANDATORY_TAG;
3156 			drbd_msg_put_info(from_attrs_err_to_txt(err));
3157 			goto out_nolock;
3158 		}
3159 	}
3160 
3161 	mutex_lock(mdev->state_mutex); /* Protects us against serialized state changes. */
3162 
3163 	if (!get_ldev(mdev)) {
3164 		retcode = ERR_NO_DISK;
3165 		goto out;
3166 	}
3167 
3168 	/* this is "skip initial sync", assume to be clean */
3169 	if (mdev->state.conn == C_CONNECTED && mdev->tconn->agreed_pro_version >= 90 &&
3170 	    mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) {
3171 		dev_info(DEV, "Preparing to skip initial sync\n");
3172 		skip_initial_sync = 1;
3173 	} else if (mdev->state.conn != C_STANDALONE) {
3174 		retcode = ERR_CONNECTED;
3175 		goto out_dec;
3176 	}
3177 
3178 	drbd_uuid_set(mdev, UI_BITMAP, 0); /* Rotate UI_BITMAP to History 1, etc... */
3179 	drbd_uuid_new_current(mdev); /* New current, previous to UI_BITMAP */
3180 
3181 	if (args.clear_bm) {
3182 		err = drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
3183 			"clear_n_write from new_c_uuid", BM_LOCKED_MASK);
3184 		if (err) {
3185 			dev_err(DEV, "Writing bitmap failed with %d\n",err);
3186 			retcode = ERR_IO_MD_DISK;
3187 		}
3188 		if (skip_initial_sync) {
3189 			drbd_send_uuids_skip_initial_sync(mdev);
3190 			_drbd_uuid_set(mdev, UI_BITMAP, 0);
3191 			drbd_print_uuids(mdev, "cleared bitmap UUID");
3192 			spin_lock_irq(&mdev->tconn->req_lock);
3193 			_drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
3194 					CS_VERBOSE, NULL);
3195 			spin_unlock_irq(&mdev->tconn->req_lock);
3196 		}
3197 	}
3198 
3199 	drbd_md_sync(mdev);
3200 out_dec:
3201 	put_ldev(mdev);
3202 out:
3203 	mutex_unlock(mdev->state_mutex);
3204 out_nolock:
3205 	drbd_adm_finish(info, retcode);
3206 	return 0;
3207 }
3208 
3209 static enum drbd_ret_code
3210 drbd_check_resource_name(const char *name)
3211 {
3212 	if (!name || !name[0]) {
3213 		drbd_msg_put_info("resource name missing");
3214 		return ERR_MANDATORY_TAG;
3215 	}
3216 	/* if we want to use these in sysfs/configfs/debugfs some day,
3217 	 * we must not allow slashes */
3218 	if (strchr(name, '/')) {
3219 		drbd_msg_put_info("invalid resource name");
3220 		return ERR_INVALID_REQUEST;
3221 	}
3222 	return NO_ERROR;
3223 }
3224 
3225 int drbd_adm_new_resource(struct sk_buff *skb, struct genl_info *info)
3226 {
3227 	enum drbd_ret_code retcode;
3228 	struct res_opts res_opts;
3229 	int err;
3230 
3231 	retcode = drbd_adm_prepare(skb, info, 0);
3232 	if (!adm_ctx.reply_skb)
3233 		return retcode;
3234 	if (retcode != NO_ERROR)
3235 		goto out;
3236 
3237 	set_res_opts_defaults(&res_opts);
3238 	err = res_opts_from_attrs(&res_opts, info);
3239 	if (err && err != -ENOMSG) {
3240 		retcode = ERR_MANDATORY_TAG;
3241 		drbd_msg_put_info(from_attrs_err_to_txt(err));
3242 		goto out;
3243 	}
3244 
3245 	retcode = drbd_check_resource_name(adm_ctx.resource_name);
3246 	if (retcode != NO_ERROR)
3247 		goto out;
3248 
3249 	if (adm_ctx.tconn) {
3250 		if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) {
3251 			retcode = ERR_INVALID_REQUEST;
3252 			drbd_msg_put_info("resource exists");
3253 		}
3254 		/* else: still NO_ERROR */
3255 		goto out;
3256 	}
3257 
3258 	if (!conn_create(adm_ctx.resource_name, &res_opts))
3259 		retcode = ERR_NOMEM;
3260 out:
3261 	drbd_adm_finish(info, retcode);
3262 	return 0;
3263 }
3264 
3265 int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info)
3266 {
3267 	struct drbd_genlmsghdr *dh = info->userhdr;
3268 	enum drbd_ret_code retcode;
3269 
3270 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
3271 	if (!adm_ctx.reply_skb)
3272 		return retcode;
3273 	if (retcode != NO_ERROR)
3274 		goto out;
3275 
3276 	if (dh->minor > MINORMASK) {
3277 		drbd_msg_put_info("requested minor out of range");
3278 		retcode = ERR_INVALID_REQUEST;
3279 		goto out;
3280 	}
3281 	if (adm_ctx.volume > DRBD_VOLUME_MAX) {
3282 		drbd_msg_put_info("requested volume id out of range");
3283 		retcode = ERR_INVALID_REQUEST;
3284 		goto out;
3285 	}
3286 
3287 	/* drbd_adm_prepare made sure already
3288 	 * that mdev->tconn and mdev->vnr match the request. */
3289 	if (adm_ctx.mdev) {
3290 		if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
3291 			retcode = ERR_MINOR_EXISTS;
3292 		/* else: still NO_ERROR */
3293 		goto out;
3294 	}
3295 
3296 	retcode = conn_new_minor(adm_ctx.tconn, dh->minor, adm_ctx.volume);
3297 out:
3298 	drbd_adm_finish(info, retcode);
3299 	return 0;
3300 }
3301 
3302 static enum drbd_ret_code adm_delete_minor(struct drbd_conf *mdev)
3303 {
3304 	if (mdev->state.disk == D_DISKLESS &&
3305 	    /* no need to be mdev->state.conn == C_STANDALONE &&
3306 	     * we may want to delete a minor from a live replication group.
3307 	     */
3308 	    mdev->state.role == R_SECONDARY) {
3309 		_drbd_request_state(mdev, NS(conn, C_WF_REPORT_PARAMS),
3310 				    CS_VERBOSE + CS_WAIT_COMPLETE);
3311 		idr_remove(&mdev->tconn->volumes, mdev->vnr);
3312 		idr_remove(&minors, mdev_to_minor(mdev));
3313 		destroy_workqueue(mdev->submit.wq);
3314 		del_gendisk(mdev->vdisk);
3315 		synchronize_rcu();
3316 		kref_put(&mdev->kref, &drbd_minor_destroy);
3317 		return NO_ERROR;
3318 	} else
3319 		return ERR_MINOR_CONFIGURED;
3320 }
3321 
3322 int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info)
3323 {
3324 	enum drbd_ret_code retcode;
3325 
3326 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
3327 	if (!adm_ctx.reply_skb)
3328 		return retcode;
3329 	if (retcode != NO_ERROR)
3330 		goto out;
3331 
3332 	retcode = adm_delete_minor(adm_ctx.mdev);
3333 out:
3334 	drbd_adm_finish(info, retcode);
3335 	return 0;
3336 }
3337 
3338 int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
3339 {
3340 	int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */
3341 	struct drbd_conf *mdev;
3342 	unsigned i;
3343 
3344 	retcode = drbd_adm_prepare(skb, info, 0);
3345 	if (!adm_ctx.reply_skb)
3346 		return retcode;
3347 	if (retcode != NO_ERROR)
3348 		goto out;
3349 
3350 	if (!adm_ctx.tconn) {
3351 		retcode = ERR_RES_NOT_KNOWN;
3352 		goto out;
3353 	}
3354 
3355 	/* demote */
3356 	idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
3357 		retcode = drbd_set_role(mdev, R_SECONDARY, 0);
3358 		if (retcode < SS_SUCCESS) {
3359 			drbd_msg_put_info("failed to demote");
3360 			goto out;
3361 		}
3362 	}
3363 
3364 	retcode = conn_try_disconnect(adm_ctx.tconn, 0);
3365 	if (retcode < SS_SUCCESS) {
3366 		drbd_msg_put_info("failed to disconnect");
3367 		goto out;
3368 	}
3369 
3370 	/* detach */
3371 	idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
3372 		retcode = adm_detach(mdev, 0);
3373 		if (retcode < SS_SUCCESS || retcode > NO_ERROR) {
3374 			drbd_msg_put_info("failed to detach");
3375 			goto out;
3376 		}
3377 	}
3378 
3379 	/* If we reach this, all volumes (of this tconn) are Secondary,
3380 	 * Disconnected, Diskless, aka Unconfigured. Make sure all threads have
3381 	 * actually stopped, state handling only does drbd_thread_stop_nowait(). */
3382 	drbd_thread_stop(&adm_ctx.tconn->worker);
3383 
3384 	/* Now, nothing can fail anymore */
3385 
3386 	/* delete volumes */
3387 	idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
3388 		retcode = adm_delete_minor(mdev);
3389 		if (retcode != NO_ERROR) {
3390 			/* "can not happen" */
3391 			drbd_msg_put_info("failed to delete volume");
3392 			goto out;
3393 		}
3394 	}
3395 
3396 	/* delete connection */
3397 	if (conn_lowest_minor(adm_ctx.tconn) < 0) {
3398 		list_del_rcu(&adm_ctx.tconn->all_tconn);
3399 		synchronize_rcu();
3400 		kref_put(&adm_ctx.tconn->kref, &conn_destroy);
3401 
3402 		retcode = NO_ERROR;
3403 	} else {
3404 		/* "can not happen" */
3405 		retcode = ERR_RES_IN_USE;
3406 		drbd_msg_put_info("failed to delete connection");
3407 	}
3408 	goto out;
3409 out:
3410 	drbd_adm_finish(info, retcode);
3411 	return 0;
3412 }
3413 
3414 int drbd_adm_del_resource(struct sk_buff *skb, struct genl_info *info)
3415 {
3416 	enum drbd_ret_code retcode;
3417 
3418 	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_RESOURCE);
3419 	if (!adm_ctx.reply_skb)
3420 		return retcode;
3421 	if (retcode != NO_ERROR)
3422 		goto out;
3423 
3424 	if (conn_lowest_minor(adm_ctx.tconn) < 0) {
3425 		list_del_rcu(&adm_ctx.tconn->all_tconn);
3426 		synchronize_rcu();
3427 		kref_put(&adm_ctx.tconn->kref, &conn_destroy);
3428 
3429 		retcode = NO_ERROR;
3430 	} else {
3431 		retcode = ERR_RES_IN_USE;
3432 	}
3433 
3434 	if (retcode == NO_ERROR)
3435 		drbd_thread_stop(&adm_ctx.tconn->worker);
3436 out:
3437 	drbd_adm_finish(info, retcode);
3438 	return 0;
3439 }
3440 
3441 void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib)
3442 {
3443 	static atomic_t drbd_genl_seq = ATOMIC_INIT(2); /* two. */
3444 	struct sk_buff *msg;
3445 	struct drbd_genlmsghdr *d_out;
3446 	unsigned seq;
3447 	int err = -ENOMEM;
3448 
3449 	if (sib->sib_reason == SIB_SYNC_PROGRESS) {
3450 		if (time_after(jiffies, mdev->rs_last_bcast + HZ))
3451 			mdev->rs_last_bcast = jiffies;
3452 		else
3453 			return;
3454 	}
3455 
3456 	seq = atomic_inc_return(&drbd_genl_seq);
3457 	msg = genlmsg_new(NLMSG_GOODSIZE, GFP_NOIO);
3458 	if (!msg)
3459 		goto failed;
3460 
3461 	err = -EMSGSIZE;
3462 	d_out = genlmsg_put(msg, 0, seq, &drbd_genl_family, 0, DRBD_EVENT);
3463 	if (!d_out) /* cannot happen, but anyways. */
3464 		goto nla_put_failure;
3465 	d_out->minor = mdev_to_minor(mdev);
3466 	d_out->ret_code = NO_ERROR;
3467 
3468 	if (nla_put_status_info(msg, mdev, sib))
3469 		goto nla_put_failure;
3470 	genlmsg_end(msg, d_out);
3471 	err = drbd_genl_multicast_events(msg, 0);
3472 	/* msg has been consumed or freed in netlink_broadcast() */
3473 	if (err && err != -ESRCH)
3474 		goto failed;
3475 
3476 	return;
3477 
3478 nla_put_failure:
3479 	nlmsg_free(msg);
3480 failed:
3481 	dev_err(DEV, "Error %d while broadcasting event. "
3482 			"Event seq:%u sib_reason:%u\n",
3483 			err, seq, sib->sib_reason);
3484 }
3485