Root/target/linux/generic-2.6/files/drivers/net/phy/swconfig.c

1/*
2 * swconfig.c: Switch configuration API
3 *
4 * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 */
16
17#include <linux/types.h>
18#include <linux/module.h>
19#include <linux/init.h>
20#include <linux/list.h>
21#include <linux/if.h>
22#include <linux/if_ether.h>
23#include <linux/capability.h>
24#include <linux/skbuff.h>
25#include <linux/switch.h>
26
27//#define DEBUG 1
28#ifdef DEBUG
29#define DPRINTF(format, ...) printk("%s: " format, __func__, ##__VA_ARGS__)
30#else
31#define DPRINTF(...) do {} while(0)
32#endif
33
34MODULE_AUTHOR("Felix Fietkau <nbd@openwrt.org>");
35MODULE_LICENSE("GPL");
36
37static int swdev_id = 0;
38static struct list_head swdevs;
39static spinlock_t swdevs_lock = SPIN_LOCK_UNLOCKED;
40struct swconfig_callback;
41
42struct swconfig_callback
43{
44    struct sk_buff *msg;
45    struct genlmsghdr *hdr;
46    struct genl_info *info;
47    int cmd;
48
49    /* callback for filling in the message data */
50    int (*fill)(struct swconfig_callback *cb, void *arg);
51
52    /* callback for closing the message before sending it */
53    int (*close)(struct swconfig_callback *cb, void *arg);
54
55    struct nlattr *nest[4];
56    int args[4];
57};
58
59/* defaults */
60
61static int
62swconfig_get_vlan_ports(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
63{
64    int ret;
65    if (val->port_vlan >= dev->vlans)
66        return -EINVAL;
67
68    if (!dev->ops->get_vlan_ports)
69        return -EOPNOTSUPP;
70
71    ret = dev->ops->get_vlan_ports(dev, val);
72    return ret;
73}
74
75static int
76swconfig_set_vlan_ports(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
77{
78    struct switch_port *ports = val->value.ports;
79    const struct switch_dev_ops *ops = dev->ops;
80    int i;
81
82    if (val->port_vlan >= dev->vlans)
83        return -EINVAL;
84
85    /* validate ports */
86    if (val->len > dev->ports)
87        return -EINVAL;
88
89    if (!ops->set_vlan_ports)
90        return -EOPNOTSUPP;
91
92    for (i = 0; i < val->len; i++) {
93        if (ports[i].id >= dev->ports)
94            return -EINVAL;
95
96        if (ops->set_port_pvid &&
97            !(ports[i].flags & (1 << SWITCH_PORT_FLAG_TAGGED)))
98            ops->set_port_pvid(dev, ports[i].id, val->port_vlan);
99    }
100
101    return ops->set_vlan_ports(dev, val);
102}
103
104static int
105swconfig_set_pvid(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
106{
107    if (val->port_vlan >= dev->ports)
108        return -EINVAL;
109
110    if (!dev->ops->set_port_pvid)
111        return -EOPNOTSUPP;
112
113    return dev->ops->set_port_pvid(dev, val->port_vlan, val->value.i);
114}
115
116static int
117swconfig_get_pvid(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
118{
119    if (val->port_vlan >= dev->ports)
120        return -EINVAL;
121
122    if (!dev->ops->get_port_pvid)
123        return -EOPNOTSUPP;
124
125    return dev->ops->get_port_pvid(dev, val->port_vlan, &val->value.i);
126}
127
128static int
129swconfig_apply_config(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
130{
131    /* don't complain if not supported by the switch driver */
132    if (!dev->ops->apply_config)
133        return 0;
134
135    return dev->ops->apply_config(dev);
136}
137
138static int
139swconfig_reset_switch(struct switch_dev *dev, const struct switch_attr *attr, struct switch_val *val)
140{
141    /* don't complain if not supported by the switch driver */
142    if (!dev->ops->reset_switch)
143        return 0;
144
145    return dev->ops->reset_switch(dev);
146}
147
148enum global_defaults {
149    GLOBAL_APPLY,
150    GLOBAL_RESET,
151};
152
153enum vlan_defaults {
154    VLAN_PORTS,
155};
156
157enum port_defaults {
158    PORT_PVID,
159};
160
161static struct switch_attr default_global[] = {
162    [GLOBAL_APPLY] = {
163        .type = SWITCH_TYPE_NOVAL,
164        .name = "apply",
165        .description = "Activate changes in the hardware",
166        .set = swconfig_apply_config,
167    },
168    [GLOBAL_RESET] = {
169        .type = SWITCH_TYPE_NOVAL,
170        .name = "reset",
171        .description = "Reset the switch",
172        .set = swconfig_reset_switch,
173    }
174};
175
176static struct switch_attr default_port[] = {
177    [PORT_PVID] = {
178        .type = SWITCH_TYPE_INT,
179        .name = "pvid",
180        .description = "Primary VLAN ID",
181        .set = swconfig_set_pvid,
182        .get = swconfig_get_pvid,
183    }
184};
185
186static struct switch_attr default_vlan[] = {
187    [VLAN_PORTS] = {
188        .type = SWITCH_TYPE_PORTS,
189        .name = "ports",
190        .description = "VLAN port mapping",
191        .set = swconfig_set_vlan_ports,
192        .get = swconfig_get_vlan_ports,
193    },
194};
195
196
197static void swconfig_defaults_init(struct switch_dev *dev)
198{
199    const struct switch_dev_ops *ops = dev->ops;
200
201    dev->def_global = 0;
202    dev->def_vlan = 0;
203    dev->def_port = 0;
204
205    if (ops->get_vlan_ports || ops->set_vlan_ports)
206        set_bit(VLAN_PORTS, &dev->def_vlan);
207
208    if (ops->get_port_pvid || ops->set_port_pvid)
209        set_bit(PORT_PVID, &dev->def_port);
210
211    /* always present, can be no-op */
212    set_bit(GLOBAL_APPLY, &dev->def_global);
213    set_bit(GLOBAL_RESET, &dev->def_global);
214}
215
216
217static struct genl_family switch_fam = {
218    .id = GENL_ID_GENERATE,
219    .name = "switch",
220    .hdrsize = 0,
221    .version = 1,
222    .maxattr = SWITCH_ATTR_MAX,
223};
224
225static const struct nla_policy switch_policy[SWITCH_ATTR_MAX+1] = {
226    [SWITCH_ATTR_ID] = { .type = NLA_U32 },
227    [SWITCH_ATTR_OP_ID] = { .type = NLA_U32 },
228    [SWITCH_ATTR_OP_PORT] = { .type = NLA_U32 },
229    [SWITCH_ATTR_OP_VLAN] = { .type = NLA_U32 },
230    [SWITCH_ATTR_OP_VALUE_INT] = { .type = NLA_U32 },
231    [SWITCH_ATTR_OP_VALUE_STR] = { .type = NLA_NUL_STRING },
232    [SWITCH_ATTR_OP_VALUE_PORTS] = { .type = NLA_NESTED },
233    [SWITCH_ATTR_TYPE] = { .type = NLA_U32 },
234};
235
236static const struct nla_policy port_policy[SWITCH_PORT_ATTR_MAX+1] = {
237    [SWITCH_PORT_ID] = { .type = NLA_U32 },
238    [SWITCH_PORT_FLAG_TAGGED] = { .type = NLA_FLAG },
239};
240
241static inline void
242swconfig_lock(void)
243{
244    spin_lock(&swdevs_lock);
245}
246
247static inline void
248swconfig_unlock(void)
249{
250    spin_unlock(&swdevs_lock);
251}
252
253static struct switch_dev *
254swconfig_get_dev(struct genl_info *info)
255{
256    struct switch_dev *dev = NULL;
257    struct switch_dev *p;
258    int id;
259
260    if (!info->attrs[SWITCH_ATTR_ID])
261        goto done;
262
263    id = nla_get_u32(info->attrs[SWITCH_ATTR_ID]);
264    swconfig_lock();
265    list_for_each_entry(p, &swdevs, dev_list) {
266        if (id != p->id)
267            continue;
268
269        dev = p;
270        break;
271    }
272    if (dev)
273        spin_lock(&dev->lock);
274    else
275        DPRINTF("device %d not found\n", id);
276    swconfig_unlock();
277done:
278    return dev;
279}
280
281static inline void
282swconfig_put_dev(struct switch_dev *dev)
283{
284    spin_unlock(&dev->lock);
285}
286
287static int
288swconfig_dump_attr(struct swconfig_callback *cb, void *arg)
289{
290    struct switch_attr *op = arg;
291    struct genl_info *info = cb->info;
292    struct sk_buff *msg = cb->msg;
293    int id = cb->args[0];
294    void *hdr;
295
296    hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, &switch_fam,
297            NLM_F_MULTI, SWITCH_CMD_NEW_ATTR);
298    if (IS_ERR(hdr))
299        return -1;
300
301    NLA_PUT_U32(msg, SWITCH_ATTR_OP_ID, id);
302    NLA_PUT_U32(msg, SWITCH_ATTR_OP_TYPE, op->type);
303    NLA_PUT_STRING(msg, SWITCH_ATTR_OP_NAME, op->name);
304    if (op->description)
305        NLA_PUT_STRING(msg, SWITCH_ATTR_OP_DESCRIPTION,
306            op->description);
307
308    return genlmsg_end(msg, hdr);
309nla_put_failure:
310    genlmsg_cancel(msg, hdr);
311    return -EMSGSIZE;
312}
313
314/* spread multipart messages across multiple message buffers */
315static int
316swconfig_send_multipart(struct swconfig_callback *cb, void *arg)
317{
318    struct genl_info *info = cb->info;
319    int restart = 0;
320    int err;
321
322    do {
323        if (!cb->msg) {
324            cb->msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
325            if (cb->msg == NULL)
326                goto error;
327        }
328
329        if (!(cb->fill(cb, arg) < 0))
330            break;
331
332        /* fill failed, check if this was already the second attempt */
333        if (restart)
334            goto error;
335
336        /* try again in a new message, send the current one */
337        restart = 1;
338        if (cb->close) {
339            if (cb->close(cb, arg) < 0)
340                goto error;
341        }
342        err = genlmsg_reply(cb->msg, info);
343        cb->msg = NULL;
344        if (err < 0)
345            goto error;
346
347    } while (restart);
348
349    return 0;
350
351error:
352    if (cb->msg)
353        nlmsg_free(cb->msg);
354    return -1;
355}
356
357static int
358swconfig_list_attrs(struct sk_buff *skb, struct genl_info *info)
359{
360    struct genlmsghdr *hdr = nlmsg_data(info->nlhdr);
361    const struct switch_attrlist *alist;
362    struct switch_dev *dev;
363    struct swconfig_callback cb;
364    int err = -EINVAL;
365    int i;
366
367    /* defaults */
368    struct switch_attr *def_list;
369    unsigned long *def_active;
370    int n_def;
371
372    dev = swconfig_get_dev(info);
373    if (!dev)
374        return -EINVAL;
375
376    switch(hdr->cmd) {
377    case SWITCH_CMD_LIST_GLOBAL:
378        alist = &dev->ops->attr_global;
379        def_list = default_global;
380        def_active = &dev->def_global;
381        n_def = ARRAY_SIZE(default_global);
382        break;
383    case SWITCH_CMD_LIST_VLAN:
384        alist = &dev->ops->attr_vlan;
385        def_list = default_vlan;
386        def_active = &dev->def_vlan;
387        n_def = ARRAY_SIZE(default_vlan);
388        break;
389    case SWITCH_CMD_LIST_PORT:
390        alist = &dev->ops->attr_port;
391        def_list = default_port;
392        def_active = &dev->def_port;
393        n_def = ARRAY_SIZE(default_port);
394        break;
395    default:
396        WARN_ON(1);
397        goto out;
398    }
399
400    memset(&cb, 0, sizeof(cb));
401    cb.info = info;
402    cb.fill = swconfig_dump_attr;
403    for (i = 0; i < alist->n_attr; i++) {
404        if (alist->attr[i].disabled)
405            continue;
406        cb.args[0] = i;
407        err = swconfig_send_multipart(&cb, (void *) &alist->attr[i]);
408        if (err < 0)
409            goto error;
410    }
411
412    /* defaults */
413    for (i = 0; i < n_def; i++) {
414        if (!test_bit(i, def_active))
415            continue;
416        cb.args[0] = SWITCH_ATTR_DEFAULTS_OFFSET + i;
417        err = swconfig_send_multipart(&cb, (void *) &def_list[i]);
418        if (err < 0)
419            goto error;
420    }
421    swconfig_put_dev(dev);
422
423    if (!cb.msg)
424        return 0;
425
426    return genlmsg_reply(cb.msg, info);
427
428error:
429    if (cb.msg)
430        nlmsg_free(cb.msg);
431out:
432    swconfig_put_dev(dev);
433    return err;
434}
435
436static const struct switch_attr *
437swconfig_lookup_attr(struct switch_dev *dev, struct genl_info *info,
438        struct switch_val *val)
439{
440    struct genlmsghdr *hdr = nlmsg_data(info->nlhdr);
441    const struct switch_attrlist *alist;
442    const struct switch_attr *attr = NULL;
443    int attr_id;
444
445    /* defaults */
446    struct switch_attr *def_list;
447    unsigned long *def_active;
448    int n_def;
449
450    if (!info->attrs[SWITCH_ATTR_OP_ID])
451        goto done;
452
453    switch(hdr->cmd) {
454    case SWITCH_CMD_SET_GLOBAL:
455    case SWITCH_CMD_GET_GLOBAL:
456        alist = &dev->ops->attr_global;
457        def_list = default_global;
458        def_active = &dev->def_global;
459        n_def = ARRAY_SIZE(default_global);
460        break;
461    case SWITCH_CMD_SET_VLAN:
462    case SWITCH_CMD_GET_VLAN:
463        alist = &dev->ops->attr_vlan;
464        def_list = default_vlan;
465        def_active = &dev->def_vlan;
466        n_def = ARRAY_SIZE(default_vlan);
467        if (!info->attrs[SWITCH_ATTR_OP_VLAN])
468            goto done;
469        val->port_vlan = nla_get_u32(info->attrs[SWITCH_ATTR_OP_VLAN]);
470        if (val->port_vlan >= dev->vlans)
471            goto done;
472        break;
473    case SWITCH_CMD_SET_PORT:
474    case SWITCH_CMD_GET_PORT:
475        alist = &dev->ops->attr_port;
476        def_list = default_port;
477        def_active = &dev->def_port;
478        n_def = ARRAY_SIZE(default_port);
479        if (!info->attrs[SWITCH_ATTR_OP_PORT])
480            goto done;
481        val->port_vlan = nla_get_u32(info->attrs[SWITCH_ATTR_OP_PORT]);
482        if (val->port_vlan >= dev->ports)
483            goto done;
484        break;
485    default:
486        WARN_ON(1);
487        goto done;
488    }
489
490    if (!alist)
491        goto done;
492
493    attr_id = nla_get_u32(info->attrs[SWITCH_ATTR_OP_ID]);
494    if (attr_id >= SWITCH_ATTR_DEFAULTS_OFFSET) {
495        attr_id -= SWITCH_ATTR_DEFAULTS_OFFSET;
496        if (attr_id >= n_def)
497            goto done;
498        if (!test_bit(attr_id, def_active))
499            goto done;
500        attr = &def_list[attr_id];
501    } else {
502        if (attr_id >= alist->n_attr)
503            goto done;
504        attr = &alist->attr[attr_id];
505    }
506
507    if (attr->disabled)
508        attr = NULL;
509
510done:
511    if (!attr)
512        DPRINTF("attribute lookup failed\n");
513    val->attr = attr;
514    return attr;
515}
516
517static int
518swconfig_parse_ports(struct sk_buff *msg, struct nlattr *head,
519        struct switch_val *val, int max)
520{
521    struct nlattr *nla;
522    int rem;
523
524    val->len = 0;
525    nla_for_each_nested(nla, head, rem) {
526        struct nlattr *tb[SWITCH_PORT_ATTR_MAX+1];
527        struct switch_port *port = &val->value.ports[val->len];
528
529        if (val->len >= max)
530            return -EINVAL;
531
532        if (nla_parse_nested(tb, SWITCH_PORT_ATTR_MAX, nla,
533                port_policy))
534            return -EINVAL;
535
536        if (!tb[SWITCH_PORT_ID])
537            return -EINVAL;
538
539        port->id = nla_get_u32(tb[SWITCH_PORT_ID]);
540        if (tb[SWITCH_PORT_FLAG_TAGGED])
541            port->flags |= (1 << SWITCH_PORT_FLAG_TAGGED);
542        val->len++;
543    }
544
545    return 0;
546}
547
548static int
549swconfig_set_attr(struct sk_buff *skb, struct genl_info *info)
550{
551    const struct switch_attr *attr;
552    struct switch_dev *dev;
553    struct switch_val val;
554    int err = -EINVAL;
555
556    dev = swconfig_get_dev(info);
557    if (!dev)
558        return -EINVAL;
559
560    memset(&val, 0, sizeof(val));
561    attr = swconfig_lookup_attr(dev, info, &val);
562    if (!attr || !attr->set)
563        goto error;
564
565    val.attr = attr;
566    switch(attr->type) {
567    case SWITCH_TYPE_NOVAL:
568        break;
569    case SWITCH_TYPE_INT:
570        if (!info->attrs[SWITCH_ATTR_OP_VALUE_INT])
571            goto error;
572        val.value.i =
573            nla_get_u32(info->attrs[SWITCH_ATTR_OP_VALUE_INT]);
574        break;
575    case SWITCH_TYPE_STRING:
576        if (!info->attrs[SWITCH_ATTR_OP_VALUE_STR])
577            goto error;
578        val.value.s =
579            nla_data(info->attrs[SWITCH_ATTR_OP_VALUE_STR]);
580        break;
581    case SWITCH_TYPE_PORTS:
582        val.value.ports = dev->portbuf;
583        memset(dev->portbuf, 0,
584            sizeof(struct switch_port) * dev->ports);
585
586        /* TODO: implement multipart? */
587        if (info->attrs[SWITCH_ATTR_OP_VALUE_PORTS]) {
588            err = swconfig_parse_ports(skb,
589                info->attrs[SWITCH_ATTR_OP_VALUE_PORTS], &val, dev->ports);
590            if (err < 0)
591                goto error;
592        } else {
593            val.len = 0;
594            err = 0;
595        }
596        break;
597    default:
598        goto error;
599    }
600
601    err = attr->set(dev, attr, &val);
602error:
603    swconfig_put_dev(dev);
604    return err;
605}
606
607static int
608swconfig_close_portlist(struct swconfig_callback *cb, void *arg)
609{
610    if (cb->nest[0])
611        nla_nest_end(cb->msg, cb->nest[0]);
612    return 0;
613}
614
615static int
616swconfig_send_port(struct swconfig_callback *cb, void *arg)
617{
618    const struct switch_port *port = arg;
619    struct nlattr *p = NULL;
620
621    if (!cb->nest[0]) {
622        cb->nest[0] = nla_nest_start(cb->msg, cb->cmd);
623        if (!cb->nest[0])
624            return -1;
625    }
626
627    p = nla_nest_start(cb->msg, SWITCH_ATTR_PORT);
628    if (!p)
629        goto error;
630
631    NLA_PUT_U32(cb->msg, SWITCH_PORT_ID, port->id);
632    if (port->flags & (1 << SWITCH_PORT_FLAG_TAGGED))
633        NLA_PUT_FLAG(cb->msg, SWITCH_PORT_FLAG_TAGGED);
634
635    nla_nest_end(cb->msg, p);
636    return 0;
637
638nla_put_failure:
639        nla_nest_cancel(cb->msg, p);
640error:
641    nla_nest_cancel(cb->msg, cb->nest[0]);
642    return -1;
643}
644
645static int
646swconfig_send_ports(struct sk_buff **msg, struct genl_info *info, int attr,
647        const struct switch_val *val)
648{
649    struct swconfig_callback cb;
650    int err = 0;
651    int i;
652
653    if (!val->value.ports)
654        return -EINVAL;
655
656    memset(&cb, 0, sizeof(cb));
657    cb.cmd = attr;
658    cb.msg = *msg;
659    cb.info = info;
660    cb.fill = swconfig_send_port;
661    cb.close = swconfig_close_portlist;
662
663    cb.nest[0] = nla_nest_start(cb.msg, cb.cmd);
664    for (i = 0; i < val->len; i++) {
665        err = swconfig_send_multipart(&cb, &val->value.ports[i]);
666        if (err)
667            goto done;
668    }
669    err = val->len;
670    swconfig_close_portlist(&cb, NULL);
671    *msg = cb.msg;
672
673done:
674    return err;
675}
676
677static int
678swconfig_get_attr(struct sk_buff *skb, struct genl_info *info)
679{
680    struct genlmsghdr *hdr = nlmsg_data(info->nlhdr);
681    const struct switch_attr *attr;
682    struct switch_dev *dev;
683    struct sk_buff *msg = NULL;
684    struct switch_val val;
685    int err = -EINVAL;
686    int cmd = hdr->cmd;
687
688    dev = swconfig_get_dev(info);
689    if (!dev)
690        return -EINVAL;
691
692    memset(&val, 0, sizeof(val));
693    attr = swconfig_lookup_attr(dev, info, &val);
694    if (!attr || !attr->get)
695        goto error;
696
697    if (attr->type == SWITCH_TYPE_PORTS) {
698        val.value.ports = dev->portbuf;
699        memset(dev->portbuf, 0,
700            sizeof(struct switch_port) * dev->ports);
701    }
702
703    err = attr->get(dev, attr, &val);
704    if (err)
705        goto error;
706
707    msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
708    if (!msg)
709        goto error;
710
711    hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq, &switch_fam,
712            0, cmd);
713    if (IS_ERR(hdr))
714        goto nla_put_failure;
715
716    switch(attr->type) {
717    case SWITCH_TYPE_INT:
718        NLA_PUT_U32(msg, SWITCH_ATTR_OP_VALUE_INT, val.value.i);
719        break;
720    case SWITCH_TYPE_STRING:
721        NLA_PUT_STRING(msg, SWITCH_ATTR_OP_VALUE_STR, val.value.s);
722        break;
723    case SWITCH_TYPE_PORTS:
724        err = swconfig_send_ports(&msg, info,
725                SWITCH_ATTR_OP_VALUE_PORTS, &val);
726        if (err < 0)
727            goto nla_put_failure;
728        break;
729    default:
730        DPRINTF("invalid type in attribute\n");
731        err = -EINVAL;
732        goto error;
733    }
734    err = genlmsg_end(msg, hdr);
735    if (err < 0)
736        goto nla_put_failure;
737
738    swconfig_put_dev(dev);
739    return genlmsg_reply(msg, info);
740
741nla_put_failure:
742    if (msg)
743        nlmsg_free(msg);
744error:
745    swconfig_put_dev(dev);
746    if (!err)
747        err = -ENOMEM;
748    return err;
749}
750
751static int
752swconfig_send_switch(struct sk_buff *msg, u32 pid, u32 seq, int flags,
753        const struct switch_dev *dev)
754{
755    void *hdr;
756
757    hdr = genlmsg_put(msg, pid, seq, &switch_fam, flags,
758            SWITCH_CMD_NEW_ATTR);
759    if (IS_ERR(hdr))
760        return -1;
761
762    NLA_PUT_U32(msg, SWITCH_ATTR_ID, dev->id);
763    NLA_PUT_STRING(msg, SWITCH_ATTR_NAME, dev->name);
764    NLA_PUT_STRING(msg, SWITCH_ATTR_DEV_NAME, dev->devname);
765    NLA_PUT_U32(msg, SWITCH_ATTR_VLANS, dev->vlans);
766    NLA_PUT_U32(msg, SWITCH_ATTR_PORTS, dev->ports);
767    NLA_PUT_U32(msg, SWITCH_ATTR_CPU_PORT, dev->cpu_port);
768
769    return genlmsg_end(msg, hdr);
770nla_put_failure:
771    genlmsg_cancel(msg, hdr);
772    return -EMSGSIZE;
773}
774
775static int swconfig_dump_switches(struct sk_buff *skb,
776        struct netlink_callback *cb)
777{
778    struct switch_dev *dev;
779    int start = cb->args[0];
780    int idx = 0;
781
782    swconfig_lock();
783    list_for_each_entry(dev, &swdevs, dev_list) {
784        if (++idx <= start)
785            continue;
786        if (swconfig_send_switch(skb, NETLINK_CB(cb->skb).pid,
787                cb->nlh->nlmsg_seq, NLM_F_MULTI,
788                dev) < 0)
789            break;
790    }
791    swconfig_unlock();
792    cb->args[0] = idx;
793
794    return skb->len;
795}
796
797static int
798swconfig_done(struct netlink_callback *cb)
799{
800    return 0;
801}
802
803static struct genl_ops swconfig_ops[] = {
804    {
805        .cmd = SWITCH_CMD_LIST_GLOBAL,
806        .doit = swconfig_list_attrs,
807        .policy = switch_policy,
808    },
809    {
810        .cmd = SWITCH_CMD_LIST_VLAN,
811        .doit = swconfig_list_attrs,
812        .policy = switch_policy,
813    },
814    {
815        .cmd = SWITCH_CMD_LIST_PORT,
816        .doit = swconfig_list_attrs,
817        .policy = switch_policy,
818    },
819    {
820        .cmd = SWITCH_CMD_GET_GLOBAL,
821        .doit = swconfig_get_attr,
822        .policy = switch_policy,
823    },
824    {
825        .cmd = SWITCH_CMD_GET_VLAN,
826        .doit = swconfig_get_attr,
827        .policy = switch_policy,
828    },
829    {
830        .cmd = SWITCH_CMD_GET_PORT,
831        .doit = swconfig_get_attr,
832        .policy = switch_policy,
833    },
834    {
835        .cmd = SWITCH_CMD_SET_GLOBAL,
836        .doit = swconfig_set_attr,
837        .policy = switch_policy,
838    },
839    {
840        .cmd = SWITCH_CMD_SET_VLAN,
841        .doit = swconfig_set_attr,
842        .policy = switch_policy,
843    },
844    {
845        .cmd = SWITCH_CMD_SET_PORT,
846        .doit = swconfig_set_attr,
847        .policy = switch_policy,
848    },
849    {
850        .cmd = SWITCH_CMD_GET_SWITCH,
851        .dumpit = swconfig_dump_switches,
852        .policy = switch_policy,
853        .done = swconfig_done,
854    }
855};
856
857int
858register_switch(struct switch_dev *dev, struct net_device *netdev)
859{
860    INIT_LIST_HEAD(&dev->dev_list);
861    if (netdev) {
862        dev->netdev = netdev;
863        if (!dev->devname)
864            dev->devname = netdev->name;
865    }
866    BUG_ON(!dev->devname);
867
868    if (dev->ports > 0) {
869        dev->portbuf = kzalloc(sizeof(struct switch_port) * dev->ports,
870                GFP_KERNEL);
871        if (!dev->portbuf)
872            return -ENOMEM;
873    }
874    dev->id = ++swdev_id;
875    swconfig_defaults_init(dev);
876    spin_lock_init(&dev->lock);
877    swconfig_lock();
878    list_add(&dev->dev_list, &swdevs);
879    swconfig_unlock();
880
881    return 0;
882}
883EXPORT_SYMBOL_GPL(register_switch);
884
885void
886unregister_switch(struct switch_dev *dev)
887{
888    kfree(dev->portbuf);
889    spin_lock(&dev->lock);
890    swconfig_lock();
891    list_del(&dev->dev_list);
892    swconfig_unlock();
893    spin_unlock(&dev->lock);
894}
895EXPORT_SYMBOL_GPL(unregister_switch);
896
897
898static int __init
899swconfig_init(void)
900{
901    int i, err;
902
903    INIT_LIST_HEAD(&swdevs);
904    err = genl_register_family(&switch_fam);
905    if (err)
906        return err;
907
908    for (i = 0; i < ARRAY_SIZE(swconfig_ops); i++) {
909        err = genl_register_ops(&switch_fam, &swconfig_ops[i]);
910        if (err)
911            goto unregister;
912    }
913
914    return 0;
915
916unregister:
917    genl_unregister_family(&switch_fam);
918    return err;
919}
920
921static void __exit
922swconfig_exit(void)
923{
924    genl_unregister_family(&switch_fam);
925}
926
927module_init(swconfig_init);
928module_exit(swconfig_exit);
929
930

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive