xref: /linux/drivers/net/bonding/bond_sysfs.c (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
4  */
5 
6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7 
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/device.h>
11 #include <linux/sched/signal.h>
12 #include <linux/fs.h>
13 #include <linux/types.h>
14 #include <linux/string.h>
15 #include <linux/netdevice.h>
16 #include <linux/inetdevice.h>
17 #include <linux/in.h>
18 #include <linux/sysfs.h>
19 #include <linux/ctype.h>
20 #include <linux/inet.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/etherdevice.h>
23 #include <net/net_namespace.h>
24 #include <net/netns/generic.h>
25 #include <linux/nsproxy.h>
26 
27 #include <net/bonding.h>
28 
29 #define to_bond(cd)	((struct bonding *)(netdev_priv(to_net_dev(cd))))
30 
31 /* "show" function for the bond_masters attribute.
32  * The class parameter is ignored.
33  */
bonding_show_bonds(const struct class * cls,const struct class_attribute * attr,char * buf)34 static ssize_t bonding_show_bonds(const struct class *cls,
35 				  const struct class_attribute *attr,
36 				  char *buf)
37 {
38 	const struct bond_net *bn =
39 		container_of_const(attr, struct bond_net, class_attr_bonding_masters);
40 	struct bonding *bond;
41 	int res = 0;
42 
43 	rcu_read_lock();
44 
45 	list_for_each_entry_rcu(bond, &bn->dev_list, bond_list) {
46 		if (res > (PAGE_SIZE - IFNAMSIZ)) {
47 			/* not enough space for another interface name */
48 			if ((PAGE_SIZE - res) > 10)
49 				res = PAGE_SIZE - 10;
50 			res += sysfs_emit_at(buf, res, "++more++ ");
51 			break;
52 		}
53 		res += sysfs_emit_at(buf, res, "%s ", bond->dev->name);
54 	}
55 	if (res)
56 		buf[res-1] = '\n'; /* eat the leftover space */
57 
58 	rcu_read_unlock();
59 	return res;
60 }
61 
bond_get_by_name(const struct bond_net * bn,const char * ifname)62 static struct net_device *bond_get_by_name(const struct bond_net *bn, const char *ifname)
63 {
64 	struct bonding *bond;
65 
66 	list_for_each_entry(bond, &bn->dev_list, bond_list) {
67 		if (strncmp(bond->dev->name, ifname, IFNAMSIZ) == 0)
68 			return bond->dev;
69 	}
70 	return NULL;
71 }
72 
73 /* "store" function for the bond_masters attribute.  This is what
74  * creates and deletes entire bonds.
75  *
76  * The class parameter is ignored.
77  */
bonding_store_bonds(const struct class * cls,const struct class_attribute * attr,const char * buffer,size_t count)78 static ssize_t bonding_store_bonds(const struct class *cls,
79 				   const struct class_attribute *attr,
80 				   const char *buffer, size_t count)
81 {
82 	const struct bond_net *bn =
83 		container_of_const(attr, struct bond_net, class_attr_bonding_masters);
84 	char command[IFNAMSIZ + 1] = {0, };
85 	char *ifname;
86 	int rv, res = count;
87 
88 	sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
89 	ifname = command + 1;
90 	if ((strlen(command) <= 1) ||
91 	    !dev_valid_name(ifname))
92 		goto err_no_cmd;
93 
94 	if (command[0] == '+') {
95 		pr_info("%s is being created...\n", ifname);
96 		rv = bond_create(bn->net, ifname);
97 		if (rv) {
98 			if (rv == -EEXIST)
99 				pr_info("%s already exists\n", ifname);
100 			else
101 				pr_info("%s creation failed\n", ifname);
102 			res = rv;
103 		}
104 	} else if (command[0] == '-') {
105 		struct net_device *bond_dev;
106 
107 		rtnl_lock();
108 		bond_dev = bond_get_by_name(bn, ifname);
109 		if (bond_dev) {
110 			pr_info("%s is being deleted...\n", ifname);
111 			unregister_netdevice(bond_dev);
112 		} else {
113 			pr_err("unable to delete non-existent %s\n", ifname);
114 			res = -ENODEV;
115 		}
116 		rtnl_unlock();
117 	} else
118 		goto err_no_cmd;
119 
120 	/* Always return either count or an error.  If you return 0, you'll
121 	 * get called forever, which is bad.
122 	 */
123 	return res;
124 
125 err_no_cmd:
126 	pr_err("no command found in bonding_masters - use +ifname or -ifname\n");
127 	return -EPERM;
128 }
129 
130 /* class attribute for bond_masters file.  This ends up in /sys/class/net */
131 static const struct class_attribute class_attr_bonding_masters = {
132 	.attr = {
133 		.name = "bonding_masters",
134 		.mode = 0644,
135 	},
136 	.show = bonding_show_bonds,
137 	.store = bonding_store_bonds,
138 };
139 
140 /* Generic "store" method for bonding sysfs option setting */
bonding_sysfs_store_option(struct device * d,struct device_attribute * attr,const char * buffer,size_t count)141 static ssize_t bonding_sysfs_store_option(struct device *d,
142 					  struct device_attribute *attr,
143 					  const char *buffer, size_t count)
144 {
145 	struct bonding *bond = to_bond(d);
146 	const struct bond_option *opt;
147 	char *buffer_clone;
148 	int ret;
149 
150 	opt = bond_opt_get_by_name(attr->attr.name);
151 	if (WARN_ON(!opt))
152 		return -ENOENT;
153 	buffer_clone = kstrndup(buffer, count, GFP_KERNEL);
154 	if (!buffer_clone)
155 		return -ENOMEM;
156 	ret = bond_opt_tryset_rtnl(bond, opt->id, buffer_clone);
157 	if (!ret)
158 		ret = count;
159 	kfree(buffer_clone);
160 
161 	return ret;
162 }
163 
164 /* Show the slaves in the current bond. */
bonding_show_slaves(struct device * d,struct device_attribute * attr,char * buf)165 static ssize_t bonding_show_slaves(struct device *d,
166 				   struct device_attribute *attr, char *buf)
167 {
168 	struct bonding *bond = to_bond(d);
169 	struct list_head *iter;
170 	struct slave *slave;
171 	int res = 0;
172 
173 	rcu_read_lock();
174 
175 	bond_for_each_slave_rcu(bond, slave, iter) {
176 		if (res > (PAGE_SIZE - IFNAMSIZ)) {
177 			/* not enough space for another interface name */
178 			if ((PAGE_SIZE - res) > 10)
179 				res = PAGE_SIZE - 10;
180 			res += sysfs_emit_at(buf, res, "++more++ ");
181 			break;
182 		}
183 		res += sysfs_emit_at(buf, res, "%s ", slave->dev->name);
184 	}
185 
186 	rcu_read_unlock();
187 
188 	if (res)
189 		buf[res-1] = '\n'; /* eat the leftover space */
190 
191 	return res;
192 }
193 static DEVICE_ATTR(slaves, 0644, bonding_show_slaves,
194 		   bonding_sysfs_store_option);
195 
196 /* Show the bonding mode. */
bonding_show_mode(struct device * d,struct device_attribute * attr,char * buf)197 static ssize_t bonding_show_mode(struct device *d,
198 				 struct device_attribute *attr, char *buf)
199 {
200 	struct bonding *bond = to_bond(d);
201 	const struct bond_opt_value *val;
202 
203 	val = bond_opt_get_val(BOND_OPT_MODE, BOND_MODE(bond));
204 
205 	return sysfs_emit(buf, "%s %d\n", val->string, BOND_MODE(bond));
206 }
207 static DEVICE_ATTR(mode, 0644, bonding_show_mode, bonding_sysfs_store_option);
208 
209 /* Show the bonding transmit hash method. */
bonding_show_xmit_hash(struct device * d,struct device_attribute * attr,char * buf)210 static ssize_t bonding_show_xmit_hash(struct device *d,
211 				      struct device_attribute *attr,
212 				      char *buf)
213 {
214 	struct bonding *bond = to_bond(d);
215 	const struct bond_opt_value *val;
216 
217 	val = bond_opt_get_val(BOND_OPT_XMIT_HASH, bond->params.xmit_policy);
218 
219 	return sysfs_emit(buf, "%s %d\n", val->string, bond->params.xmit_policy);
220 }
221 static DEVICE_ATTR(xmit_hash_policy, 0644,
222 		   bonding_show_xmit_hash, bonding_sysfs_store_option);
223 
224 /* Show arp_validate. */
bonding_show_arp_validate(struct device * d,struct device_attribute * attr,char * buf)225 static ssize_t bonding_show_arp_validate(struct device *d,
226 					 struct device_attribute *attr,
227 					 char *buf)
228 {
229 	struct bonding *bond = to_bond(d);
230 	const struct bond_opt_value *val;
231 
232 	val = bond_opt_get_val(BOND_OPT_ARP_VALIDATE,
233 			       bond->params.arp_validate);
234 
235 	return sysfs_emit(buf, "%s %d\n", val->string, bond->params.arp_validate);
236 }
237 static DEVICE_ATTR(arp_validate, 0644, bonding_show_arp_validate,
238 		   bonding_sysfs_store_option);
239 
240 /* Show arp_all_targets. */
bonding_show_arp_all_targets(struct device * d,struct device_attribute * attr,char * buf)241 static ssize_t bonding_show_arp_all_targets(struct device *d,
242 					 struct device_attribute *attr,
243 					 char *buf)
244 {
245 	struct bonding *bond = to_bond(d);
246 	const struct bond_opt_value *val;
247 
248 	val = bond_opt_get_val(BOND_OPT_ARP_ALL_TARGETS,
249 			       bond->params.arp_all_targets);
250 	return sysfs_emit(buf, "%s %d\n",
251 		       val->string, bond->params.arp_all_targets);
252 }
253 static DEVICE_ATTR(arp_all_targets, 0644,
254 		   bonding_show_arp_all_targets, bonding_sysfs_store_option);
255 
256 /* Show fail_over_mac. */
bonding_show_fail_over_mac(struct device * d,struct device_attribute * attr,char * buf)257 static ssize_t bonding_show_fail_over_mac(struct device *d,
258 					  struct device_attribute *attr,
259 					  char *buf)
260 {
261 	struct bonding *bond = to_bond(d);
262 	const struct bond_opt_value *val;
263 
264 	val = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC,
265 			       bond->params.fail_over_mac);
266 
267 	return sysfs_emit(buf, "%s %d\n", val->string, bond->params.fail_over_mac);
268 }
269 static DEVICE_ATTR(fail_over_mac, 0644,
270 		   bonding_show_fail_over_mac, bonding_sysfs_store_option);
271 
272 /* Show the arp timer interval. */
bonding_show_arp_interval(struct device * d,struct device_attribute * attr,char * buf)273 static ssize_t bonding_show_arp_interval(struct device *d,
274 					 struct device_attribute *attr,
275 					 char *buf)
276 {
277 	struct bonding *bond = to_bond(d);
278 
279 	return sysfs_emit(buf, "%d\n", bond->params.arp_interval);
280 }
281 static DEVICE_ATTR(arp_interval, 0644,
282 		   bonding_show_arp_interval, bonding_sysfs_store_option);
283 
284 /* Show the arp targets. */
bonding_show_arp_targets(struct device * d,struct device_attribute * attr,char * buf)285 static ssize_t bonding_show_arp_targets(struct device *d,
286 					struct device_attribute *attr,
287 					char *buf)
288 {
289 	struct bonding *bond = to_bond(d);
290 	int i, res = 0;
291 
292 	for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
293 		if (bond->params.arp_targets[i])
294 			res += sysfs_emit_at(buf, res, "%pI4 ",
295 					     &bond->params.arp_targets[i]);
296 	}
297 	if (res)
298 		buf[res-1] = '\n'; /* eat the leftover space */
299 
300 	return res;
301 }
302 static DEVICE_ATTR(arp_ip_target, 0644,
303 		   bonding_show_arp_targets, bonding_sysfs_store_option);
304 
305 /* Show the arp missed max. */
bonding_show_missed_max(struct device * d,struct device_attribute * attr,char * buf)306 static ssize_t bonding_show_missed_max(struct device *d,
307 				       struct device_attribute *attr,
308 				       char *buf)
309 {
310 	struct bonding *bond = to_bond(d);
311 
312 	return sysfs_emit(buf, "%u\n", bond->params.missed_max);
313 }
314 static DEVICE_ATTR(arp_missed_max, 0644,
315 		   bonding_show_missed_max, bonding_sysfs_store_option);
316 
317 /* Show the up and down delays. */
bonding_show_downdelay(struct device * d,struct device_attribute * attr,char * buf)318 static ssize_t bonding_show_downdelay(struct device *d,
319 				      struct device_attribute *attr,
320 				      char *buf)
321 {
322 	struct bonding *bond = to_bond(d);
323 
324 	return sysfs_emit(buf, "%d\n", bond->params.downdelay * bond->params.miimon);
325 }
326 static DEVICE_ATTR(downdelay, 0644,
327 		   bonding_show_downdelay, bonding_sysfs_store_option);
328 
bonding_show_updelay(struct device * d,struct device_attribute * attr,char * buf)329 static ssize_t bonding_show_updelay(struct device *d,
330 				    struct device_attribute *attr,
331 				    char *buf)
332 {
333 	struct bonding *bond = to_bond(d);
334 
335 	return sysfs_emit(buf, "%d\n", bond->params.updelay * bond->params.miimon);
336 
337 }
338 static DEVICE_ATTR(updelay, 0644,
339 		   bonding_show_updelay, bonding_sysfs_store_option);
340 
bonding_show_peer_notif_delay(struct device * d,struct device_attribute * attr,char * buf)341 static ssize_t bonding_show_peer_notif_delay(struct device *d,
342 					     struct device_attribute *attr,
343 					     char *buf)
344 {
345 	struct bonding *bond = to_bond(d);
346 
347 	return sysfs_emit(buf, "%d\n",
348 			  bond->params.peer_notif_delay * bond->params.miimon);
349 }
350 static DEVICE_ATTR(peer_notif_delay, 0644,
351 		   bonding_show_peer_notif_delay, bonding_sysfs_store_option);
352 
353 /* Show the LACP activity and interval. */
bonding_show_lacp_active(struct device * d,struct device_attribute * attr,char * buf)354 static ssize_t bonding_show_lacp_active(struct device *d,
355 					struct device_attribute *attr,
356 					char *buf)
357 {
358 	struct bonding *bond = to_bond(d);
359 	const struct bond_opt_value *val;
360 
361 	val = bond_opt_get_val(BOND_OPT_LACP_ACTIVE, bond->params.lacp_active);
362 
363 	return sysfs_emit(buf, "%s %d\n", val->string, bond->params.lacp_active);
364 }
365 static DEVICE_ATTR(lacp_active, 0644,
366 		   bonding_show_lacp_active, bonding_sysfs_store_option);
367 
bonding_show_lacp_rate(struct device * d,struct device_attribute * attr,char * buf)368 static ssize_t bonding_show_lacp_rate(struct device *d,
369 				      struct device_attribute *attr,
370 				      char *buf)
371 {
372 	struct bonding *bond = to_bond(d);
373 	const struct bond_opt_value *val;
374 
375 	val = bond_opt_get_val(BOND_OPT_LACP_RATE, bond->params.lacp_fast);
376 
377 	return sysfs_emit(buf, "%s %d\n", val->string, bond->params.lacp_fast);
378 }
379 static DEVICE_ATTR(lacp_rate, 0644,
380 		   bonding_show_lacp_rate, bonding_sysfs_store_option);
381 
bonding_show_min_links(struct device * d,struct device_attribute * attr,char * buf)382 static ssize_t bonding_show_min_links(struct device *d,
383 				      struct device_attribute *attr,
384 				      char *buf)
385 {
386 	struct bonding *bond = to_bond(d);
387 
388 	return sysfs_emit(buf, "%u\n", bond->params.min_links);
389 }
390 static DEVICE_ATTR(min_links, 0644,
391 		   bonding_show_min_links, bonding_sysfs_store_option);
392 
bonding_show_ad_select(struct device * d,struct device_attribute * attr,char * buf)393 static ssize_t bonding_show_ad_select(struct device *d,
394 				      struct device_attribute *attr,
395 				      char *buf)
396 {
397 	struct bonding *bond = to_bond(d);
398 	const struct bond_opt_value *val;
399 
400 	val = bond_opt_get_val(BOND_OPT_AD_SELECT, bond->params.ad_select);
401 
402 	return sysfs_emit(buf, "%s %d\n", val->string, bond->params.ad_select);
403 }
404 static DEVICE_ATTR(ad_select, 0644,
405 		   bonding_show_ad_select, bonding_sysfs_store_option);
406 
407 /* Show the number of peer notifications to send after a failover event. */
bonding_show_num_peer_notif(struct device * d,struct device_attribute * attr,char * buf)408 static ssize_t bonding_show_num_peer_notif(struct device *d,
409 					   struct device_attribute *attr,
410 					   char *buf)
411 {
412 	struct bonding *bond = to_bond(d);
413 
414 	return sysfs_emit(buf, "%d\n", bond->params.num_peer_notif);
415 }
416 static DEVICE_ATTR(num_grat_arp, 0644,
417 		   bonding_show_num_peer_notif, bonding_sysfs_store_option);
418 static DEVICE_ATTR(num_unsol_na, 0644,
419 		   bonding_show_num_peer_notif, bonding_sysfs_store_option);
420 
421 /* Show the MII monitor interval. */
bonding_show_miimon(struct device * d,struct device_attribute * attr,char * buf)422 static ssize_t bonding_show_miimon(struct device *d,
423 				   struct device_attribute *attr,
424 				   char *buf)
425 {
426 	struct bonding *bond = to_bond(d);
427 
428 	return sysfs_emit(buf, "%d\n", bond->params.miimon);
429 }
430 static DEVICE_ATTR(miimon, 0644,
431 		   bonding_show_miimon, bonding_sysfs_store_option);
432 
433 /* Show the primary slave. */
bonding_show_primary(struct device * d,struct device_attribute * attr,char * buf)434 static ssize_t bonding_show_primary(struct device *d,
435 				    struct device_attribute *attr,
436 				    char *buf)
437 {
438 	struct bonding *bond = to_bond(d);
439 	struct slave *primary;
440 	int count = 0;
441 
442 	rcu_read_lock();
443 	primary = rcu_dereference(bond->primary_slave);
444 	if (primary)
445 		count = sysfs_emit(buf, "%s\n", primary->dev->name);
446 	rcu_read_unlock();
447 
448 	return count;
449 }
450 static DEVICE_ATTR(primary, 0644,
451 		   bonding_show_primary, bonding_sysfs_store_option);
452 
453 /* Show the primary_reselect flag. */
bonding_show_primary_reselect(struct device * d,struct device_attribute * attr,char * buf)454 static ssize_t bonding_show_primary_reselect(struct device *d,
455 					     struct device_attribute *attr,
456 					     char *buf)
457 {
458 	struct bonding *bond = to_bond(d);
459 	const struct bond_opt_value *val;
460 
461 	val = bond_opt_get_val(BOND_OPT_PRIMARY_RESELECT,
462 			       bond->params.primary_reselect);
463 
464 	return sysfs_emit(buf, "%s %d\n",
465 			  val->string, bond->params.primary_reselect);
466 }
467 static DEVICE_ATTR(primary_reselect, 0644,
468 		   bonding_show_primary_reselect, bonding_sysfs_store_option);
469 
470 /* Show the use_carrier flag. */
bonding_show_carrier(struct device * d,struct device_attribute * attr,char * buf)471 static ssize_t bonding_show_carrier(struct device *d,
472 				    struct device_attribute *attr,
473 				    char *buf)
474 {
475 	struct bonding *bond = to_bond(d);
476 
477 	return sysfs_emit(buf, "%d\n", bond->params.use_carrier);
478 }
479 static DEVICE_ATTR(use_carrier, 0644,
480 		   bonding_show_carrier, bonding_sysfs_store_option);
481 
482 
483 /* Show currently active_slave. */
bonding_show_active_slave(struct device * d,struct device_attribute * attr,char * buf)484 static ssize_t bonding_show_active_slave(struct device *d,
485 					 struct device_attribute *attr,
486 					 char *buf)
487 {
488 	struct bonding *bond = to_bond(d);
489 	struct net_device *slave_dev;
490 	int count = 0;
491 
492 	rcu_read_lock();
493 	slave_dev = bond_option_active_slave_get_rcu(bond);
494 	if (slave_dev)
495 		count = sysfs_emit(buf, "%s\n", slave_dev->name);
496 	rcu_read_unlock();
497 
498 	return count;
499 }
500 static DEVICE_ATTR(active_slave, 0644,
501 		   bonding_show_active_slave, bonding_sysfs_store_option);
502 
503 /* Show link status of the bond interface. */
bonding_show_mii_status(struct device * d,struct device_attribute * attr,char * buf)504 static ssize_t bonding_show_mii_status(struct device *d,
505 				       struct device_attribute *attr,
506 				       char *buf)
507 {
508 	struct bonding *bond = to_bond(d);
509 	bool active = netif_carrier_ok(bond->dev);
510 
511 	return sysfs_emit(buf, "%s\n", active ? "up" : "down");
512 }
513 static DEVICE_ATTR(mii_status, 0444, bonding_show_mii_status, NULL);
514 
515 /* Show current 802.3ad aggregator ID. */
bonding_show_ad_aggregator(struct device * d,struct device_attribute * attr,char * buf)516 static ssize_t bonding_show_ad_aggregator(struct device *d,
517 					  struct device_attribute *attr,
518 					  char *buf)
519 {
520 	int count = 0;
521 	struct bonding *bond = to_bond(d);
522 
523 	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
524 		struct ad_info ad_info;
525 
526 		count = sysfs_emit(buf, "%d\n",
527 				   bond_3ad_get_active_agg_info(bond, &ad_info)
528 				   ?  0 : ad_info.aggregator_id);
529 	}
530 
531 	return count;
532 }
533 static DEVICE_ATTR(ad_aggregator, 0444, bonding_show_ad_aggregator, NULL);
534 
535 
536 /* Show number of active 802.3ad ports. */
bonding_show_ad_num_ports(struct device * d,struct device_attribute * attr,char * buf)537 static ssize_t bonding_show_ad_num_ports(struct device *d,
538 					 struct device_attribute *attr,
539 					 char *buf)
540 {
541 	int count = 0;
542 	struct bonding *bond = to_bond(d);
543 
544 	if (BOND_MODE(bond) == BOND_MODE_8023AD) {
545 		struct ad_info ad_info;
546 
547 		count = sysfs_emit(buf, "%d\n",
548 				   bond_3ad_get_active_agg_info(bond, &ad_info)
549 				   ?  0 : ad_info.ports);
550 	}
551 
552 	return count;
553 }
554 static DEVICE_ATTR(ad_num_ports, 0444, bonding_show_ad_num_ports, NULL);
555 
556 
557 /* Show current 802.3ad actor key. */
bonding_show_ad_actor_key(struct device * d,struct device_attribute * attr,char * buf)558 static ssize_t bonding_show_ad_actor_key(struct device *d,
559 					 struct device_attribute *attr,
560 					 char *buf)
561 {
562 	int count = 0;
563 	struct bonding *bond = to_bond(d);
564 
565 	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) {
566 		struct ad_info ad_info;
567 
568 		count = sysfs_emit(buf, "%d\n",
569 				   bond_3ad_get_active_agg_info(bond, &ad_info)
570 				   ?  0 : ad_info.actor_key);
571 	}
572 
573 	return count;
574 }
575 static DEVICE_ATTR(ad_actor_key, 0444, bonding_show_ad_actor_key, NULL);
576 
577 
578 /* Show current 802.3ad partner key. */
bonding_show_ad_partner_key(struct device * d,struct device_attribute * attr,char * buf)579 static ssize_t bonding_show_ad_partner_key(struct device *d,
580 					   struct device_attribute *attr,
581 					   char *buf)
582 {
583 	int count = 0;
584 	struct bonding *bond = to_bond(d);
585 
586 	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) {
587 		struct ad_info ad_info;
588 
589 		count = sysfs_emit(buf, "%d\n",
590 				   bond_3ad_get_active_agg_info(bond, &ad_info)
591 				   ?  0 : ad_info.partner_key);
592 	}
593 
594 	return count;
595 }
596 static DEVICE_ATTR(ad_partner_key, 0444, bonding_show_ad_partner_key, NULL);
597 
598 
599 /* Show current 802.3ad partner mac. */
bonding_show_ad_partner_mac(struct device * d,struct device_attribute * attr,char * buf)600 static ssize_t bonding_show_ad_partner_mac(struct device *d,
601 					   struct device_attribute *attr,
602 					   char *buf)
603 {
604 	int count = 0;
605 	struct bonding *bond = to_bond(d);
606 
607 	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN)) {
608 		struct ad_info ad_info;
609 
610 		if (!bond_3ad_get_active_agg_info(bond, &ad_info))
611 			count = sysfs_emit(buf, "%pM\n", ad_info.partner_system);
612 	}
613 
614 	return count;
615 }
616 static DEVICE_ATTR(ad_partner_mac, 0444, bonding_show_ad_partner_mac, NULL);
617 
618 /* Show the queue_ids of the slaves in the current bond. */
bonding_show_queue_id(struct device * d,struct device_attribute * attr,char * buf)619 static ssize_t bonding_show_queue_id(struct device *d,
620 				     struct device_attribute *attr,
621 				     char *buf)
622 {
623 	struct bonding *bond = to_bond(d);
624 	struct list_head *iter;
625 	struct slave *slave;
626 	int res = 0;
627 
628 	rcu_read_lock();
629 
630 	bond_for_each_slave_rcu(bond, slave, iter) {
631 		if (res > (PAGE_SIZE - IFNAMSIZ - 6)) {
632 			/* not enough space for another interface_name:queue_id pair */
633 			if ((PAGE_SIZE - res) > 10)
634 				res = PAGE_SIZE - 10;
635 			res += sysfs_emit_at(buf, res, "++more++ ");
636 			break;
637 		}
638 		res += sysfs_emit_at(buf, res, "%s:%d ",
639 				     slave->dev->name,
640 				     READ_ONCE(slave->queue_id));
641 	}
642 	if (res)
643 		buf[res-1] = '\n'; /* eat the leftover space */
644 
645 	rcu_read_unlock();
646 
647 	return res;
648 }
649 static DEVICE_ATTR(queue_id, 0644, bonding_show_queue_id,
650 		   bonding_sysfs_store_option);
651 
652 
653 /* Show the all_slaves_active flag. */
bonding_show_slaves_active(struct device * d,struct device_attribute * attr,char * buf)654 static ssize_t bonding_show_slaves_active(struct device *d,
655 					  struct device_attribute *attr,
656 					  char *buf)
657 {
658 	struct bonding *bond = to_bond(d);
659 
660 	return sysfs_emit(buf, "%d\n", bond->params.all_slaves_active);
661 }
662 static DEVICE_ATTR(all_slaves_active, 0644,
663 		   bonding_show_slaves_active, bonding_sysfs_store_option);
664 
665 /* Show the number of IGMP membership reports to send on link failure */
bonding_show_resend_igmp(struct device * d,struct device_attribute * attr,char * buf)666 static ssize_t bonding_show_resend_igmp(struct device *d,
667 					struct device_attribute *attr,
668 					char *buf)
669 {
670 	struct bonding *bond = to_bond(d);
671 
672 	return sysfs_emit(buf, "%d\n", bond->params.resend_igmp);
673 }
674 static DEVICE_ATTR(resend_igmp, 0644,
675 		   bonding_show_resend_igmp, bonding_sysfs_store_option);
676 
677 
bonding_show_lp_interval(struct device * d,struct device_attribute * attr,char * buf)678 static ssize_t bonding_show_lp_interval(struct device *d,
679 					struct device_attribute *attr,
680 					char *buf)
681 {
682 	struct bonding *bond = to_bond(d);
683 
684 	return sysfs_emit(buf, "%d\n", bond->params.lp_interval);
685 }
686 static DEVICE_ATTR(lp_interval, 0644,
687 		   bonding_show_lp_interval, bonding_sysfs_store_option);
688 
bonding_show_tlb_dynamic_lb(struct device * d,struct device_attribute * attr,char * buf)689 static ssize_t bonding_show_tlb_dynamic_lb(struct device *d,
690 					   struct device_attribute *attr,
691 					   char *buf)
692 {
693 	struct bonding *bond = to_bond(d);
694 
695 	return sysfs_emit(buf, "%d\n", bond->params.tlb_dynamic_lb);
696 }
697 static DEVICE_ATTR(tlb_dynamic_lb, 0644,
698 		   bonding_show_tlb_dynamic_lb, bonding_sysfs_store_option);
699 
bonding_show_packets_per_slave(struct device * d,struct device_attribute * attr,char * buf)700 static ssize_t bonding_show_packets_per_slave(struct device *d,
701 					      struct device_attribute *attr,
702 					      char *buf)
703 {
704 	struct bonding *bond = to_bond(d);
705 	unsigned int packets_per_slave = bond->params.packets_per_slave;
706 
707 	return sysfs_emit(buf, "%u\n", packets_per_slave);
708 }
709 static DEVICE_ATTR(packets_per_slave, 0644,
710 		   bonding_show_packets_per_slave, bonding_sysfs_store_option);
711 
bonding_show_ad_actor_sys_prio(struct device * d,struct device_attribute * attr,char * buf)712 static ssize_t bonding_show_ad_actor_sys_prio(struct device *d,
713 					      struct device_attribute *attr,
714 					      char *buf)
715 {
716 	struct bonding *bond = to_bond(d);
717 
718 	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN))
719 		return sysfs_emit(buf, "%hu\n", bond->params.ad_actor_sys_prio);
720 
721 	return 0;
722 }
723 static DEVICE_ATTR(ad_actor_sys_prio, 0644,
724 		   bonding_show_ad_actor_sys_prio, bonding_sysfs_store_option);
725 
bonding_show_ad_actor_system(struct device * d,struct device_attribute * attr,char * buf)726 static ssize_t bonding_show_ad_actor_system(struct device *d,
727 					    struct device_attribute *attr,
728 					    char *buf)
729 {
730 	struct bonding *bond = to_bond(d);
731 
732 	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN))
733 		return sysfs_emit(buf, "%pM\n", bond->params.ad_actor_system);
734 
735 	return 0;
736 }
737 
738 static DEVICE_ATTR(ad_actor_system, 0644,
739 		   bonding_show_ad_actor_system, bonding_sysfs_store_option);
740 
bonding_show_ad_user_port_key(struct device * d,struct device_attribute * attr,char * buf)741 static ssize_t bonding_show_ad_user_port_key(struct device *d,
742 					     struct device_attribute *attr,
743 					     char *buf)
744 {
745 	struct bonding *bond = to_bond(d);
746 
747 	if (BOND_MODE(bond) == BOND_MODE_8023AD && capable(CAP_NET_ADMIN))
748 		return sysfs_emit(buf, "%hu\n", bond->params.ad_user_port_key);
749 
750 	return 0;
751 }
752 static DEVICE_ATTR(ad_user_port_key, 0644,
753 		   bonding_show_ad_user_port_key, bonding_sysfs_store_option);
754 
755 static struct attribute *per_bond_attrs[] = {
756 	&dev_attr_slaves.attr,
757 	&dev_attr_mode.attr,
758 	&dev_attr_fail_over_mac.attr,
759 	&dev_attr_arp_validate.attr,
760 	&dev_attr_arp_all_targets.attr,
761 	&dev_attr_arp_interval.attr,
762 	&dev_attr_arp_ip_target.attr,
763 	&dev_attr_downdelay.attr,
764 	&dev_attr_updelay.attr,
765 	&dev_attr_peer_notif_delay.attr,
766 	&dev_attr_lacp_active.attr,
767 	&dev_attr_lacp_rate.attr,
768 	&dev_attr_ad_select.attr,
769 	&dev_attr_xmit_hash_policy.attr,
770 	&dev_attr_num_grat_arp.attr,
771 	&dev_attr_num_unsol_na.attr,
772 	&dev_attr_miimon.attr,
773 	&dev_attr_primary.attr,
774 	&dev_attr_primary_reselect.attr,
775 	&dev_attr_use_carrier.attr,
776 	&dev_attr_active_slave.attr,
777 	&dev_attr_mii_status.attr,
778 	&dev_attr_ad_aggregator.attr,
779 	&dev_attr_ad_num_ports.attr,
780 	&dev_attr_ad_actor_key.attr,
781 	&dev_attr_ad_partner_key.attr,
782 	&dev_attr_ad_partner_mac.attr,
783 	&dev_attr_queue_id.attr,
784 	&dev_attr_all_slaves_active.attr,
785 	&dev_attr_resend_igmp.attr,
786 	&dev_attr_min_links.attr,
787 	&dev_attr_lp_interval.attr,
788 	&dev_attr_packets_per_slave.attr,
789 	&dev_attr_tlb_dynamic_lb.attr,
790 	&dev_attr_ad_actor_sys_prio.attr,
791 	&dev_attr_ad_actor_system.attr,
792 	&dev_attr_ad_user_port_key.attr,
793 	&dev_attr_arp_missed_max.attr,
794 	NULL,
795 };
796 
797 static const struct attribute_group bonding_group = {
798 	.name = "bonding",
799 	.attrs = per_bond_attrs,
800 };
801 
802 /* Initialize sysfs.  This sets up the bonding_masters file in
803  * /sys/class/net.
804  */
bond_create_sysfs(struct bond_net * bn)805 int __net_init bond_create_sysfs(struct bond_net *bn)
806 {
807 	int ret;
808 
809 	bn->class_attr_bonding_masters = class_attr_bonding_masters;
810 	sysfs_attr_init(&bn->class_attr_bonding_masters.attr);
811 
812 	ret = netdev_class_create_file_ns(&bn->class_attr_bonding_masters,
813 					  bn->net);
814 	/* Permit multiple loads of the module by ignoring failures to
815 	 * create the bonding_masters sysfs file.  Bonding devices
816 	 * created by second or subsequent loads of the module will
817 	 * not be listed in, or controllable by, bonding_masters, but
818 	 * will have the usual "bonding" sysfs directory.
819 	 *
820 	 * This is done to preserve backwards compatibility for
821 	 * initscripts/sysconfig, which load bonding multiple times to
822 	 * configure multiple bonding devices.
823 	 */
824 	if (ret == -EEXIST) {
825 		/* Is someone being kinky and naming a device bonding_master? */
826 		if (netdev_name_in_use(bn->net,
827 				       class_attr_bonding_masters.attr.name))
828 			pr_err("network device named %s already exists in sysfs\n",
829 			       class_attr_bonding_masters.attr.name);
830 		ret = 0;
831 	}
832 
833 	return ret;
834 
835 }
836 
837 /* Remove /sys/class/net/bonding_masters. */
bond_destroy_sysfs(struct bond_net * bn)838 void __net_exit bond_destroy_sysfs(struct bond_net *bn)
839 {
840 	netdev_class_remove_file_ns(&bn->class_attr_bonding_masters, bn->net);
841 }
842 
843 /* Initialize sysfs for each bond.  This sets up and registers
844  * the 'bondctl' directory for each individual bond under /sys/class/net.
845  */
bond_prepare_sysfs_group(struct bonding * bond)846 void bond_prepare_sysfs_group(struct bonding *bond)
847 {
848 	bond->dev->sysfs_groups[0] = &bonding_group;
849 }
850 
851