Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 1 | #include <linux/proc_fs.h> |
Paul Gortmaker | ee40fa0 | 2011-05-27 16:14:23 -0400 | [diff] [blame] | 2 | #include <linux/export.h> |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 3 | #include <net/net_namespace.h> |
| 4 | #include <net/netns/generic.h> |
David S. Miller | 1ef8019 | 2014-11-10 13:27:49 -0500 | [diff] [blame] | 5 | #include <net/bonding.h> |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 6 | |
Matan Barak | 73b5a6f2 | 2015-04-26 15:55:57 +0300 | [diff] [blame] | 7 | #include "bonding_priv.h" |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 8 | |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 9 | static void *bond_info_seq_start(struct seq_file *seq, loff_t *pos) |
| 10 | __acquires(RCU) |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 11 | { |
| 12 | struct bonding *bond = seq->private; |
Veaceslav Falico | 9caff1e | 2013-09-25 09:20:14 +0200 | [diff] [blame] | 13 | struct list_head *iter; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 14 | struct slave *slave; |
Veaceslav Falico | 9caff1e | 2013-09-25 09:20:14 +0200 | [diff] [blame] | 15 | loff_t off = 0; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 16 | |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 17 | rcu_read_lock(); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 18 | |
| 19 | if (*pos == 0) |
| 20 | return SEQ_START_TOKEN; |
| 21 | |
Nikolay Aleksandrov | e9fe8ef | 2014-09-09 23:17:01 +0200 | [diff] [blame] | 22 | bond_for_each_slave_rcu(bond, slave, iter) |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 23 | if (++off == *pos) |
| 24 | return slave; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 25 | |
| 26 | return NULL; |
| 27 | } |
| 28 | |
| 29 | static void *bond_info_seq_next(struct seq_file *seq, void *v, loff_t *pos) |
| 30 | { |
| 31 | struct bonding *bond = seq->private; |
Veaceslav Falico | f965084 | 2013-09-27 16:12:04 +0200 | [diff] [blame] | 32 | struct list_head *iter; |
| 33 | struct slave *slave; |
| 34 | bool found = false; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 35 | |
| 36 | ++*pos; |
| 37 | if (v == SEQ_START_TOKEN) |
Nikolay Aleksandrov | e9fe8ef | 2014-09-09 23:17:01 +0200 | [diff] [blame] | 38 | return bond_first_slave_rcu(bond); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 39 | |
Nikolay Aleksandrov | e9fe8ef | 2014-09-09 23:17:01 +0200 | [diff] [blame] | 40 | bond_for_each_slave_rcu(bond, slave, iter) { |
Veaceslav Falico | f965084 | 2013-09-27 16:12:04 +0200 | [diff] [blame] | 41 | if (found) |
| 42 | return slave; |
| 43 | if (slave == v) |
| 44 | found = true; |
| 45 | } |
| 46 | |
| 47 | return NULL; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 48 | } |
| 49 | |
| 50 | static void bond_info_seq_stop(struct seq_file *seq, void *v) |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 51 | __releases(RCU) |
| 52 | { |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 53 | rcu_read_unlock(); |
| 54 | } |
| 55 | |
| 56 | static void bond_info_show_master(struct seq_file *seq) |
| 57 | { |
| 58 | struct bonding *bond = seq->private; |
stephen hemminger | 28f084c | 2014-03-06 14:20:17 -0800 | [diff] [blame] | 59 | const struct bond_opt_value *optval; |
Nikolay Aleksandrov | 059b47e | 2014-09-09 23:17:00 +0200 | [diff] [blame] | 60 | struct slave *curr, *primary; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 61 | int i; |
| 62 | |
dingtianhong | 4335d60 | 2014-02-21 16:08:53 +0800 | [diff] [blame] | 63 | curr = rcu_dereference(bond->curr_active_slave); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 64 | |
| 65 | seq_printf(seq, "Bonding Mode: %s", |
Veaceslav Falico | 0184409 | 2014-05-15 21:39:55 +0200 | [diff] [blame] | 66 | bond_mode_name(BOND_MODE(bond))); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 67 | |
Veaceslav Falico | 0184409 | 2014-05-15 21:39:55 +0200 | [diff] [blame] | 68 | if (BOND_MODE(bond) == BOND_MODE_ACTIVEBACKUP && |
Nikolay Aleksandrov | 1df6b6a | 2014-01-22 14:53:22 +0100 | [diff] [blame] | 69 | bond->params.fail_over_mac) { |
| 70 | optval = bond_opt_get_val(BOND_OPT_FAIL_OVER_MAC, |
| 71 | bond->params.fail_over_mac); |
| 72 | seq_printf(seq, " (fail_over_mac %s)", optval->string); |
| 73 | } |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 74 | |
| 75 | seq_printf(seq, "\n"); |
| 76 | |
Mahesh Bandewar | d702132 | 2014-10-04 17:44:44 -0700 | [diff] [blame] | 77 | if (bond_mode_uses_xmit_hash(bond)) { |
Nikolay Aleksandrov | a4b32ce | 2014-01-22 14:53:19 +0100 | [diff] [blame] | 78 | optval = bond_opt_get_val(BOND_OPT_XMIT_HASH, |
| 79 | bond->params.xmit_policy); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 80 | seq_printf(seq, "Transmit Hash Policy: %s (%d)\n", |
Nikolay Aleksandrov | a4b32ce | 2014-01-22 14:53:19 +0100 | [diff] [blame] | 81 | optval->string, bond->params.xmit_policy); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 82 | } |
| 83 | |
Veaceslav Falico | ec0865a | 2014-05-15 21:39:54 +0200 | [diff] [blame] | 84 | if (bond_uses_primary(bond)) { |
Nikolay Aleksandrov | 059b47e | 2014-09-09 23:17:00 +0200 | [diff] [blame] | 85 | primary = rcu_dereference(bond->primary_slave); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 86 | seq_printf(seq, "Primary Slave: %s", |
Nikolay Aleksandrov | 059b47e | 2014-09-09 23:17:00 +0200 | [diff] [blame] | 87 | primary ? primary->dev->name : "None"); |
| 88 | if (primary) { |
Nikolay Aleksandrov | 388d3a6 | 2014-01-22 14:53:33 +0100 | [diff] [blame] | 89 | optval = bond_opt_get_val(BOND_OPT_PRIMARY_RESELECT, |
| 90 | bond->params.primary_reselect); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 91 | seq_printf(seq, " (primary_reselect %s)", |
Nikolay Aleksandrov | 388d3a6 | 2014-01-22 14:53:33 +0100 | [diff] [blame] | 92 | optval->string); |
| 93 | } |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 94 | |
| 95 | seq_printf(seq, "\nCurrently Active Slave: %s\n", |
| 96 | (curr) ? curr->dev->name : "None"); |
| 97 | } |
| 98 | |
| 99 | seq_printf(seq, "MII Status: %s\n", netif_carrier_ok(bond->dev) ? |
| 100 | "up" : "down"); |
| 101 | seq_printf(seq, "MII Polling Interval (ms): %d\n", bond->params.miimon); |
| 102 | seq_printf(seq, "Up Delay (ms): %d\n", |
| 103 | bond->params.updelay * bond->params.miimon); |
| 104 | seq_printf(seq, "Down Delay (ms): %d\n", |
| 105 | bond->params.downdelay * bond->params.miimon); |
| 106 | |
| 107 | |
| 108 | /* ARP information */ |
| 109 | if (bond->params.arp_interval > 0) { |
| 110 | int printed = 0; |
| 111 | seq_printf(seq, "ARP Polling Interval (ms): %d\n", |
| 112 | bond->params.arp_interval); |
| 113 | |
| 114 | seq_printf(seq, "ARP IP target/s (n.n.n.n form):"); |
| 115 | |
| 116 | for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) { |
| 117 | if (!bond->params.arp_targets[i]) |
| 118 | break; |
| 119 | if (printed) |
| 120 | seq_printf(seq, ","); |
| 121 | seq_printf(seq, " %pI4", &bond->params.arp_targets[i]); |
| 122 | printed = 1; |
| 123 | } |
| 124 | seq_printf(seq, "\n"); |
| 125 | } |
| 126 | |
Veaceslav Falico | 0184409 | 2014-05-15 21:39:55 +0200 | [diff] [blame] | 127 | if (BOND_MODE(bond) == BOND_MODE_8023AD) { |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 128 | struct ad_info ad_info; |
| 129 | |
| 130 | seq_puts(seq, "\n802.3ad info\n"); |
| 131 | seq_printf(seq, "LACP rate: %s\n", |
| 132 | (bond->params.lacp_fast) ? "fast" : "slow"); |
stephen hemminger | 655f891 | 2011-06-22 09:54:39 +0000 | [diff] [blame] | 133 | seq_printf(seq, "Min links: %d\n", bond->params.min_links); |
Nikolay Aleksandrov | 9e5f5ee | 2014-01-22 14:53:29 +0100 | [diff] [blame] | 134 | optval = bond_opt_get_val(BOND_OPT_AD_SELECT, |
| 135 | bond->params.ad_select); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 136 | seq_printf(seq, "Aggregator selection policy (ad_select): %s\n", |
Nikolay Aleksandrov | 9e5f5ee | 2014-01-22 14:53:29 +0100 | [diff] [blame] | 137 | optval->string); |
Mahesh Bandewar | 4cd6b47 | 2015-06-18 11:30:54 -0700 | [diff] [blame] | 138 | if (capable(CAP_NET_ADMIN)) { |
| 139 | seq_printf(seq, "System priority: %d\n", |
| 140 | BOND_AD_INFO(bond).system.sys_priority); |
| 141 | seq_printf(seq, "System MAC address: %pM\n", |
| 142 | &BOND_AD_INFO(bond).system.sys_mac_addr); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 143 | |
Mahesh Bandewar | 4cd6b47 | 2015-06-18 11:30:54 -0700 | [diff] [blame] | 144 | if (__bond_3ad_get_active_agg_info(bond, &ad_info)) { |
| 145 | seq_printf(seq, |
| 146 | "bond %s has no active aggregator\n", |
| 147 | bond->dev->name); |
| 148 | } else { |
| 149 | seq_printf(seq, "Active Aggregator Info:\n"); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 150 | |
Mahesh Bandewar | 4cd6b47 | 2015-06-18 11:30:54 -0700 | [diff] [blame] | 151 | seq_printf(seq, "\tAggregator ID: %d\n", |
| 152 | ad_info.aggregator_id); |
| 153 | seq_printf(seq, "\tNumber of ports: %d\n", |
| 154 | ad_info.ports); |
| 155 | seq_printf(seq, "\tActor Key: %d\n", |
| 156 | ad_info.actor_key); |
| 157 | seq_printf(seq, "\tPartner Key: %d\n", |
| 158 | ad_info.partner_key); |
| 159 | seq_printf(seq, "\tPartner Mac Address: %pM\n", |
| 160 | ad_info.partner_system); |
| 161 | } |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 162 | } |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | static void bond_info_show_slave(struct seq_file *seq, |
| 167 | const struct slave *slave) |
| 168 | { |
| 169 | struct bonding *bond = seq->private; |
| 170 | |
| 171 | seq_printf(seq, "\nSlave Interface: %s\n", slave->dev->name); |
Amerigo Wang | df2bcc4 | 2012-06-14 22:39:27 +0000 | [diff] [blame] | 172 | seq_printf(seq, "MII Status: %s\n", bond_slave_link_status(slave->link)); |
Dan Carpenter | 589665f | 2011-11-04 08:21:38 +0000 | [diff] [blame] | 173 | if (slave->speed == SPEED_UNKNOWN) |
Weiping Pan | 98f41f6 | 2011-10-31 17:20:48 +0000 | [diff] [blame] | 174 | seq_printf(seq, "Speed: %s\n", "Unknown"); |
| 175 | else |
| 176 | seq_printf(seq, "Speed: %d Mbps\n", slave->speed); |
| 177 | |
Dan Carpenter | 589665f | 2011-11-04 08:21:38 +0000 | [diff] [blame] | 178 | if (slave->duplex == DUPLEX_UNKNOWN) |
Weiping Pan | 98f41f6 | 2011-10-31 17:20:48 +0000 | [diff] [blame] | 179 | seq_printf(seq, "Duplex: %s\n", "Unknown"); |
| 180 | else |
| 181 | seq_printf(seq, "Duplex: %s\n", slave->duplex ? "full" : "half"); |
| 182 | |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 183 | seq_printf(seq, "Link Failure Count: %u\n", |
| 184 | slave->link_failure_count); |
| 185 | |
| 186 | seq_printf(seq, "Permanent HW addr: %pM\n", slave->perm_hwaddr); |
Mahesh Bandewar | 14c9551 | 2015-02-23 17:50:11 -0800 | [diff] [blame] | 187 | seq_printf(seq, "Slave queue ID: %d\n", slave->queue_id); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 188 | |
Veaceslav Falico | 0184409 | 2014-05-15 21:39:55 +0200 | [diff] [blame] | 189 | if (BOND_MODE(bond) == BOND_MODE_8023AD) { |
Mahesh Bandewar | 14c9551 | 2015-02-23 17:50:11 -0800 | [diff] [blame] | 190 | const struct port *port = &SLAVE_AD_INFO(slave)->port; |
| 191 | const struct aggregator *agg = port->aggregator; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 192 | |
Mahesh Bandewar | 14c9551 | 2015-02-23 17:50:11 -0800 | [diff] [blame] | 193 | if (agg) { |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 194 | seq_printf(seq, "Aggregator ID: %d\n", |
| 195 | agg->aggregator_identifier); |
Mahesh Bandewar | 14c9551 | 2015-02-23 17:50:11 -0800 | [diff] [blame] | 196 | seq_printf(seq, "Actor Churn State: %s\n", |
| 197 | bond_3ad_churn_desc(port->sm_churn_actor_state)); |
| 198 | seq_printf(seq, "Partner Churn State: %s\n", |
| 199 | bond_3ad_churn_desc(port->sm_churn_partner_state)); |
| 200 | seq_printf(seq, "Actor Churned Count: %d\n", |
| 201 | port->churn_actor_count); |
| 202 | seq_printf(seq, "Partner Churned Count: %d\n", |
| 203 | port->churn_partner_count); |
| 204 | |
Mahesh Bandewar | 4cd6b47 | 2015-06-18 11:30:54 -0700 | [diff] [blame] | 205 | if (capable(CAP_NET_ADMIN)) { |
| 206 | seq_puts(seq, "details actor lacp pdu:\n"); |
| 207 | seq_printf(seq, " system priority: %d\n", |
| 208 | port->actor_system_priority); |
| 209 | seq_printf(seq, " system mac address: %pM\n", |
| 210 | &port->actor_system); |
| 211 | seq_printf(seq, " port key: %d\n", |
| 212 | port->actor_oper_port_key); |
| 213 | seq_printf(seq, " port priority: %d\n", |
| 214 | port->actor_port_priority); |
| 215 | seq_printf(seq, " port number: %d\n", |
| 216 | port->actor_port_number); |
| 217 | seq_printf(seq, " port state: %d\n", |
| 218 | port->actor_oper_port_state); |
Mahesh Bandewar | 14c9551 | 2015-02-23 17:50:11 -0800 | [diff] [blame] | 219 | |
Mahesh Bandewar | 4cd6b47 | 2015-06-18 11:30:54 -0700 | [diff] [blame] | 220 | seq_puts(seq, "details partner lacp pdu:\n"); |
| 221 | seq_printf(seq, " system priority: %d\n", |
| 222 | port->partner_oper.system_priority); |
| 223 | seq_printf(seq, " system mac address: %pM\n", |
| 224 | &port->partner_oper.system); |
| 225 | seq_printf(seq, " oper key: %d\n", |
| 226 | port->partner_oper.key); |
| 227 | seq_printf(seq, " port priority: %d\n", |
| 228 | port->partner_oper.port_priority); |
| 229 | seq_printf(seq, " port number: %d\n", |
| 230 | port->partner_oper.port_number); |
| 231 | seq_printf(seq, " port state: %d\n", |
| 232 | port->partner_oper.port_state); |
| 233 | } |
Mahesh Bandewar | 14c9551 | 2015-02-23 17:50:11 -0800 | [diff] [blame] | 234 | } else { |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 235 | seq_puts(seq, "Aggregator ID: N/A\n"); |
Mahesh Bandewar | 14c9551 | 2015-02-23 17:50:11 -0800 | [diff] [blame] | 236 | } |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 237 | } |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | static int bond_info_seq_show(struct seq_file *seq, void *v) |
| 241 | { |
| 242 | if (v == SEQ_START_TOKEN) { |
| 243 | seq_printf(seq, "%s\n", bond_version); |
| 244 | bond_info_show_master(seq); |
| 245 | } else |
| 246 | bond_info_show_slave(seq, v); |
| 247 | |
| 248 | return 0; |
| 249 | } |
| 250 | |
| 251 | static const struct seq_operations bond_info_seq_ops = { |
| 252 | .start = bond_info_seq_start, |
| 253 | .next = bond_info_seq_next, |
| 254 | .stop = bond_info_seq_stop, |
| 255 | .show = bond_info_seq_show, |
| 256 | }; |
| 257 | |
| 258 | static int bond_info_open(struct inode *inode, struct file *file) |
| 259 | { |
| 260 | struct seq_file *seq; |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 261 | int res; |
| 262 | |
| 263 | res = seq_open(file, &bond_info_seq_ops); |
| 264 | if (!res) { |
| 265 | /* recover the pointer buried in proc_dir_entry data */ |
| 266 | seq = file->private_data; |
Al Viro | d9dda78 | 2013-03-31 18:16:14 -0400 | [diff] [blame] | 267 | seq->private = PDE_DATA(inode); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 268 | } |
| 269 | |
| 270 | return res; |
| 271 | } |
| 272 | |
| 273 | static const struct file_operations bond_info_fops = { |
| 274 | .owner = THIS_MODULE, |
| 275 | .open = bond_info_open, |
| 276 | .read = seq_read, |
| 277 | .llseek = seq_lseek, |
| 278 | .release = seq_release, |
| 279 | }; |
| 280 | |
| 281 | void bond_create_proc_entry(struct bonding *bond) |
| 282 | { |
| 283 | struct net_device *bond_dev = bond->dev; |
| 284 | struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id); |
| 285 | |
| 286 | if (bn->proc_dir) { |
| 287 | bond->proc_entry = proc_create_data(bond_dev->name, |
| 288 | S_IRUGO, bn->proc_dir, |
| 289 | &bond_info_fops, bond); |
| 290 | if (bond->proc_entry == NULL) |
Veaceslav Falico | c735ee6 | 2014-07-15 19:36:07 +0200 | [diff] [blame] | 291 | netdev_warn(bond_dev, "Cannot create /proc/net/%s/%s\n", |
| 292 | DRV_NAME, bond_dev->name); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 293 | else |
| 294 | memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ); |
| 295 | } |
| 296 | } |
| 297 | |
| 298 | void bond_remove_proc_entry(struct bonding *bond) |
| 299 | { |
| 300 | struct net_device *bond_dev = bond->dev; |
| 301 | struct bond_net *bn = net_generic(dev_net(bond_dev), bond_net_id); |
| 302 | |
| 303 | if (bn->proc_dir && bond->proc_entry) { |
| 304 | remove_proc_entry(bond->proc_file_name, bn->proc_dir); |
| 305 | memset(bond->proc_file_name, 0, IFNAMSIZ); |
| 306 | bond->proc_entry = NULL; |
| 307 | } |
| 308 | } |
| 309 | |
| 310 | /* Create the bonding directory under /proc/net, if doesn't exist yet. |
| 311 | * Caller must hold rtnl_lock. |
| 312 | */ |
| 313 | void __net_init bond_create_proc_dir(struct bond_net *bn) |
| 314 | { |
| 315 | if (!bn->proc_dir) { |
| 316 | bn->proc_dir = proc_mkdir(DRV_NAME, bn->net->proc_net); |
| 317 | if (!bn->proc_dir) |
Joe Perches | 9019426 | 2014-02-15 16:01:45 -0800 | [diff] [blame] | 318 | pr_warn("Warning: Cannot create /proc/net/%s\n", |
Joe Perches | 91565eb | 2014-02-15 15:57:04 -0800 | [diff] [blame] | 319 | DRV_NAME); |
Amerigo Wang | bd33acc | 2011-03-06 21:58:46 +0000 | [diff] [blame] | 320 | } |
| 321 | } |
| 322 | |
| 323 | /* Destroy the bonding directory under /proc/net, if empty. |
| 324 | * Caller must hold rtnl_lock. |
| 325 | */ |
| 326 | void __net_exit bond_destroy_proc_dir(struct bond_net *bn) |
| 327 | { |
| 328 | if (bn->proc_dir) { |
| 329 | remove_proc_entry(DRV_NAME, bn->net->proc_net); |
| 330 | bn->proc_dir = NULL; |
| 331 | } |
| 332 | } |