| 1 | /* |
| 2 | * Equalizer Load-balancer for serial network interfaces. |
| 3 | * |
| 4 | * (c) Copyright 1995 Simon "Guru Aleph-Null" Janes |
| 5 | * NCM: Network and Communications Management, Inc. |
| 6 | * |
| 7 | * (c) Copyright 2002 David S. Miller (davem@redhat.com) |
| 8 | * |
| 9 | * This software may be used and distributed according to the terms |
| 10 | * of the GNU General Public License, incorporated herein by reference. |
| 11 | * |
| 12 | * The author may be reached as simon@ncm.com, or C/O |
| 13 | * NCM |
| 14 | * Attn: Simon Janes |
| 15 | * 6803 Whittier Ave |
| 16 | * McLean VA 22101 |
| 17 | * Phone: 1-703-847-0040 ext 103 |
| 18 | */ |
| 19 | |
| 20 | /* |
| 21 | * Sources: |
| 22 | * skeleton.c by Donald Becker. |
| 23 | * Inspirations: |
| 24 | * The Harried and Overworked Alan Cox |
| 25 | * Conspiracies: |
| 26 | * The Alan Cox and Mike McLagan plot to get someone else to do the code, |
| 27 | * which turned out to be me. |
| 28 | */ |
| 29 | |
| 30 | /* |
| 31 | * $Log: eql.c,v $ |
| 32 | * Revision 1.2 1996/04/11 17:51:52 guru |
| 33 | * Added one-line eql_remove_slave patch. |
| 34 | * |
| 35 | * Revision 1.1 1996/04/11 17:44:17 guru |
| 36 | * Initial revision |
| 37 | * |
| 38 | * Revision 3.13 1996/01/21 15:17:18 alan |
| 39 | * tx_queue_len changes. |
| 40 | * reformatted. |
| 41 | * |
| 42 | * Revision 3.12 1995/03/22 21:07:51 anarchy |
| 43 | * Added capable() checks on configuration. |
| 44 | * Moved header file. |
| 45 | * |
| 46 | * Revision 3.11 1995/01/19 23:14:31 guru |
| 47 | * slave_load = (ULONG_MAX - (ULONG_MAX / 2)) - |
| 48 | * (priority_Bps) + bytes_queued * 8; |
| 49 | * |
| 50 | * Revision 3.10 1995/01/19 23:07:53 guru |
| 51 | * back to |
| 52 | * slave_load = (ULONG_MAX - (ULONG_MAX / 2)) - |
| 53 | * (priority_Bps) + bytes_queued; |
| 54 | * |
| 55 | * Revision 3.9 1995/01/19 22:38:20 guru |
| 56 | * slave_load = (ULONG_MAX - (ULONG_MAX / 2)) - |
| 57 | * (priority_Bps) + bytes_queued * 4; |
| 58 | * |
| 59 | * Revision 3.8 1995/01/19 22:30:55 guru |
| 60 | * slave_load = (ULONG_MAX - (ULONG_MAX / 2)) - |
| 61 | * (priority_Bps) + bytes_queued * 2; |
| 62 | * |
| 63 | * Revision 3.7 1995/01/19 21:52:35 guru |
| 64 | * printk's trimmed out. |
| 65 | * |
| 66 | * Revision 3.6 1995/01/19 21:49:56 guru |
| 67 | * This is working pretty well. I gained 1 K/s in speed.. now it's just |
| 68 | * robustness and printk's to be diked out. |
| 69 | * |
| 70 | * Revision 3.5 1995/01/18 22:29:59 guru |
| 71 | * still crashes the kernel when the lock_wait thing is woken up. |
| 72 | * |
| 73 | * Revision 3.4 1995/01/18 21:59:47 guru |
| 74 | * Broken set-bit locking snapshot |
| 75 | * |
| 76 | * Revision 3.3 1995/01/17 22:09:18 guru |
| 77 | * infinite sleep in a lock somewhere.. |
| 78 | * |
| 79 | * Revision 3.2 1995/01/15 16:46:06 guru |
| 80 | * Log trimmed of non-pertinent 1.x branch messages |
| 81 | * |
| 82 | * Revision 3.1 1995/01/15 14:41:45 guru |
| 83 | * New Scheduler and timer stuff... |
| 84 | * |
| 85 | * Revision 1.15 1995/01/15 14:29:02 guru |
| 86 | * Will make 1.14 (now 1.15) the 3.0 branch, and the 1.12 the 2.0 branch, the one |
| 87 | * with the dumber scheduler |
| 88 | * |
| 89 | * Revision 1.14 1995/01/15 02:37:08 guru |
| 90 | * shock.. the kept-new-versions could have zonked working |
| 91 | * stuff.. shudder |
| 92 | * |
| 93 | * Revision 1.13 1995/01/15 02:36:31 guru |
| 94 | * big changes |
| 95 | * |
| 96 | * scheduler was torn out and replaced with something smarter |
| 97 | * |
| 98 | * global names not prefixed with eql_ were renamed to protect |
| 99 | * against namespace collisions |
| 100 | * |
| 101 | * a few more abstract interfaces were added to facilitate any |
| 102 | * potential change of datastructure. the driver is still using |
| 103 | * a linked list of slaves. going to a heap would be a bit of |
| 104 | * an overkill. |
| 105 | * |
| 106 | * this compiles fine with no warnings. |
| 107 | * |
| 108 | * the locking mechanism and timer stuff must be written however, |
| 109 | * this version will not work otherwise |
| 110 | * |
| 111 | * Sorry, I had to rewrite most of this for 2.5.x -DaveM |
| 112 | */ |
| 113 | |
| 114 | #include <linux/module.h> |
| 115 | #include <linux/kernel.h> |
| 116 | #include <linux/init.h> |
| 117 | #include <linux/timer.h> |
| 118 | #include <linux/netdevice.h> |
| 119 | #include <net/net_namespace.h> |
| 120 | |
| 121 | #include <linux/if.h> |
| 122 | #include <linux/if_arp.h> |
| 123 | #include <linux/if_eql.h> |
| 124 | |
| 125 | #include <asm/uaccess.h> |
| 126 | |
| 127 | static int eql_open(struct net_device *dev); |
| 128 | static int eql_close(struct net_device *dev); |
| 129 | static int eql_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd); |
| 130 | static netdev_tx_t eql_slave_xmit(struct sk_buff *skb, struct net_device *dev); |
| 131 | |
| 132 | #define eql_is_slave(dev) ((dev->flags & IFF_SLAVE) == IFF_SLAVE) |
| 133 | #define eql_is_master(dev) ((dev->flags & IFF_MASTER) == IFF_MASTER) |
| 134 | |
| 135 | static void eql_kill_one_slave(slave_queue_t *queue, slave_t *slave); |
| 136 | |
| 137 | static void eql_timer(unsigned long param) |
| 138 | { |
| 139 | equalizer_t *eql = (equalizer_t *) param; |
| 140 | struct list_head *this, *tmp, *head; |
| 141 | |
| 142 | spin_lock_bh(&eql->queue.lock); |
| 143 | head = &eql->queue.all_slaves; |
| 144 | list_for_each_safe(this, tmp, head) { |
| 145 | slave_t *slave = list_entry(this, slave_t, list); |
| 146 | |
| 147 | if ((slave->dev->flags & IFF_UP) == IFF_UP) { |
| 148 | slave->bytes_queued -= slave->priority_Bps; |
| 149 | if (slave->bytes_queued < 0) |
| 150 | slave->bytes_queued = 0; |
| 151 | } else { |
| 152 | eql_kill_one_slave(&eql->queue, slave); |
| 153 | } |
| 154 | |
| 155 | } |
| 156 | spin_unlock_bh(&eql->queue.lock); |
| 157 | |
| 158 | eql->timer.expires = jiffies + EQL_DEFAULT_RESCHED_IVAL; |
| 159 | add_timer(&eql->timer); |
| 160 | } |
| 161 | |
| 162 | static const char version[] __initconst = |
| 163 | "Equalizer2002: Simon Janes (simon@ncm.com) and David S. Miller (davem@redhat.com)\n"; |
| 164 | |
| 165 | static const struct net_device_ops eql_netdev_ops = { |
| 166 | .ndo_open = eql_open, |
| 167 | .ndo_stop = eql_close, |
| 168 | .ndo_do_ioctl = eql_ioctl, |
| 169 | .ndo_start_xmit = eql_slave_xmit, |
| 170 | }; |
| 171 | |
| 172 | static void __init eql_setup(struct net_device *dev) |
| 173 | { |
| 174 | equalizer_t *eql = netdev_priv(dev); |
| 175 | |
| 176 | init_timer(&eql->timer); |
| 177 | eql->timer.data = (unsigned long) eql; |
| 178 | eql->timer.expires = jiffies + EQL_DEFAULT_RESCHED_IVAL; |
| 179 | eql->timer.function = eql_timer; |
| 180 | |
| 181 | spin_lock_init(&eql->queue.lock); |
| 182 | INIT_LIST_HEAD(&eql->queue.all_slaves); |
| 183 | eql->queue.master_dev = dev; |
| 184 | |
| 185 | dev->netdev_ops = &eql_netdev_ops; |
| 186 | |
| 187 | /* |
| 188 | * Now we undo some of the things that eth_setup does |
| 189 | * that we don't like |
| 190 | */ |
| 191 | |
| 192 | dev->mtu = EQL_DEFAULT_MTU; /* set to 576 in if_eql.h */ |
| 193 | dev->flags = IFF_MASTER; |
| 194 | |
| 195 | dev->type = ARPHRD_SLIP; |
| 196 | dev->tx_queue_len = 5; /* Hands them off fast */ |
| 197 | dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; |
| 198 | } |
| 199 | |
| 200 | static int eql_open(struct net_device *dev) |
| 201 | { |
| 202 | equalizer_t *eql = netdev_priv(dev); |
| 203 | |
| 204 | /* XXX We should force this off automatically for the user. */ |
| 205 | printk(KERN_INFO "%s: remember to turn off Van-Jacobson compression on " |
| 206 | "your slave devices.\n", dev->name); |
| 207 | |
| 208 | BUG_ON(!list_empty(&eql->queue.all_slaves)); |
| 209 | |
| 210 | eql->min_slaves = 1; |
| 211 | eql->max_slaves = EQL_DEFAULT_MAX_SLAVES; /* 4 usually... */ |
| 212 | |
| 213 | add_timer(&eql->timer); |
| 214 | |
| 215 | return 0; |
| 216 | } |
| 217 | |
| 218 | static void eql_kill_one_slave(slave_queue_t *queue, slave_t *slave) |
| 219 | { |
| 220 | list_del(&slave->list); |
| 221 | queue->num_slaves--; |
| 222 | slave->dev->flags &= ~IFF_SLAVE; |
| 223 | dev_put(slave->dev); |
| 224 | kfree(slave); |
| 225 | } |
| 226 | |
| 227 | static void eql_kill_slave_queue(slave_queue_t *queue) |
| 228 | { |
| 229 | struct list_head *head, *tmp, *this; |
| 230 | |
| 231 | spin_lock_bh(&queue->lock); |
| 232 | |
| 233 | head = &queue->all_slaves; |
| 234 | list_for_each_safe(this, tmp, head) { |
| 235 | slave_t *s = list_entry(this, slave_t, list); |
| 236 | |
| 237 | eql_kill_one_slave(queue, s); |
| 238 | } |
| 239 | |
| 240 | spin_unlock_bh(&queue->lock); |
| 241 | } |
| 242 | |
| 243 | static int eql_close(struct net_device *dev) |
| 244 | { |
| 245 | equalizer_t *eql = netdev_priv(dev); |
| 246 | |
| 247 | /* |
| 248 | * The timer has to be stopped first before we start hacking away |
| 249 | * at the data structure it scans every so often... |
| 250 | */ |
| 251 | |
| 252 | del_timer_sync(&eql->timer); |
| 253 | |
| 254 | eql_kill_slave_queue(&eql->queue); |
| 255 | |
| 256 | return 0; |
| 257 | } |
| 258 | |
| 259 | static int eql_enslave(struct net_device *dev, slaving_request_t __user *srq); |
| 260 | static int eql_emancipate(struct net_device *dev, slaving_request_t __user *srq); |
| 261 | |
| 262 | static int eql_g_slave_cfg(struct net_device *dev, slave_config_t __user *sc); |
| 263 | static int eql_s_slave_cfg(struct net_device *dev, slave_config_t __user *sc); |
| 264 | |
| 265 | static int eql_g_master_cfg(struct net_device *dev, master_config_t __user *mc); |
| 266 | static int eql_s_master_cfg(struct net_device *dev, master_config_t __user *mc); |
| 267 | |
| 268 | static int eql_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) |
| 269 | { |
| 270 | if (cmd != EQL_GETMASTRCFG && cmd != EQL_GETSLAVECFG && |
| 271 | !capable(CAP_NET_ADMIN)) |
| 272 | return -EPERM; |
| 273 | |
| 274 | switch (cmd) { |
| 275 | case EQL_ENSLAVE: |
| 276 | return eql_enslave(dev, ifr->ifr_data); |
| 277 | case EQL_EMANCIPATE: |
| 278 | return eql_emancipate(dev, ifr->ifr_data); |
| 279 | case EQL_GETSLAVECFG: |
| 280 | return eql_g_slave_cfg(dev, ifr->ifr_data); |
| 281 | case EQL_SETSLAVECFG: |
| 282 | return eql_s_slave_cfg(dev, ifr->ifr_data); |
| 283 | case EQL_GETMASTRCFG: |
| 284 | return eql_g_master_cfg(dev, ifr->ifr_data); |
| 285 | case EQL_SETMASTRCFG: |
| 286 | return eql_s_master_cfg(dev, ifr->ifr_data); |
| 287 | default: |
| 288 | return -EOPNOTSUPP; |
| 289 | }; |
| 290 | } |
| 291 | |
| 292 | /* queue->lock must be held */ |
| 293 | static slave_t *__eql_schedule_slaves(slave_queue_t *queue) |
| 294 | { |
| 295 | unsigned long best_load = ~0UL; |
| 296 | struct list_head *this, *tmp, *head; |
| 297 | slave_t *best_slave; |
| 298 | |
| 299 | best_slave = NULL; |
| 300 | |
| 301 | /* Make a pass to set the best slave. */ |
| 302 | head = &queue->all_slaves; |
| 303 | list_for_each_safe(this, tmp, head) { |
| 304 | slave_t *slave = list_entry(this, slave_t, list); |
| 305 | unsigned long slave_load, bytes_queued, priority_Bps; |
| 306 | |
| 307 | /* Go through the slave list once, updating best_slave |
| 308 | * whenever a new best_load is found. |
| 309 | */ |
| 310 | bytes_queued = slave->bytes_queued; |
| 311 | priority_Bps = slave->priority_Bps; |
| 312 | if ((slave->dev->flags & IFF_UP) == IFF_UP) { |
| 313 | slave_load = (~0UL - (~0UL / 2)) - |
| 314 | (priority_Bps) + bytes_queued * 8; |
| 315 | |
| 316 | if (slave_load < best_load) { |
| 317 | best_load = slave_load; |
| 318 | best_slave = slave; |
| 319 | } |
| 320 | } else { |
| 321 | /* We found a dead slave, kill it. */ |
| 322 | eql_kill_one_slave(queue, slave); |
| 323 | } |
| 324 | } |
| 325 | return best_slave; |
| 326 | } |
| 327 | |
| 328 | static netdev_tx_t eql_slave_xmit(struct sk_buff *skb, struct net_device *dev) |
| 329 | { |
| 330 | equalizer_t *eql = netdev_priv(dev); |
| 331 | slave_t *slave; |
| 332 | |
| 333 | spin_lock(&eql->queue.lock); |
| 334 | |
| 335 | slave = __eql_schedule_slaves(&eql->queue); |
| 336 | if (slave) { |
| 337 | struct net_device *slave_dev = slave->dev; |
| 338 | |
| 339 | skb->dev = slave_dev; |
| 340 | skb->priority = 1; |
| 341 | slave->bytes_queued += skb->len; |
| 342 | dev_queue_xmit(skb); |
| 343 | dev->stats.tx_packets++; |
| 344 | } else { |
| 345 | dev->stats.tx_dropped++; |
| 346 | dev_kfree_skb(skb); |
| 347 | } |
| 348 | |
| 349 | spin_unlock(&eql->queue.lock); |
| 350 | |
| 351 | return NETDEV_TX_OK; |
| 352 | } |
| 353 | |
| 354 | /* |
| 355 | * Private ioctl functions |
| 356 | */ |
| 357 | |
| 358 | /* queue->lock must be held */ |
| 359 | static slave_t *__eql_find_slave_dev(slave_queue_t *queue, struct net_device *dev) |
| 360 | { |
| 361 | struct list_head *this, *head; |
| 362 | |
| 363 | head = &queue->all_slaves; |
| 364 | list_for_each(this, head) { |
| 365 | slave_t *slave = list_entry(this, slave_t, list); |
| 366 | |
| 367 | if (slave->dev == dev) |
| 368 | return slave; |
| 369 | } |
| 370 | |
| 371 | return NULL; |
| 372 | } |
| 373 | |
| 374 | static inline int eql_is_full(slave_queue_t *queue) |
| 375 | { |
| 376 | equalizer_t *eql = netdev_priv(queue->master_dev); |
| 377 | |
| 378 | if (queue->num_slaves >= eql->max_slaves) |
| 379 | return 1; |
| 380 | return 0; |
| 381 | } |
| 382 | |
| 383 | /* queue->lock must be held */ |
| 384 | static int __eql_insert_slave(slave_queue_t *queue, slave_t *slave) |
| 385 | { |
| 386 | if (!eql_is_full(queue)) { |
| 387 | slave_t *duplicate_slave = NULL; |
| 388 | |
| 389 | duplicate_slave = __eql_find_slave_dev(queue, slave->dev); |
| 390 | if (duplicate_slave) |
| 391 | eql_kill_one_slave(queue, duplicate_slave); |
| 392 | |
| 393 | list_add(&slave->list, &queue->all_slaves); |
| 394 | queue->num_slaves++; |
| 395 | slave->dev->flags |= IFF_SLAVE; |
| 396 | |
| 397 | return 0; |
| 398 | } |
| 399 | |
| 400 | return -ENOSPC; |
| 401 | } |
| 402 | |
| 403 | static int eql_enslave(struct net_device *master_dev, slaving_request_t __user *srqp) |
| 404 | { |
| 405 | struct net_device *slave_dev; |
| 406 | slaving_request_t srq; |
| 407 | |
| 408 | if (copy_from_user(&srq, srqp, sizeof (slaving_request_t))) |
| 409 | return -EFAULT; |
| 410 | |
| 411 | slave_dev = dev_get_by_name(&init_net, srq.slave_name); |
| 412 | if (slave_dev) { |
| 413 | if ((master_dev->flags & IFF_UP) == IFF_UP) { |
| 414 | /* slave is not a master & not already a slave: */ |
| 415 | if (!eql_is_master(slave_dev) && |
| 416 | !eql_is_slave(slave_dev)) { |
| 417 | slave_t *s = kmalloc(sizeof(*s), GFP_KERNEL); |
| 418 | equalizer_t *eql = netdev_priv(master_dev); |
| 419 | int ret; |
| 420 | |
| 421 | if (!s) { |
| 422 | dev_put(slave_dev); |
| 423 | return -ENOMEM; |
| 424 | } |
| 425 | |
| 426 | memset(s, 0, sizeof(*s)); |
| 427 | s->dev = slave_dev; |
| 428 | s->priority = srq.priority; |
| 429 | s->priority_bps = srq.priority; |
| 430 | s->priority_Bps = srq.priority / 8; |
| 431 | |
| 432 | spin_lock_bh(&eql->queue.lock); |
| 433 | ret = __eql_insert_slave(&eql->queue, s); |
| 434 | if (ret) { |
| 435 | dev_put(slave_dev); |
| 436 | kfree(s); |
| 437 | } |
| 438 | spin_unlock_bh(&eql->queue.lock); |
| 439 | |
| 440 | return ret; |
| 441 | } |
| 442 | } |
| 443 | dev_put(slave_dev); |
| 444 | } |
| 445 | |
| 446 | return -EINVAL; |
| 447 | } |
| 448 | |
| 449 | static int eql_emancipate(struct net_device *master_dev, slaving_request_t __user *srqp) |
| 450 | { |
| 451 | equalizer_t *eql = netdev_priv(master_dev); |
| 452 | struct net_device *slave_dev; |
| 453 | slaving_request_t srq; |
| 454 | int ret; |
| 455 | |
| 456 | if (copy_from_user(&srq, srqp, sizeof (slaving_request_t))) |
| 457 | return -EFAULT; |
| 458 | |
| 459 | slave_dev = dev_get_by_name(&init_net, srq.slave_name); |
| 460 | ret = -EINVAL; |
| 461 | if (slave_dev) { |
| 462 | spin_lock_bh(&eql->queue.lock); |
| 463 | |
| 464 | if (eql_is_slave(slave_dev)) { |
| 465 | slave_t *slave = __eql_find_slave_dev(&eql->queue, |
| 466 | slave_dev); |
| 467 | |
| 468 | if (slave) { |
| 469 | eql_kill_one_slave(&eql->queue, slave); |
| 470 | ret = 0; |
| 471 | } |
| 472 | } |
| 473 | dev_put(slave_dev); |
| 474 | |
| 475 | spin_unlock_bh(&eql->queue.lock); |
| 476 | } |
| 477 | |
| 478 | return ret; |
| 479 | } |
| 480 | |
| 481 | static int eql_g_slave_cfg(struct net_device *dev, slave_config_t __user *scp) |
| 482 | { |
| 483 | equalizer_t *eql = netdev_priv(dev); |
| 484 | slave_t *slave; |
| 485 | struct net_device *slave_dev; |
| 486 | slave_config_t sc; |
| 487 | int ret; |
| 488 | |
| 489 | if (copy_from_user(&sc, scp, sizeof (slave_config_t))) |
| 490 | return -EFAULT; |
| 491 | |
| 492 | slave_dev = dev_get_by_name(&init_net, sc.slave_name); |
| 493 | if (!slave_dev) |
| 494 | return -ENODEV; |
| 495 | |
| 496 | ret = -EINVAL; |
| 497 | |
| 498 | spin_lock_bh(&eql->queue.lock); |
| 499 | if (eql_is_slave(slave_dev)) { |
| 500 | slave = __eql_find_slave_dev(&eql->queue, slave_dev); |
| 501 | if (slave) { |
| 502 | sc.priority = slave->priority; |
| 503 | ret = 0; |
| 504 | } |
| 505 | } |
| 506 | spin_unlock_bh(&eql->queue.lock); |
| 507 | |
| 508 | dev_put(slave_dev); |
| 509 | |
| 510 | if (!ret && copy_to_user(scp, &sc, sizeof (slave_config_t))) |
| 511 | ret = -EFAULT; |
| 512 | |
| 513 | return ret; |
| 514 | } |
| 515 | |
| 516 | static int eql_s_slave_cfg(struct net_device *dev, slave_config_t __user *scp) |
| 517 | { |
| 518 | slave_t *slave; |
| 519 | equalizer_t *eql; |
| 520 | struct net_device *slave_dev; |
| 521 | slave_config_t sc; |
| 522 | int ret; |
| 523 | |
| 524 | if (copy_from_user(&sc, scp, sizeof (slave_config_t))) |
| 525 | return -EFAULT; |
| 526 | |
| 527 | slave_dev = dev_get_by_name(&init_net, sc.slave_name); |
| 528 | if (!slave_dev) |
| 529 | return -ENODEV; |
| 530 | |
| 531 | ret = -EINVAL; |
| 532 | |
| 533 | eql = netdev_priv(dev); |
| 534 | spin_lock_bh(&eql->queue.lock); |
| 535 | if (eql_is_slave(slave_dev)) { |
| 536 | slave = __eql_find_slave_dev(&eql->queue, slave_dev); |
| 537 | if (slave) { |
| 538 | slave->priority = sc.priority; |
| 539 | slave->priority_bps = sc.priority; |
| 540 | slave->priority_Bps = sc.priority / 8; |
| 541 | ret = 0; |
| 542 | } |
| 543 | } |
| 544 | spin_unlock_bh(&eql->queue.lock); |
| 545 | |
| 546 | dev_put(slave_dev); |
| 547 | |
| 548 | return ret; |
| 549 | } |
| 550 | |
| 551 | static int eql_g_master_cfg(struct net_device *dev, master_config_t __user *mcp) |
| 552 | { |
| 553 | equalizer_t *eql; |
| 554 | master_config_t mc; |
| 555 | |
| 556 | if (eql_is_master(dev)) { |
| 557 | eql = netdev_priv(dev); |
| 558 | mc.max_slaves = eql->max_slaves; |
| 559 | mc.min_slaves = eql->min_slaves; |
| 560 | if (copy_to_user(mcp, &mc, sizeof (master_config_t))) |
| 561 | return -EFAULT; |
| 562 | return 0; |
| 563 | } |
| 564 | return -EINVAL; |
| 565 | } |
| 566 | |
| 567 | static int eql_s_master_cfg(struct net_device *dev, master_config_t __user *mcp) |
| 568 | { |
| 569 | equalizer_t *eql; |
| 570 | master_config_t mc; |
| 571 | |
| 572 | if (copy_from_user(&mc, mcp, sizeof (master_config_t))) |
| 573 | return -EFAULT; |
| 574 | |
| 575 | if (eql_is_master(dev)) { |
| 576 | eql = netdev_priv(dev); |
| 577 | eql->max_slaves = mc.max_slaves; |
| 578 | eql->min_slaves = mc.min_slaves; |
| 579 | return 0; |
| 580 | } |
| 581 | return -EINVAL; |
| 582 | } |
| 583 | |
| 584 | static struct net_device *dev_eql; |
| 585 | |
| 586 | static int __init eql_init_module(void) |
| 587 | { |
| 588 | int err; |
| 589 | |
| 590 | printk(version); |
| 591 | |
| 592 | dev_eql = alloc_netdev(sizeof(equalizer_t), "eql", eql_setup); |
| 593 | if (!dev_eql) |
| 594 | return -ENOMEM; |
| 595 | |
| 596 | err = register_netdev(dev_eql); |
| 597 | if (err) |
| 598 | free_netdev(dev_eql); |
| 599 | return err; |
| 600 | } |
| 601 | |
| 602 | static void __exit eql_cleanup_module(void) |
| 603 | { |
| 604 | unregister_netdev(dev_eql); |
| 605 | free_netdev(dev_eql); |
| 606 | } |
| 607 | |
| 608 | module_init(eql_init_module); |
| 609 | module_exit(eql_cleanup_module); |
| 610 | MODULE_LICENSE("GPL"); |