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