bond_sysfs.c 36.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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
15
 * with this program; if not, see <http://www.gnu.org/licenses/>.
16 17 18 19 20
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 */
J
Joe Perches 已提交
21 22 23

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

24 25 26
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
27
#include <linux/sched.h>
28 29 30 31 32 33 34 35 36 37
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/netdevice.h>
#include <linux/inetdevice.h>
#include <linux/in.h>
#include <linux/sysfs.h>
#include <linux/ctype.h>
#include <linux/inet.h>
#include <linux/rtnetlink.h>
38
#include <linux/etherdevice.h>
39
#include <net/net_namespace.h>
40 41
#include <net/netns/generic.h>
#include <linux/nsproxy.h>
42
#include <linux/reciprocal_div.h>
43 44

#include "bonding.h"
45

S
Stephen Hemminger 已提交
46
#define to_dev(obj)	container_of(obj, struct device, kobj)
47
#define to_bond(cd)	((struct bonding *)(netdev_priv(to_net_dev(cd))))
48 49 50 51 52

/*
 * "show" function for the bond_masters attribute.
 * The class parameter is ignored.
 */
53 54 55
static ssize_t bonding_show_bonds(struct class *cls,
				  struct class_attribute *attr,
				  char *buf)
56
{
57 58
	struct bond_net *bn =
		container_of(attr, struct bond_net, class_attr_bonding_masters);
59 60 61
	int res = 0;
	struct bonding *bond;

62
	rtnl_lock();
63

64
	list_for_each_entry(bond, &bn->dev_list, bond_list) {
65 66 67 68
		if (res > (PAGE_SIZE - IFNAMSIZ)) {
			/* not enough space for another interface name */
			if ((PAGE_SIZE - res) > 10)
				res = PAGE_SIZE - 10;
69
			res += sprintf(buf + res, "++more++ ");
70 71
			break;
		}
72
		res += sprintf(buf + res, "%s ", bond->dev->name);
73
	}
74 75
	if (res)
		buf[res-1] = '\n'; /* eat the leftover space */
76 77

	rtnl_unlock();
78 79 80
	return res;
}

81
static struct net_device *bond_get_by_name(struct bond_net *bn, const char *ifname)
82 83 84
{
	struct bonding *bond;

85
	list_for_each_entry(bond, &bn->dev_list, bond_list) {
86 87 88 89 90 91
		if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0)
			return bond->dev;
	}
	return NULL;
}

92 93 94 95 96 97 98 99
/*
 * "store" function for the bond_masters attribute.  This is what
 * creates and deletes entire bonds.
 *
 * The class parameter is ignored.
 *
 */

S
Stephen Hemminger 已提交
100
static ssize_t bonding_store_bonds(struct class *cls,
101
				   struct class_attribute *attr,
S
Stephen Hemminger 已提交
102
				   const char *buffer, size_t count)
103
{
104 105
	struct bond_net *bn =
		container_of(attr, struct bond_net, class_attr_bonding_masters);
106 107
	char command[IFNAMSIZ + 1] = {0, };
	char *ifname;
108
	int rv, res = count;
109 110 111 112 113 114 115 116

	sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
	ifname = command + 1;
	if ((strlen(command) <= 1) ||
	    !dev_valid_name(ifname))
		goto err_no_cmd;

	if (command[0] == '+') {
J
Joe Perches 已提交
117
		pr_info("%s is being created...\n", ifname);
118
		rv = bond_create(bn->net, ifname);
119
		if (rv) {
120 121 122 123
			if (rv == -EEXIST)
				pr_info("%s already exists.\n", ifname);
			else
				pr_info("%s creation failed.\n", ifname);
124
			res = rv;
125
		}
126 127
	} else if (command[0] == '-') {
		struct net_device *bond_dev;
128

129
		rtnl_lock();
130
		bond_dev = bond_get_by_name(bn, ifname);
131
		if (bond_dev) {
J
Joe Perches 已提交
132
			pr_info("%s is being deleted...\n", ifname);
133 134
			unregister_netdevice(bond_dev);
		} else {
J
Joe Perches 已提交
135
			pr_err("unable to delete non-existent %s\n", ifname);
136 137 138 139 140
			res = -ENODEV;
		}
		rtnl_unlock();
	} else
		goto err_no_cmd;
141

142 143 144 145
	/* Always return either count or an error.  If you return 0, you'll
	 * get called forever, which is bad.
	 */
	return res;
146 147

err_no_cmd:
J
Joe Perches 已提交
148
	pr_err("no command found in bonding_masters. Use +ifname or -ifname.\n");
149
	return -EPERM;
150
}
151

152
/* class attribute for bond_masters file.  This ends up in /sys/class/net */
153 154 155 156 157 158 159 160
static const struct class_attribute class_attr_bonding_masters = {
	.attr = {
		.name = "bonding_masters",
		.mode = S_IWUSR | S_IRUGO,
	},
	.show = bonding_show_bonds,
	.store = bonding_store_bonds,
};
161 162 163 164

/*
 * Show the slaves in the current bond.
 */
165 166
static ssize_t bonding_show_slaves(struct device *d,
				   struct device_attribute *attr, char *buf)
167
{
168
	struct bonding *bond = to_bond(d);
169
	struct list_head *iter;
170 171
	struct slave *slave;
	int res = 0;
172

173 174 175
	if (!rtnl_trylock())
		return restart_syscall();

176
	bond_for_each_slave(bond, slave, iter) {
177 178 179 180
		if (res > (PAGE_SIZE - IFNAMSIZ)) {
			/* not enough space for another interface name */
			if ((PAGE_SIZE - res) > 10)
				res = PAGE_SIZE - 10;
181
			res += sprintf(buf + res, "++more++ ");
182 183 184 185
			break;
		}
		res += sprintf(buf + res, "%s ", slave->dev->name);
	}
186 187 188

	rtnl_unlock();

189 190
	if (res)
		buf[res-1] = '\n'; /* eat the leftover space */
191

192 193 194 195
	return res;
}

/*
196
 * Set the slaves in the current bond.
197 198
 * This is supposed to be only thin wrapper for bond_enslave and bond_release.
 * All hard work should be done there.
199
 */
200 201 202
static ssize_t bonding_store_slaves(struct device *d,
				    struct device_attribute *attr,
				    const char *buffer, size_t count)
203 204 205
{
	char command[IFNAMSIZ + 1] = { 0, };
	char *ifname;
206 207
	int res, ret = count;
	struct net_device *dev;
208
	struct bonding *bond = to_bond(d);
209

210 211
	if (!rtnl_trylock())
		return restart_syscall();
212

213 214 215 216 217 218
	sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
	ifname = command + 1;
	if ((strlen(command) <= 1) ||
	    !dev_valid_name(ifname))
		goto err_no_cmd;

219 220 221 222 223 224 225
	dev = __dev_get_by_name(dev_net(bond->dev), ifname);
	if (!dev) {
		pr_info("%s: Interface %s does not exist!\n",
			bond->dev->name, ifname);
		ret = -ENODEV;
		goto out;
	}
226

227 228 229
	switch (command[0]) {
	case '+':
		pr_info("%s: Adding slave %s.\n", bond->dev->name, dev->name);
230
		res = bond_enslave(bond->dev, dev);
231
		break;
S
Stephen Hemminger 已提交
232

233 234 235 236
	case '-':
		pr_info("%s: Removing slave %s.\n", bond->dev->name, dev->name);
		res = bond_release(bond->dev, dev);
		break;
237

238 239
	default:
		goto err_no_cmd;
240 241
	}

242 243 244 245
	if (res)
		ret = res;
	goto out;

246
err_no_cmd:
J
Joe Perches 已提交
247 248
	pr_err("no command found in slaves file for bond %s. Use +ifname or -ifname.\n",
	       bond->dev->name);
249 250 251
	ret = -EPERM;

out:
252
	rtnl_unlock();
253 254 255
	return ret;
}

S
Stephen Hemminger 已提交
256 257
static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves,
		   bonding_store_slaves);
258 259 260 261 262

/*
 * Show and set the bonding mode.  The bond interface must be down to
 * change the mode.
 */
263 264
static ssize_t bonding_show_mode(struct device *d,
				 struct device_attribute *attr, char *buf)
265
{
266
	struct bonding *bond = to_bond(d);
267 268 269

	return sprintf(buf, "%s %d\n",
			bond_mode_tbl[bond->params.mode].modename,
270
			bond->params.mode);
271 272
}

273 274 275
static ssize_t bonding_store_mode(struct device *d,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
276
{
277
	int new_value, ret;
278
	struct bonding *bond = to_bond(d);
279

J
Jay Vosburgh 已提交
280
	new_value = bond_parse_parm(buf, bond_mode_tbl);
281
	if (new_value < 0)  {
J
Joe Perches 已提交
282 283
		pr_err("%s: Ignoring invalid mode value %.*s.\n",
		       bond->dev->name, (int)strlen(buf) - 1, buf);
284
		return -EINVAL;
285
	}
286 287 288 289 290 291 292 293 294
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_mode_set(bond, new_value);
	if (!ret) {
		pr_info("%s: setting mode to %s (%d).\n",
			bond->dev->name, bond_mode_tbl[new_value].modename,
			new_value);
		ret = count;
295
	}
296

297
	rtnl_unlock();
298 299
	return ret;
}
S
Stephen Hemminger 已提交
300 301
static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
		   bonding_show_mode, bonding_store_mode);
302 303

/*
S
Stephen Hemminger 已提交
304
 * Show and set the bonding transmit hash method.
305
 */
306 307 308
static ssize_t bonding_show_xmit_hash(struct device *d,
				      struct device_attribute *attr,
				      char *buf)
309
{
310
	struct bonding *bond = to_bond(d);
311

312 313 314
	return sprintf(buf, "%s %d\n",
		       xmit_hashtype_tbl[bond->params.xmit_policy].modename,
		       bond->params.xmit_policy);
315 316
}

317 318 319
static ssize_t bonding_store_xmit_hash(struct device *d,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
320
{
321
	int new_value, ret;
322
	struct bonding *bond = to_bond(d);
323

J
Jay Vosburgh 已提交
324
	new_value = bond_parse_parm(buf, xmit_hashtype_tbl);
325
	if (new_value < 0)  {
J
Joe Perches 已提交
326
		pr_err("%s: Ignoring invalid xmit hash policy value %.*s.\n",
327 328
		       bond->dev->name,
		       (int)strlen(buf) - 1, buf);
329
		return -EINVAL;
330
	}
331

332 333 334 335 336 337 338 339
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_xmit_hash_policy_set(bond, new_value);
	if (!ret)
		ret = count;

	rtnl_unlock();
340 341
	return ret;
}
S
Stephen Hemminger 已提交
342 343
static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR,
		   bonding_show_xmit_hash, bonding_store_xmit_hash);
344

345 346 347
/*
 * Show and set arp_validate.
 */
348 349 350
static ssize_t bonding_show_arp_validate(struct device *d,
					 struct device_attribute *attr,
					 char *buf)
351
{
352
	struct bonding *bond = to_bond(d);
353 354 355

	return sprintf(buf, "%s %d\n",
		       arp_validate_tbl[bond->params.arp_validate].modename,
356
		       bond->params.arp_validate);
357 358
}

359 360 361
static ssize_t bonding_store_arp_validate(struct device *d,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
362
{
363
	struct bonding *bond = to_bond(d);
364
	int new_value, ret;
365

J
Jay Vosburgh 已提交
366
	new_value = bond_parse_parm(buf, arp_validate_tbl);
367
	if (new_value < 0) {
J
Joe Perches 已提交
368
		pr_err("%s: Ignoring invalid arp_validate value %s\n",
369
		       bond->dev->name, buf);
370
		return -EINVAL;
371
	}
372 373 374 375 376 377 378
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_arp_validate_set(bond, new_value);
	if (!ret)
		ret = count;

379
	rtnl_unlock();
380

381
	return ret;
382 383
}

S
Stephen Hemminger 已提交
384 385
static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate,
		   bonding_store_arp_validate);
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
/*
 * Show and set arp_all_targets.
 */
static ssize_t bonding_show_arp_all_targets(struct device *d,
					 struct device_attribute *attr,
					 char *buf)
{
	struct bonding *bond = to_bond(d);
	int value = bond->params.arp_all_targets;

	return sprintf(buf, "%s %d\n", arp_all_targets_tbl[value].modename,
		       value);
}

static ssize_t bonding_store_arp_all_targets(struct device *d,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
{
	struct bonding *bond = to_bond(d);
405
	int new_value, ret;
406 407 408 409 410 411 412 413

	new_value = bond_parse_parm(buf, arp_all_targets_tbl);
	if (new_value < 0) {
		pr_err("%s: Ignoring invalid arp_all_targets value %s\n",
		       bond->dev->name, buf);
		return -EINVAL;
	}

414 415
	if (!rtnl_trylock())
		return restart_syscall();
416

417 418 419 420 421 422 423
	ret = bond_option_arp_all_targets_set(bond, new_value);
	if (!ret)
		ret = count;

	rtnl_unlock();

	return ret;
424 425 426 427
}

static DEVICE_ATTR(arp_all_targets, S_IRUGO | S_IWUSR,
		   bonding_show_arp_all_targets, bonding_store_arp_all_targets);
428

429 430 431 432
/*
 * Show and store fail_over_mac.  User only allowed to change the
 * value when there are no slaves.
 */
S
Stephen Hemminger 已提交
433 434 435
static ssize_t bonding_show_fail_over_mac(struct device *d,
					  struct device_attribute *attr,
					  char *buf)
436 437 438
{
	struct bonding *bond = to_bond(d);

439 440 441
	return sprintf(buf, "%s %d\n",
		       fail_over_mac_tbl[bond->params.fail_over_mac].modename,
		       bond->params.fail_over_mac);
442 443
}

S
Stephen Hemminger 已提交
444 445 446
static ssize_t bonding_store_fail_over_mac(struct device *d,
					   struct device_attribute *attr,
					   const char *buf, size_t count)
447
{
448
	int new_value, ret;
449 450
	struct bonding *bond = to_bond(d);

451 452
	new_value = bond_parse_parm(buf, fail_over_mac_tbl);
	if (new_value < 0) {
J
Joe Perches 已提交
453
		pr_err("%s: Ignoring invalid fail_over_mac value %s.\n",
454
		       bond->dev->name, buf);
455
		return -EINVAL;
456 457
	}

458 459 460 461 462 463
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_fail_over_mac_set(bond, new_value);
	if (!ret)
		ret = count;
464

465 466
	rtnl_unlock();
	return ret;
467 468
}

S
Stephen Hemminger 已提交
469 470
static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR,
		   bonding_show_fail_over_mac, bonding_store_fail_over_mac);
471

472 473 474 475 476 477
/*
 * Show and set the arp timer interval.  There are two tricky bits
 * here.  First, if ARP monitoring is activated, then we must disable
 * MII monitoring.  Second, if the ARP timer isn't running, we must
 * start it.
 */
478 479 480
static ssize_t bonding_show_arp_interval(struct device *d,
					 struct device_attribute *attr,
					 char *buf)
481
{
482
	struct bonding *bond = to_bond(d);
483

484
	return sprintf(buf, "%d\n", bond->params.arp_interval);
485 486
}

487 488 489
static ssize_t bonding_store_arp_interval(struct device *d,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
490
{
491
	struct bonding *bond = to_bond(d);
492
	int new_value, ret;
493 494

	if (sscanf(buf, "%d", &new_value) != 1) {
J
Joe Perches 已提交
495
		pr_err("%s: no arp_interval value specified.\n",
496 497
		bond->dev->name);
		return -EINVAL;
498
	}
499 500 501 502 503 504 505 506

	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_arp_interval_set(bond, new_value);
	if (!ret)
		ret = count;

507
	rtnl_unlock();
508 509
	return ret;
}
S
Stephen Hemminger 已提交
510 511
static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR,
		   bonding_show_arp_interval, bonding_store_arp_interval);
512 513 514 515

/*
 * Show and set the arp targets.
 */
516 517 518
static ssize_t bonding_show_arp_targets(struct device *d,
					struct device_attribute *attr,
					char *buf)
519 520
{
	int i, res = 0;
521
	struct bonding *bond = to_bond(d);
522 523 524

	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
		if (bond->params.arp_targets[i])
H
Harvey Harrison 已提交
525 526
			res += sprintf(buf + res, "%pI4 ",
				       &bond->params.arp_targets[i]);
527
	}
528 529
	if (res)
		buf[res-1] = '\n'; /* eat the leftover space */
530 531 532
	return res;
}

533 534 535
static ssize_t bonding_store_arp_targets(struct device *d,
					 struct device_attribute *attr,
					 const char *buf, size_t count)
536
{
537
	struct bonding *bond = to_bond(d);
538 539
	__be32 target;
	int ret = -EPERM;
540

541 542 543 544
	if (!in4_pton(buf + 1, -1, (u8 *)&target, -1, NULL)) {
		pr_err("%s: invalid ARP target %pI4 specified\n",
		       bond->dev->name, &target);
		return -EPERM;
545
	}
546

547 548
	if (!rtnl_trylock())
		return restart_syscall();
549

550 551 552 553 554
	if (buf[0] == '+')
		ret = bond_option_arp_ip_target_add(bond, target);
	else if (buf[0] == '-')
		ret = bond_option_arp_ip_target_rem(bond, target);
	else
J
Joe Perches 已提交
555 556
		pr_err("no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n",
		       bond->dev->name);
557

558 559 560
	if (!ret)
		ret = count;

561
	rtnl_unlock();
562 563
	return ret;
}
564
static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
565 566 567 568 569 570

/*
 * Show and set the up and down delays.  These must be multiples of the
 * MII monitoring value, and are stored internally as the multiplier.
 * Thus, we must translate to MS for the real world.
 */
571 572 573
static ssize_t bonding_show_downdelay(struct device *d,
				      struct device_attribute *attr,
				      char *buf)
574
{
575
	struct bonding *bond = to_bond(d);
576

577
	return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon);
578 579
}

580 581 582
static ssize_t bonding_store_downdelay(struct device *d,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
583
{
584
	int new_value, ret;
585
	struct bonding *bond = to_bond(d);
586 587

	if (sscanf(buf, "%d", &new_value) != 1) {
J
Joe Perches 已提交
588
		pr_err("%s: no down delay value specified.\n", bond->dev->name);
589
		return -EINVAL;
590 591
	}

592 593 594 595 596 597
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_downdelay_set(bond, new_value);
	if (!ret)
		ret = count;
598

599
	rtnl_unlock();
600 601
	return ret;
}
S
Stephen Hemminger 已提交
602 603
static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR,
		   bonding_show_downdelay, bonding_store_downdelay);
604

605 606 607
static ssize_t bonding_show_updelay(struct device *d,
				    struct device_attribute *attr,
				    char *buf)
608
{
609
	struct bonding *bond = to_bond(d);
610

611
	return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon);
612 613 614

}

615 616 617
static ssize_t bonding_store_updelay(struct device *d,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
618
{
619
	int new_value, ret;
620
	struct bonding *bond = to_bond(d);
621 622

	if (sscanf(buf, "%d", &new_value) != 1) {
J
Joe Perches 已提交
623
		pr_err("%s: no up delay value specified.\n",
624 625
		bond->dev->name);
		return -EINVAL;
626 627
	}

628 629 630 631 632 633 634
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_updelay_set(bond, new_value);
	if (!ret)
		ret = count;

635
	rtnl_unlock();
636 637
	return ret;
}
S
Stephen Hemminger 已提交
638 639
static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR,
		   bonding_show_updelay, bonding_store_updelay);
640 641 642 643 644

/*
 * Show and set the LACP interval.  Interface must be down, and the mode
 * must be set to 802.3ad mode.
 */
645 646 647
static ssize_t bonding_show_lacp(struct device *d,
				 struct device_attribute *attr,
				 char *buf)
648
{
649
	struct bonding *bond = to_bond(d);
650 651 652

	return sprintf(buf, "%s %d\n",
		bond_lacp_tbl[bond->params.lacp_fast].modename,
653
		bond->params.lacp_fast);
654 655
}

656 657 658
static ssize_t bonding_store_lacp(struct device *d,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
659
{
660
	struct bonding *bond = to_bond(d);
661 662 663 664
	int new_value, ret = count;

	if (!rtnl_trylock())
		return restart_syscall();
665 666

	if (bond->dev->flags & IFF_UP) {
J
Joe Perches 已提交
667
		pr_err("%s: Unable to update LACP rate because interface is up.\n",
668 669 670 671 672 673
		       bond->dev->name);
		ret = -EPERM;
		goto out;
	}

	if (bond->params.mode != BOND_MODE_8023AD) {
J
Joe Perches 已提交
674
		pr_err("%s: Unable to update LACP rate because bond is not in 802.3ad mode.\n",
675 676 677 678 679
		       bond->dev->name);
		ret = -EPERM;
		goto out;
	}

J
Jay Vosburgh 已提交
680
	new_value = bond_parse_parm(buf, bond_lacp_tbl);
681 682 683

	if ((new_value == 1) || (new_value == 0)) {
		bond->params.lacp_fast = new_value;
684
		bond_3ad_update_lacp_rate(bond);
J
Joe Perches 已提交
685
		pr_info("%s: Setting LACP rate to %s (%d).\n",
S
Stephen Hemminger 已提交
686 687
			bond->dev->name, bond_lacp_tbl[new_value].modename,
			new_value);
688
	} else {
J
Joe Perches 已提交
689
		pr_err("%s: Ignoring invalid LACP rate value %.*s.\n",
S
Stephen Hemminger 已提交
690
		       bond->dev->name, (int)strlen(buf) - 1, buf);
691 692 693
		ret = -EINVAL;
	}
out:
694 695
	rtnl_unlock();

696 697
	return ret;
}
S
Stephen Hemminger 已提交
698 699
static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR,
		   bonding_show_lacp, bonding_store_lacp);
700

701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
static ssize_t bonding_show_min_links(struct device *d,
				      struct device_attribute *attr,
				      char *buf)
{
	struct bonding *bond = to_bond(d);

	return sprintf(buf, "%d\n", bond->params.min_links);
}

static ssize_t bonding_store_min_links(struct device *d,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
{
	struct bonding *bond = to_bond(d);
	int ret;
	unsigned int new_value;

	ret = kstrtouint(buf, 0, &new_value);
	if (ret < 0) {
		pr_err("%s: Ignoring invalid min links value %s.\n",
		       bond->dev->name, buf);
		return ret;
	}

725 726 727 728 729 730 731 732 733
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_min_links_set(bond, new_value);
	if (!ret)
		ret = count;

	rtnl_unlock();
	return ret;
734 735 736 737
}
static DEVICE_ATTR(min_links, S_IRUGO | S_IWUSR,
		   bonding_show_min_links, bonding_store_min_links);

738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
static ssize_t bonding_show_ad_select(struct device *d,
				      struct device_attribute *attr,
				      char *buf)
{
	struct bonding *bond = to_bond(d);

	return sprintf(buf, "%s %d\n",
		ad_select_tbl[bond->params.ad_select].modename,
		bond->params.ad_select);
}


static ssize_t bonding_store_ad_select(struct device *d,
				       struct device_attribute *attr,
				       const char *buf, size_t count)
{
	int new_value, ret = count;
	struct bonding *bond = to_bond(d);

	if (bond->dev->flags & IFF_UP) {
J
Joe Perches 已提交
758 759
		pr_err("%s: Unable to update ad_select because interface is up.\n",
		       bond->dev->name);
760 761 762 763 764 765 766 767
		ret = -EPERM;
		goto out;
	}

	new_value = bond_parse_parm(buf, ad_select_tbl);

	if (new_value != -1) {
		bond->params.ad_select = new_value;
J
Joe Perches 已提交
768 769 770
		pr_info("%s: Setting ad_select to %s (%d).\n",
			bond->dev->name, ad_select_tbl[new_value].modename,
			new_value);
771
	} else {
J
Joe Perches 已提交
772
		pr_err("%s: Ignoring invalid ad_select value %.*s.\n",
773 774 775 776 777 778
		       bond->dev->name, (int)strlen(buf) - 1, buf);
		ret = -EINVAL;
	}
out:
	return ret;
}
S
Stephen Hemminger 已提交
779 780
static DEVICE_ATTR(ad_select, S_IRUGO | S_IWUSR,
		   bonding_show_ad_select, bonding_store_ad_select);
781

782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
/*
 * Show and set the number of peer notifications to send after a failover event.
 */
static ssize_t bonding_show_num_peer_notif(struct device *d,
					   struct device_attribute *attr,
					   char *buf)
{
	struct bonding *bond = to_bond(d);
	return sprintf(buf, "%d\n", bond->params.num_peer_notif);
}

static ssize_t bonding_store_num_peer_notif(struct device *d,
					    struct device_attribute *attr,
					    const char *buf, size_t count)
{
	struct bonding *bond = to_bond(d);
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
	u8 new_value;
	int ret;

	ret = kstrtou8(buf, 10, &new_value);
	if (!ret) {
		pr_err("%s: invalid value %s specified.\n",
		       bond->dev->name, buf);
		return ret;
	}

	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_num_peer_notif_set(bond, new_value);
	if (!ret)
		ret = count;

	rtnl_unlock();
	return ret;
817 818 819 820 821 822
}
static DEVICE_ATTR(num_grat_arp, S_IRUGO | S_IWUSR,
		   bonding_show_num_peer_notif, bonding_store_num_peer_notif);
static DEVICE_ATTR(num_unsol_na, S_IRUGO | S_IWUSR,
		   bonding_show_num_peer_notif, bonding_store_num_peer_notif);

823 824 825 826 827 828
/*
 * Show and set the MII monitor interval.  There are two tricky bits
 * here.  First, if MII monitoring is activated, then we must disable
 * ARP monitoring.  Second, if the timer isn't running, we must
 * start it.
 */
829 830 831
static ssize_t bonding_show_miimon(struct device *d,
				   struct device_attribute *attr,
				   char *buf)
832
{
833
	struct bonding *bond = to_bond(d);
834

835
	return sprintf(buf, "%d\n", bond->params.miimon);
836 837
}

838 839 840
static ssize_t bonding_store_miimon(struct device *d,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
841
{
842
	int new_value, ret;
843
	struct bonding *bond = to_bond(d);
844 845

	if (sscanf(buf, "%d", &new_value) != 1) {
J
Joe Perches 已提交
846
		pr_err("%s: no miimon value specified.\n",
847
		       bond->dev->name);
848
		return -EINVAL;
849
	}
850 851 852 853 854 855 856 857

	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_miimon_set(bond, new_value);
	if (!ret)
		ret = count;

858
	rtnl_unlock();
859 860
	return ret;
}
S
Stephen Hemminger 已提交
861 862
static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR,
		   bonding_show_miimon, bonding_store_miimon);
863 864 865 866 867 868 869 870

/*
 * Show and set the primary slave.  The store function is much
 * simpler than bonding_store_slaves function because it only needs to
 * handle one interface name.
 * The bond must be a mode that supports a primary for this be
 * set.
 */
871 872 873
static ssize_t bonding_show_primary(struct device *d,
				    struct device_attribute *attr,
				    char *buf)
874 875
{
	int count = 0;
876
	struct bonding *bond = to_bond(d);
877 878

	if (bond->primary_slave)
879
		count = sprintf(buf, "%s\n", bond->primary_slave->dev->name);
880 881 882 883

	return count;
}

884 885 886
static ssize_t bonding_store_primary(struct device *d,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
887
{
888
	struct bonding *bond = to_bond(d);
889
	char ifname[IFNAMSIZ];
890
	int ret;
891

N
nikolay@redhat.com 已提交
892
	sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
893 894
	if (ifname[0] == '\n')
		ifname[0] = '\0';
895

896 897
	if (!rtnl_trylock())
		return restart_syscall();
898

899 900 901
	ret = bond_option_primary_set(bond, ifname);
	if (!ret)
		ret = count;
902

903
	rtnl_unlock();
904
	return ret;
905
}
S
Stephen Hemminger 已提交
906 907
static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR,
		   bonding_show_primary, bonding_store_primary);
908

909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
/*
 * Show and set the primary_reselect flag.
 */
static ssize_t bonding_show_primary_reselect(struct device *d,
					     struct device_attribute *attr,
					     char *buf)
{
	struct bonding *bond = to_bond(d);

	return sprintf(buf, "%s %d\n",
		       pri_reselect_tbl[bond->params.primary_reselect].modename,
		       bond->params.primary_reselect);
}

static ssize_t bonding_store_primary_reselect(struct device *d,
					      struct device_attribute *attr,
					      const char *buf, size_t count)
{
927
	int new_value, ret;
928 929 930 931
	struct bonding *bond = to_bond(d);

	new_value = bond_parse_parm(buf, pri_reselect_tbl);
	if (new_value < 0)  {
J
Joe Perches 已提交
932
		pr_err("%s: Ignoring invalid primary_reselect value %.*s.\n",
933 934
		       bond->dev->name,
		       (int) strlen(buf) - 1, buf);
935
		return -EINVAL;
936 937
	}

938 939 940 941 942 943
	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_primary_reselect_set(bond, new_value);
	if (!ret)
		ret = count;
944 945 946 947 948 949 950 951

	rtnl_unlock();
	return ret;
}
static DEVICE_ATTR(primary_reselect, S_IRUGO | S_IWUSR,
		   bonding_show_primary_reselect,
		   bonding_store_primary_reselect);

952 953 954
/*
 * Show and set the use_carrier flag.
 */
955 956 957
static ssize_t bonding_show_carrier(struct device *d,
				    struct device_attribute *attr,
				    char *buf)
958
{
959
	struct bonding *bond = to_bond(d);
960

961
	return sprintf(buf, "%d\n", bond->params.use_carrier);
962 963
}

964 965 966
static ssize_t bonding_store_carrier(struct device *d,
				     struct device_attribute *attr,
				     const char *buf, size_t count)
967
{
968
	int new_value, ret;
969
	struct bonding *bond = to_bond(d);
970 971

	if (sscanf(buf, "%d", &new_value) != 1) {
J
Joe Perches 已提交
972
		pr_err("%s: no use_carrier value specified.\n",
973
		       bond->dev->name);
974
		return -EINVAL;
975
	}
976 977 978 979 980 981 982 983 984

	if (!rtnl_trylock())
		return restart_syscall();

	ret = bond_option_use_carrier_set(bond, new_value);
	if (!ret)
		ret = count;

	rtnl_unlock();
985
	return ret;
986
}
S
Stephen Hemminger 已提交
987 988
static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR,
		   bonding_show_carrier, bonding_store_carrier);
989 990 991 992 993


/*
 * Show and set currently active_slave.
 */
994 995 996
static ssize_t bonding_show_active_slave(struct device *d,
					 struct device_attribute *attr,
					 char *buf)
997
{
998
	struct bonding *bond = to_bond(d);
999
	struct net_device *slave_dev;
1000
	int count = 0;
1001

1002
	rcu_read_lock();
1003 1004 1005
	slave_dev = bond_option_active_slave_get_rcu(bond);
	if (slave_dev)
		count = sprintf(buf, "%s\n", slave_dev->name);
1006 1007
	rcu_read_unlock();

1008 1009 1010
	return count;
}

1011 1012 1013
static ssize_t bonding_store_active_slave(struct device *d,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
1014
{
1015
	int ret;
1016
	struct bonding *bond = to_bond(d);
1017
	char ifname[IFNAMSIZ];
1018
	struct net_device *dev;
1019

1020 1021
	if (!rtnl_trylock())
		return restart_syscall();
1022

1023
	sscanf(buf, "%15s", ifname); /* IFNAMSIZ */
1024
	if (!strlen(ifname) || buf[0] == '\n') {
1025 1026 1027 1028 1029 1030
		dev = NULL;
	} else {
		dev = __dev_get_by_name(dev_net(bond->dev), ifname);
		if (!dev) {
			ret = -ENODEV;
			goto out;
1031 1032
		}
	}
1033

1034 1035 1036
	ret = bond_option_active_slave_set(bond, dev);
	if (!ret)
		ret = count;
1037

1038
 out:
1039 1040
	rtnl_unlock();

1041
	return ret;
1042 1043

}
S
Stephen Hemminger 已提交
1044 1045
static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR,
		   bonding_show_active_slave, bonding_store_active_slave);
1046 1047 1048 1049 1050


/*
 * Show link status of the bond interface.
 */
1051 1052 1053
static ssize_t bonding_show_mii_status(struct device *d,
				       struct device_attribute *attr,
				       char *buf)
1054
{
1055
	struct bonding *bond = to_bond(d);
1056

1057
	return sprintf(buf, "%s\n", bond->curr_active_slave ? "up" : "down");
1058
}
1059
static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
1060 1061 1062 1063

/*
 * Show current 802.3ad aggregator ID.
 */
1064 1065 1066
static ssize_t bonding_show_ad_aggregator(struct device *d,
					  struct device_attribute *attr,
					  char *buf)
1067 1068
{
	int count = 0;
1069
	struct bonding *bond = to_bond(d);
1070 1071 1072

	if (bond->params.mode == BOND_MODE_8023AD) {
		struct ad_info ad_info;
S
Stephen Hemminger 已提交
1073
		count = sprintf(buf, "%d\n",
1074
				bond_3ad_get_active_agg_info(bond, &ad_info)
S
Stephen Hemminger 已提交
1075
				?  0 : ad_info.aggregator_id);
1076 1077 1078 1079
	}

	return count;
}
1080
static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
1081 1082 1083 1084 1085


/*
 * Show number of active 802.3ad ports.
 */
1086 1087 1088
static ssize_t bonding_show_ad_num_ports(struct device *d,
					 struct device_attribute *attr,
					 char *buf)
1089 1090
{
	int count = 0;
1091
	struct bonding *bond = to_bond(d);
1092 1093 1094

	if (bond->params.mode == BOND_MODE_8023AD) {
		struct ad_info ad_info;
S
Stephen Hemminger 已提交
1095
		count = sprintf(buf, "%d\n",
1096
				bond_3ad_get_active_agg_info(bond, &ad_info)
S
Stephen Hemminger 已提交
1097
				?  0 : ad_info.ports);
1098 1099 1100 1101
	}

	return count;
}
1102
static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
1103 1104 1105 1106 1107


/*
 * Show current 802.3ad actor key.
 */
1108 1109 1110
static ssize_t bonding_show_ad_actor_key(struct device *d,
					 struct device_attribute *attr,
					 char *buf)
1111 1112
{
	int count = 0;
1113
	struct bonding *bond = to_bond(d);
1114 1115 1116

	if (bond->params.mode == BOND_MODE_8023AD) {
		struct ad_info ad_info;
S
Stephen Hemminger 已提交
1117
		count = sprintf(buf, "%d\n",
1118
				bond_3ad_get_active_agg_info(bond, &ad_info)
S
Stephen Hemminger 已提交
1119
				?  0 : ad_info.actor_key);
1120 1121 1122 1123
	}

	return count;
}
1124
static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
1125 1126 1127 1128 1129


/*
 * Show current 802.3ad partner key.
 */
1130 1131 1132
static ssize_t bonding_show_ad_partner_key(struct device *d,
					   struct device_attribute *attr,
					   char *buf)
1133 1134
{
	int count = 0;
1135
	struct bonding *bond = to_bond(d);
1136 1137 1138

	if (bond->params.mode == BOND_MODE_8023AD) {
		struct ad_info ad_info;
S
Stephen Hemminger 已提交
1139
		count = sprintf(buf, "%d\n",
1140
				bond_3ad_get_active_agg_info(bond, &ad_info)
S
Stephen Hemminger 已提交
1141
				?  0 : ad_info.partner_key);
1142 1143 1144 1145
	}

	return count;
}
1146
static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
1147 1148 1149 1150 1151


/*
 * Show current 802.3ad partner mac.
 */
1152 1153 1154
static ssize_t bonding_show_ad_partner_mac(struct device *d,
					   struct device_attribute *attr,
					   char *buf)
1155 1156
{
	int count = 0;
1157
	struct bonding *bond = to_bond(d);
1158 1159 1160

	if (bond->params.mode == BOND_MODE_8023AD) {
		struct ad_info ad_info;
S
Stephen Hemminger 已提交
1161
		if (!bond_3ad_get_active_agg_info(bond, &ad_info))
J
Johannes Berg 已提交
1162
			count = sprintf(buf, "%pM\n", ad_info.partner_system);
1163 1164 1165 1166
	}

	return count;
}
1167
static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
1168

1169 1170 1171 1172 1173 1174 1175 1176
/*
 * Show the queue_ids of the slaves in the current bond.
 */
static ssize_t bonding_show_queue_id(struct device *d,
				     struct device_attribute *attr,
				     char *buf)
{
	struct bonding *bond = to_bond(d);
1177
	struct list_head *iter;
1178 1179
	struct slave *slave;
	int res = 0;
1180 1181 1182 1183

	if (!rtnl_trylock())
		return restart_syscall();

1184
	bond_for_each_slave(bond, slave, iter) {
1185 1186
		if (res > (PAGE_SIZE - IFNAMSIZ - 6)) {
			/* not enough space for another interface_name:queue_id pair */
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
			if ((PAGE_SIZE - res) > 10)
				res = PAGE_SIZE - 10;
			res += sprintf(buf + res, "++more++ ");
			break;
		}
		res += sprintf(buf + res, "%s:%d ",
			       slave->dev->name, slave->queue_id);
	}
	if (res)
		buf[res-1] = '\n'; /* eat the leftover space */
1197

1198
	rtnl_unlock();
1199

1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
	return res;
}

/*
 * Set the queue_ids of the  slaves in the current bond.  The bond
 * interface must be enslaved for this to work.
 */
static ssize_t bonding_store_queue_id(struct device *d,
				      struct device_attribute *attr,
				      const char *buffer, size_t count)
{
	struct slave *slave, *update_slave;
	struct bonding *bond = to_bond(d);
1213
	struct list_head *iter;
1214
	u16 qid;
1215
	int ret = count;
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
	char *delim;
	struct net_device *sdev = NULL;

	if (!rtnl_trylock())
		return restart_syscall();

	/* delim will point to queue id if successful */
	delim = strchr(buffer, ':');
	if (!delim)
		goto err_no_cmd;

	/*
	 * Terminate string that points to device name and bump it
	 * up one, so we can read the queue id there.
	 */
	*delim = '\0';
	if (sscanf(++delim, "%hd\n", &qid) != 1)
		goto err_no_cmd;

	/* Check buffer length, valid ifname and queue id */
	if (strlen(buffer) > IFNAMSIZ ||
	    !dev_valid_name(buffer) ||
1238
	    qid > bond->dev->real_num_tx_queues)
1239 1240 1241 1242 1243 1244 1245 1246 1247
		goto err_no_cmd;

	/* Get the pointer to that interface if it exists */
	sdev = __dev_get_by_name(dev_net(bond->dev), buffer);
	if (!sdev)
		goto err_no_cmd;

	/* Search for thes slave and check for duplicate qids */
	update_slave = NULL;
1248
	bond_for_each_slave(bond, slave, iter) {
1249 1250 1251 1252 1253 1254 1255
		if (sdev == slave->dev)
			/*
			 * We don't need to check the matching
			 * slave for dups, since we're overwriting it
			 */
			update_slave = slave;
		else if (qid && qid == slave->queue_id) {
1256
			goto err_no_cmd;
1257 1258 1259 1260
		}
	}

	if (!update_slave)
1261
		goto err_no_cmd;
1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280

	/* Actually set the qids for the slave */
	update_slave->queue_id = qid;

out:
	rtnl_unlock();
	return ret;

err_no_cmd:
	pr_info("invalid input for queue_id set for %s.\n",
		bond->dev->name);
	ret = -EPERM;
	goto out;
}

static DEVICE_ATTR(queue_id, S_IRUGO | S_IWUSR, bonding_show_queue_id,
		   bonding_store_queue_id);


1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297
/*
 * Show and set the all_slaves_active flag.
 */
static ssize_t bonding_show_slaves_active(struct device *d,
					  struct device_attribute *attr,
					  char *buf)
{
	struct bonding *bond = to_bond(d);

	return sprintf(buf, "%d\n", bond->params.all_slaves_active);
}

static ssize_t bonding_store_slaves_active(struct device *d,
					   struct device_attribute *attr,
					   const char *buf, size_t count)
{
	struct bonding *bond = to_bond(d);
1298
	int new_value, ret;
1299

1300 1301 1302
	if (sscanf(buf, "%d", &new_value) != 1) {
		pr_err("%s: no all_slaves_active value specified.\n",
		       bond->dev->name);
1303
		return -EINVAL;
1304 1305
	}

1306 1307
	if (!rtnl_trylock())
		return restart_syscall();
1308

1309 1310 1311
	ret = bond_option_all_slaves_active_set(bond, new_value);
	if (!ret)
		ret = count;
1312

1313
	rtnl_unlock();
1314
	return ret;
1315 1316 1317
}
static DEVICE_ATTR(all_slaves_active, S_IRUGO | S_IWUSR,
		   bonding_show_slaves_active, bonding_store_slaves_active);
1318

1319 1320 1321 1322
/*
 * Show and set the number of IGMP membership reports to send on link failure
 */
static ssize_t bonding_show_resend_igmp(struct device *d,
1323 1324
					struct device_attribute *attr,
					char *buf)
1325 1326 1327 1328 1329 1330 1331
{
	struct bonding *bond = to_bond(d);

	return sprintf(buf, "%d\n", bond->params.resend_igmp);
}

static ssize_t bonding_store_resend_igmp(struct device *d,
1332 1333
					 struct device_attribute *attr,
					 const char *buf, size_t count)
1334 1335 1336 1337 1338 1339 1340
{
	int new_value, ret = count;
	struct bonding *bond = to_bond(d);

	if (sscanf(buf, "%d", &new_value) != 1) {
		pr_err("%s: no resend_igmp value specified.\n",
		       bond->dev->name);
1341
		return -EINVAL;
1342 1343
	}

1344 1345
	if (!rtnl_trylock())
		return restart_syscall();
1346

1347 1348 1349 1350 1351
	ret = bond_option_resend_igmp_set(bond, new_value);
	if (!ret)
		ret = count;

	rtnl_unlock();
1352 1353 1354 1355 1356 1357
	return ret;
}

static DEVICE_ATTR(resend_igmp, S_IRUGO | S_IWUSR,
		   bonding_show_resend_igmp, bonding_store_resend_igmp);

1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395

static ssize_t bonding_show_lp_interval(struct device *d,
					struct device_attribute *attr,
					char *buf)
{
	struct bonding *bond = to_bond(d);
	return sprintf(buf, "%d\n", bond->params.lp_interval);
}

static ssize_t bonding_store_lp_interval(struct device *d,
					 struct device_attribute *attr,
					 const char *buf, size_t count)
{
	struct bonding *bond = to_bond(d);
	int new_value, ret = count;

	if (sscanf(buf, "%d", &new_value) != 1) {
		pr_err("%s: no lp interval value specified.\n",
			bond->dev->name);
		ret = -EINVAL;
		goto out;
	}

	if (new_value <= 0) {
		pr_err ("%s: lp_interval must be between 1 and %d\n",
			bond->dev->name, INT_MAX);
		ret = -EINVAL;
		goto out;
	}

	bond->params.lp_interval = new_value;
out:
	return ret;
}

static DEVICE_ATTR(lp_interval, S_IRUGO | S_IWUSR,
		   bonding_show_lp_interval, bonding_store_lp_interval);

1396 1397 1398 1399 1400
static ssize_t bonding_show_packets_per_slave(struct device *d,
					      struct device_attribute *attr,
					      char *buf)
{
	struct bonding *bond = to_bond(d);
1401
	unsigned int packets_per_slave = bond->params.packets_per_slave;
1402 1403 1404 1405

	if (packets_per_slave > 1)
		packets_per_slave = reciprocal_value(packets_per_slave);

1406
	return sprintf(buf, "%u\n", packets_per_slave);
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
}

static ssize_t bonding_store_packets_per_slave(struct device *d,
					       struct device_attribute *attr,
					       const char *buf, size_t count)
{
	struct bonding *bond = to_bond(d);
	int new_value, ret = count;

	if (sscanf(buf, "%d", &new_value) != 1) {
		pr_err("%s: no packets_per_slave value specified.\n",
		       bond->dev->name);
		ret = -EINVAL;
		goto out;
	}
	if (new_value < 0 || new_value > USHRT_MAX) {
		pr_err("%s: packets_per_slave must be between 0 and %u\n",
		       bond->dev->name, USHRT_MAX);
		ret = -EINVAL;
		goto out;
	}
	if (bond->params.mode != BOND_MODE_ROUNDROBIN)
		pr_warn("%s: Warning: packets_per_slave has effect only in balance-rr mode\n",
			bond->dev->name);
	if (new_value > 1)
		bond->params.packets_per_slave = reciprocal_value(new_value);
	else
		bond->params.packets_per_slave = new_value;
out:
	return ret;
}

static DEVICE_ATTR(packets_per_slave, S_IRUGO | S_IWUSR,
		   bonding_show_packets_per_slave,
		   bonding_store_packets_per_slave);

1443
static struct attribute *per_bond_attrs[] = {
1444 1445
	&dev_attr_slaves.attr,
	&dev_attr_mode.attr,
1446
	&dev_attr_fail_over_mac.attr,
1447
	&dev_attr_arp_validate.attr,
1448
	&dev_attr_arp_all_targets.attr,
1449 1450 1451 1452 1453
	&dev_attr_arp_interval.attr,
	&dev_attr_arp_ip_target.attr,
	&dev_attr_downdelay.attr,
	&dev_attr_updelay.attr,
	&dev_attr_lacp_rate.attr,
1454
	&dev_attr_ad_select.attr,
1455
	&dev_attr_xmit_hash_policy.attr,
1456 1457
	&dev_attr_num_grat_arp.attr,
	&dev_attr_num_unsol_na.attr,
1458 1459
	&dev_attr_miimon.attr,
	&dev_attr_primary.attr,
1460
	&dev_attr_primary_reselect.attr,
1461 1462 1463 1464 1465 1466 1467 1468
	&dev_attr_use_carrier.attr,
	&dev_attr_active_slave.attr,
	&dev_attr_mii_status.attr,
	&dev_attr_ad_aggregator.attr,
	&dev_attr_ad_num_ports.attr,
	&dev_attr_ad_actor_key.attr,
	&dev_attr_ad_partner_key.attr,
	&dev_attr_ad_partner_mac.attr,
1469
	&dev_attr_queue_id.attr,
1470
	&dev_attr_all_slaves_active.attr,
1471
	&dev_attr_resend_igmp.attr,
1472
	&dev_attr_min_links.attr,
1473
	&dev_attr_lp_interval.attr,
1474
	&dev_attr_packets_per_slave.attr,
1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
	NULL,
};

static struct attribute_group bonding_group = {
	.name = "bonding",
	.attrs = per_bond_attrs,
};

/*
 * Initialize sysfs.  This sets up the bonding_masters file in
 * /sys/class/net.
 */
1487
int bond_create_sysfs(struct bond_net *bn)
1488
{
1489
	int ret;
1490

1491
	bn->class_attr_bonding_masters = class_attr_bonding_masters;
1492
	sysfs_attr_init(&bn->class_attr_bonding_masters.attr);
1493

1494 1495
	ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters,
					  bn->net);
1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
	/*
	 * Permit multiple loads of the module by ignoring failures to
	 * create the bonding_masters sysfs file.  Bonding devices
	 * created by second or subsequent loads of the module will
	 * not be listed in, or controllable by, bonding_masters, but
	 * will have the usual "bonding" sysfs directory.
	 *
	 * This is done to preserve backwards compatibility for
	 * initscripts/sysconfig, which load bonding multiple times to
	 * configure multiple bonding devices.
	 */
	if (ret == -EEXIST) {
1508
		/* Is someone being kinky and naming a device bonding_master? */
1509
		if (__dev_get_by_name(bn->net,
1510
				      class_attr_bonding_masters.attr.name))
J
Joe Perches 已提交
1511
			pr_err("network device named %s already exists in sysfs",
1512
			       class_attr_bonding_masters.attr.name);
1513
		ret = 0;
1514
	}
1515 1516 1517 1518 1519 1520 1521 1522

	return ret;

}

/*
 * Remove /sys/class/net/bonding_masters.
 */
1523
void bond_destroy_sysfs(struct bond_net *bn)
1524
{
1525
	netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net);
1526 1527 1528 1529 1530 1531
}

/*
 * Initialize sysfs for each bond.  This sets up and registers
 * the 'bondctl' directory for each individual bond under /sys/class/net.
 */
1532
void bond_prepare_sysfs_group(struct bonding *bond)
1533
{
1534
	bond->dev->sysfs_groups[0] = &bonding_group;
1535 1536
}