drbd_nl.c 84.1 KB
Newer Older
P
Philipp Reisner 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
/*
   drbd_nl.c

   This file is part of DRBD by Philipp Reisner and Lars Ellenberg.

   Copyright (C) 2001-2008, LINBIT Information Technologies GmbH.
   Copyright (C) 1999-2008, Philipp Reisner <philipp.reisner@linbit.com>.
   Copyright (C) 2002-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.

   drbd is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   drbd is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with drbd; see the file COPYING.  If not, write to
   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <linux/module.h>
#include <linux/drbd.h>
#include <linux/in.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/slab.h>
#include <linux/blkpg.h>
#include <linux/cpumask.h>
#include "drbd_int.h"
35
#include "drbd_req.h"
P
Philipp Reisner 已提交
36 37 38
#include "drbd_wrappers.h"
#include <asm/unaligned.h>
#include <linux/drbd_limits.h>
39
#include <linux/kthread.h>
P
Philipp Reisner 已提交
40

41 42 43 44 45 46 47 48 49 50 51
#include <net/genetlink.h>

/* .doit */
// int drbd_adm_create_resource(struct sk_buff *skb, struct genl_info *info);
// int drbd_adm_delete_resource(struct sk_buff *skb, struct genl_info *info);

int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info);

int drbd_adm_create_connection(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_delete_connection(struct sk_buff *skb, struct genl_info *info);
52
int drbd_adm_down(struct sk_buff *skb, struct genl_info *info);
53 54 55

int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info);
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 58
int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info);
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 61 62 63 64 65 66 67 68 69 70
int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info);
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 73 74 75 76 77 78 79 80
int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info);
int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info);
/* .dumpit */
int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb);

#include <linux/drbd_genl_api.h>
#include <linux/genl_magic_func.h>

/* used blkdev_get_by_path, to claim our meta data device(s) */
P
Philipp Reisner 已提交
81 82
static char *drbd_m_holder = "Hands off! this is DRBD's meta data device.";

83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
/* Configuration is strictly serialized, because generic netlink message
 * processing is strictly serialized by the genl_lock().
 * Which means we can use one static global drbd_config_context struct.
 */
static struct drbd_config_context {
	/* assigned from drbd_genlmsghdr */
	unsigned int minor;
	/* assigned from request attributes, if present */
	unsigned int volume;
#define VOLUME_UNSPECIFIED		(-1U)
	/* pointer into the request skb,
	 * limited lifetime! */
	char *conn_name;

	/* reply buffer */
	struct sk_buff *reply_skb;
	/* pointer into reply buffer */
	struct drbd_genlmsghdr *reply_dh;
	/* resolved from attributes, if possible */
	struct drbd_conf *mdev;
	struct drbd_tconn *tconn;
} adm_ctx;

static void drbd_adm_send_reply(struct sk_buff *skb, struct genl_info *info)
{
	genlmsg_end(skb, genlmsg_data(nlmsg_data(nlmsg_hdr(skb))));
	if (genlmsg_reply(skb, info))
		printk(KERN_ERR "drbd: error sending genl reply\n");
P
Philipp Reisner 已提交
111
}
112 113 114

/* Used on a fresh "drbd_adm_prepare"d reply_skb, this cannot fail: The only
 * reason it could fail was no space in skb, and there are 4k available. */
115
int drbd_msg_put_info(const char *info)
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
{
	struct sk_buff *skb = adm_ctx.reply_skb;
	struct nlattr *nla;
	int err = -EMSGSIZE;

	if (!info || !info[0])
		return 0;

	nla = nla_nest_start(skb, DRBD_NLA_CFG_REPLY);
	if (!nla)
		return err;

	err = nla_put_string(skb, T_info_text, info);
	if (err) {
		nla_nest_cancel(skb, nla);
		return err;
	} else
		nla_nest_end(skb, nla);
	return 0;
P
Philipp Reisner 已提交
135 136
}

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
/* This would be a good candidate for a "pre_doit" hook,
 * and per-family private info->pointers.
 * But we need to stay compatible with older kernels.
 * If it returns successfully, adm_ctx members are valid.
 */
#define DRBD_ADM_NEED_MINOR	1
#define DRBD_ADM_NEED_CONN	2
static int drbd_adm_prepare(struct sk_buff *skb, struct genl_info *info,
		unsigned flags)
{
	struct drbd_genlmsghdr *d_in = info->userhdr;
	const u8 cmd = info->genlhdr->cmd;
	int err;

	memset(&adm_ctx, 0, sizeof(adm_ctx));

	/* genl_rcv_msg only checks for CAP_NET_ADMIN on "GENL_ADMIN_PERM" :( */
	if (cmd != DRBD_ADM_GET_STATUS
	&& security_netlink_recv(skb, CAP_SYS_ADMIN))
	       return -EPERM;

	adm_ctx.reply_skb = genlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
	if (!adm_ctx.reply_skb)
		goto fail;

	adm_ctx.reply_dh = genlmsg_put_reply(adm_ctx.reply_skb,
					info, &drbd_genl_family, 0, cmd);
	/* put of a few bytes into a fresh skb of >= 4k will always succeed.
	 * but anyways */
	if (!adm_ctx.reply_dh)
		goto fail;

	adm_ctx.reply_dh->minor = d_in->minor;
	adm_ctx.reply_dh->ret_code = NO_ERROR;

	if (info->attrs[DRBD_NLA_CFG_CONTEXT]) {
		struct nlattr *nla;
		/* parse and validate only */
175
		err = drbd_cfg_context_from_attrs(NULL, info);
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
		if (err)
			goto fail;

		/* It was present, and valid,
		 * copy it over to the reply skb. */
		err = nla_put_nohdr(adm_ctx.reply_skb,
				info->attrs[DRBD_NLA_CFG_CONTEXT]->nla_len,
				info->attrs[DRBD_NLA_CFG_CONTEXT]);
		if (err)
			goto fail;

		/* and assign stuff to the global adm_ctx */
		nla = nested_attr_tb[__nla_type(T_ctx_volume)];
		adm_ctx.volume = nla ? nla_get_u32(nla) : VOLUME_UNSPECIFIED;
		nla = nested_attr_tb[__nla_type(T_ctx_conn_name)];
		if (nla)
			adm_ctx.conn_name = nla_data(nla);
	} else
		adm_ctx.volume = VOLUME_UNSPECIFIED;

	adm_ctx.minor = d_in->minor;
	adm_ctx.mdev = minor_to_mdev(d_in->minor);
	adm_ctx.tconn = conn_by_name(adm_ctx.conn_name);

	if (!adm_ctx.mdev && (flags & DRBD_ADM_NEED_MINOR)) {
		drbd_msg_put_info("unknown minor");
		return ERR_MINOR_INVALID;
	}
	if (!adm_ctx.tconn && (flags & DRBD_ADM_NEED_CONN)) {
		drbd_msg_put_info("unknown connection");
		return ERR_INVALID_REQUEST;
	}

	/* some more paranoia, if the request was over-determined */
210 211 212 213 214 215 216
	if (adm_ctx.mdev && adm_ctx.tconn &&
	    adm_ctx.mdev->tconn != adm_ctx.tconn) {
		pr_warning("request: minor=%u, conn=%s; but that minor belongs to connection %s\n",
				adm_ctx.minor, adm_ctx.conn_name, adm_ctx.mdev->tconn->name);
		drbd_msg_put_info("minor exists in different connection");
		return ERR_INVALID_REQUEST;
	}
217 218 219 220 221 222
	if (adm_ctx.mdev &&
	    adm_ctx.volume != VOLUME_UNSPECIFIED &&
	    adm_ctx.volume != adm_ctx.mdev->vnr) {
		pr_warning("request: minor=%u, volume=%u; but that minor is volume %u in %s\n",
				adm_ctx.minor, adm_ctx.volume,
				adm_ctx.mdev->vnr, adm_ctx.mdev->tconn->name);
223
		drbd_msg_put_info("minor exists as different volume");
224 225
		return ERR_INVALID_REQUEST;
	}
226 227
	if (adm_ctx.mdev && !adm_ctx.tconn)
		adm_ctx.tconn = adm_ctx.mdev->tconn;
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
	return NO_ERROR;

fail:
	nlmsg_free(adm_ctx.reply_skb);
	adm_ctx.reply_skb = NULL;
	return -ENOMEM;
}

static int drbd_adm_finish(struct genl_info *info, int retcode)
{
	struct nlattr *nla;
	const char *conn_name = NULL;

	if (!adm_ctx.reply_skb)
		return -ENOMEM;

	adm_ctx.reply_dh->ret_code = retcode;

	nla = info->attrs[DRBD_NLA_CFG_CONTEXT];
	if (nla) {
		nla = nla_find_nested(nla, __nla_type(T_ctx_conn_name));
		if (nla)
			conn_name = nla_data(nla);
	}

	drbd_adm_send_reply(adm_ctx.reply_skb, info);
	return 0;
}
P
Philipp Reisner 已提交
256

257
static void setup_khelper_env(struct drbd_tconn *tconn, char **envp)
P
Philipp Reisner 已提交
258
{
259
	char *afs;
260
	struct net_conf *nc;
P
Philipp Reisner 已提交
261

262 263 264 265
	rcu_read_lock();
	nc = rcu_dereference(tconn->net_conf);
	if (nc) {
		switch (((struct sockaddr *)nc->peer_addr)->sa_family) {
P
Philipp Reisner 已提交
266 267
		case AF_INET6:
			afs = "ipv6";
268
			snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI6",
269
				 &((struct sockaddr_in6 *)nc->peer_addr)->sin6_addr);
P
Philipp Reisner 已提交
270 271 272
			break;
		case AF_INET:
			afs = "ipv4";
273
			snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
274
				 &((struct sockaddr_in *)nc->peer_addr)->sin_addr);
P
Philipp Reisner 已提交
275 276 277
			break;
		default:
			afs = "ssocks";
278
			snprintf(envp[4], 60, "DRBD_PEER_ADDRESS=%pI4",
279
				 &((struct sockaddr_in *)nc->peer_addr)->sin_addr);
P
Philipp Reisner 已提交
280
		}
281
		snprintf(envp[3], 20, "DRBD_PEER_AF=%s", afs);
P
Philipp Reisner 已提交
282
	}
283
	rcu_read_unlock();
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
}

int drbd_khelper(struct drbd_conf *mdev, char *cmd)
{
	char *envp[] = { "HOME=/",
			"TERM=linux",
			"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
			 (char[20]) { }, /* address family */
			 (char[60]) { }, /* address */
			NULL };
	char mb[12];
	char *argv[] = {usermode_helper, cmd, mb, NULL };
	struct sib_info sib;
	int ret;

	snprintf(mb, 12, "minor-%d", mdev_to_minor(mdev));
	setup_khelper_env(mdev->tconn, envp);
P
Philipp Reisner 已提交
301

302 303 304 305
	/* The helper may take some time.
	 * write out any unsynced meta data changes now */
	drbd_md_sync(mdev);

P
Philipp Reisner 已提交
306
	dev_info(DEV, "helper command: %s %s %s\n", usermode_helper, cmd, mb);
307 308 309
	sib.sib_reason = SIB_HELPER_PRE;
	sib.helper_name = cmd;
	drbd_bcast_event(mdev, &sib);
P
Philipp Reisner 已提交
310 311 312 313 314 315 316 317 318
	ret = call_usermodehelper(usermode_helper, argv, envp, 1);
	if (ret)
		dev_warn(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
				usermode_helper, cmd, mb,
				(ret >> 8) & 0xff, ret);
	else
		dev_info(DEV, "helper command: %s %s %s exit code %u (0x%x)\n",
				usermode_helper, cmd, mb,
				(ret >> 8) & 0xff, ret);
319 320 321
	sib.sib_reason = SIB_HELPER_POST;
	sib.helper_exit_code = ret;
	drbd_bcast_event(mdev, &sib);
P
Philipp Reisner 已提交
322 323 324 325 326 327 328

	if (ret < 0) /* Ignore any ERRNOs we got. */
		ret = 0;

	return ret;
}

329 330 331
static void conn_md_sync(struct drbd_tconn *tconn)
{
	struct drbd_conf *mdev;
P
Philipp Reisner 已提交
332
	int vnr;
333

334
	down_read(&drbd_cfg_rwsem);
P
Philipp Reisner 已提交
335
	idr_for_each_entry(&tconn->volumes, mdev, vnr)
336
		drbd_md_sync(mdev);
337
	up_read(&drbd_cfg_rwsem);
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
}

int conn_khelper(struct drbd_tconn *tconn, char *cmd)
{
	char *envp[] = { "HOME=/",
			"TERM=linux",
			"PATH=/sbin:/usr/sbin:/bin:/usr/bin",
			 (char[20]) { }, /* address family */
			 (char[60]) { }, /* address */
			NULL };
	char *argv[] = {usermode_helper, cmd, tconn->name, NULL };
	int ret;

	setup_khelper_env(tconn, envp);
	conn_md_sync(tconn);

	conn_info(tconn, "helper command: %s %s %s\n", usermode_helper, cmd, tconn->name);
	/* TODO: conn_bcast_event() ?? */

	ret = call_usermodehelper(usermode_helper, argv, envp, 1);
	if (ret)
		conn_warn(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
			  usermode_helper, cmd, tconn->name,
			  (ret >> 8) & 0xff, ret);
	else
		conn_info(tconn, "helper command: %s %s %s exit code %u (0x%x)\n",
			  usermode_helper, cmd, tconn->name,
			  (ret >> 8) & 0xff, ret);
	/* TODO: conn_bcast_event() ?? */

	if (ret < 0) /* Ignore any ERRNOs we got. */
		ret = 0;

	return ret;
}

374
static enum drbd_fencing_p highest_fencing_policy(struct drbd_tconn *tconn)
P
Philipp Reisner 已提交
375
{
376 377 378 379
	enum drbd_fencing_p fp = FP_NOT_AVAIL;
	struct drbd_conf *mdev;
	int vnr;

380
	rcu_read_lock();
381 382 383 384 385 386
	idr_for_each_entry(&tconn->volumes, mdev, vnr) {
		if (get_ldev_if_state(mdev, D_CONSISTENT)) {
			fp = max_t(enum drbd_fencing_p, fp, mdev->ldev->dc.fencing);
			put_ldev(mdev);
		}
	}
387
	rcu_read_unlock();
388 389 390 391 392 393 394 395 396

	return fp;
}

bool conn_try_outdate_peer(struct drbd_tconn *tconn)
{
	union drbd_state mask = { };
	union drbd_state val = { };
	enum drbd_fencing_p fp;
P
Philipp Reisner 已提交
397 398 399
	char *ex_to_string;
	int r;

400 401 402 403
	if (tconn->cstate >= C_WF_REPORT_PARAMS) {
		conn_err(tconn, "Expected cstate < C_WF_REPORT_PARAMS\n");
		return false;
	}
P
Philipp Reisner 已提交
404

405 406 407 408
	fp = highest_fencing_policy(tconn);
	switch (fp) {
	case FP_NOT_AVAIL:
		conn_warn(tconn, "Not fencing peer, I'm not even Consistent myself.\n");
409
		goto out;
410 411 412
	case FP_DONT_CARE:
		return true;
	default: ;
P
Philipp Reisner 已提交
413 414
	}

415
	r = conn_khelper(tconn, "fence-peer");
P
Philipp Reisner 已提交
416 417 418 419

	switch ((r>>8) & 0xff) {
	case 3: /* peer is inconsistent */
		ex_to_string = "peer is inconsistent or worse";
420 421
		mask.pdsk = D_MASK;
		val.pdsk = D_INCONSISTENT;
P
Philipp Reisner 已提交
422 423 424
		break;
	case 4: /* peer got outdated, or was already outdated */
		ex_to_string = "peer was fenced";
425 426
		mask.pdsk = D_MASK;
		val.pdsk = D_OUTDATED;
P
Philipp Reisner 已提交
427 428
		break;
	case 5: /* peer was down */
429
		if (conn_highest_disk(tconn) == D_UP_TO_DATE) {
P
Philipp Reisner 已提交
430 431
			/* we will(have) create(d) a new UUID anyways... */
			ex_to_string = "peer is unreachable, assumed to be dead";
432 433
			mask.pdsk = D_MASK;
			val.pdsk = D_OUTDATED;
P
Philipp Reisner 已提交
434 435 436 437 438 439 440 441
		} else {
			ex_to_string = "peer unreachable, doing nothing since disk != UpToDate";
		}
		break;
	case 6: /* Peer is primary, voluntarily outdate myself.
		 * This is useful when an unconnected R_SECONDARY is asked to
		 * become R_PRIMARY, but finds the other peer being active. */
		ex_to_string = "peer is active";
442 443 444
		conn_warn(tconn, "Peer is primary, outdating myself.\n");
		mask.disk = D_MASK;
		val.disk = D_OUTDATED;
P
Philipp Reisner 已提交
445 446 447
		break;
	case 7:
		if (fp != FP_STONITH)
448
			conn_err(tconn, "fence-peer() = 7 && fencing != Stonith !!!\n");
P
Philipp Reisner 已提交
449
		ex_to_string = "peer was stonithed";
450 451
		mask.pdsk = D_MASK;
		val.pdsk = D_OUTDATED;
P
Philipp Reisner 已提交
452 453 454
		break;
	default:
		/* The script is broken ... */
455 456
		conn_err(tconn, "fence-peer helper broken, returned %d\n", (r>>8)&0xff);
		return false; /* Eventually leave IO frozen */
P
Philipp Reisner 已提交
457 458
	}

459 460
	conn_info(tconn, "fence-peer helper returned %d (%s)\n",
		  (r>>8) & 0xff, ex_to_string);
461

462
 out:
463

464 465 466 467 468 469 470 471 472 473
	/* Not using
	   conn_request_state(tconn, mask, val, CS_VERBOSE);
	   here, because we might were able to re-establish the connection in the
	   meantime. */
	spin_lock_irq(&tconn->req_lock);
	if (tconn->cstate < C_WF_REPORT_PARAMS)
		_conn_request_state(tconn, mask, val, CS_VERBOSE);
	spin_unlock_irq(&tconn->req_lock);

	return conn_highest_pdsk(tconn) <= D_OUTDATED;
P
Philipp Reisner 已提交
474 475
}

476 477
static int _try_outdate_peer_async(void *data)
{
478
	struct drbd_tconn *tconn = (struct drbd_tconn *)data;
479

480
	conn_try_outdate_peer(tconn);
481 482 483 484

	return 0;
}

485
void conn_try_outdate_peer_async(struct drbd_tconn *tconn)
486 487 488
{
	struct task_struct *opa;

489
	opa = kthread_run(_try_outdate_peer_async, tconn, "drbd_async_h");
490
	if (IS_ERR(opa))
491
		conn_err(tconn, "out of mem, failed to invoke fence-peer helper\n");
492
}
P
Philipp Reisner 已提交
493

494 495
enum drbd_state_rv
drbd_set_role(struct drbd_conf *mdev, enum drbd_role new_role, int force)
P
Philipp Reisner 已提交
496 497
{
	const int max_tries = 4;
498
	enum drbd_state_rv rv = SS_UNKNOWN_ERROR;
499
	struct net_conf *nc;
P
Philipp Reisner 已提交
500 501 502 503 504
	int try = 0;
	int forced = 0;
	union drbd_state mask, val;

	if (new_role == R_PRIMARY)
505
		request_ping(mdev->tconn); /* Detect a dead peer ASAP */
P
Philipp Reisner 已提交
506

507
	mutex_lock(mdev->state_mutex);
P
Philipp Reisner 已提交
508 509 510 511 512

	mask.i = 0; mask.role = R_MASK;
	val.i  = 0; val.role  = new_role;

	while (try++ < max_tries) {
513
		rv = _drbd_request_state(mdev, mask, val, CS_WAIT_COMPLETE);
P
Philipp Reisner 已提交
514 515 516

		/* in case we first succeeded to outdate,
		 * but now suddenly could establish a connection */
517
		if (rv == SS_CW_FAILED_BY_PEER && mask.pdsk != 0) {
P
Philipp Reisner 已提交
518 519 520 521 522
			val.pdsk = 0;
			mask.pdsk = 0;
			continue;
		}

523
		if (rv == SS_NO_UP_TO_DATE_DISK && force &&
524 525
		    (mdev->state.disk < D_UP_TO_DATE &&
		     mdev->state.disk >= D_INCONSISTENT)) {
P
Philipp Reisner 已提交
526 527 528 529 530 531
			mask.disk = D_MASK;
			val.disk  = D_UP_TO_DATE;
			forced = 1;
			continue;
		}

532
		if (rv == SS_NO_UP_TO_DATE_DISK &&
P
Philipp Reisner 已提交
533 534 535
		    mdev->state.disk == D_CONSISTENT && mask.pdsk == 0) {
			D_ASSERT(mdev->state.pdsk == D_UNKNOWN);

536
			if (conn_try_outdate_peer(mdev->tconn)) {
P
Philipp Reisner 已提交
537 538 539 540 541 542
				val.disk = D_UP_TO_DATE;
				mask.disk = D_MASK;
			}
			continue;
		}

543
		if (rv == SS_NOTHING_TO_DO)
544
			goto out;
545
		if (rv == SS_PRIMARY_NOP && mask.pdsk == 0) {
546
			if (!conn_try_outdate_peer(mdev->tconn) && force) {
P
Philipp Reisner 已提交
547
				dev_warn(DEV, "Forced into split brain situation!\n");
548 549
				mask.pdsk = D_MASK;
				val.pdsk  = D_OUTDATED;
P
Philipp Reisner 已提交
550

551
			}
P
Philipp Reisner 已提交
552 553
			continue;
		}
554
		if (rv == SS_TWO_PRIMARIES) {
P
Philipp Reisner 已提交
555 556
			/* Maybe the peer is detected as dead very soon...
			   retry at most once more in this case. */
557 558 559 560 561 562
			int timeo;
			rcu_read_lock();
			nc = rcu_dereference(mdev->tconn->net_conf);
			timeo = nc ? (nc->ping_timeo + 1) * HZ / 10 : 1;
			rcu_read_unlock();
			schedule_timeout_interruptible(timeo);
P
Philipp Reisner 已提交
563 564 565 566
			if (try < max_tries)
				try = max_tries - 1;
			continue;
		}
567 568
		if (rv < SS_SUCCESS) {
			rv = _drbd_request_state(mdev, mask, val,
P
Philipp Reisner 已提交
569
						CS_VERBOSE + CS_WAIT_COMPLETE);
570
			if (rv < SS_SUCCESS)
571
				goto out;
P
Philipp Reisner 已提交
572 573 574 575
		}
		break;
	}

576
	if (rv < SS_SUCCESS)
577
		goto out;
P
Philipp Reisner 已提交
578 579 580 581 582 583 584 585

	if (forced)
		dev_warn(DEV, "Forced to consider local data as UpToDate!\n");

	/* Wait until nothing is on the fly :) */
	wait_event(mdev->misc_wait, atomic_read(&mdev->ap_pending_cnt) == 0);

	if (new_role == R_SECONDARY) {
586
		set_disk_ro(mdev->vdisk, true);
P
Philipp Reisner 已提交
587 588 589 590 591
		if (get_ldev(mdev)) {
			mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;
			put_ldev(mdev);
		}
	} else {
592 593
		mutex_lock(&mdev->tconn->net_conf_update);
		nc = mdev->tconn->net_conf;
594
		if (nc)
595 596 597
			nc->want_lose = 0; /* without copy; single bit op is atomic */
		mutex_unlock(&mdev->tconn->net_conf_update);

598
		set_disk_ro(mdev->vdisk, false);
P
Philipp Reisner 已提交
599 600 601 602 603 604 605 606 607 608 609
		if (get_ldev(mdev)) {
			if (((mdev->state.conn < C_CONNECTED ||
			       mdev->state.pdsk <= D_FAILED)
			      && mdev->ldev->md.uuid[UI_BITMAP] == 0) || forced)
				drbd_uuid_new_current(mdev);

			mdev->ldev->md.uuid[UI_CURRENT] |=  (u64)1;
			put_ldev(mdev);
		}
	}

610 611
	/* writeout of activity log covered areas of the bitmap
	 * to stable storage done in after state change already */
P
Philipp Reisner 已提交
612 613 614 615 616 617 618 619 620 621 622

	if (mdev->state.conn >= C_WF_REPORT_PARAMS) {
		/* if this was forced, we should consider sync */
		if (forced)
			drbd_send_uuids(mdev);
		drbd_send_state(mdev);
	}

	drbd_md_sync(mdev);

	kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
623
out:
624
	mutex_unlock(mdev->state_mutex);
625
	return rv;
P
Philipp Reisner 已提交
626 627
}

628
static const char *from_attrs_err_to_txt(int err)
P
Philipp Reisner 已提交
629
{
630 631
	return	err == -ENOMSG ? "required attribute missing" :
		err == -EOPNOTSUPP ? "unknown mandatory attribute" :
632
		err == -EEXIST ? "can not change invariant setting" :
633
		"invalid attribute value";
P
Philipp Reisner 已提交
634 635
}

636
int drbd_adm_set_role(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
637
{
638 639 640
	struct set_role_parms parms;
	int err;
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
641

642 643 644 645 646 647 648 649
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

	memset(&parms, 0, sizeof(parms));
	if (info->attrs[DRBD_NLA_SET_ROLE_PARMS]) {
650
		err = set_role_parms_from_attrs(&parms, info);
651 652 653 654 655 656 657 658 659 660 661 662 663
		if (err) {
			retcode = ERR_MANDATORY_TAG;
			drbd_msg_put_info(from_attrs_err_to_txt(err));
			goto out;
		}
	}

	if (info->genlhdr->cmd == DRBD_ADM_PRIMARY)
		retcode = drbd_set_role(adm_ctx.mdev, R_PRIMARY, parms.assume_uptodate);
	else
		retcode = drbd_set_role(adm_ctx.mdev, R_SECONDARY, 0);
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
	return 0;
}

/* initializes the md.*_offset members, so we are able to find
 * the on disk meta data */
static void drbd_md_set_sector_offsets(struct drbd_conf *mdev,
				       struct drbd_backing_dev *bdev)
{
	sector_t md_size_sect = 0;
	switch (bdev->dc.meta_dev_idx) {
	default:
		/* v07 style fixed size indexed meta data */
		bdev->md.md_size_sect = MD_RESERVED_SECT;
		bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
		bdev->md.al_offset = MD_AL_OFFSET;
		bdev->md.bm_offset = MD_BM_OFFSET;
		break;
	case DRBD_MD_INDEX_FLEX_EXT:
		/* just occupy the full device; unit: sectors */
		bdev->md.md_size_sect = drbd_get_capacity(bdev->md_bdev);
		bdev->md.md_offset = 0;
		bdev->md.al_offset = MD_AL_OFFSET;
		bdev->md.bm_offset = MD_BM_OFFSET;
		break;
	case DRBD_MD_INDEX_INTERNAL:
	case DRBD_MD_INDEX_FLEX_INT:
		bdev->md.md_offset = drbd_md_ss__(mdev, bdev);
		/* al size is still fixed */
692
		bdev->md.al_offset = -MD_AL_SECTORS;
P
Philipp Reisner 已提交
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
		/* we need (slightly less than) ~ this much bitmap sectors: */
		md_size_sect = drbd_get_capacity(bdev->backing_bdev);
		md_size_sect = ALIGN(md_size_sect, BM_SECT_PER_EXT);
		md_size_sect = BM_SECT_TO_EXT(md_size_sect);
		md_size_sect = ALIGN(md_size_sect, 8);

		/* plus the "drbd meta data super block",
		 * and the activity log; */
		md_size_sect += MD_BM_OFFSET;

		bdev->md.md_size_sect = md_size_sect;
		/* bitmap offset is adjusted by 'super' block size */
		bdev->md.bm_offset   = -md_size_sect + MD_AL_OFFSET;
		break;
	}
}

710
/* input size is expected to be in KB */
P
Philipp Reisner 已提交
711 712
char *ppsize(char *buf, unsigned long long size)
{
713 714
	/* Needs 9 bytes at max including trailing NUL:
	 * -1ULL ==> "16384 EB" */
P
Philipp Reisner 已提交
715 716
	static char units[] = { 'K', 'M', 'G', 'T', 'P', 'E' };
	int base = 0;
717
	while (size >= 10000 && base < sizeof(units)-1) {
P
Philipp Reisner 已提交
718 719 720 721
		/* shift + round */
		size = (size >> 10) + !!(size & (1<<9));
		base++;
	}
722
	sprintf(buf, "%u %cB", (unsigned)size, units[base]);
P
Philipp Reisner 已提交
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739

	return buf;
}

/* there is still a theoretical deadlock when called from receiver
 * on an D_INCONSISTENT R_PRIMARY:
 *  remote READ does inc_ap_bio, receiver would need to receive answer
 *  packet from remote to dec_ap_bio again.
 *  receiver receive_sizes(), comes here,
 *  waits for ap_bio_cnt == 0. -> deadlock.
 * but this cannot happen, actually, because:
 *  R_PRIMARY D_INCONSISTENT, and peer's disk is unreachable
 *  (not connected, or bad/no disk on peer):
 *  see drbd_fail_request_early, ap_bio_cnt is zero.
 *  R_PRIMARY D_INCONSISTENT, and C_SYNC_TARGET:
 *  peer may not initiate a resize.
 */
740 741 742 743 744 745
/* Note these are not to be confused with
 * drbd_adm_suspend_io/drbd_adm_resume_io,
 * which are (sub) state changes triggered by admin (drbdsetup),
 * and can be long lived.
 * This changes an mdev->flag, is triggered by drbd internals,
 * and should be short-lived. */
P
Philipp Reisner 已提交
746 747 748
void drbd_suspend_io(struct drbd_conf *mdev)
{
	set_bit(SUSPEND_IO, &mdev->flags);
749
	if (drbd_suspended(mdev))
750
		return;
P
Philipp Reisner 已提交
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
	wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_bio_cnt));
}

void drbd_resume_io(struct drbd_conf *mdev)
{
	clear_bit(SUSPEND_IO, &mdev->flags);
	wake_up(&mdev->misc_wait);
}

/**
 * drbd_determine_dev_size() -  Sets the right device size obeying all constraints
 * @mdev:	DRBD device.
 *
 * Returns 0 on success, negative return values indicate errors.
 * You should call drbd_md_sync() after calling this function.
 */
B
Bart Van Assche 已提交
767
enum determine_dev_size drbd_determine_dev_size(struct drbd_conf *mdev, enum dds_flags flags) __must_hold(local)
P
Philipp Reisner 已提交
768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
{
	sector_t prev_first_sect, prev_size; /* previous meta location */
	sector_t la_size;
	sector_t size;
	char ppb[10];

	int md_moved, la_size_changed;
	enum determine_dev_size rv = unchanged;

	/* race:
	 * application request passes inc_ap_bio,
	 * but then cannot get an AL-reference.
	 * this function later may wait on ap_bio_cnt == 0. -> deadlock.
	 *
	 * to avoid that:
	 * Suspend IO right here.
	 * still lock the act_log to not trigger ASSERTs there.
	 */
	drbd_suspend_io(mdev);

	/* no wait necessary anymore, actually we could assert that */
	wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));

	prev_first_sect = drbd_md_first_sector(mdev->ldev);
	prev_size = mdev->ldev->md.md_size_sect;
	la_size = mdev->ldev->md.la_size_sect;

	/* TODO: should only be some assert here, not (re)init... */
	drbd_md_set_sector_offsets(mdev, mdev->ldev);

798
	size = drbd_new_dev_size(mdev, mdev->ldev, flags & DDSF_FORCED);
P
Philipp Reisner 已提交
799 800 801 802

	if (drbd_get_capacity(mdev->this_bdev) != size ||
	    drbd_bm_capacity(mdev) != size) {
		int err;
803
		err = drbd_bm_resize(mdev, size, !(flags & DDSF_NO_RESYNC));
P
Philipp Reisner 已提交
804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
		if (unlikely(err)) {
			/* currently there is only one error: ENOMEM! */
			size = drbd_bm_capacity(mdev)>>1;
			if (size == 0) {
				dev_err(DEV, "OUT OF MEMORY! "
				    "Could not allocate bitmap!\n");
			} else {
				dev_err(DEV, "BM resizing failed. "
				    "Leaving size unchanged at size = %lu KB\n",
				    (unsigned long)size);
			}
			rv = dev_size_error;
		}
		/* racy, see comments above. */
		drbd_set_my_capacity(mdev, size);
		mdev->ldev->md.la_size_sect = size;
		dev_info(DEV, "size = %s (%llu KB)\n", ppsize(ppb, size>>1),
		     (unsigned long long)size>>1);
	}
	if (rv == dev_size_error)
		goto out;

	la_size_changed = (la_size != mdev->ldev->md.la_size_sect);

	md_moved = prev_first_sect != drbd_md_first_sector(mdev->ldev)
		|| prev_size	   != mdev->ldev->md.md_size_sect;

	if (la_size_changed || md_moved) {
832 833
		int err;

P
Philipp Reisner 已提交
834 835 836 837
		drbd_al_shrink(mdev); /* All extents inactive. */
		dev_info(DEV, "Writing the whole bitmap, %s\n",
			 la_size_changed && md_moved ? "size changed and md moved" :
			 la_size_changed ? "size changed" : "md moved");
838 839 840
		/* next line implicitly does drbd_suspend_io()+drbd_resume_io() */
		err = drbd_bitmap_io(mdev, &drbd_bm_write,
				"size changed", BM_LOCKED_MASK);
841 842 843 844
		if (err) {
			rv = dev_size_error;
			goto out;
		}
P
Philipp Reisner 已提交
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
		drbd_md_mark_dirty(mdev);
	}

	if (size > la_size)
		rv = grew;
	if (size < la_size)
		rv = shrunk;
out:
	lc_unlock(mdev->act_log);
	wake_up(&mdev->al_wait);
	drbd_resume_io(mdev);

	return rv;
}

sector_t
861
drbd_new_dev_size(struct drbd_conf *mdev, struct drbd_backing_dev *bdev, int assume_peer_has_space)
P
Philipp Reisner 已提交
862 863 864 865 866 867 868 869 870
{
	sector_t p_size = mdev->p_size;   /* partner's disk size. */
	sector_t la_size = bdev->md.la_size_sect; /* last agreed size. */
	sector_t m_size; /* my size */
	sector_t u_size = bdev->dc.disk_size; /* size requested by user. */
	sector_t size = 0;

	m_size = drbd_get_max_capacity(bdev);

871 872 873 874 875
	if (mdev->state.conn < C_CONNECTED && assume_peer_has_space) {
		dev_warn(DEV, "Resize while not connected was forced by the user!\n");
		p_size = m_size;
	}

P
Philipp Reisner 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
	if (p_size && m_size) {
		size = min_t(sector_t, p_size, m_size);
	} else {
		if (la_size) {
			size = la_size;
			if (m_size && m_size < size)
				size = m_size;
			if (p_size && p_size < size)
				size = p_size;
		} else {
			if (m_size)
				size = m_size;
			if (p_size)
				size = p_size;
		}
	}

	if (size == 0)
		dev_err(DEV, "Both nodes diskless!\n");

	if (u_size) {
		if (u_size > size)
			dev_err(DEV, "Requested disk size is too big (%lu > %lu)\n",
			    (unsigned long)u_size>>1, (unsigned long)size>>1);
		else
			size = u_size;
	}

	return size;
}

/**
 * drbd_check_al_size() - Ensures that the AL is of the right size
 * @mdev:	DRBD device.
 *
 * Returns -EBUSY if current al lru is still used, -ENOMEM when allocation
 * failed, and 0 on success. You should call drbd_md_sync() after you called
 * this function.
 */
915
static int drbd_check_al_size(struct drbd_conf *mdev, struct disk_conf *dc)
P
Philipp Reisner 已提交
916 917 918 919 920 921
{
	struct lru_cache *n, *t;
	struct lc_element *e;
	unsigned int in_use;
	int i;

922 923
	if (!expect(dc->al_extents >= DRBD_AL_EXTENTS_MIN))
		dc->al_extents = DRBD_AL_EXTENTS_MIN;
P
Philipp Reisner 已提交
924 925

	if (mdev->act_log &&
926
	    mdev->act_log->nr_elements == dc->al_extents)
P
Philipp Reisner 已提交
927 928 929 930
		return 0;

	in_use = 0;
	t = mdev->act_log;
931
	n = lc_create("act_log", drbd_al_ext_cache, AL_UPDATES_PER_TRANSACTION,
932
		dc->al_extents, sizeof(struct lc_element), 0);
P
Philipp Reisner 已提交
933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962

	if (n == NULL) {
		dev_err(DEV, "Cannot allocate act_log lru!\n");
		return -ENOMEM;
	}
	spin_lock_irq(&mdev->al_lock);
	if (t) {
		for (i = 0; i < t->nr_elements; i++) {
			e = lc_element_by_index(t, i);
			if (e->refcnt)
				dev_err(DEV, "refcnt(%d)==%d\n",
				    e->lc_number, e->refcnt);
			in_use += e->refcnt;
		}
	}
	if (!in_use)
		mdev->act_log = n;
	spin_unlock_irq(&mdev->al_lock);
	if (in_use) {
		dev_err(DEV, "Activity log still in use!\n");
		lc_destroy(n);
		return -EBUSY;
	} else {
		if (t)
			lc_destroy(t);
	}
	drbd_md_mark_dirty(mdev); /* we changed mdev->act_log->nr_elemens */
	return 0;
}

963
static void drbd_setup_queue_param(struct drbd_conf *mdev, unsigned int max_bio_size)
P
Philipp Reisner 已提交
964 965
{
	struct request_queue * const q = mdev->rq_queue;
966 967 968 969 970 971 972 973 974 975
	int max_hw_sectors = max_bio_size >> 9;
	int max_segments = 0;

	if (get_ldev_if_state(mdev, D_ATTACHING)) {
		struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;

		max_hw_sectors = min(queue_max_hw_sectors(b), max_bio_size >> 9);
		max_segments = mdev->ldev->dc.max_bio_bvecs;
		put_ldev(mdev);
	}
P
Philipp Reisner 已提交
976 977

	blk_queue_logical_block_size(q, 512);
978 979 980 981
	blk_queue_max_hw_sectors(q, max_hw_sectors);
	/* This is the workaround for "bio would need to, but cannot, be split" */
	blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
	blk_queue_segment_boundary(q, PAGE_CACHE_SIZE-1);
P
Philipp Reisner 已提交
982

983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
	if (get_ldev_if_state(mdev, D_ATTACHING)) {
		struct request_queue * const b = mdev->ldev->backing_bdev->bd_disk->queue;

		blk_queue_stack_limits(q, b);

		if (q->backing_dev_info.ra_pages != b->backing_dev_info.ra_pages) {
			dev_info(DEV, "Adjusting my ra_pages to backing device's (%lu -> %lu)\n",
				 q->backing_dev_info.ra_pages,
				 b->backing_dev_info.ra_pages);
			q->backing_dev_info.ra_pages = b->backing_dev_info.ra_pages;
		}
		put_ldev(mdev);
	}
}

void drbd_reconsider_max_bio_size(struct drbd_conf *mdev)
{
	int now, new, local, peer;

	now = queue_max_hw_sectors(mdev->rq_queue) << 9;
	local = mdev->local_max_bio_size; /* Eventually last known value, from volatile memory */
	peer = mdev->peer_max_bio_size; /* Eventually last known value, from meta data */
P
Philipp Reisner 已提交
1005

1006 1007 1008 1009
	if (get_ldev_if_state(mdev, D_ATTACHING)) {
		local = queue_max_hw_sectors(mdev->ldev->backing_bdev->bd_disk->queue) << 9;
		mdev->local_max_bio_size = local;
		put_ldev(mdev);
P
Philipp Reisner 已提交
1010
	}
1011 1012 1013 1014 1015

	/* We may ignore peer limits if the peer is modern enough.
	   Because new from 8.3.8 onwards the peer can use multiple
	   BIOs for a single peer_request */
	if (mdev->state.conn >= C_CONNECTED) {
1016
		if (mdev->tconn->agreed_pro_version < 94)
1017
			peer = mdev->peer_max_bio_size;
1018
		else if (mdev->tconn->agreed_pro_version == 94)
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
			peer = DRBD_MAX_SIZE_H80_PACKET;
		else /* drbd 8.3.8 onwards */
			peer = DRBD_MAX_BIO_SIZE;
	}

	new = min_t(int, local, peer);

	if (mdev->state.role == R_PRIMARY && new < now)
		dev_err(DEV, "ASSERT FAILED new < now; (%d < %d)\n", new, now);

	if (new != now)
		dev_info(DEV, "max BIO size = %u\n", new);

	drbd_setup_queue_param(mdev, new);
P
Philipp Reisner 已提交
1033 1034 1035 1036 1037
}

/* serialize deconfig (worker exiting, doing cleanup)
 * and reconfig (drbdsetup disk, drbdsetup net)
 *
1038 1039 1040
 * Wait for a potentially exiting worker, then restart it,
 * or start a new one.  Flush any pending work, there may still be an
 * after_state_change queued.
P
Philipp Reisner 已提交
1041
 */
1042
static void conn_reconfig_start(struct drbd_tconn *tconn)
P
Philipp Reisner 已提交
1043
{
1044 1045 1046 1047
	wait_event(tconn->ping_wait, !test_and_set_bit(CONFIG_PENDING, &tconn->flags));
	wait_event(tconn->ping_wait, !test_bit(OBJECT_DYING, &tconn->flags));
	drbd_thread_start(&tconn->worker);
	conn_flush_workqueue(tconn);
P
Philipp Reisner 已提交
1048 1049 1050 1051 1052
}

/* if still unconfigured, stops worker again.
 * if configured now, clears CONFIG_PENDING.
 * wakes potential waiters */
1053
static void conn_reconfig_done(struct drbd_tconn *tconn)
P
Philipp Reisner 已提交
1054
{
1055 1056 1057 1058
	spin_lock_irq(&tconn->req_lock);
	if (conn_all_vols_unconf(tconn)) {
		set_bit(OBJECT_DYING, &tconn->flags);
		drbd_thread_stop_nowait(&tconn->worker);
P
Philipp Reisner 已提交
1059
	} else
1060 1061 1062
		clear_bit(CONFIG_PENDING, &tconn->flags);
	spin_unlock_irq(&tconn->req_lock);
	wake_up(&tconn->ping_wait);
P
Philipp Reisner 已提交
1063 1064
}

1065 1066 1067 1068 1069
/* Make sure IO is suspended before calling this function(). */
static void drbd_suspend_al(struct drbd_conf *mdev)
{
	int s = 0;

1070
	if (!lc_try_lock(mdev->act_log)) {
1071 1072 1073 1074
		dev_warn(DEV, "Failed to lock al in drbd_suspend_al()\n");
		return;
	}

1075
	drbd_al_shrink(mdev);
1076
	spin_lock_irq(&mdev->tconn->req_lock);
1077 1078
	if (mdev->state.conn < C_CONNECTED)
		s = !test_and_set_bit(AL_SUSPENDED, &mdev->flags);
1079
	spin_unlock_irq(&mdev->tconn->req_lock);
1080
	lc_unlock(mdev->act_log);
1081 1082 1083 1084 1085

	if (s)
		dev_info(DEV, "Suspended AL updates\n");
}

1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
int drbd_adm_disk_opts(struct sk_buff *skb, struct genl_info *info)
{
	enum drbd_ret_code retcode;
	struct drbd_conf *mdev;
	struct disk_conf *ndc; /* new disk conf */
	int err, fifo_size;
	int *rs_plan_s = NULL;

	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

	mdev = adm_ctx.mdev;

	/* we also need a disk
	 * to change the options on */
	if (!get_ldev(mdev)) {
		retcode = ERR_NO_DISK;
		goto out;
	}

/* FIXME freeze IO, cluster wide.
 *
 * We should make sure no-one uses
 * some half-updated struct when we
 * assign it later. */

	ndc = kmalloc(sizeof(*ndc), GFP_KERNEL);
	if (!ndc) {
		retcode = ERR_NOMEM;
		goto fail;
	}

	memcpy(ndc, &mdev->ldev->dc, sizeof(*ndc));
	err = disk_conf_from_attrs_for_change(ndc, info);
	if (err) {
		retcode = ERR_MANDATORY_TAG;
		drbd_msg_put_info(from_attrs_err_to_txt(err));
	}

	if (!expect(ndc->resync_rate >= 1))
		ndc->resync_rate = 1;

	/* clip to allowed range */
	if (!expect(ndc->al_extents >= DRBD_AL_EXTENTS_MIN))
		ndc->al_extents = DRBD_AL_EXTENTS_MIN;
	if (!expect(ndc->al_extents <= DRBD_AL_EXTENTS_MAX))
		ndc->al_extents = DRBD_AL_EXTENTS_MAX;

	/* most sanity checks done, try to assign the new sync-after
	 * dependency.  need to hold the global lock in there,
	 * to avoid a race in the dependency loop check. */
	retcode = drbd_alter_sa(mdev, ndc->resync_after);
	if (retcode != NO_ERROR)
		goto fail;

	fifo_size = (ndc->c_plan_ahead * 10 * SLEEP_TIME) / HZ;
	if (fifo_size != mdev->rs_plan_s.size && fifo_size > 0) {
		rs_plan_s   = kzalloc(sizeof(int) * fifo_size, GFP_KERNEL);
		if (!rs_plan_s) {
			dev_err(DEV, "kmalloc of fifo_buffer failed");
			retcode = ERR_NOMEM;
			goto fail;
		}
	}

	if (fifo_size != mdev->rs_plan_s.size) {
		kfree(mdev->rs_plan_s.values);
		mdev->rs_plan_s.values = rs_plan_s;
		mdev->rs_plan_s.size   = fifo_size;
		mdev->rs_planed = 0;
		rs_plan_s = NULL;
	}

	wait_event(mdev->al_wait, lc_try_lock(mdev->act_log));
	drbd_al_shrink(mdev);
	err = drbd_check_al_size(mdev, ndc);
	lc_unlock(mdev->act_log);
	wake_up(&mdev->al_wait);

	if (err) {
		retcode = ERR_NOMEM;
		goto fail;
	}

	/* FIXME
	 * To avoid someone looking at a half-updated struct, we probably
	 * should have a rw-semaphor on net_conf and disk_conf.
	 */
	mdev->ldev->dc = *ndc;

	drbd_md_sync(mdev);


	if (mdev->state.conn >= C_CONNECTED)
		drbd_send_sync_param(mdev);

 fail:
	put_ldev(mdev);
	kfree(ndc);
	kfree(rs_plan_s);
 out:
	drbd_adm_finish(info, retcode);
	return 0;
}

1194
int drbd_adm_attach(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
1195
{
1196 1197
	struct drbd_conf *mdev;
	int err;
1198
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
1199 1200 1201 1202
	enum determine_dev_size dd;
	sector_t max_possible_sectors;
	sector_t min_md_device_sectors;
	struct drbd_backing_dev *nbc = NULL; /* new_backing_conf */
1203
	struct block_device *bdev;
P
Philipp Reisner 已提交
1204 1205
	struct lru_cache *resync_lru = NULL;
	union drbd_state ns, os;
1206
	enum drbd_state_rv rv;
1207
	struct net_conf *nc;
P
Philipp Reisner 已提交
1208 1209
	int cp_discovered = 0;

1210 1211 1212 1213
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
1214
		goto finish;
1215 1216

	mdev = adm_ctx.mdev;
1217
	conn_reconfig_start(mdev->tconn);
P
Philipp Reisner 已提交
1218 1219 1220 1221 1222 1223

	/* if you want to reconfigure, please tear down first */
	if (mdev->state.disk > D_DISKLESS) {
		retcode = ERR_DISK_CONFIGURED;
		goto fail;
	}
1224 1225 1226 1227 1228
	/* It may just now have detached because of IO error.  Make sure
	 * drbd_ldev_destroy is done already, we may end up here very fast,
	 * e.g. if someone calls attach from the on-io-error handler,
	 * to realize a "hot spare" feature (not that I'd recommend that) */
	wait_event(mdev->misc_wait, !atomic_read(&mdev->local_cnt));
P
Philipp Reisner 已提交
1229

1230
	/* allocation not in the IO path, drbdsetup context */
P
Philipp Reisner 已提交
1231 1232 1233 1234 1235 1236
	nbc = kzalloc(sizeof(struct drbd_backing_dev), GFP_KERNEL);
	if (!nbc) {
		retcode = ERR_NOMEM;
		goto fail;
	}

1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259
	nbc->dc = (struct disk_conf) {
		{}, 0, /* backing_dev */
		{}, 0, /* meta_dev */
		0, /* meta_dev_idx */
		DRBD_DISK_SIZE_SECT_DEF, /* disk_size */
		DRBD_MAX_BIO_BVECS_DEF, /* max_bio_bvecs */
		DRBD_ON_IO_ERROR_DEF, /* on_io_error */
		DRBD_FENCING_DEF, /* fencing */
		DRBD_RATE_DEF, /* resync_rate */
		DRBD_AFTER_DEF, /* resync_after */
		DRBD_AL_EXTENTS_DEF, /* al_extents */
		DRBD_C_PLAN_AHEAD_DEF, /* c_plan_ahead */
		DRBD_C_DELAY_TARGET_DEF, /* c_delay_target */
		DRBD_C_FILL_TARGET_DEF, /* c_fill_target */
		DRBD_C_MAX_RATE_DEF, /* c_max_rate */
		DRBD_C_MIN_RATE_DEF, /* c_min_rate */
		0, /* no_disk_barrier */
		0, /* no_disk_flush */
		0, /* no_disk_drain */
		0, /* no_md_flush */
	};

	err = disk_conf_from_attrs(&nbc->dc, info);
1260
	if (err) {
P
Philipp Reisner 已提交
1261
		retcode = ERR_MANDATORY_TAG;
1262
		drbd_msg_put_info(from_attrs_err_to_txt(err));
P
Philipp Reisner 已提交
1263 1264 1265
		goto fail;
	}

1266
	if ((int)nbc->dc.meta_dev_idx < DRBD_MD_INDEX_FLEX_INT) {
P
Philipp Reisner 已提交
1267 1268 1269 1270
		retcode = ERR_MD_IDX_INVALID;
		goto fail;
	}

1271 1272 1273 1274 1275
	rcu_read_lock();
	nc = rcu_dereference(mdev->tconn->net_conf);
	if (nc) {
		if (nbc->dc.fencing == FP_STONITH && nc->wire_protocol == DRBD_PROT_A) {
			rcu_read_unlock();
1276 1277 1278 1279
			retcode = ERR_STONITH_AND_PROT_A;
			goto fail;
		}
	}
1280
	rcu_read_unlock();
1281

1282 1283
	bdev = blkdev_get_by_path(nbc->dc.backing_dev,
				  FMODE_READ | FMODE_WRITE | FMODE_EXCL, mdev);
1284
	if (IS_ERR(bdev)) {
P
Philipp Reisner 已提交
1285
		dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.backing_dev,
1286
			PTR_ERR(bdev));
P
Philipp Reisner 已提交
1287 1288 1289
		retcode = ERR_OPEN_DISK;
		goto fail;
	}
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
	nbc->backing_bdev = bdev;

	/*
	 * meta_dev_idx >= 0: external fixed size, possibly multiple
	 * drbd sharing one meta device.  TODO in that case, paranoia
	 * check that [md_bdev, meta_dev_idx] is not yet used by some
	 * other drbd minor!  (if you use drbd.conf + drbdadm, that
	 * should check it for you already; but if you don't, or
	 * someone fooled it, we need to double check here)
	 */
1300 1301
	bdev = blkdev_get_by_path(nbc->dc.meta_dev,
				  FMODE_READ | FMODE_WRITE | FMODE_EXCL,
1302
				  ((int)nbc->dc.meta_dev_idx < 0) ?
1303
				  (void *)mdev : (void *)drbd_m_holder);
1304
	if (IS_ERR(bdev)) {
P
Philipp Reisner 已提交
1305
		dev_err(DEV, "open(\"%s\") failed with %ld\n", nbc->dc.meta_dev,
1306
			PTR_ERR(bdev));
P
Philipp Reisner 已提交
1307 1308 1309
		retcode = ERR_OPEN_MD_DISK;
		goto fail;
	}
1310
	nbc->md_bdev = bdev;
P
Philipp Reisner 已提交
1311

1312 1313 1314 1315
	if ((nbc->backing_bdev == nbc->md_bdev) !=
	    (nbc->dc.meta_dev_idx == DRBD_MD_INDEX_INTERNAL ||
	     nbc->dc.meta_dev_idx == DRBD_MD_INDEX_FLEX_INT)) {
		retcode = ERR_MD_IDX_INVALID;
P
Philipp Reisner 已提交
1316 1317 1318 1319
		goto fail;
	}

	resync_lru = lc_create("resync", drbd_bm_ext_cache,
1320
			1, 61, sizeof(struct bm_extent),
P
Philipp Reisner 已提交
1321 1322 1323
			offsetof(struct bm_extent, lce));
	if (!resync_lru) {
		retcode = ERR_NOMEM;
1324
		goto fail;
P
Philipp Reisner 已提交
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
	}

	/* RT - for drbd_get_max_capacity() DRBD_MD_INDEX_FLEX_INT */
	drbd_md_set_sector_offsets(mdev, nbc);

	if (drbd_get_max_capacity(nbc) < nbc->dc.disk_size) {
		dev_err(DEV, "max capacity %llu smaller than disk size %llu\n",
			(unsigned long long) drbd_get_max_capacity(nbc),
			(unsigned long long) nbc->dc.disk_size);
		retcode = ERR_DISK_TO_SMALL;
1335
		goto fail;
P
Philipp Reisner 已提交
1336 1337
	}

1338
	if ((int)nbc->dc.meta_dev_idx < 0) {
P
Philipp Reisner 已提交
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
		max_possible_sectors = DRBD_MAX_SECTORS_FLEX;
		/* at least one MB, otherwise it does not make sense */
		min_md_device_sectors = (2<<10);
	} else {
		max_possible_sectors = DRBD_MAX_SECTORS;
		min_md_device_sectors = MD_RESERVED_SECT * (nbc->dc.meta_dev_idx + 1);
	}

	if (drbd_get_capacity(nbc->md_bdev) < min_md_device_sectors) {
		retcode = ERR_MD_DISK_TO_SMALL;
		dev_warn(DEV, "refusing attach: md-device too small, "
		     "at least %llu sectors needed for this meta-disk type\n",
		     (unsigned long long) min_md_device_sectors);
1352
		goto fail;
P
Philipp Reisner 已提交
1353 1354 1355 1356 1357 1358 1359
	}

	/* Make sure the new disk is big enough
	 * (we may currently be R_PRIMARY with no local disk...) */
	if (drbd_get_max_capacity(nbc) <
	    drbd_get_capacity(mdev->this_bdev)) {
		retcode = ERR_DISK_TO_SMALL;
1360
		goto fail;
P
Philipp Reisner 已提交
1361 1362 1363 1364
	}

	nbc->known_size = drbd_get_capacity(nbc->backing_bdev);

1365 1366 1367 1368
	if (nbc->known_size > max_possible_sectors) {
		dev_warn(DEV, "==> truncating very big lower level device "
			"to currently maximum possible %llu sectors <==\n",
			(unsigned long long) max_possible_sectors);
1369
		if ((int)nbc->dc.meta_dev_idx >= 0)
1370 1371 1372 1373
			dev_warn(DEV, "==>> using internal or flexible "
				      "meta data may help <<==\n");
	}

P
Philipp Reisner 已提交
1374 1375
	drbd_suspend_io(mdev);
	/* also wait for the last barrier ack. */
1376
	wait_event(mdev->misc_wait, !atomic_read(&mdev->ap_pending_cnt) || drbd_suspended(mdev));
P
Philipp Reisner 已提交
1377
	/* and for any other previously queued work */
1378
	drbd_flush_workqueue(mdev);
P
Philipp Reisner 已提交
1379

1380 1381
	rv = _drbd_request_state(mdev, NS(disk, D_ATTACHING), CS_VERBOSE);
	retcode = rv;  /* FIXME: Type mismatch. */
P
Philipp Reisner 已提交
1382
	drbd_resume_io(mdev);
1383
	if (rv < SS_SUCCESS)
1384
		goto fail;
P
Philipp Reisner 已提交
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411

	if (!get_ldev_if_state(mdev, D_ATTACHING))
		goto force_diskless;

	drbd_md_set_sector_offsets(mdev, nbc);

	if (!mdev->bitmap) {
		if (drbd_bm_init(mdev)) {
			retcode = ERR_NOMEM;
			goto force_diskless_dec;
		}
	}

	retcode = drbd_md_read(mdev, nbc);
	if (retcode != NO_ERROR)
		goto force_diskless_dec;

	if (mdev->state.conn < C_CONNECTED &&
	    mdev->state.role == R_PRIMARY &&
	    (mdev->ed_uuid & ~((u64)1)) != (nbc->md.uuid[UI_CURRENT] & ~((u64)1))) {
		dev_err(DEV, "Can only attach to data with current UUID=%016llX\n",
		    (unsigned long long)mdev->ed_uuid);
		retcode = ERR_DATA_NOT_CURRENT;
		goto force_diskless_dec;
	}

	/* Since we are diskless, fix the activity log first... */
1412
	if (drbd_check_al_size(mdev, &nbc->dc)) {
P
Philipp Reisner 已提交
1413 1414 1415 1416 1417 1418
		retcode = ERR_NOMEM;
		goto force_diskless_dec;
	}

	/* Prevent shrinking of consistent devices ! */
	if (drbd_md_test_flag(nbc, MDF_CONSISTENT) &&
1419
	    drbd_new_dev_size(mdev, nbc, 0) < nbc->md.la_size_sect) {
P
Philipp Reisner 已提交
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
		dev_warn(DEV, "refusing to truncate a consistent device\n");
		retcode = ERR_DISK_TO_SMALL;
		goto force_diskless_dec;
	}

	if (!drbd_al_read_log(mdev, nbc)) {
		retcode = ERR_IO_MD_DISK;
		goto force_diskless_dec;
	}

	/* Reset the "barriers don't work" bits here, then force meta data to
	 * be written, to ensure we determine if barriers are supported. */
	if (nbc->dc.no_md_flush)
1433
		set_bit(MD_NO_FUA, &mdev->flags);
P
Philipp Reisner 已提交
1434
	else
1435
		clear_bit(MD_NO_FUA, &mdev->flags);
P
Philipp Reisner 已提交
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446

	/* Point of no return reached.
	 * Devices and memory are no longer released by error cleanup below.
	 * now mdev takes over responsibility, and the state engine should
	 * clean it up somewhere.  */
	D_ASSERT(mdev->ldev == NULL);
	mdev->ldev = nbc;
	mdev->resync = resync_lru;
	nbc = NULL;
	resync_lru = NULL;

1447 1448
	mdev->write_ordering = WO_bdev_flush;
	drbd_bump_write_ordering(mdev, WO_bdev_flush);
P
Philipp Reisner 已提交
1449 1450 1451 1452 1453 1454

	if (drbd_md_test_flag(mdev->ldev, MDF_CRASHED_PRIMARY))
		set_bit(CRASHED_PRIMARY, &mdev->flags);
	else
		clear_bit(CRASHED_PRIMARY, &mdev->flags);

1455
	if (drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
1456
	    !(mdev->state.role == R_PRIMARY && mdev->tconn->susp_nod)) {
P
Philipp Reisner 已提交
1457 1458 1459 1460 1461 1462 1463 1464 1465
		set_bit(CRASHED_PRIMARY, &mdev->flags);
		cp_discovered = 1;
	}

	mdev->send_cnt = 0;
	mdev->recv_cnt = 0;
	mdev->read_cnt = 0;
	mdev->writ_cnt = 0;

1466
	drbd_reconsider_max_bio_size(mdev);
P
Philipp Reisner 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487

	/* If I am currently not R_PRIMARY,
	 * but meta data primary indicator is set,
	 * I just now recover from a hard crash,
	 * and have been R_PRIMARY before that crash.
	 *
	 * Now, if I had no connection before that crash
	 * (have been degraded R_PRIMARY), chances are that
	 * I won't find my peer now either.
	 *
	 * In that case, and _only_ in that case,
	 * we use the degr-wfc-timeout instead of the default,
	 * so we can automatically recover from a crash of a
	 * degraded but active "cluster" after a certain timeout.
	 */
	clear_bit(USE_DEGR_WFC_T, &mdev->flags);
	if (mdev->state.role != R_PRIMARY &&
	     drbd_md_test_flag(mdev->ldev, MDF_PRIMARY_IND) &&
	    !drbd_md_test_flag(mdev->ldev, MDF_CONNECTED_IND))
		set_bit(USE_DEGR_WFC_T, &mdev->flags);

B
Bart Van Assche 已提交
1488
	dd = drbd_determine_dev_size(mdev, 0);
P
Philipp Reisner 已提交
1489 1490 1491 1492 1493 1494 1495 1496 1497
	if (dd == dev_size_error) {
		retcode = ERR_NOMEM_BITMAP;
		goto force_diskless_dec;
	} else if (dd == grew)
		set_bit(RESYNC_AFTER_NEG, &mdev->flags);

	if (drbd_md_test_flag(mdev->ldev, MDF_FULL_SYNC)) {
		dev_info(DEV, "Assuming that all blocks are out of sync "
		     "(aka FullSync)\n");
1498 1499
		if (drbd_bitmap_io(mdev, &drbd_bmio_set_n_write,
			"set_n_write from attaching", BM_LOCKED_MASK)) {
P
Philipp Reisner 已提交
1500 1501 1502 1503
			retcode = ERR_IO_MD_DISK;
			goto force_diskless_dec;
		}
	} else {
1504
		if (drbd_bitmap_io(mdev, &drbd_bm_read,
1505
			"read from attaching", BM_LOCKED_MASK)) {
P
Philipp Reisner 已提交
1506 1507 1508 1509 1510 1511 1512
			retcode = ERR_IO_MD_DISK;
			goto force_diskless_dec;
		}
	}

	if (cp_discovered) {
		drbd_al_apply_to_bm(mdev);
1513 1514
		if (drbd_bitmap_io(mdev, &drbd_bm_write,
			"crashed primary apply AL", BM_LOCKED_MASK)) {
1515 1516 1517
			retcode = ERR_IO_MD_DISK;
			goto force_diskless_dec;
		}
P
Philipp Reisner 已提交
1518 1519
	}

1520 1521 1522
	if (_drbd_bm_total_weight(mdev) == drbd_bm_bits(mdev))
		drbd_suspend_al(mdev); /* IO is still suspended here... */

1523
	spin_lock_irq(&mdev->tconn->req_lock);
1524 1525
	os = drbd_read_state(mdev);
	ns = os;
P
Philipp Reisner 已提交
1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
	/* If MDF_CONSISTENT is not set go into inconsistent state,
	   otherwise investigate MDF_WasUpToDate...
	   If MDF_WAS_UP_TO_DATE is not set go into D_OUTDATED disk state,
	   otherwise into D_CONSISTENT state.
	*/
	if (drbd_md_test_flag(mdev->ldev, MDF_CONSISTENT)) {
		if (drbd_md_test_flag(mdev->ldev, MDF_WAS_UP_TO_DATE))
			ns.disk = D_CONSISTENT;
		else
			ns.disk = D_OUTDATED;
	} else {
		ns.disk = D_INCONSISTENT;
	}

	if (drbd_md_test_flag(mdev->ldev, MDF_PEER_OUT_DATED))
		ns.pdsk = D_OUTDATED;

	if ( ns.disk == D_CONSISTENT &&
	    (ns.pdsk == D_OUTDATED || mdev->ldev->dc.fencing == FP_DONT_CARE))
		ns.disk = D_UP_TO_DATE;

	/* All tests on MDF_PRIMARY_IND, MDF_CONNECTED_IND,
	   MDF_CONSISTENT and MDF_WAS_UP_TO_DATE must happen before
	   this point, because drbd_request_state() modifies these
	   flags. */

	/* In case we are C_CONNECTED postpone any decision on the new disk
	   state after the negotiation phase. */
	if (mdev->state.conn == C_CONNECTED) {
		mdev->new_state_tmp.i = ns.i;
		ns.i = os.i;
		ns.disk = D_NEGOTIATING;
1558 1559 1560 1561 1562 1563

		/* We expect to receive up-to-date UUIDs soon.
		   To avoid a race in receive_state, free p_uuid while
		   holding req_lock. I.e. atomic with the state change */
		kfree(mdev->p_uuid);
		mdev->p_uuid = NULL;
P
Philipp Reisner 已提交
1564 1565 1566
	}

	rv = _drbd_set_state(mdev, ns, CS_VERBOSE, NULL);
1567
	spin_unlock_irq(&mdev->tconn->req_lock);
P
Philipp Reisner 已提交
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581

	if (rv < SS_SUCCESS)
		goto force_diskless_dec;

	if (mdev->state.role == R_PRIMARY)
		mdev->ldev->md.uuid[UI_CURRENT] |=  (u64)1;
	else
		mdev->ldev->md.uuid[UI_CURRENT] &= ~(u64)1;

	drbd_md_mark_dirty(mdev);
	drbd_md_sync(mdev);

	kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
	put_ldev(mdev);
1582
	conn_reconfig_done(mdev->tconn);
1583
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
1584 1585 1586 1587 1588
	return 0;

 force_diskless_dec:
	put_ldev(mdev);
 force_diskless:
1589
	drbd_force_state(mdev, NS(disk, D_FAILED));
P
Philipp Reisner 已提交
1590 1591
	drbd_md_sync(mdev);
 fail:
1592
	conn_reconfig_done(mdev->tconn);
P
Philipp Reisner 已提交
1593
	if (nbc) {
1594 1595 1596 1597 1598 1599
		if (nbc->backing_bdev)
			blkdev_put(nbc->backing_bdev,
				   FMODE_READ | FMODE_WRITE | FMODE_EXCL);
		if (nbc->md_bdev)
			blkdev_put(nbc->md_bdev,
				   FMODE_READ | FMODE_WRITE | FMODE_EXCL);
P
Philipp Reisner 已提交
1600 1601 1602 1603
		kfree(nbc);
	}
	lc_destroy(resync_lru);

1604
 finish:
1605
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
1606 1607 1608
	return 0;
}

1609 1610
static int adm_detach(struct drbd_conf *mdev)
{
1611
	enum drbd_state_rv retcode;
1612 1613 1614 1615 1616 1617 1618 1619 1620
	drbd_suspend_io(mdev); /* so no-one is stuck in drbd_al_begin_io */
	retcode = drbd_request_state(mdev, NS(disk, D_DISKLESS));
	wait_event(mdev->misc_wait,
			mdev->state.disk != D_DISKLESS ||
			!atomic_read(&mdev->local_cnt));
	drbd_resume_io(mdev);
	return retcode;
}

1621 1622 1623 1624 1625
/* Detaching the disk is a process in multiple stages.  First we need to lock
 * out application IO, in-flight IO, IO stuck in drbd_al_begin_io.
 * Then we transition to D_DISKLESS, and wait for put_ldev() to return all
 * internal references as well.
 * Only then we have finally detached. */
1626
int drbd_adm_detach(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
1627
{
L
Lars Ellenberg 已提交
1628
	enum drbd_ret_code retcode;
1629 1630 1631 1632 1633 1634 1635

	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

1636
	retcode = adm_detach(adm_ctx.mdev);
1637 1638
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
1639 1640 1641
	return 0;
}

1642 1643 1644
static bool conn_resync_running(struct drbd_tconn *tconn)
{
	struct drbd_conf *mdev;
1645
	bool rv = false;
1646 1647
	int vnr;

1648
	rcu_read_lock();
1649 1650 1651 1652
	idr_for_each_entry(&tconn->volumes, mdev, vnr) {
		if (mdev->state.conn == C_SYNC_SOURCE ||
		    mdev->state.conn == C_SYNC_TARGET ||
		    mdev->state.conn == C_PAUSED_SYNC_S ||
1653 1654 1655 1656
		    mdev->state.conn == C_PAUSED_SYNC_T) {
			rv = true;
			break;
		}
1657
	}
1658 1659 1660
	rcu_read_unlock();

	return rv;
1661 1662 1663 1664 1665
}

static bool conn_ov_running(struct drbd_tconn *tconn)
{
	struct drbd_conf *mdev;
1666
	bool rv = false;
1667 1668
	int vnr;

1669
	rcu_read_lock();
1670 1671
	idr_for_each_entry(&tconn->volumes, mdev, vnr) {
		if (mdev->state.conn == C_VERIFY_S ||
1672 1673 1674 1675
		    mdev->state.conn == C_VERIFY_T) {
			rv = true;
			break;
		}
1676
	}
1677 1678 1679
	rcu_read_unlock();

	return rv;
1680 1681
}

1682
static enum drbd_ret_code
1683
_check_net_options(struct drbd_tconn *tconn, struct net_conf *old_conf, struct net_conf *new_conf)
1684 1685 1686 1687
{
	struct drbd_conf *mdev;
	int i;

1688
	if (old_conf && tconn->agreed_pro_version < 100 &&
1689
	    tconn->cstate == C_WF_REPORT_PARAMS &&
1690
	    new_conf->wire_protocol != old_conf->wire_protocol)
1691 1692
		return ERR_NEED_APV_100;

1693 1694 1695 1696 1697 1698 1699 1700
	if (new_conf->two_primaries &&
	    (new_conf->wire_protocol != DRBD_PROT_C))
		return ERR_NOT_PROTO_C;

	idr_for_each_entry(&tconn->volumes, mdev, i) {
		if (get_ldev(mdev)) {
			enum drbd_fencing_p fp = mdev->ldev->dc.fencing;
			put_ldev(mdev);
1701
			if (new_conf->wire_protocol == DRBD_PROT_A && fp == FP_STONITH)
1702 1703
				return ERR_STONITH_AND_PROT_A;
		}
1704
		if (mdev->state.role == R_PRIMARY && new_conf->want_lose)
1705 1706 1707 1708 1709 1710 1711 1712 1713
			return ERR_DISCARD;
	}

	if (new_conf->on_congestion != OC_BLOCK && new_conf->wire_protocol != DRBD_PROT_A)
		return ERR_CONG_NOT_PROTO_A;

	return NO_ERROR;
}

1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
static enum drbd_ret_code
check_net_options(struct drbd_tconn *tconn, struct net_conf *new_conf)
{
	static enum drbd_ret_code rv;
	struct drbd_conf *mdev;
	int i;

	rcu_read_lock();
	rv = _check_net_options(tconn, rcu_dereference(tconn->net_conf), new_conf);
	rcu_read_unlock();

	/* tconn->volumes protected by genl_lock() here */
	idr_for_each_entry(&tconn->volumes, mdev, i) {
		if (!mdev->bitmap) {
			if(drbd_bm_init(mdev))
				return ERR_NOMEM;
		}
	}

	return rv;
}

1736 1737 1738 1739
int drbd_adm_net_opts(struct sk_buff *skb, struct genl_info *info)
{
	enum drbd_ret_code retcode;
	struct drbd_tconn *tconn;
1740
	struct net_conf *old_conf, *new_conf = NULL;
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
	int err;
	int ovr; /* online verify running */
	int rsr; /* re-sync running */
	struct crypto_hash *verify_tfm = NULL;
	struct crypto_hash *csums_tfm = NULL;


	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

	tconn = adm_ctx.tconn;

	new_conf = kzalloc(sizeof(struct net_conf), GFP_KERNEL);
	if (!new_conf) {
		retcode = ERR_NOMEM;
		goto out;
	}

1762 1763
	conn_reconfig_start(tconn);

1764 1765
	mutex_lock(&tconn->net_conf_update);
	old_conf = tconn->net_conf;
1766 1767

	if (!old_conf) {
1768 1769
		drbd_msg_put_info("net conf missing, try connect");
		retcode = ERR_INVALID_REQUEST;
1770
		goto fail;
1771 1772
	}

1773
	*new_conf = *old_conf;
1774 1775 1776 1777 1778 1779 1780 1781

	err = net_conf_from_attrs_for_change(new_conf, info);
	if (err) {
		retcode = ERR_MANDATORY_TAG;
		drbd_msg_put_info(from_attrs_err_to_txt(err));
		goto fail;
	}

1782 1783 1784 1785
	retcode = check_net_options(tconn, new_conf);
	if (retcode != NO_ERROR)
		goto fail;

1786 1787
	/* re-sync running */
	rsr = conn_resync_running(tconn);
1788
	if (rsr && old_conf && strcmp(new_conf->csums_alg, old_conf->csums_alg)) {
1789
		retcode = ERR_CSUMS_RESYNC_RUNNING;
1790
		goto fail;
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
	}

	if (!rsr && new_conf->csums_alg[0]) {
		csums_tfm = crypto_alloc_hash(new_conf->csums_alg, 0, CRYPTO_ALG_ASYNC);
		if (IS_ERR(csums_tfm)) {
			csums_tfm = NULL;
			retcode = ERR_CSUMS_ALG;
			goto fail;
		}

		if (!drbd_crypto_is_hash(crypto_hash_tfm(csums_tfm))) {
			retcode = ERR_CSUMS_ALG_ND;
			goto fail;
		}
	}

	/* online verify running */
	ovr = conn_ov_running(tconn);
1809
	if (ovr) {
1810
		if (strcmp(new_conf->verify_alg, old_conf->verify_alg)) {
1811
			retcode = ERR_VERIFY_RUNNING;
1812
			goto fail;
1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
		}
	}

	if (!ovr && new_conf->verify_alg[0]) {
		verify_tfm = crypto_alloc_hash(new_conf->verify_alg, 0, CRYPTO_ALG_ASYNC);
		if (IS_ERR(verify_tfm)) {
			verify_tfm = NULL;
			retcode = ERR_VERIFY_ALG;
			goto fail;
		}

		if (!drbd_crypto_is_hash(crypto_hash_tfm(verify_tfm))) {
			retcode = ERR_VERIFY_ALG_ND;
			goto fail;
		}
	}

1830
	rcu_assign_pointer(tconn->net_conf, new_conf);
1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842

	if (!rsr) {
		crypto_free_hash(tconn->csums_tfm);
		tconn->csums_tfm = csums_tfm;
		csums_tfm = NULL;
	}
	if (!ovr) {
		crypto_free_hash(tconn->verify_tfm);
		tconn->verify_tfm = verify_tfm;
		verify_tfm = NULL;
	}

1843 1844 1845 1846
	mutex_unlock(&tconn->net_conf_update);
	synchronize_rcu();
	kfree(old_conf);

1847 1848 1849
	if (tconn->cstate >= C_WF_REPORT_PARAMS)
		drbd_send_sync_param(minor_to_mdev(conn_lowest_minor(tconn)));

1850 1851
	goto done;

1852
 fail:
1853
	mutex_unlock(&tconn->net_conf_update);
1854 1855 1856
	crypto_free_hash(csums_tfm);
	crypto_free_hash(verify_tfm);
	kfree(new_conf);
1857
 done:
1858 1859 1860 1861 1862 1863
	conn_reconfig_done(tconn);
 out:
	drbd_adm_finish(info, retcode);
	return 0;
}

1864
int drbd_adm_connect(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
1865
{
1866 1867
	char hmac_name[CRYPTO_MAX_ALG_NAME];
	struct drbd_conf *mdev;
1868
	struct net_conf *old_conf, *new_conf = NULL;
P
Philipp Reisner 已提交
1869 1870 1871 1872 1873
	struct crypto_hash *tfm = NULL;
	struct crypto_hash *integrity_w_tfm = NULL;
	struct crypto_hash *integrity_r_tfm = NULL;
	void *int_dig_in = NULL;
	void *int_dig_vv = NULL;
1874
	struct drbd_tconn *oconn;
1875
	struct drbd_tconn *tconn;
P
Philipp Reisner 已提交
1876
	struct sockaddr *new_my_addr, *new_peer_addr, *taken_addr;
1877 1878 1879
	enum drbd_ret_code retcode;
	int i;
	int err;
P
Philipp Reisner 已提交
1880

1881 1882 1883 1884 1885 1886 1887
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

	tconn = adm_ctx.tconn;
1888
	conn_reconfig_start(tconn);
P
Philipp Reisner 已提交
1889

1890
	if (tconn->cstate > C_STANDALONE) {
P
Philipp Reisner 已提交
1891 1892 1893 1894 1895
		retcode = ERR_NET_CONFIGURED;
		goto fail;
	}

	/* allocation not in the IO path, cqueue thread context */
1896
	new_conf = kmalloc(sizeof(struct net_conf), GFP_KERNEL);
P
Philipp Reisner 已提交
1897 1898 1899 1900 1901
	if (!new_conf) {
		retcode = ERR_NOMEM;
		goto fail;
	}

1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936
	*new_conf = (struct net_conf) {
		{}, 0, /* my_addr */
		{}, 0, /* peer_addr */
		{}, 0, /* shared_secret */
		{}, 0, /* cram_hmac_alg */
		{}, 0, /* integrity_alg */
		{}, 0, /* verify_alg */
		{}, 0, /* csums_alg */
		DRBD_PROTOCOL_DEF, /* wire_protocol */
		DRBD_CONNECT_INT_DEF, /* try_connect_int */
		DRBD_TIMEOUT_DEF, /* timeout */
		DRBD_PING_INT_DEF, /* ping_int */
		DRBD_PING_TIMEO_DEF, /* ping_timeo */
		DRBD_SNDBUF_SIZE_DEF, /* sndbuf_size */
		DRBD_RCVBUF_SIZE_DEF, /* rcvbuf_size */
		DRBD_KO_COUNT_DEF, /* ko_count */
		DRBD_MAX_BUFFERS_DEF, /* max_buffers */
		DRBD_MAX_EPOCH_SIZE_DEF, /* max_epoch_size */
		DRBD_UNPLUG_WATERMARK_DEF, /* unplug_watermark */
		DRBD_AFTER_SB_0P_DEF, /* after_sb_0p */
		DRBD_AFTER_SB_1P_DEF, /* after_sb_1p */
		DRBD_AFTER_SB_2P_DEF, /* after_sb_2p */
		DRBD_RR_CONFLICT_DEF, /* rr_conflict */
		DRBD_ON_CONGESTION_DEF, /* on_congestion */
		DRBD_CONG_FILL_DEF, /* cong_fill */
		DRBD_CONG_EXTENTS_DEF, /* cong_extents */
		0, /* two_primaries */
		0, /* want_lose */
		0, /* no_cork */
		0, /* always_asbp */
		0, /* dry_run */
		0, /* use_rle */
	};

	err = net_conf_from_attrs(new_conf, info);
1937
	if (err) {
P
Philipp Reisner 已提交
1938
		retcode = ERR_MANDATORY_TAG;
1939
		drbd_msg_put_info(from_attrs_err_to_txt(err));
P
Philipp Reisner 已提交
1940 1941 1942
		goto fail;
	}

1943 1944
	retcode = check_net_options(tconn, new_conf);
	if (retcode != NO_ERROR)
1945 1946
		goto fail;

P
Philipp Reisner 已提交
1947 1948 1949 1950
	retcode = NO_ERROR;

	new_my_addr = (struct sockaddr *)&new_conf->my_addr;
	new_peer_addr = (struct sockaddr *)&new_conf->peer_addr;
1951

1952
	/* No need to take drbd_cfg_rwsem here.  All reconfiguration is
1953 1954
	 * strictly serialized on genl_lock(). We are protected against
	 * concurrent reconfiguration/addition/deletion */
1955
	list_for_each_entry(oconn, &drbd_tconns, all_tconn) {
1956
		struct net_conf *nc;
1957
		if (oconn == tconn)
P
Philipp Reisner 已提交
1958
			continue;
1959 1960 1961 1962 1963 1964

		rcu_read_lock();
		nc = rcu_dereference(oconn->net_conf);
		if (nc) {
			taken_addr = (struct sockaddr *)&nc->my_addr;
			if (new_conf->my_addr_len == nc->my_addr_len &&
P
Philipp Reisner 已提交
1965 1966 1967
			    !memcmp(new_my_addr, taken_addr, new_conf->my_addr_len))
				retcode = ERR_LOCAL_ADDR;

1968 1969
			taken_addr = (struct sockaddr *)&nc->peer_addr;
			if (new_conf->peer_addr_len == nc->peer_addr_len &&
P
Philipp Reisner 已提交
1970 1971 1972
			    !memcmp(new_peer_addr, taken_addr, new_conf->peer_addr_len))
				retcode = ERR_PEER_ADDR;
		}
1973 1974 1975
		rcu_read_unlock();
		if (retcode != NO_ERROR)
			goto fail;
P
Philipp Reisner 已提交
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
	}

	if (new_conf->cram_hmac_alg[0] != 0) {
		snprintf(hmac_name, CRYPTO_MAX_ALG_NAME, "hmac(%s)",
			new_conf->cram_hmac_alg);
		tfm = crypto_alloc_hash(hmac_name, 0, CRYPTO_ALG_ASYNC);
		if (IS_ERR(tfm)) {
			tfm = NULL;
			retcode = ERR_AUTH_ALG;
			goto fail;
		}

1988
		if (!drbd_crypto_is_hash(crypto_hash_tfm(tfm))) {
P
Philipp Reisner 已提交
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
			retcode = ERR_AUTH_ALG_ND;
			goto fail;
		}
	}

	if (new_conf->integrity_alg[0]) {
		integrity_w_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC);
		if (IS_ERR(integrity_w_tfm)) {
			integrity_w_tfm = NULL;
			retcode=ERR_INTEGRITY_ALG;
			goto fail;
		}

		if (!drbd_crypto_is_hash(crypto_hash_tfm(integrity_w_tfm))) {
			retcode=ERR_INTEGRITY_ALG_ND;
			goto fail;
		}

		integrity_r_tfm = crypto_alloc_hash(new_conf->integrity_alg, 0, CRYPTO_ALG_ASYNC);
		if (IS_ERR(integrity_r_tfm)) {
			integrity_r_tfm = NULL;
			retcode=ERR_INTEGRITY_ALG;
			goto fail;
		}
	}

	((char *)new_conf->shared_secret)[SHARED_SECRET_MAX-1] = 0;

2017
	/* allocation not in the IO path, cqueue thread context */
P
Philipp Reisner 已提交
2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
	if (integrity_w_tfm) {
		i = crypto_hash_digestsize(integrity_w_tfm);
		int_dig_in = kmalloc(i, GFP_KERNEL);
		if (!int_dig_in) {
			retcode = ERR_NOMEM;
			goto fail;
		}
		int_dig_vv = kmalloc(i, GFP_KERNEL);
		if (!int_dig_vv) {
			retcode = ERR_NOMEM;
			goto fail;
		}
	}

2032
	conn_flush_workqueue(tconn);
2033 2034 2035 2036

	mutex_lock(&tconn->net_conf_update);
	old_conf = tconn->net_conf;
	if (old_conf) {
P
Philipp Reisner 已提交
2037
		retcode = ERR_NET_CONFIGURED;
2038
		mutex_unlock(&tconn->net_conf_update);
P
Philipp Reisner 已提交
2039 2040
		goto fail;
	}
2041
	rcu_assign_pointer(tconn->net_conf, new_conf);
P
Philipp Reisner 已提交
2042

2043
	conn_free_crypto(tconn);
2044 2045 2046
	tconn->cram_hmac_tfm = tfm;
	tconn->integrity_w_tfm = integrity_w_tfm;
	tconn->integrity_r_tfm = integrity_r_tfm;
2047 2048
	tconn->int_dig_in = int_dig_in;
	tconn->int_dig_vv = int_dig_vv;
P
Philipp Reisner 已提交
2049

2050 2051 2052
	mutex_unlock(&tconn->net_conf_update);

	retcode = conn_request_state(tconn, NS(conn, C_UNCONNECTED), CS_VERBOSE);
P
Philipp Reisner 已提交
2053

2054
	rcu_read_lock();
2055 2056 2057 2058 2059
	idr_for_each_entry(&tconn->volumes, mdev, i) {
		mdev->send_cnt = 0;
		mdev->recv_cnt = 0;
		kobject_uevent(&disk_to_dev(mdev->vdisk)->kobj, KOBJ_CHANGE);
	}
2060
	rcu_read_unlock();
2061
	conn_reconfig_done(tconn);
2062
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072
	return 0;

fail:
	kfree(int_dig_in);
	kfree(int_dig_vv);
	crypto_free_hash(tfm);
	crypto_free_hash(integrity_w_tfm);
	crypto_free_hash(integrity_r_tfm);
	kfree(new_conf);

2073
	conn_reconfig_done(tconn);
2074 2075
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2076 2077 2078
	return 0;
}

2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
static enum drbd_state_rv conn_try_disconnect(struct drbd_tconn *tconn, bool force)
{
	enum drbd_state_rv rv;
	if (force) {
		spin_lock_irq(&tconn->req_lock);
		if (tconn->cstate >= C_WF_CONNECTION)
			_conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
		spin_unlock_irq(&tconn->req_lock);
		return SS_SUCCESS;
	}

	rv = conn_request_state(tconn, NS(conn, C_DISCONNECTING), 0);

	switch (rv) {
	case SS_NOTHING_TO_DO:
	case SS_ALREADY_STANDALONE:
		return SS_SUCCESS;
	case SS_PRIMARY_NOP:
		/* Our state checking code wants to see the peer outdated. */
		rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
							pdsk, D_OUTDATED), CS_VERBOSE);
		break;
	case SS_CW_FAILED_BY_PEER:
		/* The peer probably wants to see us outdated. */
		rv = conn_request_state(tconn, NS2(conn, C_DISCONNECTING,
							disk, D_OUTDATED), 0);
		if (rv == SS_IS_DISKLESS || rv == SS_LOWER_THAN_OUTDATED) {
			conn_request_state(tconn, NS(conn, C_DISCONNECTING), CS_HARD);
			rv = SS_SUCCESS;
		}
		break;
	default:;
		/* no special handling necessary */
	}

	return rv;
}

2117
int drbd_adm_disconnect(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2118
{
2119 2120
	struct disconnect_parms parms;
	struct drbd_tconn *tconn;
2121
	enum drbd_state_rv rv;
2122 2123
	enum drbd_ret_code retcode;
	int err;
2124

2125 2126 2127 2128
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
2129
		goto fail;
2130 2131 2132 2133

	tconn = adm_ctx.tconn;
	memset(&parms, 0, sizeof(parms));
	if (info->attrs[DRBD_NLA_DISCONNECT_PARMS]) {
2134
		err = disconnect_parms_from_attrs(&parms, info);
2135 2136 2137 2138 2139
		if (err) {
			retcode = ERR_MANDATORY_TAG;
			drbd_msg_put_info(from_attrs_err_to_txt(err));
			goto fail;
		}
2140 2141
	}

2142 2143
	rv = conn_try_disconnect(tconn, parms.force_disconnect);
	if (rv < SS_SUCCESS)
P
Philipp Reisner 已提交
2144 2145
		goto fail;

2146 2147
	if (wait_event_interruptible(tconn->ping_wait,
				     tconn->cstate != C_DISCONNECTING)) {
P
Philipp Reisner 已提交
2148 2149 2150 2151 2152 2153 2154 2155
		/* Do not test for mdev->state.conn == C_STANDALONE, since
		   someone else might connect us in the mean time! */
		retcode = ERR_INTR;
		goto fail;
	}

	retcode = NO_ERROR;
 fail:
2156
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
	return 0;
}

void resync_after_online_grow(struct drbd_conf *mdev)
{
	int iass; /* I am sync source */

	dev_info(DEV, "Resync of new storage after online grow\n");
	if (mdev->state.role != mdev->state.peer)
		iass = (mdev->state.role == R_PRIMARY);
	else
2168
		iass = test_bit(DISCARD_CONCURRENT, &mdev->tconn->flags);
P
Philipp Reisner 已提交
2169 2170 2171 2172 2173 2174 2175

	if (iass)
		drbd_start_resync(mdev, C_SYNC_SOURCE);
	else
		_drbd_request_state(mdev, NS(conn, C_WF_SYNC_UUID), CS_VERBOSE + CS_SERIALIZE);
}

2176
int drbd_adm_resize(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2177
{
2178 2179 2180
	struct resize_parms rs;
	struct drbd_conf *mdev;
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
2181
	enum determine_dev_size dd;
2182
	enum dds_flags ddsf;
2183
	int err;
P
Philipp Reisner 已提交
2184

2185 2186 2187 2188
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
P
Philipp Reisner 已提交
2189
		goto fail;
2190 2191 2192

	memset(&rs, 0, sizeof(struct resize_parms));
	if (info->attrs[DRBD_NLA_RESIZE_PARMS]) {
2193
		err = resize_parms_from_attrs(&rs, info);
2194 2195 2196 2197 2198
		if (err) {
			retcode = ERR_MANDATORY_TAG;
			drbd_msg_put_info(from_attrs_err_to_txt(err));
			goto fail;
		}
P
Philipp Reisner 已提交
2199 2200
	}

2201
	mdev = adm_ctx.mdev;
P
Philipp Reisner 已提交
2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
	if (mdev->state.conn > C_CONNECTED) {
		retcode = ERR_RESIZE_RESYNC;
		goto fail;
	}

	if (mdev->state.role == R_SECONDARY &&
	    mdev->state.peer == R_SECONDARY) {
		retcode = ERR_NO_PRIMARY;
		goto fail;
	}

	if (!get_ldev(mdev)) {
		retcode = ERR_NO_DISK;
		goto fail;
	}

2218
	if (rs.no_resync && mdev->tconn->agreed_pro_version < 93) {
2219 2220 2221 2222
		retcode = ERR_NEED_APV_93;
		goto fail;
	}

2223
	if (mdev->ldev->known_size != drbd_get_capacity(mdev->ldev->backing_bdev))
P
Philipp Reisner 已提交
2224 2225 2226
		mdev->ldev->known_size = drbd_get_capacity(mdev->ldev->backing_bdev);

	mdev->ldev->dc.disk_size = (sector_t)rs.resize_size;
2227
	ddsf = (rs.resize_force ? DDSF_FORCED : 0) | (rs.no_resync ? DDSF_NO_RESYNC : 0);
B
Bart Van Assche 已提交
2228
	dd = drbd_determine_dev_size(mdev, ddsf);
P
Philipp Reisner 已提交
2229 2230 2231 2232 2233 2234 2235
	drbd_md_sync(mdev);
	put_ldev(mdev);
	if (dd == dev_size_error) {
		retcode = ERR_NOMEM_BITMAP;
		goto fail;
	}

2236
	if (mdev->state.conn == C_CONNECTED) {
P
Philipp Reisner 已提交
2237 2238 2239 2240
		if (dd == grew)
			set_bit(RESIZE_PENDING, &mdev->flags);

		drbd_send_uuids(mdev);
2241
		drbd_send_sizes(mdev, 1, ddsf);
P
Philipp Reisner 已提交
2242 2243 2244
	}

 fail:
2245
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2246 2247 2248
	return 0;
}

2249
int drbd_adm_resource_opts(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2250
{
2251
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
2252
	cpumask_var_t new_cpu_mask;
2253
	struct drbd_tconn *tconn;
2254
	int *rs_plan_s = NULL;
2255 2256
	struct res_opts sc;
	int err;
P
Philipp Reisner 已提交
2257

2258
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
2259 2260 2261 2262
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto fail;
2263
	tconn = adm_ctx.tconn;
2264

P
Philipp Reisner 已提交
2265 2266
	if (!zalloc_cpumask_var(&new_cpu_mask, GFP_KERNEL)) {
		retcode = ERR_NOMEM;
2267
		drbd_msg_put_info("unable to allocate cpumask");
P
Philipp Reisner 已提交
2268 2269 2270
		goto fail;
	}

2271 2272
	if (((struct drbd_genlmsghdr*)info->userhdr)->flags
			& DRBD_GENL_F_SET_DEFAULTS) {
2273
		memset(&sc, 0, sizeof(struct res_opts));
2274
		sc.on_no_data  = DRBD_ON_NO_DATA_DEF;
P
Philipp Reisner 已提交
2275
	} else
2276
		sc = tconn->res_opts;
P
Philipp Reisner 已提交
2277

2278
	err = res_opts_from_attrs(&sc, info);
2279
	if (err) {
P
Philipp Reisner 已提交
2280
		retcode = ERR_MANDATORY_TAG;
2281
		drbd_msg_put_info(from_attrs_err_to_txt(err));
P
Philipp Reisner 已提交
2282 2283 2284 2285 2286 2287 2288 2289
		goto fail;
	}

	/* silently ignore cpu mask on UP kernel */
	if (nr_cpu_ids > 1 && sc.cpu_mask[0] != 0) {
		err = __bitmap_parse(sc.cpu_mask, 32, 0,
				cpumask_bits(new_cpu_mask), nr_cpu_ids);
		if (err) {
2290
			conn_warn(tconn, "__bitmap_parse() failed with %d\n", err);
P
Philipp Reisner 已提交
2291 2292 2293 2294 2295 2296
			retcode = ERR_CPU_MASK_PARSE;
			goto fail;
		}
	}


2297
	tconn->res_opts = sc;
P
Philipp Reisner 已提交
2298

2299 2300 2301 2302 2303 2304
	if (!cpumask_equal(tconn->cpu_mask, new_cpu_mask)) {
		cpumask_copy(tconn->cpu_mask, new_cpu_mask);
		drbd_calc_cpu_mask(tconn);
		tconn->receiver.reset_cpu_mask = 1;
		tconn->asender.reset_cpu_mask = 1;
		tconn->worker.reset_cpu_mask = 1;
P
Philipp Reisner 已提交
2305 2306 2307
	}

fail:
2308
	kfree(rs_plan_s);
P
Philipp Reisner 已提交
2309
	free_cpumask_var(new_cpu_mask);
2310 2311

	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2312 2313 2314
	return 0;
}

2315
int drbd_adm_invalidate(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2316
{
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326
	struct drbd_conf *mdev;
	int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */

	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

	mdev = adm_ctx.mdev;
P
Philipp Reisner 已提交
2327

2328 2329 2330 2331
	/* If there is still bitmap IO pending, probably because of a previous
	 * resync just being finished, wait for it before requesting a new resync. */
	wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));

P
Philipp Reisner 已提交
2332 2333 2334 2335 2336 2337
	retcode = _drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T), CS_ORDERED);

	if (retcode < SS_SUCCESS && retcode != SS_NEED_CONNECTION)
		retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));

	while (retcode == SS_NEED_CONNECTION) {
2338
		spin_lock_irq(&mdev->tconn->req_lock);
P
Philipp Reisner 已提交
2339 2340
		if (mdev->state.conn < C_CONNECTED)
			retcode = _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_VERBOSE, NULL);
2341
		spin_unlock_irq(&mdev->tconn->req_lock);
P
Philipp Reisner 已提交
2342 2343 2344 2345 2346 2347 2348

		if (retcode != SS_NEED_CONNECTION)
			break;

		retcode = drbd_request_state(mdev, NS(conn, C_STARTING_SYNC_T));
	}

2349 2350
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2351 2352 2353
	return 0;
}

2354 2355 2356 2357 2358 2359 2360 2361 2362
static int drbd_bmio_set_susp_al(struct drbd_conf *mdev)
{
	int rv;

	rv = drbd_bmio_set_n_write(mdev);
	drbd_suspend_al(mdev);
	return rv;
}

2363 2364
static int drbd_adm_simple_request_state(struct sk_buff *skb, struct genl_info *info,
		union drbd_state mask, union drbd_state val)
P
Philipp Reisner 已提交
2365
{
2366
	enum drbd_ret_code retcode;
2367

2368 2369 2370 2371 2372
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2373

2374 2375 2376
	retcode = drbd_request_state(adm_ctx.mdev, mask, val);
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2377 2378 2379
	return 0;
}

2380
int drbd_adm_invalidate_peer(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2381
{
2382 2383
	return drbd_adm_simple_request_state(skb, info, NS(conn, C_STARTING_SYNC_S));
}
P
Philipp Reisner 已提交
2384

2385 2386 2387 2388 2389 2390 2391 2392 2393
int drbd_adm_pause_sync(struct sk_buff *skb, struct genl_info *info)
{
	enum drbd_ret_code retcode;

	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2394

2395 2396 2397 2398
	if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 1)) == SS_NOTHING_TO_DO)
		retcode = ERR_PAUSE_IS_SET;
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2399 2400 2401
	return 0;
}

2402
int drbd_adm_resume_sync(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2403
{
2404
	union drbd_dev_state s;
2405 2406 2407 2408 2409 2410 2411
	enum drbd_ret_code retcode;

	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2412

2413 2414
	if (drbd_request_state(adm_ctx.mdev, NS(user_isp, 0)) == SS_NOTHING_TO_DO) {
		s = adm_ctx.mdev->state;
2415 2416 2417 2418 2419 2420 2421
		if (s.conn == C_PAUSED_SYNC_S || s.conn == C_PAUSED_SYNC_T) {
			retcode = s.aftr_isp ? ERR_PIC_AFTER_DEP :
				  s.peer_isp ? ERR_PIC_PEER_DEP : ERR_PAUSE_IS_CLEAR;
		} else {
			retcode = ERR_PAUSE_IS_CLEAR;
		}
	}
P
Philipp Reisner 已提交
2422

2423 2424
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2425 2426 2427
	return 0;
}

2428
int drbd_adm_suspend_io(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2429
{
2430
	return drbd_adm_simple_request_state(skb, info, NS(susp, 1));
P
Philipp Reisner 已提交
2431 2432
}

2433
int drbd_adm_resume_io(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2434
{
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444
	struct drbd_conf *mdev;
	int retcode; /* enum drbd_ret_code rsp. enum drbd_state_rv */

	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

	mdev = adm_ctx.mdev;
2445 2446 2447 2448
	if (test_bit(NEW_CUR_UUID, &mdev->flags)) {
		drbd_uuid_new_current(mdev);
		clear_bit(NEW_CUR_UUID, &mdev->flags);
	}
2449
	drbd_suspend_io(mdev);
2450 2451
	retcode = drbd_request_state(mdev, NS3(susp, 0, susp_nod, 0, susp_fen, 0));
	if (retcode == SS_SUCCESS) {
2452
		if (mdev->state.conn < C_CONNECTED)
2453
			tl_clear(mdev->tconn);
2454
		if (mdev->state.disk == D_DISKLESS || mdev->state.disk == D_FAILED)
2455
			tl_restart(mdev->tconn, FAIL_FROZEN_DISK_IO);
2456 2457 2458
	}
	drbd_resume_io(mdev);

2459 2460
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2461 2462 2463
	return 0;
}

2464
int drbd_adm_outdate(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2465
{
2466
	return drbd_adm_simple_request_state(skb, info, NS(disk, D_OUTDATED));
P
Philipp Reisner 已提交
2467 2468
}

2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
int nla_put_drbd_cfg_context(struct sk_buff *skb, const char *conn_name, unsigned vnr)
{
	struct nlattr *nla;
	nla = nla_nest_start(skb, DRBD_NLA_CFG_CONTEXT);
	if (!nla)
		goto nla_put_failure;
	if (vnr != VOLUME_UNSPECIFIED)
		NLA_PUT_U32(skb, T_ctx_volume, vnr);
	NLA_PUT_STRING(skb, T_ctx_conn_name, conn_name);
	nla_nest_end(skb, nla);
	return 0;

nla_put_failure:
	if (nla)
		nla_nest_cancel(skb, nla);
	return -EMSGSIZE;
}

2487 2488
int nla_put_status_info(struct sk_buff *skb, struct drbd_conf *mdev,
		const struct sib_info *sib)
P
Philipp Reisner 已提交
2489
{
2490
	struct state_info *si = NULL; /* for sizeof(si->member); */
2491
	struct net_conf *nc;
2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513
	struct nlattr *nla;
	int got_ldev;
	int err = 0;
	int exclude_sensitive;

	/* If sib != NULL, this is drbd_bcast_event, which anyone can listen
	 * to.  So we better exclude_sensitive information.
	 *
	 * If sib == NULL, this is drbd_adm_get_status, executed synchronously
	 * in the context of the requesting user process. Exclude sensitive
	 * information, unless current has superuser.
	 *
	 * NOTE: for drbd_adm_get_status_all(), this is a netlink dump, and
	 * relies on the current implementation of netlink_dump(), which
	 * executes the dump callback successively from netlink_recvmsg(),
	 * always in the context of the receiving process */
	exclude_sensitive = sib || !capable(CAP_SYS_ADMIN);

	got_ldev = get_ldev(mdev);

	/* We need to add connection name and volume number information still.
	 * Minor number is in drbd_genlmsghdr. */
2514
	if (nla_put_drbd_cfg_context(skb, mdev->tconn->name, mdev->vnr))
2515 2516
		goto nla_put_failure;

2517 2518 2519
	if (res_opts_to_skb(skb, &mdev->tconn->res_opts, exclude_sensitive))
		goto nla_put_failure;

2520 2521 2522
	if (got_ldev)
		if (disk_conf_to_skb(skb, &mdev->ldev->dc, exclude_sensitive))
			goto nla_put_failure;
2523 2524 2525 2526 2527 2528 2529 2530

	rcu_read_lock();
	nc = rcu_dereference(mdev->tconn->net_conf);
	if (nc)
		err = net_conf_to_skb(skb, nc, exclude_sensitive);
	rcu_read_unlock();
	if (err)
		goto nla_put_failure;
2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549

	nla = nla_nest_start(skb, DRBD_NLA_STATE_INFO);
	if (!nla)
		goto nla_put_failure;
	NLA_PUT_U32(skb, T_sib_reason, sib ? sib->sib_reason : SIB_GET_STATUS_REPLY);
	NLA_PUT_U32(skb, T_current_state, mdev->state.i);
	NLA_PUT_U64(skb, T_ed_uuid, mdev->ed_uuid);
	NLA_PUT_U64(skb, T_capacity, drbd_get_capacity(mdev->this_bdev));

	if (got_ldev) {
		NLA_PUT_U32(skb, T_disk_flags, mdev->ldev->md.flags);
		NLA_PUT(skb, T_uuids, sizeof(si->uuids), mdev->ldev->md.uuid);
		NLA_PUT_U64(skb, T_bits_total, drbd_bm_bits(mdev));
		NLA_PUT_U64(skb, T_bits_oos, drbd_bm_total_weight(mdev));
		if (C_SYNC_SOURCE <= mdev->state.conn &&
		    C_PAUSED_SYNC_T >= mdev->state.conn) {
			NLA_PUT_U64(skb, T_bits_rs_total, mdev->rs_total);
			NLA_PUT_U64(skb, T_bits_rs_failed, mdev->rs_failed);
		}
P
Philipp Reisner 已提交
2550 2551
	}

2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568
	if (sib) {
		switch(sib->sib_reason) {
		case SIB_SYNC_PROGRESS:
		case SIB_GET_STATUS_REPLY:
			break;
		case SIB_STATE_CHANGE:
			NLA_PUT_U32(skb, T_prev_state, sib->os.i);
			NLA_PUT_U32(skb, T_new_state, sib->ns.i);
			break;
		case SIB_HELPER_POST:
			NLA_PUT_U32(skb,
				T_helper_exit_code, sib->helper_exit_code);
			/* fall through */
		case SIB_HELPER_PRE:
			NLA_PUT_STRING(skb, T_helper, sib->helper_name);
			break;
		}
P
Philipp Reisner 已提交
2569
	}
2570
	nla_nest_end(skb, nla);
P
Philipp Reisner 已提交
2571

2572 2573 2574 2575 2576 2577
	if (0)
nla_put_failure:
		err = -EMSGSIZE;
	if (got_ldev)
		put_ldev(mdev);
	return err;
P
Philipp Reisner 已提交
2578 2579
}

2580
int drbd_adm_get_status(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2581
{
2582 2583
	enum drbd_ret_code retcode;
	int err;
P
Philipp Reisner 已提交
2584

2585 2586 2587 2588 2589
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2590

2591 2592 2593 2594
	err = nla_put_status_info(adm_ctx.reply_skb, adm_ctx.mdev, NULL);
	if (err) {
		nlmsg_free(adm_ctx.reply_skb);
		return err;
P
Philipp Reisner 已提交
2595
	}
2596 2597 2598
out:
	drbd_adm_finish(info, retcode);
	return 0;
P
Philipp Reisner 已提交
2599 2600
}

2601
int get_one_status(struct sk_buff *skb, struct netlink_callback *cb)
P
Philipp Reisner 已提交
2602
{
2603 2604
	struct drbd_conf *mdev;
	struct drbd_genlmsghdr *dh;
2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618
	struct drbd_tconn *pos = (struct drbd_tconn*)cb->args[0];
	struct drbd_tconn *tconn = NULL;
	struct drbd_tconn *tmp;
	unsigned volume = cb->args[1];

	/* Open coded, deferred, iteration:
	 * list_for_each_entry_safe(tconn, tmp, &drbd_tconns, all_tconn) {
	 *	idr_for_each_entry(&tconn->volumes, mdev, i) {
	 *	  ...
	 *	}
	 * }
	 * where tconn is cb->args[0];
	 * and i is cb->args[1];
	 *
2619 2620 2621
	 * cb->args[2] indicates if we shall loop over all resources,
	 * or just dump all volumes of a single resource.
	 *
2622 2623
	 * This may miss entries inserted after this dump started,
	 * or entries deleted before they are reached.
2624 2625 2626 2627 2628
	 *
	 * We need to make sure the mdev won't disappear while
	 * we are looking at it, and revalidate our iterators
	 * on each iteration.
	 */
2629

2630
	/* synchronize with drbd_new_tconn/drbd_free_tconn */
2631
	down_read(&drbd_cfg_rwsem);
2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645
	/* revalidate iterator position */
	list_for_each_entry(tmp, &drbd_tconns, all_tconn) {
		if (pos == NULL) {
			/* first iteration */
			pos = tmp;
			tconn = pos;
			break;
		}
		if (tmp == pos) {
			tconn = pos;
			break;
		}
	}
	if (tconn) {
2646
next_tconn:
2647 2648 2649 2650 2651 2652
		mdev = idr_get_next(&tconn->volumes, &volume);
		if (!mdev) {
			/* No more volumes to dump on this tconn.
			 * Advance tconn iterator. */
			pos = list_entry(tconn->all_tconn.next,
					struct drbd_tconn, all_tconn);
2653
			/* Did we dump any volume on this tconn yet? */
2654
			if (volume != 0) {
2655 2656 2657 2658 2659
				/* If we reached the end of the list,
				 * or only a single resource dump was requested,
				 * we are done. */
				if (&pos->all_tconn == &drbd_tconns || cb->args[2])
					goto out;
2660
				volume = 0;
2661
				tconn = pos;
2662 2663 2664 2665
				goto next_tconn;
			}
		}

2666 2667 2668 2669
		dh = genlmsg_put(skb, NETLINK_CB(cb->skb).pid,
				cb->nlh->nlmsg_seq, &drbd_genl_family,
				NLM_F_MULTI, DRBD_ADM_GET_STATUS);
		if (!dh)
2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681
			goto out;

		if (!mdev) {
			/* this is a tconn without a single volume */
			dh->minor = -1U;
			dh->ret_code = NO_ERROR;
			if (nla_put_drbd_cfg_context(skb, tconn->name, VOLUME_UNSPECIFIED))
				genlmsg_cancel(skb, dh);
			else
				genlmsg_end(skb, dh);
			goto out;
		}
2682

2683 2684
		D_ASSERT(mdev->vnr == volume);
		D_ASSERT(mdev->tconn == tconn);
2685

2686
		dh->minor = mdev_to_minor(mdev);
2687 2688 2689 2690
		dh->ret_code = NO_ERROR;

		if (nla_put_status_info(skb, mdev, NULL)) {
			genlmsg_cancel(skb, dh);
2691
			goto out;
2692 2693 2694
		}
		genlmsg_end(skb, dh);
        }
P
Philipp Reisner 已提交
2695

2696
out:
2697
	up_read(&drbd_cfg_rwsem);
2698 2699 2700
	/* where to start the next iteration */
        cb->args[0] = (long)pos;
        cb->args[1] = (pos == tconn) ? volume + 1 : 0;
P
Philipp Reisner 已提交
2701

2702 2703
	/* No more tconns/volumes/minors found results in an empty skb.
	 * Which will terminate the dump. */
2704
        return skb->len;
P
Philipp Reisner 已提交
2705 2706
}

2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760
/*
 * Request status of all resources, or of all volumes within a single resource.
 *
 * This is a dump, as the answer may not fit in a single reply skb otherwise.
 * Which means we cannot use the family->attrbuf or other such members, because
 * dump is NOT protected by the genl_lock().  During dump, we only have access
 * to the incoming skb, and need to opencode "parsing" of the nlattr payload.
 *
 * Once things are setup properly, we call into get_one_status().
 */
int drbd_adm_get_status_all(struct sk_buff *skb, struct netlink_callback *cb)
{
	const unsigned hdrlen = GENL_HDRLEN + GENL_MAGIC_FAMILY_HDRSZ;
	struct nlattr *nla;
	const char *conn_name;
	struct drbd_tconn *tconn;

	/* Is this a followup call? */
	if (cb->args[0]) {
		/* ... of a single resource dump,
		 * and the resource iterator has been advanced already? */
		if (cb->args[2] && cb->args[2] != cb->args[0])
			return 0; /* DONE. */
		goto dump;
	}

	/* First call (from netlink_dump_start).  We need to figure out
	 * which resource(s) the user wants us to dump. */
	nla = nla_find(nlmsg_attrdata(cb->nlh, hdrlen),
			nlmsg_attrlen(cb->nlh, hdrlen),
			DRBD_NLA_CFG_CONTEXT);

	/* No explicit context given.  Dump all. */
	if (!nla)
		goto dump;
	nla = nla_find_nested(nla, __nla_type(T_ctx_conn_name));
	/* context given, but no name present? */
	if (!nla)
		return -EINVAL;
	conn_name = nla_data(nla);
	tconn = conn_by_name(conn_name);
	if (!tconn)
		return -ENODEV;

	/* prime iterators, and set "filter" mode mark:
	 * only dump this tconn. */
	cb->args[0] = (long)tconn;
	/* cb->args[1] = 0; passed in this way. */
	cb->args[2] = (long)tconn;

dump:
	return get_one_status(skb, cb);
}

2761
int drbd_adm_get_timeout_type(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2762
{
2763 2764 2765
	enum drbd_ret_code retcode;
	struct timeout_parms tp;
	int err;
P
Philipp Reisner 已提交
2766

2767 2768 2769 2770 2771
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2772

2773 2774 2775 2776
	tp.timeout_type =
		adm_ctx.mdev->state.pdsk == D_OUTDATED ? UT_PEER_OUTDATED :
		test_bit(USE_DEGR_WFC_T, &adm_ctx.mdev->flags) ? UT_DEGRADED :
		UT_DEFAULT;
P
Philipp Reisner 已提交
2777

2778 2779 2780 2781 2782 2783 2784 2785
	err = timeout_parms_to_priv_skb(adm_ctx.reply_skb, &tp);
	if (err) {
		nlmsg_free(adm_ctx.reply_skb);
		return err;
	}
out:
	drbd_adm_finish(info, retcode);
	return 0;
P
Philipp Reisner 已提交
2786 2787
}

2788
int drbd_adm_start_ov(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2789
{
2790 2791
	struct drbd_conf *mdev;
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
2792

2793 2794 2795 2796 2797
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
2798

2799 2800 2801 2802 2803
	mdev = adm_ctx.mdev;
	if (info->attrs[DRBD_NLA_START_OV_PARMS]) {
		/* resume from last known position, if possible */
		struct start_ov_parms parms =
			{ .ov_start_sector = mdev->ov_start_sector };
2804
		int err = start_ov_parms_from_attrs(&parms, info);
2805 2806 2807 2808 2809 2810 2811 2812
		if (err) {
			retcode = ERR_MANDATORY_TAG;
			drbd_msg_put_info(from_attrs_err_to_txt(err));
			goto out;
		}
		/* w_make_ov_request expects position to be aligned */
		mdev->ov_start_sector = parms.ov_start_sector & ~BM_SECT_PER_BIT;
	}
2813 2814 2815
	/* If there is still bitmap IO pending, e.g. previous resync or verify
	 * just being finished, wait for it before requesting a new resync. */
	wait_event(mdev->misc_wait, !test_bit(BITMAP_IO, &mdev->flags));
2816 2817 2818
	retcode = drbd_request_state(mdev,NS(conn,C_VERIFY_S));
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
2819 2820 2821 2822
	return 0;
}


2823
int drbd_adm_new_c_uuid(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2824
{
2825 2826
	struct drbd_conf *mdev;
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
2827 2828
	int skip_initial_sync = 0;
	int err;
2829
	struct new_c_uuid_parms args;
P
Philipp Reisner 已提交
2830

2831 2832 2833 2834 2835
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out_nolock;
P
Philipp Reisner 已提交
2836

2837 2838 2839
	mdev = adm_ctx.mdev;
	memset(&args, 0, sizeof(args));
	if (info->attrs[DRBD_NLA_NEW_C_UUID_PARMS]) {
2840
		err = new_c_uuid_parms_from_attrs(&args, info);
2841 2842 2843 2844 2845
		if (err) {
			retcode = ERR_MANDATORY_TAG;
			drbd_msg_put_info(from_attrs_err_to_txt(err));
			goto out_nolock;
		}
P
Philipp Reisner 已提交
2846 2847
	}

2848
	mutex_lock(mdev->state_mutex); /* Protects us against serialized state changes. */
P
Philipp Reisner 已提交
2849 2850 2851 2852 2853 2854 2855

	if (!get_ldev(mdev)) {
		retcode = ERR_NO_DISK;
		goto out;
	}

	/* this is "skip initial sync", assume to be clean */
2856
	if (mdev->state.conn == C_CONNECTED && mdev->tconn->agreed_pro_version >= 90 &&
P
Philipp Reisner 已提交
2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
	    mdev->ldev->md.uuid[UI_CURRENT] == UUID_JUST_CREATED && args.clear_bm) {
		dev_info(DEV, "Preparing to skip initial sync\n");
		skip_initial_sync = 1;
	} else if (mdev->state.conn != C_STANDALONE) {
		retcode = ERR_CONNECTED;
		goto out_dec;
	}

	drbd_uuid_set(mdev, UI_BITMAP, 0); /* Rotate UI_BITMAP to History 1, etc... */
	drbd_uuid_new_current(mdev); /* New current, previous to UI_BITMAP */

	if (args.clear_bm) {
2869 2870
		err = drbd_bitmap_io(mdev, &drbd_bmio_clear_n_write,
			"clear_n_write from new_c_uuid", BM_LOCKED_MASK);
P
Philipp Reisner 已提交
2871 2872 2873 2874 2875 2876 2877
		if (err) {
			dev_err(DEV, "Writing bitmap failed with %d\n",err);
			retcode = ERR_IO_MD_DISK;
		}
		if (skip_initial_sync) {
			drbd_send_uuids_skip_initial_sync(mdev);
			_drbd_uuid_set(mdev, UI_BITMAP, 0);
2878
			drbd_print_uuids(mdev, "cleared bitmap UUID");
2879
			spin_lock_irq(&mdev->tconn->req_lock);
P
Philipp Reisner 已提交
2880 2881
			_drbd_set_state(_NS2(mdev, disk, D_UP_TO_DATE, pdsk, D_UP_TO_DATE),
					CS_VERBOSE, NULL);
2882
			spin_unlock_irq(&mdev->tconn->req_lock);
P
Philipp Reisner 已提交
2883 2884 2885 2886 2887 2888 2889
		}
	}

	drbd_md_sync(mdev);
out_dec:
	put_ldev(mdev);
out:
2890
	mutex_unlock(mdev->state_mutex);
2891 2892
out_nolock:
	drbd_adm_finish(info, retcode);
2893 2894 2895
	return 0;
}

2896 2897
static enum drbd_ret_code
drbd_check_conn_name(const char *name)
2898
{
2899 2900 2901
	if (!name || !name[0]) {
		drbd_msg_put_info("connection name missing");
		return ERR_MANDATORY_TAG;
2902
	}
2903 2904 2905 2906 2907
	/* if we want to use these in sysfs/configfs/debugfs some day,
	 * we must not allow slashes */
	if (strchr(name, '/')) {
		drbd_msg_put_info("invalid connection name");
		return ERR_INVALID_REQUEST;
2908
	}
2909
	return NO_ERROR;
2910 2911
}

2912
int drbd_adm_create_connection(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2913
{
2914
	enum drbd_ret_code retcode;
2915

2916 2917 2918 2919 2920
	retcode = drbd_adm_prepare(skb, info, 0);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2921

2922 2923 2924
	retcode = drbd_check_conn_name(adm_ctx.conn_name);
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2925

2926
	if (adm_ctx.tconn) {
2927 2928 2929 2930 2931
		if (info->nlhdr->nlmsg_flags & NLM_F_EXCL) {
			retcode = ERR_INVALID_REQUEST;
			drbd_msg_put_info("connection exists");
		}
		/* else: still NO_ERROR */
2932
		goto out;
P
Philipp Reisner 已提交
2933 2934
	}

2935
	if (!drbd_new_tconn(adm_ctx.conn_name))
P
Philipp Reisner 已提交
2936
		retcode = ERR_NOMEM;
2937 2938 2939
out:
	drbd_adm_finish(info, retcode);
	return 0;
P
Philipp Reisner 已提交
2940 2941
}

2942
int drbd_adm_add_minor(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2943
{
2944 2945
	struct drbd_genlmsghdr *dh = info->userhdr;
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
2946

2947 2948 2949 2950 2951
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
2952

2953 2954 2955 2956 2957
	/* FIXME drop minor_count parameter, limit to MINORMASK */
	if (dh->minor >= minor_count) {
		drbd_msg_put_info("requested minor out of range");
		retcode = ERR_INVALID_REQUEST;
		goto out;
P
Philipp Reisner 已提交
2958
	}
2959
	if (adm_ctx.volume > DRBD_VOLUME_MAX) {
2960 2961 2962
		drbd_msg_put_info("requested volume id out of range");
		retcode = ERR_INVALID_REQUEST;
		goto out;
P
Philipp Reisner 已提交
2963 2964
	}

2965 2966 2967 2968 2969 2970 2971 2972 2973
	/* drbd_adm_prepare made sure already
	 * that mdev->tconn and mdev->vnr match the request. */
	if (adm_ctx.mdev) {
		if (info->nlhdr->nlmsg_flags & NLM_F_EXCL)
			retcode = ERR_MINOR_EXISTS;
		/* else: still NO_ERROR */
		goto out;
	}

2974
	down_write(&drbd_cfg_rwsem);
2975
	retcode = conn_new_minor(adm_ctx.tconn, dh->minor, adm_ctx.volume);
2976
	up_write(&drbd_cfg_rwsem);
2977 2978 2979
out:
	drbd_adm_finish(info, retcode);
	return 0;
P
Philipp Reisner 已提交
2980 2981
}

2982 2983 2984 2985 2986 2987 2988
static enum drbd_ret_code adm_delete_minor(struct drbd_conf *mdev)
{
	if (mdev->state.disk == D_DISKLESS &&
	    /* no need to be mdev->state.conn == C_STANDALONE &&
	     * we may want to delete a minor from a live replication group.
	     */
	    mdev->state.role == R_SECONDARY) {
2989
		drbd_delete_device(mdev);
2990 2991 2992 2993 2994
		return NO_ERROR;
	} else
		return ERR_MINOR_CONFIGURED;
}

2995
int drbd_adm_delete_minor(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
2996
{
2997
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
2998

2999 3000 3001 3002 3003
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_MINOR);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;
P
Philipp Reisner 已提交
3004

3005
	down_write(&drbd_cfg_rwsem);
3006
	retcode = adm_delete_minor(adm_ctx.mdev);
3007
	up_write(&drbd_cfg_rwsem);
3008 3009 3010
	/* if this was the last volume of this connection,
	 * this will terminate all threads */
	if (retcode == NO_ERROR)
3011
		conn_reconfig_done(adm_ctx.tconn);
3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034
out:
	drbd_adm_finish(info, retcode);
	return 0;
}

int drbd_adm_down(struct sk_buff *skb, struct genl_info *info)
{
	enum drbd_ret_code retcode;
	enum drbd_state_rv rv;
	struct drbd_conf *mdev;
	unsigned i;

	retcode = drbd_adm_prepare(skb, info, 0);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

	if (!adm_ctx.tconn) {
		retcode = ERR_CONN_NOT_KNOWN;
		goto out;
	}

3035
	down_read(&drbd_cfg_rwsem);
3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061
	/* demote */
	idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
		retcode = drbd_set_role(mdev, R_SECONDARY, 0);
		if (retcode < SS_SUCCESS) {
			drbd_msg_put_info("failed to demote");
			goto out_unlock;
		}
	}

	/* disconnect */
	rv = conn_try_disconnect(adm_ctx.tconn, 0);
	if (rv < SS_SUCCESS) {
		retcode = rv; /* enum type mismatch! */
		drbd_msg_put_info("failed to disconnect");
		goto out_unlock;
	}

	/* detach */
	idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
		rv = adm_detach(mdev);
		if (rv < SS_SUCCESS) {
			retcode = rv; /* enum type mismatch! */
			drbd_msg_put_info("failed to detach");
			goto out_unlock;
		}
	}
3062
	up_read(&drbd_cfg_rwsem);
3063 3064

	/* delete volumes */
3065
	down_write(&drbd_cfg_rwsem);
3066 3067 3068 3069 3070
	idr_for_each_entry(&adm_ctx.tconn->volumes, mdev, i) {
		retcode = adm_delete_minor(mdev);
		if (retcode != NO_ERROR) {
			/* "can not happen" */
			drbd_msg_put_info("failed to delete volume");
3071 3072
			up_write(&drbd_cfg_rwsem);
			goto out;
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087
		}
	}

	/* stop all threads */
	conn_reconfig_done(adm_ctx.tconn);

	/* delete connection */
	if (conn_lowest_minor(adm_ctx.tconn) < 0) {
		drbd_free_tconn(adm_ctx.tconn);
		retcode = NO_ERROR;
	} else {
		/* "can not happen" */
		retcode = ERR_CONN_IN_USE;
		drbd_msg_put_info("failed to delete connection");
	}
3088 3089 3090

	up_write(&drbd_cfg_rwsem);
	goto out;
3091
out_unlock:
3092
	up_read(&drbd_cfg_rwsem);
3093 3094 3095
out:
	drbd_adm_finish(info, retcode);
	return 0;
P
Philipp Reisner 已提交
3096 3097
}

3098
int drbd_adm_delete_connection(struct sk_buff *skb, struct genl_info *info)
P
Philipp Reisner 已提交
3099
{
3100
	enum drbd_ret_code retcode;
P
Philipp Reisner 已提交
3101

3102 3103 3104 3105 3106 3107
	retcode = drbd_adm_prepare(skb, info, DRBD_ADM_NEED_CONN);
	if (!adm_ctx.reply_skb)
		return retcode;
	if (retcode != NO_ERROR)
		goto out;

3108
	down_write(&drbd_cfg_rwsem);
3109 3110 3111 3112 3113
	if (conn_lowest_minor(adm_ctx.tconn) < 0) {
		drbd_free_tconn(adm_ctx.tconn);
		retcode = NO_ERROR;
	} else {
		retcode = ERR_CONN_IN_USE;
P
Philipp Reisner 已提交
3114
	}
3115
	up_write(&drbd_cfg_rwsem);
P
Philipp Reisner 已提交
3116

3117 3118
out:
	drbd_adm_finish(info, retcode);
P
Philipp Reisner 已提交
3119 3120 3121
	return 0;
}

3122
void drbd_bcast_event(struct drbd_conf *mdev, const struct sib_info *sib)
P
Philipp Reisner 已提交
3123
{
3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148
	static atomic_t drbd_genl_seq = ATOMIC_INIT(2); /* two. */
	struct sk_buff *msg;
	struct drbd_genlmsghdr *d_out;
	unsigned seq;
	int err = -ENOMEM;

	seq = atomic_inc_return(&drbd_genl_seq);
	msg = genlmsg_new(NLMSG_GOODSIZE, GFP_NOIO);
	if (!msg)
		goto failed;

	err = -EMSGSIZE;
	d_out = genlmsg_put(msg, 0, seq, &drbd_genl_family, 0, DRBD_EVENT);
	if (!d_out) /* cannot happen, but anyways. */
		goto nla_put_failure;
	d_out->minor = mdev_to_minor(mdev);
	d_out->ret_code = 0;

	if (nla_put_status_info(msg, mdev, sib))
		goto nla_put_failure;
	genlmsg_end(msg, d_out);
	err = drbd_genl_multicast_events(msg, 0);
	/* msg has been consumed or freed in netlink_broadcast() */
	if (err && err != -ESRCH)
		goto failed;
P
Philipp Reisner 已提交
3149

3150
	return;
P
Philipp Reisner 已提交
3151

3152 3153 3154 3155 3156 3157
nla_put_failure:
	nlmsg_free(msg);
failed:
	dev_err(DEV, "Error %d while broadcasting event. "
			"Event seq:%u sib_reason:%u\n",
			err, seq, sib->sib_reason);
P
Philipp Reisner 已提交
3158
}