OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [net/] [bonding/] [bond_sysfs.c] - Blame information for rev 79

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl 
 
2 
/*
3 
 * Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
4 
 *
5 
 * This program is free software; you can redistribute it and/or modify it
6 
 * under the terms of the GNU General Public License as published by the
7 
 * Free Software Foundation; either version 2 of the License, or
8 
 * (at your option) any later version.
9 
 *
10 
 * This program is distributed in the hope that it will be useful, but
11 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12 
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13 
 * for more details.
14 
 *
15 
 * You should have received a copy of the GNU General Public License along
16 
 * with this program; if not, write to the Free Software Foundation, Inc.,
17 
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18 
 *
19 
 * The full GNU General Public License is included in this distribution in the
20 
 * file called LICENSE.
21 
 *
22 
 */
23 
#include <linux/kernel.h>
24 
#include <linux/module.h>
25 
#include <linux/device.h>
26 
#include <linux/sysdev.h>
27 
#include <linux/fs.h>
28 
#include <linux/types.h>
29 
#include <linux/string.h>
30 
#include <linux/netdevice.h>
31 
#include <linux/inetdevice.h>
32 
#include <linux/in.h>
33 
#include <linux/sysfs.h>
34 
#include <linux/ctype.h>
35 
#include <linux/inet.h>
36 
#include <linux/rtnetlink.h>
37 
#include <net/net_namespace.h>
38 
 
39 
/* #define BONDING_DEBUG 1 */
40 
#include "bonding.h"
41 
#define to_dev(obj)     container_of(obj,struct device,kobj)
42 
#define to_bond(cd)     ((struct bonding *)(to_net_dev(cd)->priv))
43 
 
44 
/*---------------------------- Declarations -------------------------------*/
45 
 
46 
 
47 
extern struct list_head bond_dev_list;
48 
extern struct bond_params bonding_defaults;
49 
extern struct bond_parm_tbl bond_mode_tbl[];
50 
extern struct bond_parm_tbl bond_lacp_tbl[];
51 
extern struct bond_parm_tbl xmit_hashtype_tbl[];
52 
extern struct bond_parm_tbl arp_validate_tbl[];
53 
 
54 
static int expected_refcount = -1;
55 
static struct class *netdev_class;
56 
/*--------------------------- Data Structures -----------------------------*/
57 
 
58 
/* Bonding sysfs lock.  Why can't we just use the subsystem lock?
59 
 * Because kobject_register tries to acquire the subsystem lock.  If
60 
 * we already hold the lock (which we would if the user was creating
61 
 * a new bond through the sysfs interface), we deadlock.
62 
 * This lock is only needed when deleting a bond - we need to make sure
63 
 * that we don't collide with an ongoing ioctl.
64 
 */
65 
 
66 
struct rw_semaphore bonding_rwsem;
67 
 
68 
 
69 
 
70 
 
71 
/*------------------------------ Functions --------------------------------*/
72 
 
73 
/*
74 
 * "show" function for the bond_masters attribute.
75 
 * The class parameter is ignored.
76 
 */
77 
static ssize_t bonding_show_bonds(struct class *cls, char *buf)
78 
{
79 
        int res = 0;
80 
        struct bonding *bond;
81 
 
82 
        down_read(&(bonding_rwsem));
83 
 
84 
        list_for_each_entry(bond, &bond_dev_list, bond_list) {
85 
                if (res > (PAGE_SIZE - IFNAMSIZ)) {
86 
                        /* not enough space for another interface name */
87 
                        if ((PAGE_SIZE - res) > 10)
88 
                                res = PAGE_SIZE - 10;
89 
                        res += sprintf(buf + res, "++more++ ");
90 
                        break;
91 
                }
92 
                res += sprintf(buf + res, "%s ", bond->dev->name);
93 
        }
94 
        if (res)
95 
                buf[res-1] = '\n'; /* eat the leftover space */
96 
        up_read(&(bonding_rwsem));
97 
        return res;
98 
}
99 
 
100 
/*
101 
 * "store" function for the bond_masters attribute.  This is what
102 
 * creates and deletes entire bonds.
103 
 *
104 
 * The class parameter is ignored.
105 
 *
106 
 */
107 
 
108 
static ssize_t bonding_store_bonds(struct class *cls, const char *buffer, size_t count)
109 
{
110 
        char command[IFNAMSIZ + 1] = {0, };
111 
        char *ifname;
112 
        int rv, res = count;
113 
        struct bonding *bond;
114 
        struct bonding *nxt;
115 
 
116 
        sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
117 
        ifname = command + 1;
118 
        if ((strlen(command) <= 1) ||
119 
            !dev_valid_name(ifname))
120 
                goto err_no_cmd;
121 
 
122 
        if (command[0] == '+') {
123 
                printk(KERN_INFO DRV_NAME
124 
                        ": %s is being created...\n", ifname);
125 
                rv = bond_create(ifname, &bonding_defaults, &bond);
126 
                if (rv) {
127 
                        printk(KERN_INFO DRV_NAME ": Bond creation failed.\n");
128 
                        res = rv;
129 
                }
130 
                goto out;
131 
        }
132 
 
133 
        if (command[0] == '-') {
134 
                rtnl_lock();
135 
                down_write(&bonding_rwsem);
136 
 
137 
                list_for_each_entry_safe(bond, nxt, &bond_dev_list, bond_list)
138 
                        if (strnicmp(bond->dev->name, ifname, IFNAMSIZ) == 0) {
139 
                                /* check the ref count on the bond's kobject.
140 
                                 * If it's > expected, then there's a file open,
141 
                                 * and we have to fail.
142 
                                 */
143 
                                if (atomic_read(&bond->dev->dev.kobj.kref.refcount)
144 
                                                        > expected_refcount){
145 
                                        printk(KERN_INFO DRV_NAME
146 
                                                ": Unable remove bond %s due to open references.\n",
147 
                                                ifname);
148 
                                        res = -EPERM;
149 
                                        goto out;
150 
                                }
151 
                                printk(KERN_INFO DRV_NAME
152 
                                        ": %s is being deleted...\n",
153 
                                        bond->dev->name);
154 
                                bond_destroy(bond);
155 
                                up_write(&bonding_rwsem);
156 
                                rtnl_unlock();
157 
                                goto out;
158 
                        }
159 
 
160 
                printk(KERN_ERR DRV_NAME
161 
                        ": unable to delete non-existent bond %s\n", ifname);
162 
                res = -ENODEV;
163 
                up_write(&bonding_rwsem);
164 
                rtnl_unlock();
165 
                goto out;
166 
        }
167 
 
168 
err_no_cmd:
169 
        printk(KERN_ERR DRV_NAME
170 
                ": no command found in bonding_masters. Use +ifname or -ifname.\n");
171 
        res = -EPERM;
172 
 
173 
        /* Always return either count or an error.  If you return 0, you'll
174 
         * get called forever, which is bad.
175 
         */
176 
out:
177 
        return res;
178 
}
179 
/* class attribute for bond_masters file.  This ends up in /sys/class/net */
180 
static CLASS_ATTR(bonding_masters,  S_IWUSR | S_IRUGO,
181 
                  bonding_show_bonds, bonding_store_bonds);
182 
 
183 
int bond_create_slave_symlinks(struct net_device *master, struct net_device *slave)
184 
{
185 
        char linkname[IFNAMSIZ+7];
186 
        int ret = 0;
187 
 
188 
        /* first, create a link from the slave back to the master */
189 
        ret = sysfs_create_link(&(slave->dev.kobj), &(master->dev.kobj),
190 
                                "master");
191 
        if (ret)
192 
                return ret;
193 
        /* next, create a link from the master to the slave */
194 
        sprintf(linkname,"slave_%s",slave->name);
195 
        ret = sysfs_create_link(&(master->dev.kobj), &(slave->dev.kobj),
196 
                                linkname);
197 
        return ret;
198 
 
199 
}
200 
 
201 
void bond_destroy_slave_symlinks(struct net_device *master, struct net_device *slave)
202 
{
203 
        char linkname[IFNAMSIZ+7];
204 
 
205 
        sysfs_remove_link(&(slave->dev.kobj), "master");
206 
        sprintf(linkname,"slave_%s",slave->name);
207 
        sysfs_remove_link(&(master->dev.kobj), linkname);
208 
}
209 
 
210 
 
211 
/*
212 
 * Show the slaves in the current bond.
213 
 */
214 
static ssize_t bonding_show_slaves(struct device *d,
215 
                                   struct device_attribute *attr, char *buf)
216 
{
217 
        struct slave *slave;
218 
        int i, res = 0;
219 
        struct bonding *bond = to_bond(d);
220 
 
221 
        read_lock(&bond->lock);
222 
        bond_for_each_slave(bond, slave, i) {
223 
                if (res > (PAGE_SIZE - IFNAMSIZ)) {
224 
                        /* not enough space for another interface name */
225 
                        if ((PAGE_SIZE - res) > 10)
226 
                                res = PAGE_SIZE - 10;
227 
                        res += sprintf(buf + res, "++more++ ");
228 
                        break;
229 
                }
230 
                res += sprintf(buf + res, "%s ", slave->dev->name);
231 
        }
232 
        read_unlock(&bond->lock);
233 
        if (res)
234 
                buf[res-1] = '\n'; /* eat the leftover space */
235 
        return res;
236 
}
237 
 
238 
/*
239 
 * Set the slaves in the current bond.  The bond interface must be
240 
 * up for this to succeed.
241 
 * This function is largely the same flow as bonding_update_bonds().
242 
 */
243 
static ssize_t bonding_store_slaves(struct device *d,
244 
                                    struct device_attribute *attr,
245 
                                    const char *buffer, size_t count)
246 
{
247 
        char command[IFNAMSIZ + 1] = { 0, };
248 
        char *ifname;
249 
        int i, res, found, ret = count;
250 
        u32 original_mtu;
251 
        struct slave *slave;
252 
        struct net_device *dev = NULL;
253 
        struct bonding *bond = to_bond(d);
254 
 
255 
        /* Quick sanity check -- is the bond interface up? */
256 
        if (!(bond->dev->flags & IFF_UP)) {
257 
                printk(KERN_WARNING DRV_NAME
258 
                       ": %s: doing slave updates when interface is down.\n",
259 
                       bond->dev->name);
260 
        }
261 
 
262 
        /* Note:  We can't hold bond->lock here, as bond_create grabs it. */
263 
 
264 
        rtnl_lock();
265 
        down_write(&(bonding_rwsem));
266 
 
267 
        sscanf(buffer, "%16s", command); /* IFNAMSIZ*/
268 
        ifname = command + 1;
269 
        if ((strlen(command) <= 1) ||
270 
            !dev_valid_name(ifname))
271 
                goto err_no_cmd;
272 
 
273 
        if (command[0] == '+') {
274 
 
275 
                /* Got a slave name in ifname.  Is it already in the list? */
276 
                found = 0;
277 
                read_lock(&bond->lock);
278 
                bond_for_each_slave(bond, slave, i)
279 
                        if (strnicmp(slave->dev->name, ifname, IFNAMSIZ) == 0) {
280 
                                printk(KERN_ERR DRV_NAME
281 
                                       ": %s: Interface %s is already enslaved!\n",
282 
                                       bond->dev->name, ifname);
283 
                                ret = -EPERM;
284 
                                read_unlock(&bond->lock);
285 
                                goto out;
286 
                        }
287 
 
288 
                read_unlock(&bond->lock);
289 
                printk(KERN_INFO DRV_NAME ": %s: Adding slave %s.\n",
290 
                       bond->dev->name, ifname);
291 
                dev = dev_get_by_name(&init_net, ifname);
292 
                if (!dev) {
293 
                        printk(KERN_INFO DRV_NAME
294 
                               ": %s: Interface %s does not exist!\n",
295 
                               bond->dev->name, ifname);
296 
                        ret = -EPERM;
297 
                        goto out;
298 
                }
299 
                else
300 
                        dev_put(dev);
301 
 
302 
                if (dev->flags & IFF_UP) {
303 
                        printk(KERN_ERR DRV_NAME
304 
                               ": %s: Error: Unable to enslave %s "
305 
                               "because it is already up.\n",
306 
                               bond->dev->name, dev->name);
307 
                        ret = -EPERM;
308 
                        goto out;
309 
                }
310 
                /* If this is the first slave, then we need to set
311 
                   the master's hardware address to be the same as the
312 
                   slave's. */
313 
                if (!(*((u32 *) & (bond->dev->dev_addr[0])))) {
314 
                        memcpy(bond->dev->dev_addr, dev->dev_addr,
315 
                               dev->addr_len);
316 
                }
317 
 
318 
                /* Set the slave's MTU to match the bond */
319 
                original_mtu = dev->mtu;
320 
                if (dev->mtu != bond->dev->mtu) {
321 
                        if (dev->change_mtu) {
322 
                                res = dev->change_mtu(dev,
323 
                                                      bond->dev->mtu);
324 
                                if (res) {
325 
                                        ret = res;
326 
                                        goto out;
327 
                                }
328 
                        } else {
329 
                                dev->mtu = bond->dev->mtu;
330 
                        }
331 
                }
332 
                res = bond_enslave(bond->dev, dev);
333 
                bond_for_each_slave(bond, slave, i)
334 
                        if (strnicmp(slave->dev->name, ifname, IFNAMSIZ) == 0)
335 
                                slave->original_mtu = original_mtu;
336 
                if (res) {
337 
                        ret = res;
338 
                }
339 
                goto out;
340 
        }
341 
 
342 
        if (command[0] == '-') {
343 
                dev = NULL;
344 
                bond_for_each_slave(bond, slave, i)
345 
                        if (strnicmp(slave->dev->name, ifname, IFNAMSIZ) == 0) {
346 
                                dev = slave->dev;
347 
                                original_mtu = slave->original_mtu;
348 
                                break;
349 
                        }
350 
                if (dev) {
351 
                        printk(KERN_INFO DRV_NAME ": %s: Removing slave %s\n",
352 
                                bond->dev->name, dev->name);
353 
                        if (bond->setup_by_slave)
354 
                                res = bond_release_and_destroy(bond->dev, dev);
355 
                        else
356 
                                res = bond_release(bond->dev, dev);
357 
                        if (res) {
358 
                                ret = res;
359 
                                goto out;
360 
                        }
361 
                        /* set the slave MTU to the default */
362 
                        if (dev->change_mtu) {
363 
                                dev->change_mtu(dev, original_mtu);
364 
                        } else {
365 
                                dev->mtu = original_mtu;
366 
                        }
367 
                }
368 
                else {
369 
                        printk(KERN_ERR DRV_NAME ": unable to remove non-existent slave %s for bond %s.\n",
370 
                                ifname, bond->dev->name);
371 
                        ret = -ENODEV;
372 
                }
373 
                goto out;
374 
        }
375 
 
376 
err_no_cmd:
377 
        printk(KERN_ERR DRV_NAME ": no command found in slaves file for bond %s. Use +ifname or -ifname.\n", bond->dev->name);
378 
        ret = -EPERM;
379 
 
380 
out:
381 
        up_write(&(bonding_rwsem));
382 
        rtnl_unlock();
383 
        return ret;
384 
}
385 
 
386 
static DEVICE_ATTR(slaves, S_IRUGO | S_IWUSR, bonding_show_slaves, bonding_store_slaves);
387 
 
388 
/*
389 
 * Show and set the bonding mode.  The bond interface must be down to
390 
 * change the mode.
391 
 */
392 
static ssize_t bonding_show_mode(struct device *d,
393 
                                 struct device_attribute *attr, char *buf)
394 
{
395 
        struct bonding *bond = to_bond(d);
396 
 
397 
        return sprintf(buf, "%s %d\n",
398 
                        bond_mode_tbl[bond->params.mode].modename,
399 
                        bond->params.mode);
400 
}
401 
 
402 
static ssize_t bonding_store_mode(struct device *d,
403 
                                  struct device_attribute *attr,
404 
                                  const char *buf, size_t count)
405 
{
406 
        int new_value, ret = count;
407 
        struct bonding *bond = to_bond(d);
408 
 
409 
        if (bond->dev->flags & IFF_UP) {
410 
                printk(KERN_ERR DRV_NAME
411 
                       ": unable to update mode of %s because interface is up.\n",
412 
                       bond->dev->name);
413 
                ret = -EPERM;
414 
                goto out;
415 
        }
416 
 
417 
        new_value = bond_parse_parm(buf, bond_mode_tbl);
418 
        if (new_value < 0)  {
419 
                printk(KERN_ERR DRV_NAME
420 
                       ": %s: Ignoring invalid mode value %.*s.\n",
421 
                       bond->dev->name,
422 
                       (int)strlen(buf) - 1, buf);
423 
                ret = -EINVAL;
424 
                goto out;
425 
        } else {
426 
                if (bond->params.mode == BOND_MODE_8023AD)
427 
                        bond_unset_master_3ad_flags(bond);
428 
 
429 
                if (bond->params.mode == BOND_MODE_ALB)
430 
                        bond_unset_master_alb_flags(bond);
431 
 
432 
                bond->params.mode = new_value;
433 
                bond_set_mode_ops(bond, bond->params.mode);
434 
                printk(KERN_INFO DRV_NAME ": %s: setting mode to %s (%d).\n",
435 
                        bond->dev->name, bond_mode_tbl[new_value].modename, new_value);
436 
        }
437 
out:
438 
        return ret;
439 
}
440 
static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, bonding_show_mode, bonding_store_mode);
441 
 
442 
/*
443 
 * Show and set the bonding transmit hash method.  The bond interface must be down to
444 
 * change the xmit hash policy.
445 
 */
446 
static ssize_t bonding_show_xmit_hash(struct device *d,
447 
                                      struct device_attribute *attr,
448 
                                      char *buf)
449 
{
450 
        struct bonding *bond = to_bond(d);
451 
 
452 
        return sprintf(buf, "%s %d\n",
453 
                       xmit_hashtype_tbl[bond->params.xmit_policy].modename,
454 
                       bond->params.xmit_policy);
455 
}
456 
 
457 
static ssize_t bonding_store_xmit_hash(struct device *d,
458 
                                       struct device_attribute *attr,
459 
                                       const char *buf, size_t count)
460 
{
461 
        int new_value, ret = count;
462 
        struct bonding *bond = to_bond(d);
463 
 
464 
        if (bond->dev->flags & IFF_UP) {
465 
                printk(KERN_ERR DRV_NAME
466 
                       "%s: Interface is up. Unable to update xmit policy.\n",
467 
                       bond->dev->name);
468 
                ret = -EPERM;
469 
                goto out;
470 
        }
471 
 
472 
        new_value = bond_parse_parm(buf, xmit_hashtype_tbl);
473 
        if (new_value < 0)  {
474 
                printk(KERN_ERR DRV_NAME
475 
                       ": %s: Ignoring invalid xmit hash policy value %.*s.\n",
476 
                       bond->dev->name,
477 
                       (int)strlen(buf) - 1, buf);
478 
                ret = -EINVAL;
479 
                goto out;
480 
        } else {
481 
                bond->params.xmit_policy = new_value;
482 
                bond_set_mode_ops(bond, bond->params.mode);
483 
                printk(KERN_INFO DRV_NAME ": %s: setting xmit hash policy to %s (%d).\n",
484 
                        bond->dev->name, xmit_hashtype_tbl[new_value].modename, new_value);
485 
        }
486 
out:
487 
        return ret;
488 
}
489 
static DEVICE_ATTR(xmit_hash_policy, S_IRUGO | S_IWUSR, bonding_show_xmit_hash, bonding_store_xmit_hash);
490 
 
491 
/*
492 
 * Show and set arp_validate.
493 
 */
494 
static ssize_t bonding_show_arp_validate(struct device *d,
495 
                                         struct device_attribute *attr,
496 
                                         char *buf)
497 
{
498 
        struct bonding *bond = to_bond(d);
499 
 
500 
        return sprintf(buf, "%s %d\n",
501 
                       arp_validate_tbl[bond->params.arp_validate].modename,
502 
                       bond->params.arp_validate);
503 
}
504 
 
505 
static ssize_t bonding_store_arp_validate(struct device *d,
506 
                                          struct device_attribute *attr,
507 
                                          const char *buf, size_t count)
508 
{
509 
        int new_value;
510 
        struct bonding *bond = to_bond(d);
511 
 
512 
        new_value = bond_parse_parm(buf, arp_validate_tbl);
513 
        if (new_value < 0) {
514 
                printk(KERN_ERR DRV_NAME
515 
                       ": %s: Ignoring invalid arp_validate value %s\n",
516 
                       bond->dev->name, buf);
517 
                return -EINVAL;
518 
        }
519 
        if (new_value && (bond->params.mode != BOND_MODE_ACTIVEBACKUP)) {
520 
                printk(KERN_ERR DRV_NAME
521 
                       ": %s: arp_validate only supported in active-backup mode.\n",
522 
                       bond->dev->name);
523 
                return -EINVAL;
524 
        }
525 
        printk(KERN_INFO DRV_NAME ": %s: setting arp_validate to %s (%d).\n",
526 
               bond->dev->name, arp_validate_tbl[new_value].modename,
527 
               new_value);
528 
 
529 
        if (!bond->params.arp_validate && new_value) {
530 
                bond_register_arp(bond);
531 
        } else if (bond->params.arp_validate && !new_value) {
532 
                bond_unregister_arp(bond);
533 
        }
534 
 
535 
        bond->params.arp_validate = new_value;
536 
 
537 
        return count;
538 
}
539 
 
540 
static DEVICE_ATTR(arp_validate, S_IRUGO | S_IWUSR, bonding_show_arp_validate, bonding_store_arp_validate);
541 
 
542 
/*
543 
 * Show and store fail_over_mac.  User only allowed to change the
544 
 * value when there are no slaves.
545 
 */
546 
static ssize_t bonding_show_fail_over_mac(struct device *d, struct device_attribute *attr, char *buf)
547 
{
548 
        struct bonding *bond = to_bond(d);
549 
 
550 
        return sprintf(buf, "%d\n", bond->params.fail_over_mac) + 1;
551 
}
552 
 
553 
static ssize_t bonding_store_fail_over_mac(struct device *d, struct device_attribute *attr, const char *buf, size_t count)
554 
{
555 
        int new_value;
556 
        int ret = count;
557 
        struct bonding *bond = to_bond(d);
558 
 
559 
        if (bond->slave_cnt != 0) {
560 
                printk(KERN_ERR DRV_NAME
561 
                       ": %s: Can't alter fail_over_mac with slaves in bond.\n",
562 
                       bond->dev->name);
563 
                ret = -EPERM;
564 
                goto out;
565 
        }
566 
 
567 
        if (sscanf(buf, "%d", &new_value) != 1) {
568 
                printk(KERN_ERR DRV_NAME
569 
                       ": %s: no fail_over_mac value specified.\n",
570 
                       bond->dev->name);
571 
                ret = -EINVAL;
572 
                goto out;
573 
        }
574 
 
575 
        if ((new_value == 0) || (new_value == 1)) {
576 
                bond->params.fail_over_mac = new_value;
577 
                printk(KERN_INFO DRV_NAME ": %s: Setting fail_over_mac to %d.\n",
578 
                       bond->dev->name, new_value);
579 
        } else {
580 
                printk(KERN_INFO DRV_NAME
581 
                       ": %s: Ignoring invalid fail_over_mac value %d.\n",
582 
                       bond->dev->name, new_value);
583 
        }
584 
out:
585 
        return ret;
586 
}
587 
 
588 
static DEVICE_ATTR(fail_over_mac, S_IRUGO | S_IWUSR, bonding_show_fail_over_mac, bonding_store_fail_over_mac);
589 
 
590 
/*
591 
 * Show and set the arp timer interval.  There are two tricky bits
592 
 * here.  First, if ARP monitoring is activated, then we must disable
593 
 * MII monitoring.  Second, if the ARP timer isn't running, we must
594 
 * start it.
595 
 */
596 
static ssize_t bonding_show_arp_interval(struct device *d,
597 
                                         struct device_attribute *attr,
598 
                                         char *buf)
599 
{
600 
        struct bonding *bond = to_bond(d);
601 
 
602 
        return sprintf(buf, "%d\n", bond->params.arp_interval);
603 
}
604 
 
605 
static ssize_t bonding_store_arp_interval(struct device *d,
606 
                                          struct device_attribute *attr,
607 
                                          const char *buf, size_t count)
608 
{
609 
        int new_value, ret = count;
610 
        struct bonding *bond = to_bond(d);
611 
 
612 
        if (sscanf(buf, "%d", &new_value) != 1) {
613 
                printk(KERN_ERR DRV_NAME
614 
                       ": %s: no arp_interval value specified.\n",
615 
                       bond->dev->name);
616 
                ret = -EINVAL;
617 
                goto out;
618 
        }
619 
        if (new_value < 0) {
620 
                printk(KERN_ERR DRV_NAME
621 
                       ": %s: Invalid arp_interval value %d not in range 1-%d; rejected.\n",
622 
                       bond->dev->name, new_value, INT_MAX);
623 
                ret = -EINVAL;
624 
                goto out;
625 
        }
626 
 
627 
        printk(KERN_INFO DRV_NAME
628 
               ": %s: Setting ARP monitoring interval to %d.\n",
629 
               bond->dev->name, new_value);
630 
        bond->params.arp_interval = new_value;
631 
        if (bond->params.miimon) {
632 
                printk(KERN_INFO DRV_NAME
633 
                       ": %s: ARP monitoring cannot be used with MII monitoring. "
634 
                       "%s Disabling MII monitoring.\n",
635 
                       bond->dev->name, bond->dev->name);
636 
                bond->params.miimon = 0;
637 
                if (delayed_work_pending(&bond->mii_work)) {
638 
                        cancel_delayed_work(&bond->mii_work);
639 
                        flush_workqueue(bond->wq);
640 
                }
641 
        }
642 
        if (!bond->params.arp_targets[0]) {
643 
                printk(KERN_INFO DRV_NAME
644 
                       ": %s: ARP monitoring has been set up, "
645 
                       "but no ARP targets have been specified.\n",
646 
                       bond->dev->name);
647 
        }
648 
        if (bond->dev->flags & IFF_UP) {
649 
                /* If the interface is up, we may need to fire off
650 
                 * the ARP timer.  If the interface is down, the
651 
                 * timer will get fired off when the open function
652 
                 * is called.
653 
                 */
654 
                if (!delayed_work_pending(&bond->arp_work)) {
655 
                        if (bond->params.mode == BOND_MODE_ACTIVEBACKUP)
656 
                                INIT_DELAYED_WORK(&bond->arp_work,
657 
                                                  bond_activebackup_arp_mon);
658 
                        else
659 
                                INIT_DELAYED_WORK(&bond->arp_work,
660 
                                                  bond_loadbalance_arp_mon);
661 
 
662 
                        queue_delayed_work(bond->wq, &bond->arp_work, 0);
663 
                }
664 
        }
665 
 
666 
out:
667 
        return ret;
668 
}
669 
static DEVICE_ATTR(arp_interval, S_IRUGO | S_IWUSR , bonding_show_arp_interval, bonding_store_arp_interval);
670 
 
671 
/*
672 
 * Show and set the arp targets.
673 
 */
674 
static ssize_t bonding_show_arp_targets(struct device *d,
675 
                                        struct device_attribute *attr,
676 
                                        char *buf)
677 
{
678 
        int i, res = 0;
679 
        struct bonding *bond = to_bond(d);
680 
 
681 
        for (i = 0; i < BOND_MAX_ARP_TARGETS; i++) {
682 
                if (bond->params.arp_targets[i])
683 
                        res += sprintf(buf + res, "%u.%u.%u.%u ",
684 
                               NIPQUAD(bond->params.arp_targets[i]));
685 
        }
686 
        if (res)
687 
                buf[res-1] = '\n'; /* eat the leftover space */
688 
        return res;
689 
}
690 
 
691 
static ssize_t bonding_store_arp_targets(struct device *d,
692 
                                         struct device_attribute *attr,
693 
                                         const char *buf, size_t count)
694 
{
695 
        __be32 newtarget;
696 
        int i = 0, done = 0, ret = count;
697 
        struct bonding *bond = to_bond(d);
698 
        __be32 *targets;
699 
 
700 
        targets = bond->params.arp_targets;
701 
        newtarget = in_aton(buf + 1);
702 
        /* look for adds */
703 
        if (buf[0] == '+') {
704 
                if ((newtarget == 0) || (newtarget == htonl(INADDR_BROADCAST))) {
705 
                        printk(KERN_ERR DRV_NAME
706 
                               ": %s: invalid ARP target %u.%u.%u.%u specified for addition\n",
707 
                               bond->dev->name, NIPQUAD(newtarget));
708 
                        ret = -EINVAL;
709 
                        goto out;
710 
                }
711 
                /* look for an empty slot to put the target in, and check for dupes */
712 
                for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
713 
                        if (targets[i] == newtarget) { /* duplicate */
714 
                                printk(KERN_ERR DRV_NAME
715 
                                       ": %s: ARP target %u.%u.%u.%u is already present\n",
716 
                                       bond->dev->name, NIPQUAD(newtarget));
717 
                                if (done)
718 
                                        targets[i] = 0;
719 
                                ret = -EINVAL;
720 
                                goto out;
721 
                        }
722 
                        if (targets[i] == 0 && !done) {
723 
                                printk(KERN_INFO DRV_NAME
724 
                                       ": %s: adding ARP target %d.%d.%d.%d.\n",
725 
                                       bond->dev->name, NIPQUAD(newtarget));
726 
                                done = 1;
727 
                                targets[i] = newtarget;
728 
                        }
729 
                }
730 
                if (!done) {
731 
                        printk(KERN_ERR DRV_NAME
732 
                               ": %s: ARP target table is full!\n",
733 
                               bond->dev->name);
734 
                        ret = -EINVAL;
735 
                        goto out;
736 
                }
737 
 
738 
        }
739 
        else if (buf[0] == '-')  {
740 
                if ((newtarget == 0) || (newtarget == htonl(INADDR_BROADCAST))) {
741 
                        printk(KERN_ERR DRV_NAME
742 
                               ": %s: invalid ARP target %d.%d.%d.%d specified for removal\n",
743 
                               bond->dev->name, NIPQUAD(newtarget));
744 
                        ret = -EINVAL;
745 
                        goto out;
746 
                }
747 
 
748 
                for (i = 0; (i < BOND_MAX_ARP_TARGETS); i++) {
749 
                        if (targets[i] == newtarget) {
750 
                                printk(KERN_INFO DRV_NAME
751 
                                       ": %s: removing ARP target %d.%d.%d.%d.\n",
752 
                                       bond->dev->name, NIPQUAD(newtarget));
753 
                                targets[i] = 0;
754 
                                done = 1;
755 
                        }
756 
                }
757 
                if (!done) {
758 
                        printk(KERN_INFO DRV_NAME
759 
                               ": %s: unable to remove nonexistent ARP target %d.%d.%d.%d.\n",
760 
                               bond->dev->name, NIPQUAD(newtarget));
761 
                        ret = -EINVAL;
762 
                        goto out;
763 
                }
764 
        }
765 
        else {
766 
                printk(KERN_ERR DRV_NAME ": no command found in arp_ip_targets file for bond %s. Use +<addr> or -<addr>.\n",
767 
                        bond->dev->name);
768 
                ret = -EPERM;
769 
                goto out;
770 
        }
771 
 
772 
out:
773 
        return ret;
774 
}
775 
static DEVICE_ATTR(arp_ip_target, S_IRUGO | S_IWUSR , bonding_show_arp_targets, bonding_store_arp_targets);
776 
 
777 
/*
778 
 * Show and set the up and down delays.  These must be multiples of the
779 
 * MII monitoring value, and are stored internally as the multiplier.
780 
 * Thus, we must translate to MS for the real world.
781 
 */
782 
static ssize_t bonding_show_downdelay(struct device *d,
783 
                                      struct device_attribute *attr,
784 
                                      char *buf)
785 
{
786 
        struct bonding *bond = to_bond(d);
787 
 
788 
        return sprintf(buf, "%d\n", bond->params.downdelay * bond->params.miimon);
789 
}
790 
 
791 
static ssize_t bonding_store_downdelay(struct device *d,
792 
                                       struct device_attribute *attr,
793 
                                       const char *buf, size_t count)
794 
{
795 
        int new_value, ret = count;
796 
        struct bonding *bond = to_bond(d);
797 
 
798 
        if (!(bond->params.miimon)) {
799 
                printk(KERN_ERR DRV_NAME
800 
                       ": %s: Unable to set down delay as MII monitoring is disabled\n",
801 
                       bond->dev->name);
802 
                ret = -EPERM;
803 
                goto out;
804 
        }
805 
 
806 
        if (sscanf(buf, "%d", &new_value) != 1) {
807 
                printk(KERN_ERR DRV_NAME
808 
                       ": %s: no down delay value specified.\n",
809 
                       bond->dev->name);
810 
                ret = -EINVAL;
811 
                goto out;
812 
        }
813 
        if (new_value < 0) {
814 
                printk(KERN_ERR DRV_NAME
815 
                       ": %s: Invalid down delay value %d not in range %d-%d; rejected.\n",
816 
                       bond->dev->name, new_value, 1, INT_MAX);
817 
                ret = -EINVAL;
818 
                goto out;
819 
        } else {
820 
                if ((new_value % bond->params.miimon) != 0) {
821 
                        printk(KERN_WARNING DRV_NAME
822 
                               ": %s: Warning: down delay (%d) is not a multiple "
823 
                               "of miimon (%d), delay rounded to %d ms\n",
824 
                               bond->dev->name, new_value, bond->params.miimon,
825 
                               (new_value / bond->params.miimon) *
826 
                               bond->params.miimon);
827 
                }
828 
                bond->params.downdelay = new_value / bond->params.miimon;
829 
                printk(KERN_INFO DRV_NAME ": %s: Setting down delay to %d.\n",
830 
                       bond->dev->name, bond->params.downdelay * bond->params.miimon);
831 
 
832 
        }
833 
 
834 
out:
835 
        return ret;
836 
}
837 
static DEVICE_ATTR(downdelay, S_IRUGO | S_IWUSR , bonding_show_downdelay, bonding_store_downdelay);
838 
 
839 
static ssize_t bonding_show_updelay(struct device *d,
840 
                                    struct device_attribute *attr,
841 
                                    char *buf)
842 
{
843 
        struct bonding *bond = to_bond(d);
844 
 
845 
        return sprintf(buf, "%d\n", bond->params.updelay * bond->params.miimon);
846 
 
847 
}
848 
 
849 
static ssize_t bonding_store_updelay(struct device *d,
850 
                                     struct device_attribute *attr,
851 
                                     const char *buf, size_t count)
852 
{
853 
        int new_value, ret = count;
854 
        struct bonding *bond = to_bond(d);
855 
 
856 
        if (!(bond->params.miimon)) {
857 
                printk(KERN_ERR DRV_NAME
858 
                       ": %s: Unable to set up delay as MII monitoring is disabled\n",
859 
                       bond->dev->name);
860 
                ret = -EPERM;
861 
                goto out;
862 
        }
863 
 
864 
        if (sscanf(buf, "%d", &new_value) != 1) {
865 
                printk(KERN_ERR DRV_NAME
866 
                       ": %s: no up delay value specified.\n",
867 
                       bond->dev->name);
868 
                ret = -EINVAL;
869 
                goto out;
870 
        }
871 
        if (new_value < 0) {
872 
                printk(KERN_ERR DRV_NAME
873 
                       ": %s: Invalid down delay value %d not in range %d-%d; rejected.\n",
874 
                       bond->dev->name, new_value, 1, INT_MAX);
875 
                ret = -EINVAL;
876 
                goto out;
877 
        } else {
878 
                if ((new_value % bond->params.miimon) != 0) {
879 
                        printk(KERN_WARNING DRV_NAME
880 
                               ": %s: Warning: up delay (%d) is not a multiple "
881 
                               "of miimon (%d), updelay rounded to %d ms\n",
882 
                               bond->dev->name, new_value, bond->params.miimon,
883 
                               (new_value / bond->params.miimon) *
884 
                               bond->params.miimon);
885 
                }
886 
                bond->params.updelay = new_value / bond->params.miimon;
887 
                printk(KERN_INFO DRV_NAME ": %s: Setting up delay to %d.\n",
888 
                       bond->dev->name, bond->params.updelay * bond->params.miimon);
889 
 
890 
        }
891 
 
892 
out:
893 
        return ret;
894 
}
895 
static DEVICE_ATTR(updelay, S_IRUGO | S_IWUSR , bonding_show_updelay, bonding_store_updelay);
896 
 
897 
/*
898 
 * Show and set the LACP interval.  Interface must be down, and the mode
899 
 * must be set to 802.3ad mode.
900 
 */
901 
static ssize_t bonding_show_lacp(struct device *d,
902 
                                 struct device_attribute *attr,
903 
                                 char *buf)
904 
{
905 
        struct bonding *bond = to_bond(d);
906 
 
907 
        return sprintf(buf, "%s %d\n",
908 
                bond_lacp_tbl[bond->params.lacp_fast].modename,
909 
                bond->params.lacp_fast);
910 
}
911 
 
912 
static ssize_t bonding_store_lacp(struct device *d,
913 
                                  struct device_attribute *attr,
914 
                                  const char *buf, size_t count)
915 
{
916 
        int new_value, ret = count;
917 
        struct bonding *bond = to_bond(d);
918 
 
919 
        if (bond->dev->flags & IFF_UP) {
920 
                printk(KERN_ERR DRV_NAME
921 
                       ": %s: Unable to update LACP rate because interface is up.\n",
922 
                       bond->dev->name);
923 
                ret = -EPERM;
924 
                goto out;
925 
        }
926 
 
927 
        if (bond->params.mode != BOND_MODE_8023AD) {
928 
                printk(KERN_ERR DRV_NAME
929 
                       ": %s: Unable to update LACP rate because bond is not in 802.3ad mode.\n",
930 
                       bond->dev->name);
931 
                ret = -EPERM;
932 
                goto out;
933 
        }
934 
 
935 
        new_value = bond_parse_parm(buf, bond_lacp_tbl);
936 
 
937 
        if ((new_value == 1) || (new_value == 0)) {
938 
                bond->params.lacp_fast = new_value;
939 
                printk(KERN_INFO DRV_NAME
940 
                       ": %s: Setting LACP rate to %s (%d).\n",
941 
                       bond->dev->name, bond_lacp_tbl[new_value].modename, new_value);
942 
        } else {
943 
                printk(KERN_ERR DRV_NAME
944 
                       ": %s: Ignoring invalid LACP rate value %.*s.\n",
945 
                        bond->dev->name, (int)strlen(buf) - 1, buf);
946 
                ret = -EINVAL;
947 
        }
948 
out:
949 
        return ret;
950 
}
951 
static DEVICE_ATTR(lacp_rate, S_IRUGO | S_IWUSR, bonding_show_lacp, bonding_store_lacp);
952 
 
953 
/*
954 
 * Show and set the MII monitor interval.  There are two tricky bits
955 
 * here.  First, if MII monitoring is activated, then we must disable
956 
 * ARP monitoring.  Second, if the timer isn't running, we must
957 
 * start it.
958 
 */
959 
static ssize_t bonding_show_miimon(struct device *d,
960 
                                   struct device_attribute *attr,
961 
                                   char *buf)
962 
{
963 
        struct bonding *bond = to_bond(d);
964 
 
965 
        return sprintf(buf, "%d\n", bond->params.miimon);
966 
}
967 
 
968 
static ssize_t bonding_store_miimon(struct device *d,
969 
                                    struct device_attribute *attr,
970 
                                    const char *buf, size_t count)
971 
{
972 
        int new_value, ret = count;
973 
        struct bonding *bond = to_bond(d);
974 
 
975 
        if (sscanf(buf, "%d", &new_value) != 1) {
976 
                printk(KERN_ERR DRV_NAME
977 
                       ": %s: no miimon value specified.\n",
978 
                       bond->dev->name);
979 
                ret = -EINVAL;
980 
                goto out;
981 
        }
982 
        if (new_value < 0) {
983 
                printk(KERN_ERR DRV_NAME
984 
                       ": %s: Invalid miimon value %d not in range %d-%d; rejected.\n",
985 
                       bond->dev->name, new_value, 1, INT_MAX);
986 
                ret = -EINVAL;
987 
                goto out;
988 
        } else {
989 
                printk(KERN_INFO DRV_NAME
990 
                       ": %s: Setting MII monitoring interval to %d.\n",
991 
                       bond->dev->name, new_value);
992 
                bond->params.miimon = new_value;
993 
                if(bond->params.updelay)
994 
                        printk(KERN_INFO DRV_NAME
995 
                              ": %s: Note: Updating updelay (to %d) "
996 
                              "since it is a multiple of the miimon value.\n",
997 
                              bond->dev->name,
998 
                              bond->params.updelay * bond->params.miimon);
999 
                if(bond->params.downdelay)
1000 
                        printk(KERN_INFO DRV_NAME
1001 
                              ": %s: Note: Updating downdelay (to %d) "
1002 
                              "since it is a multiple of the miimon value.\n",
1003 
                              bond->dev->name,
1004 
                              bond->params.downdelay * bond->params.miimon);
1005 
                if (bond->params.arp_interval) {
1006 
                        printk(KERN_INFO DRV_NAME
1007 
                               ": %s: MII monitoring cannot be used with "
1008 
                               "ARP monitoring. Disabling ARP monitoring...\n",
1009 
                               bond->dev->name);
1010 
                        bond->params.arp_interval = 0;
1011 
                        if (bond->params.arp_validate) {
1012 
                                bond_unregister_arp(bond);
1013 
                                bond->params.arp_validate =
1014 
                                        BOND_ARP_VALIDATE_NONE;
1015 
                        }
1016 
                        if (delayed_work_pending(&bond->arp_work)) {
1017 
                                cancel_delayed_work(&bond->arp_work);
1018 
                                flush_workqueue(bond->wq);
1019 
                        }
1020 
                }
1021 
 
1022 
                if (bond->dev->flags & IFF_UP) {
1023 
                        /* If the interface is up, we may need to fire off
1024 
                         * the MII timer. If the interface is down, the
1025 
                         * timer will get fired off when the open function
1026 
                         * is called.
1027 
                         */
1028 
                        if (!delayed_work_pending(&bond->mii_work)) {
1029 
                                INIT_DELAYED_WORK(&bond->mii_work,
1030 
                                                  bond_mii_monitor);
1031 
                                queue_delayed_work(bond->wq,
1032 
                                                   &bond->mii_work, 0);
1033 
                        }
1034 
                }
1035 
        }
1036 
out:
1037 
        return ret;
1038 
}
1039 
static DEVICE_ATTR(miimon, S_IRUGO | S_IWUSR, bonding_show_miimon, bonding_store_miimon);
1040 
 
1041 
/*
1042 
 * Show and set the primary slave.  The store function is much
1043 
 * simpler than bonding_store_slaves function because it only needs to
1044 
 * handle one interface name.
1045 
 * The bond must be a mode that supports a primary for this be
1046 
 * set.
1047 
 */
1048 
static ssize_t bonding_show_primary(struct device *d,
1049 
                                    struct device_attribute *attr,
1050 
                                    char *buf)
1051 
{
1052 
        int count = 0;
1053 
        struct bonding *bond = to_bond(d);
1054 
 
1055 
        if (bond->primary_slave)
1056 
                count = sprintf(buf, "%s\n", bond->primary_slave->dev->name);
1057 
 
1058 
        return count;
1059 
}
1060 
 
1061 
static ssize_t bonding_store_primary(struct device *d,
1062 
                                     struct device_attribute *attr,
1063 
                                     const char *buf, size_t count)
1064 
{
1065 
        int i;
1066 
        struct slave *slave;
1067 
        struct bonding *bond = to_bond(d);
1068 
 
1069 
        rtnl_lock();
1070 
        read_lock(&bond->lock);
1071 
        write_lock_bh(&bond->curr_slave_lock);
1072 
 
1073 
        if (!USES_PRIMARY(bond->params.mode)) {
1074 
                printk(KERN_INFO DRV_NAME
1075 
                       ": %s: Unable to set primary slave; %s is in mode %d\n",
1076 
                       bond->dev->name, bond->dev->name, bond->params.mode);
1077 
        } else {
1078 
                bond_for_each_slave(bond, slave, i) {
1079 
                        if (strnicmp
1080 
                            (slave->dev->name, buf,
1081 
                             strlen(slave->dev->name)) == 0) {
1082 
                                printk(KERN_INFO DRV_NAME
1083 
                                       ": %s: Setting %s as primary slave.\n",
1084 
                                       bond->dev->name, slave->dev->name);
1085 
                                bond->primary_slave = slave;
1086 
                                bond_select_active_slave(bond);
1087 
                                goto out;
1088 
                        }
1089 
                }
1090 
 
1091 
                /* if we got here, then we didn't match the name of any slave */
1092 
 
1093 
                if (strlen(buf) == 0 || buf[0] == '\n') {
1094 
                        printk(KERN_INFO DRV_NAME
1095 
                               ": %s: Setting primary slave to None.\n",
1096 
                               bond->dev->name);
1097 
                        bond->primary_slave = NULL;
1098 
                                bond_select_active_slave(bond);
1099 
                } else {
1100 
                        printk(KERN_INFO DRV_NAME
1101 
                               ": %s: Unable to set %.*s as primary slave as it is not a slave.\n",
1102 
                               bond->dev->name, (int)strlen(buf) - 1, buf);
1103 
                }
1104 
        }
1105 
out:
1106 
        write_unlock_bh(&bond->curr_slave_lock);
1107 
        read_unlock(&bond->lock);
1108 
        rtnl_unlock();
1109 
 
1110 
        return count;
1111 
}
1112 
static DEVICE_ATTR(primary, S_IRUGO | S_IWUSR, bonding_show_primary, bonding_store_primary);
1113 
 
1114 
/*
1115 
 * Show and set the use_carrier flag.
1116 
 */
1117 
static ssize_t bonding_show_carrier(struct device *d,
1118 
                                    struct device_attribute *attr,
1119 
                                    char *buf)
1120 
{
1121 
        struct bonding *bond = to_bond(d);
1122 
 
1123 
        return sprintf(buf, "%d\n", bond->params.use_carrier);
1124 
}
1125 
 
1126 
static ssize_t bonding_store_carrier(struct device *d,
1127 
                                     struct device_attribute *attr,
1128 
                                     const char *buf, size_t count)
1129 
{
1130 
        int new_value, ret = count;
1131 
        struct bonding *bond = to_bond(d);
1132 
 
1133 
 
1134 
        if (sscanf(buf, "%d", &new_value) != 1) {
1135 
                printk(KERN_ERR DRV_NAME
1136 
                       ": %s: no use_carrier value specified.\n",
1137 
                       bond->dev->name);
1138 
                ret = -EINVAL;
1139 
                goto out;
1140 
        }
1141 
        if ((new_value == 0) || (new_value == 1)) {
1142 
                bond->params.use_carrier = new_value;
1143 
                printk(KERN_INFO DRV_NAME ": %s: Setting use_carrier to %d.\n",
1144 
                       bond->dev->name, new_value);
1145 
        } else {
1146 
                printk(KERN_INFO DRV_NAME
1147 
                       ": %s: Ignoring invalid use_carrier value %d.\n",
1148 
                       bond->dev->name, new_value);
1149 
        }
1150 
out:
1151 
        return count;
1152 
}
1153 
static DEVICE_ATTR(use_carrier, S_IRUGO | S_IWUSR, bonding_show_carrier, bonding_store_carrier);
1154 
 
1155 
 
1156 
/*
1157 
 * Show and set currently active_slave.
1158 
 */
1159 
static ssize_t bonding_show_active_slave(struct device *d,
1160 
                                         struct device_attribute *attr,
1161 
                                         char *buf)
1162 
{
1163 
        struct slave *curr;
1164 
        struct bonding *bond = to_bond(d);
1165 
        int count = 0;
1166 
 
1167 
        read_lock(&bond->curr_slave_lock);
1168 
        curr = bond->curr_active_slave;
1169 
        read_unlock(&bond->curr_slave_lock);
1170 
 
1171 
        if (USES_PRIMARY(bond->params.mode) && curr)
1172 
                count = sprintf(buf, "%s\n", curr->dev->name);
1173 
        return count;
1174 
}
1175 
 
1176 
static ssize_t bonding_store_active_slave(struct device *d,
1177 
                                          struct device_attribute *attr,
1178 
                                          const char *buf, size_t count)
1179 
{
1180 
        int i;
1181 
        struct slave *slave;
1182 
        struct slave *old_active = NULL;
1183 
        struct slave *new_active = NULL;
1184 
        struct bonding *bond = to_bond(d);
1185 
 
1186 
        rtnl_lock();
1187 
        read_lock(&bond->lock);
1188 
        write_lock_bh(&bond->curr_slave_lock);
1189 
 
1190 
        if (!USES_PRIMARY(bond->params.mode)) {
1191 
                printk(KERN_INFO DRV_NAME
1192 
                       ": %s: Unable to change active slave; %s is in mode %d\n",
1193 
                       bond->dev->name, bond->dev->name, bond->params.mode);
1194 
        } else {
1195 
                bond_for_each_slave(bond, slave, i) {
1196 
                        if (strnicmp
1197 
                            (slave->dev->name, buf,
1198 
                             strlen(slave->dev->name)) == 0) {
1199 
                                old_active = bond->curr_active_slave;
1200 
                                new_active = slave;
1201 
                                if (new_active == old_active) {
1202 
                                        /* do nothing */
1203 
                                        printk(KERN_INFO DRV_NAME
1204 
                                               ": %s: %s is already the current active slave.\n",
1205 
                                               bond->dev->name, slave->dev->name);
1206 
                                        goto out;
1207 
                                }
1208 
                                else {
1209 
                                        if ((new_active) &&
1210 
                                            (old_active) &&
1211 
                                            (new_active->link == BOND_LINK_UP) &&
1212 
                                            IS_UP(new_active->dev)) {
1213 
                                                printk(KERN_INFO DRV_NAME
1214 
                                                      ": %s: Setting %s as active slave.\n",
1215 
                                                      bond->dev->name, slave->dev->name);
1216 
                                                bond_change_active_slave(bond, new_active);
1217 
                                        }
1218 
                                        else {
1219 
                                                printk(KERN_INFO DRV_NAME
1220 
                                                      ": %s: Could not set %s as active slave; "
1221 
                                                      "either %s is down or the link is down.\n",
1222 
                                                      bond->dev->name, slave->dev->name,
1223 
                                                      slave->dev->name);
1224 
                                        }
1225 
                                        goto out;
1226 
                                }
1227 
                        }
1228 
                }
1229 
 
1230 
                /* if we got here, then we didn't match the name of any slave */
1231 
 
1232 
                if (strlen(buf) == 0 || buf[0] == '\n') {
1233 
                        printk(KERN_INFO DRV_NAME
1234 
                               ": %s: Setting active slave to None.\n",
1235 
                               bond->dev->name);
1236 
                        bond->primary_slave = NULL;
1237 
                                bond_select_active_slave(bond);
1238 
                } else {
1239 
                        printk(KERN_INFO DRV_NAME
1240 
                               ": %s: Unable to set %.*s as active slave as it is not a slave.\n",
1241 
                               bond->dev->name, (int)strlen(buf) - 1, buf);
1242 
                }
1243 
        }
1244 
out:
1245 
        write_unlock_bh(&bond->curr_slave_lock);
1246 
        read_unlock(&bond->lock);
1247 
        rtnl_unlock();
1248 
 
1249 
        return count;
1250 
 
1251 
}
1252 
static DEVICE_ATTR(active_slave, S_IRUGO | S_IWUSR, bonding_show_active_slave, bonding_store_active_slave);
1253 
 
1254 
 
1255 
/*
1256 
 * Show link status of the bond interface.
1257 
 */
1258 
static ssize_t bonding_show_mii_status(struct device *d,
1259 
                                       struct device_attribute *attr,
1260 
                                       char *buf)
1261 
{
1262 
        struct slave *curr;
1263 
        struct bonding *bond = to_bond(d);
1264 
 
1265 
        read_lock(&bond->curr_slave_lock);
1266 
        curr = bond->curr_active_slave;
1267 
        read_unlock(&bond->curr_slave_lock);
1268 
 
1269 
        return sprintf(buf, "%s\n", (curr) ? "up" : "down");
1270 
}
1271 
static DEVICE_ATTR(mii_status, S_IRUGO, bonding_show_mii_status, NULL);
1272 
 
1273 
 
1274 
/*
1275 
 * Show current 802.3ad aggregator ID.
1276 
 */
1277 
static ssize_t bonding_show_ad_aggregator(struct device *d,
1278 
                                          struct device_attribute *attr,
1279 
                                          char *buf)
1280 
{
1281 
        int count = 0;
1282 
        struct bonding *bond = to_bond(d);
1283 
 
1284 
        if (bond->params.mode == BOND_MODE_8023AD) {
1285 
                struct ad_info ad_info;
1286 
                count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0 : ad_info.aggregator_id);
1287 
        }
1288 
 
1289 
        return count;
1290 
}
1291 
static DEVICE_ATTR(ad_aggregator, S_IRUGO, bonding_show_ad_aggregator, NULL);
1292 
 
1293 
 
1294 
/*
1295 
 * Show number of active 802.3ad ports.
1296 
 */
1297 
static ssize_t bonding_show_ad_num_ports(struct device *d,
1298 
                                         struct device_attribute *attr,
1299 
                                         char *buf)
1300 
{
1301 
        int count = 0;
1302 
        struct bonding *bond = to_bond(d);
1303 
 
1304 
        if (bond->params.mode == BOND_MODE_8023AD) {
1305 
                struct ad_info ad_info;
1306 
                count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0: ad_info.ports);
1307 
        }
1308 
 
1309 
        return count;
1310 
}
1311 
static DEVICE_ATTR(ad_num_ports, S_IRUGO, bonding_show_ad_num_ports, NULL);
1312 
 
1313 
 
1314 
/*
1315 
 * Show current 802.3ad actor key.
1316 
 */
1317 
static ssize_t bonding_show_ad_actor_key(struct device *d,
1318 
                                         struct device_attribute *attr,
1319 
                                         char *buf)
1320 
{
1321 
        int count = 0;
1322 
        struct bonding *bond = to_bond(d);
1323 
 
1324 
        if (bond->params.mode == BOND_MODE_8023AD) {
1325 
                struct ad_info ad_info;
1326 
                count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0 : ad_info.actor_key);
1327 
        }
1328 
 
1329 
        return count;
1330 
}
1331 
static DEVICE_ATTR(ad_actor_key, S_IRUGO, bonding_show_ad_actor_key, NULL);
1332 
 
1333 
 
1334 
/*
1335 
 * Show current 802.3ad partner key.
1336 
 */
1337 
static ssize_t bonding_show_ad_partner_key(struct device *d,
1338 
                                           struct device_attribute *attr,
1339 
                                           char *buf)
1340 
{
1341 
        int count = 0;
1342 
        struct bonding *bond = to_bond(d);
1343 
 
1344 
        if (bond->params.mode == BOND_MODE_8023AD) {
1345 
                struct ad_info ad_info;
1346 
                count = sprintf(buf, "%d\n", (bond_3ad_get_active_agg_info(bond, &ad_info)) ?  0 : ad_info.partner_key);
1347 
        }
1348 
 
1349 
        return count;
1350 
}
1351 
static DEVICE_ATTR(ad_partner_key, S_IRUGO, bonding_show_ad_partner_key, NULL);
1352 
 
1353 
 
1354 
/*
1355 
 * Show current 802.3ad partner mac.
1356 
 */
1357 
static ssize_t bonding_show_ad_partner_mac(struct device *d,
1358 
                                           struct device_attribute *attr,
1359 
                                           char *buf)
1360 
{
1361 
        int count = 0;
1362 
        struct bonding *bond = to_bond(d);
1363 
        DECLARE_MAC_BUF(mac);
1364 
 
1365 
        if (bond->params.mode == BOND_MODE_8023AD) {
1366 
                struct ad_info ad_info;
1367 
                if (!bond_3ad_get_active_agg_info(bond, &ad_info)) {
1368 
                        count = sprintf(buf,"%s\n",
1369 
                                        print_mac(mac, ad_info.partner_system));
1370 
                }
1371 
        }
1372 
 
1373 
        return count;
1374 
}
1375 
static DEVICE_ATTR(ad_partner_mac, S_IRUGO, bonding_show_ad_partner_mac, NULL);
1376 
 
1377 
 
1378 
 
1379 
static struct attribute *per_bond_attrs[] = {
1380 
        &dev_attr_slaves.attr,
1381 
        &dev_attr_mode.attr,
1382 
        &dev_attr_fail_over_mac.attr,
1383 
        &dev_attr_arp_validate.attr,
1384 
        &dev_attr_arp_interval.attr,
1385 
        &dev_attr_arp_ip_target.attr,
1386 
        &dev_attr_downdelay.attr,
1387 
        &dev_attr_updelay.attr,
1388 
        &dev_attr_lacp_rate.attr,
1389 
        &dev_attr_xmit_hash_policy.attr,
1390 
        &dev_attr_miimon.attr,
1391 
        &dev_attr_primary.attr,
1392 
        &dev_attr_use_carrier.attr,
1393 
        &dev_attr_active_slave.attr,
1394 
        &dev_attr_mii_status.attr,
1395 
        &dev_attr_ad_aggregator.attr,
1396 
        &dev_attr_ad_num_ports.attr,
1397 
        &dev_attr_ad_actor_key.attr,
1398 
        &dev_attr_ad_partner_key.attr,
1399 
        &dev_attr_ad_partner_mac.attr,
1400 
        NULL,
1401 
};
1402 
 
1403 
static struct attribute_group bonding_group = {
1404 
        .name = "bonding",
1405 
        .attrs = per_bond_attrs,
1406 
};
1407 
 
1408 
/*
1409 
 * Initialize sysfs.  This sets up the bonding_masters file in
1410 
 * /sys/class/net.
1411 
 */
1412 
int bond_create_sysfs(void)
1413 
{
1414 
        int ret = 0;
1415 
        struct bonding *firstbond;
1416 
 
1417 
        /* get the netdev class pointer */
1418 
        firstbond = container_of(bond_dev_list.next, struct bonding, bond_list);
1419 
        if (!firstbond)
1420 
                return -ENODEV;
1421 
 
1422 
        netdev_class = firstbond->dev->dev.class;
1423 
        if (!netdev_class)
1424 
                return -ENODEV;
1425 
 
1426 
        ret = class_create_file(netdev_class, &class_attr_bonding_masters);
1427 
        /*
1428 
         * Permit multiple loads of the module by ignoring failures to
1429 
         * create the bonding_masters sysfs file.  Bonding devices
1430 
         * created by second or subsequent loads of the module will
1431 
         * not be listed in, or controllable by, bonding_masters, but
1432 
         * will have the usual "bonding" sysfs directory.
1433 
         *
1434 
         * This is done to preserve backwards compatibility for
1435 
         * initscripts/sysconfig, which load bonding multiple times to
1436 
         * configure multiple bonding devices.
1437 
         */
1438 
        if (ret == -EEXIST) {
1439 
                netdev_class = NULL;
1440 
                return 0;
1441 
        }
1442 
 
1443 
        return ret;
1444 
 
1445 
}
1446 
 
1447 
/*
1448 
 * Remove /sys/class/net/bonding_masters.
1449 
 */
1450 
void bond_destroy_sysfs(void)
1451 
{
1452 
        if (netdev_class)
1453 
                class_remove_file(netdev_class, &class_attr_bonding_masters);
1454 
}
1455 
 
1456 
/*
1457 
 * Initialize sysfs for each bond.  This sets up and registers
1458 
 * the 'bondctl' directory for each individual bond under /sys/class/net.
1459 
 */
1460 
int bond_create_sysfs_entry(struct bonding *bond)
1461 
{
1462 
        struct net_device *dev = bond->dev;
1463 
        int err;
1464 
 
1465 
        err = sysfs_create_group(&(dev->dev.kobj), &bonding_group);
1466 
        if (err) {
1467 
                printk(KERN_EMERG "eek! didn't create group!\n");
1468 
        }
1469 
 
1470 
        if (expected_refcount < 1)
1471 
                expected_refcount = atomic_read(&bond->dev->dev.kobj.kref.refcount);
1472 
 
1473 
        return err;
1474 
}
1475 
/*
1476 
 * Remove sysfs entries for each bond.
1477 
 */
1478 
void bond_destroy_sysfs_entry(struct bonding *bond)
1479 
{
1480 
        struct net_device *dev = bond->dev;
1481 
 
1482 
        sysfs_remove_group(&(dev->dev.kobj), &bonding_group);
1483 
}
1484 
 

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.