← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to net/atm/br2684.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
net/atm/br2684.c
 
1
/*
 
2
 * Ethernet netdevice using ATM AAL5 as underlying carrier
 
3
 * (RFC1483 obsoleted by RFC2684) for Linux
 
4
 *
 
5
 * Authors: Marcell GAL, 2000, XDSL Ltd, Hungary
 
6
 *          Eric Kinzie, 2006-2007, US Naval Research Laboratory
 
7
 */
 
8
 
 
9
#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
 
10
 
 
11
#include <linux/module.h>
 
12
#include <linux/init.h>
 
13
#include <linux/kernel.h>
 
14
#include <linux/list.h>
 
15
#include <linux/netdevice.h>
 
16
#include <linux/skbuff.h>
 
17
#include <linux/etherdevice.h>
 
18
#include <linux/rtnetlink.h>
 
19
#include <linux/ip.h>
 
20
#include <linux/uaccess.h>
 
21
#include <linux/slab.h>
 
22
#include <net/arp.h>
 
23
#include <linux/atm.h>
 
24
#include <linux/atmdev.h>
 
25
#include <linux/capability.h>
 
26
#include <linux/seq_file.h>
 
27
 
 
28
#include <linux/atmbr2684.h>
 
29
 
 
30
#include "common.h"
 
31
 
 
32
static void skb_debug(const struct sk_buff *skb)
 
33
{
 
34
#ifdef SKB_DEBUG
 
35
#define NUM2PRINT 50
 
36
        print_hex_dump(KERN_DEBUG, "br2684: skb: ", DUMP_OFFSET,
 
37
                       16, 1, skb->data, min(NUM2PRINT, skb->len), true);
 
38
#endif
 
39
}
 
40
 
 
41
#define BR2684_ETHERTYPE_LEN    2
 
42
#define BR2684_PAD_LEN          2
 
43
 
 
44
#define LLC             0xaa, 0xaa, 0x03
 
45
#define SNAP_BRIDGED    0x00, 0x80, 0xc2
 
46
#define SNAP_ROUTED     0x00, 0x00, 0x00
 
47
#define PID_ETHERNET    0x00, 0x07
 
48
#define ETHERTYPE_IPV4  0x08, 0x00
 
49
#define ETHERTYPE_IPV6  0x86, 0xdd
 
50
#define PAD_BRIDGED     0x00, 0x00
 
51
 
 
52
static const unsigned char ethertype_ipv4[] = { ETHERTYPE_IPV4 };
 
53
static const unsigned char ethertype_ipv6[] = { ETHERTYPE_IPV6 };
 
54
static const unsigned char llc_oui_pid_pad[] =
 
55
                        { LLC, SNAP_BRIDGED, PID_ETHERNET, PAD_BRIDGED };
 
56
static const unsigned char llc_oui_ipv4[] = { LLC, SNAP_ROUTED, ETHERTYPE_IPV4 };
 
57
static const unsigned char llc_oui_ipv6[] = { LLC, SNAP_ROUTED, ETHERTYPE_IPV6 };
 
58
 
 
59
enum br2684_encaps {
 
60
        e_vc = BR2684_ENCAPS_VC,
 
61
        e_llc = BR2684_ENCAPS_LLC,
 
62
};
 
63
 
 
64
struct br2684_vcc {
 
65
        struct atm_vcc *atmvcc;
 
66
        struct net_device *device;
 
67
        /* keep old push, pop functions for chaining */
 
68
        void (*old_push)(struct atm_vcc *vcc, struct sk_buff *skb);
 
69
        void (*old_pop)(struct atm_vcc *vcc, struct sk_buff *skb);
 
70
        enum br2684_encaps encaps;
 
71
        struct list_head brvccs;
 
72
#ifdef CONFIG_ATM_BR2684_IPFILTER
 
73
        struct br2684_filter filter;
 
74
#endif /* CONFIG_ATM_BR2684_IPFILTER */
 
75
        unsigned copies_needed, copies_failed;
 
76
};
 
77
 
 
78
struct br2684_dev {
 
79
        struct net_device *net_dev;
 
80
        struct list_head br2684_devs;
 
81
        int number;
 
82
        struct list_head brvccs;        /* one device <=> one vcc (before xmas) */
 
83
        int mac_was_set;
 
84
        enum br2684_payload payload;
 
85
};
 
86
 
 
87
/*
 
88
 * This lock should be held for writing any time the list of devices or
 
89
 * their attached vcc's could be altered.  It should be held for reading
 
90
 * any time these are being queried.  Note that we sometimes need to
 
91
 * do read-locking under interrupt context, so write locking must block
 
92
 * the current CPU's interrupts
 
93
 */
 
94
static DEFINE_RWLOCK(devs_lock);
 
95
 
 
96
static LIST_HEAD(br2684_devs);
 
97
 
 
98
static inline struct br2684_dev *BRPRIV(const struct net_device *net_dev)
 
99
{
 
100
        return netdev_priv(net_dev);
 
101
}
 
102
 
 
103
static inline struct net_device *list_entry_brdev(const struct list_head *le)
 
104
{
 
105
        return list_entry(le, struct br2684_dev, br2684_devs)->net_dev;
 
106
}
 
107
 
 
108
static inline struct br2684_vcc *BR2684_VCC(const struct atm_vcc *atmvcc)
 
109
{
 
110
        return (struct br2684_vcc *)(atmvcc->user_back);
 
111
}
 
112
 
 
113
static inline struct br2684_vcc *list_entry_brvcc(const struct list_head *le)
 
114
{
 
115
        return list_entry(le, struct br2684_vcc, brvccs);
 
116
}
 
117
 
 
118
/* Caller should hold read_lock(&devs_lock) */
 
119
static struct net_device *br2684_find_dev(const struct br2684_if_spec *s)
 
120
{
 
121
        struct list_head *lh;
 
122
        struct net_device *net_dev;
 
123
        switch (s->method) {
 
124
        case BR2684_FIND_BYNUM:
 
125
                list_for_each(lh, &br2684_devs) {
 
126
                        net_dev = list_entry_brdev(lh);
 
127
                        if (BRPRIV(net_dev)->number == s->spec.devnum)
 
128
                                return net_dev;
 
129
                }
 
130
                break;
 
131
        case BR2684_FIND_BYIFNAME:
 
132
                list_for_each(lh, &br2684_devs) {
 
133
                        net_dev = list_entry_brdev(lh);
 
134
                        if (!strncmp(net_dev->name, s->spec.ifname, IFNAMSIZ))
 
135
                                return net_dev;
 
136
                }
 
137
                break;
 
138
        }
 
139
        return NULL;
 
140
}
 
141
 
 
142
static int atm_dev_event(struct notifier_block *this, unsigned long event,
 
143
                 void *arg)
 
144
{
 
145
        struct atm_dev *atm_dev = arg;
 
146
        struct list_head *lh;
 
147
        struct net_device *net_dev;
 
148
        struct br2684_vcc *brvcc;
 
149
        struct atm_vcc *atm_vcc;
 
150
        unsigned long flags;
 
151
 
 
152
        pr_debug("event=%ld dev=%p\n", event, atm_dev);
 
153
 
 
154
        read_lock_irqsave(&devs_lock, flags);
 
155
        list_for_each(lh, &br2684_devs) {
 
156
                net_dev = list_entry_brdev(lh);
 
157
 
 
158
                list_for_each_entry(brvcc, &BRPRIV(net_dev)->brvccs, brvccs) {
 
159
                        atm_vcc = brvcc->atmvcc;
 
160
                        if (atm_vcc && brvcc->atmvcc->dev == atm_dev) {
 
161
 
 
162
                                if (atm_vcc->dev->signal == ATM_PHY_SIG_LOST)
 
163
                                        netif_carrier_off(net_dev);
 
164
                                else
 
165
                                        netif_carrier_on(net_dev);
 
166
 
 
167
                        }
 
168
                }
 
169
        }
 
170
        read_unlock_irqrestore(&devs_lock, flags);
 
171
 
 
172
        return NOTIFY_DONE;
 
173
}
 
174
 
 
175
static struct notifier_block atm_dev_notifier = {
 
176
        .notifier_call = atm_dev_event,
 
177
};
 
178
 
 
179
/* chained vcc->pop function.  Check if we should wake the netif_queue */
 
180
static void br2684_pop(struct atm_vcc *vcc, struct sk_buff *skb)
 
181
{
 
182
        struct br2684_vcc *brvcc = BR2684_VCC(vcc);
 
183
        struct net_device *net_dev = skb->dev;
 
184
 
 
185
        pr_debug("(vcc %p ; net_dev %p )\n", vcc, net_dev);
 
186
        brvcc->old_pop(vcc, skb);
 
187
 
 
188
        if (!net_dev)
 
189
                return;
 
190
 
 
191
        if (atm_may_send(vcc, 0))
 
192
                netif_wake_queue(net_dev);
 
193
 
 
194
}
 
195
/*
 
196
 * Send a packet out a particular vcc.  Not to useful right now, but paves
 
197
 * the way for multiple vcc's per itf.  Returns true if we can send,
 
198
 * otherwise false
 
199
 */
 
200
static int br2684_xmit_vcc(struct sk_buff *skb, struct net_device *dev,
 
201
                           struct br2684_vcc *brvcc)
 
202
{
 
203
        struct br2684_dev *brdev = BRPRIV(dev);
 
204
        struct atm_vcc *atmvcc;
 
205
        int minheadroom = (brvcc->encaps == e_llc) ? 10 : 2;
 
206
 
 
207
        if (skb_headroom(skb) < minheadroom) {
 
208
                struct sk_buff *skb2 = skb_realloc_headroom(skb, minheadroom);
 
209
                brvcc->copies_needed++;
 
210
                dev_kfree_skb(skb);
 
211
                if (skb2 == NULL) {
 
212
                        brvcc->copies_failed++;
 
213
                        return 0;
 
214
                }
 
215
                skb = skb2;
 
216
        }
 
217
 
 
218
        if (brvcc->encaps == e_llc) {
 
219
                if (brdev->payload == p_bridged) {
 
220
                        skb_push(skb, sizeof(llc_oui_pid_pad));
 
221
                        skb_copy_to_linear_data(skb, llc_oui_pid_pad,
 
222
                                                sizeof(llc_oui_pid_pad));
 
223
                } else if (brdev->payload == p_routed) {
 
224
                        unsigned short prot = ntohs(skb->protocol);
 
225
 
 
226
                        skb_push(skb, sizeof(llc_oui_ipv4));
 
227
                        switch (prot) {
 
228
                        case ETH_P_IP:
 
229
                                skb_copy_to_linear_data(skb, llc_oui_ipv4,
 
230
                                                        sizeof(llc_oui_ipv4));
 
231
                                break;
 
232
                        case ETH_P_IPV6:
 
233
                                skb_copy_to_linear_data(skb, llc_oui_ipv6,
 
234
                                                        sizeof(llc_oui_ipv6));
 
235
                                break;
 
236
                        default:
 
237
                                dev_kfree_skb(skb);
 
238
                                return 0;
 
239
                        }
 
240
                }
 
241
        } else { /* e_vc */
 
242
                if (brdev->payload == p_bridged) {
 
243
                        skb_push(skb, 2);
 
244
                        memset(skb->data, 0, 2);
 
245
                }
 
246
        }
 
247
        skb_debug(skb);
 
248
 
 
249
        ATM_SKB(skb)->vcc = atmvcc = brvcc->atmvcc;
 
250
        pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, atmvcc, atmvcc->dev);
 
251
        atomic_add(skb->truesize, &sk_atm(atmvcc)->sk_wmem_alloc);
 
252
        ATM_SKB(skb)->atm_options = atmvcc->atm_options;
 
253
        dev->stats.tx_packets++;
 
254
        dev->stats.tx_bytes += skb->len;
 
255
        atmvcc->send(atmvcc, skb);
 
256
 
 
257
        if (!atm_may_send(atmvcc, 0)) {
 
258
                netif_stop_queue(brvcc->device);
 
259
                /*check for race with br2684_pop*/
 
260
                if (atm_may_send(atmvcc, 0))
 
261
                        netif_start_queue(brvcc->device);
 
262
        }
 
263
 
 
264
        return 1;
 
265
}
 
266
 
 
267
static inline struct br2684_vcc *pick_outgoing_vcc(const struct sk_buff *skb,
 
268
                                                   const struct br2684_dev *brdev)
 
269
{
 
270
        return list_empty(&brdev->brvccs) ? NULL : list_entry_brvcc(brdev->brvccs.next);        /* 1 vcc/dev right now */
 
271
}
 
272
 
 
273
static netdev_tx_t br2684_start_xmit(struct sk_buff *skb,
 
274
                                     struct net_device *dev)
 
275
{
 
276
        struct br2684_dev *brdev = BRPRIV(dev);
 
277
        struct br2684_vcc *brvcc;
 
278
 
 
279
        pr_debug("skb_dst(skb)=%p\n", skb_dst(skb));
 
280
        read_lock(&devs_lock);
 
281
        brvcc = pick_outgoing_vcc(skb, brdev);
 
282
        if (brvcc == NULL) {
 
283
                pr_debug("no vcc attached to dev %s\n", dev->name);
 
284
                dev->stats.tx_errors++;
 
285
                dev->stats.tx_carrier_errors++;
 
286
                /* netif_stop_queue(dev); */
 
287
                dev_kfree_skb(skb);
 
288
                read_unlock(&devs_lock);
 
289
                return NETDEV_TX_OK;
 
290
        }
 
291
        if (!br2684_xmit_vcc(skb, dev, brvcc)) {
 
292
                /*
 
293
                 * We should probably use netif_*_queue() here, but that
 
294
                 * involves added complication.  We need to walk before
 
295
                 * we can run.
 
296
                 *
 
297
                 * Don't free here! this pointer might be no longer valid!
 
298
                 */
 
299
                dev->stats.tx_errors++;
 
300
                dev->stats.tx_fifo_errors++;
 
301
        }
 
302
        read_unlock(&devs_lock);
 
303
        return NETDEV_TX_OK;
 
304
}
 
305
 
 
306
/*
 
307
 * We remember when the MAC gets set, so we don't override it later with
 
308
 * the ESI of the ATM card of the first VC
 
309
 */
 
310
static int br2684_mac_addr(struct net_device *dev, void *p)
 
311
{
 
312
        int err = eth_mac_addr(dev, p);
 
313
        if (!err)
 
314
                BRPRIV(dev)->mac_was_set = 1;
 
315
        return err;
 
316
}
 
317
 
 
318
#ifdef CONFIG_ATM_BR2684_IPFILTER
 
319
/* this IOCTL is experimental. */
 
320
static int br2684_setfilt(struct atm_vcc *atmvcc, void __user * arg)
 
321
{
 
322
        struct br2684_vcc *brvcc;
 
323
        struct br2684_filter_set fs;
 
324
 
 
325
        if (copy_from_user(&fs, arg, sizeof fs))
 
326
                return -EFAULT;
 
327
        if (fs.ifspec.method != BR2684_FIND_BYNOTHING) {
 
328
                /*
 
329
                 * This is really a per-vcc thing, but we can also search
 
330
                 * by device.
 
331
                 */
 
332
                struct br2684_dev *brdev;
 
333
                read_lock(&devs_lock);
 
334
                brdev = BRPRIV(br2684_find_dev(&fs.ifspec));
 
335
                if (brdev == NULL || list_empty(&brdev->brvccs) ||
 
336
                    brdev->brvccs.next != brdev->brvccs.prev)   /* >1 VCC */
 
337
                        brvcc = NULL;
 
338
                else
 
339
                        brvcc = list_entry_brvcc(brdev->brvccs.next);
 
340
                read_unlock(&devs_lock);
 
341
                if (brvcc == NULL)
 
342
                        return -ESRCH;
 
343
        } else
 
344
                brvcc = BR2684_VCC(atmvcc);
 
345
        memcpy(&brvcc->filter, &fs.filter, sizeof(brvcc->filter));
 
346
        return 0;
 
347
}
 
348
 
 
349
/* Returns 1 if packet should be dropped */
 
350
static inline int
 
351
packet_fails_filter(__be16 type, struct br2684_vcc *brvcc, struct sk_buff *skb)
 
352
{
 
353
        if (brvcc->filter.netmask == 0)
 
354
                return 0;       /* no filter in place */
 
355
        if (type == htons(ETH_P_IP) &&
 
356
            (((struct iphdr *)(skb->data))->daddr & brvcc->filter.
 
357
             netmask) == brvcc->filter.prefix)
 
358
                return 0;
 
359
        if (type == htons(ETH_P_ARP))
 
360
                return 0;
 
361
        /*
 
362
         * TODO: we should probably filter ARPs too.. don't want to have
 
363
         * them returning values that don't make sense, or is that ok?
 
364
         */
 
365
        return 1;               /* drop */
 
366
}
 
367
#endif /* CONFIG_ATM_BR2684_IPFILTER */
 
368
 
 
369
static void br2684_close_vcc(struct br2684_vcc *brvcc)
 
370
{
 
371
        pr_debug("removing VCC %p from dev %p\n", brvcc, brvcc->device);
 
372
        write_lock_irq(&devs_lock);
 
373
        list_del(&brvcc->brvccs);
 
374
        write_unlock_irq(&devs_lock);
 
375
        brvcc->atmvcc->user_back = NULL;        /* what about vcc->recvq ??? */
 
376
        brvcc->old_push(brvcc->atmvcc, NULL);   /* pass on the bad news */
 
377
        kfree(brvcc);
 
378
        module_put(THIS_MODULE);
 
379
}
 
380
 
 
381
/* when AAL5 PDU comes in: */
 
382
static void br2684_push(struct atm_vcc *atmvcc, struct sk_buff *skb)
 
383
{
 
384
        struct br2684_vcc *brvcc = BR2684_VCC(atmvcc);
 
385
        struct net_device *net_dev = brvcc->device;
 
386
        struct br2684_dev *brdev = BRPRIV(net_dev);
 
387
 
 
388
        pr_debug("\n");
 
389
 
 
390
        if (unlikely(skb == NULL)) {
 
391
                /* skb==NULL means VCC is being destroyed */
 
392
                br2684_close_vcc(brvcc);
 
393
                if (list_empty(&brdev->brvccs)) {
 
394
                        write_lock_irq(&devs_lock);
 
395
                        list_del(&brdev->br2684_devs);
 
396
                        write_unlock_irq(&devs_lock);
 
397
                        unregister_netdev(net_dev);
 
398
                        free_netdev(net_dev);
 
399
                }
 
400
                return;
 
401
        }
 
402
 
 
403
        skb_debug(skb);
 
404
        atm_return(atmvcc, skb->truesize);
 
405
        pr_debug("skb from brdev %p\n", brdev);
 
406
        if (brvcc->encaps == e_llc) {
 
407
 
 
408
                if (skb->len > 7 && skb->data[7] == 0x01)
 
409
                        __skb_trim(skb, skb->len - 4);
 
410
 
 
411
                /* accept packets that have "ipv[46]" in the snap header */
 
412
                if ((skb->len >= (sizeof(llc_oui_ipv4))) &&
 
413
                    (memcmp(skb->data, llc_oui_ipv4,
 
414
                            sizeof(llc_oui_ipv4) - BR2684_ETHERTYPE_LEN) == 0)) {
 
415
                        if (memcmp(skb->data + 6, ethertype_ipv6,
 
416
                                   sizeof(ethertype_ipv6)) == 0)
 
417
                                skb->protocol = htons(ETH_P_IPV6);
 
418
                        else if (memcmp(skb->data + 6, ethertype_ipv4,
 
419
                                        sizeof(ethertype_ipv4)) == 0)
 
420
                                skb->protocol = htons(ETH_P_IP);
 
421
                        else
 
422
                                goto error;
 
423
                        skb_pull(skb, sizeof(llc_oui_ipv4));
 
424
                        skb_reset_network_header(skb);
 
425
                        skb->pkt_type = PACKET_HOST;
 
426
                /*
 
427
                 * Let us waste some time for checking the encapsulation.
 
428
                 * Note, that only 7 char is checked so frames with a valid FCS
 
429
                 * are also accepted (but FCS is not checked of course).
 
430
                 */
 
431
                } else if ((skb->len >= sizeof(llc_oui_pid_pad)) &&
 
432
                           (memcmp(skb->data, llc_oui_pid_pad, 7) == 0)) {
 
433
                        skb_pull(skb, sizeof(llc_oui_pid_pad));
 
434
                        skb->protocol = eth_type_trans(skb, net_dev);
 
435
                } else
 
436
                        goto error;
 
437
 
 
438
        } else { /* e_vc */
 
439
                if (brdev->payload == p_routed) {
 
440
                        struct iphdr *iph;
 
441
 
 
442
                        skb_reset_network_header(skb);
 
443
                        iph = ip_hdr(skb);
 
444
                        if (iph->version == 4)
 
445
                                skb->protocol = htons(ETH_P_IP);
 
446
                        else if (iph->version == 6)
 
447
                                skb->protocol = htons(ETH_P_IPV6);
 
448
                        else
 
449
                                goto error;
 
450
                        skb->pkt_type = PACKET_HOST;
 
451
                } else { /* p_bridged */
 
452
                        /* first 2 chars should be 0 */
 
453
                        if (*((u16 *) (skb->data)) != 0)
 
454
                                goto error;
 
455
                        skb_pull(skb, BR2684_PAD_LEN);
 
456
                        skb->protocol = eth_type_trans(skb, net_dev);
 
457
                }
 
458
        }
 
459
 
 
460
#ifdef CONFIG_ATM_BR2684_IPFILTER
 
461
        if (unlikely(packet_fails_filter(skb->protocol, brvcc, skb)))
 
462
                goto dropped;
 
463
#endif /* CONFIG_ATM_BR2684_IPFILTER */
 
464
        skb->dev = net_dev;
 
465
        ATM_SKB(skb)->vcc = atmvcc;     /* needed ? */
 
466
        pr_debug("received packet's protocol: %x\n", ntohs(skb->protocol));
 
467
        skb_debug(skb);
 
468
        /* sigh, interface is down? */
 
469
        if (unlikely(!(net_dev->flags & IFF_UP)))
 
470
                goto dropped;
 
471
        net_dev->stats.rx_packets++;
 
472
        net_dev->stats.rx_bytes += skb->len;
 
473
        memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
 
474
        netif_rx(skb);
 
475
        return;
 
476
 
 
477
dropped:
 
478
        net_dev->stats.rx_dropped++;
 
479
        goto free_skb;
 
480
error:
 
481
        net_dev->stats.rx_errors++;
 
482
free_skb:
 
483
        dev_kfree_skb(skb);
 
484
}
 
485
 
 
486
/*
 
487
 * Assign a vcc to a dev
 
488
 * Note: we do not have explicit unassign, but look at _push()
 
489
 */
 
490
static int br2684_regvcc(struct atm_vcc *atmvcc, void __user * arg)
 
491
{
 
492
        struct sk_buff_head queue;
 
493
        int err;
 
494
        struct br2684_vcc *brvcc;
 
495
        struct sk_buff *skb, *tmp;
 
496
        struct sk_buff_head *rq;
 
497
        struct br2684_dev *brdev;
 
498
        struct net_device *net_dev;
 
499
        struct atm_backend_br2684 be;
 
500
        unsigned long flags;
 
501
 
 
502
        if (copy_from_user(&be, arg, sizeof be))
 
503
                return -EFAULT;
 
504
        brvcc = kzalloc(sizeof(struct br2684_vcc), GFP_KERNEL);
 
505
        if (!brvcc)
 
506
                return -ENOMEM;
 
507
        write_lock_irq(&devs_lock);
 
508
        net_dev = br2684_find_dev(&be.ifspec);
 
509
        if (net_dev == NULL) {
 
510
                pr_err("tried to attach to non-existent device\n");
 
511
                err = -ENXIO;
 
512
                goto error;
 
513
        }
 
514
        brdev = BRPRIV(net_dev);
 
515
        if (atmvcc->push == NULL) {
 
516
                err = -EBADFD;
 
517
                goto error;
 
518
        }
 
519
        if (!list_empty(&brdev->brvccs)) {
 
520
                /* Only 1 VCC/dev right now */
 
521
                err = -EEXIST;
 
522
                goto error;
 
523
        }
 
524
        if (be.fcs_in != BR2684_FCSIN_NO ||
 
525
            be.fcs_out != BR2684_FCSOUT_NO ||
 
526
            be.fcs_auto || be.has_vpiid || be.send_padding ||
 
527
            (be.encaps != BR2684_ENCAPS_VC &&
 
528
             be.encaps != BR2684_ENCAPS_LLC) ||
 
529
            be.min_size != 0) {
 
530
                err = -EINVAL;
 
531
                goto error;
 
532
        }
 
533
        pr_debug("vcc=%p, encaps=%d, brvcc=%p\n", atmvcc, be.encaps, brvcc);
 
534
        if (list_empty(&brdev->brvccs) && !brdev->mac_was_set) {
 
535
                unsigned char *esi = atmvcc->dev->esi;
 
536
                if (esi[0] | esi[1] | esi[2] | esi[3] | esi[4] | esi[5])
 
537
                        memcpy(net_dev->dev_addr, esi, net_dev->addr_len);
 
538
                else
 
539
                        net_dev->dev_addr[2] = 1;
 
540
        }
 
541
        list_add(&brvcc->brvccs, &brdev->brvccs);
 
542
        write_unlock_irq(&devs_lock);
 
543
        brvcc->device = net_dev;
 
544
        brvcc->atmvcc = atmvcc;
 
545
        atmvcc->user_back = brvcc;
 
546
        brvcc->encaps = (enum br2684_encaps)be.encaps;
 
547
        brvcc->old_push = atmvcc->push;
 
548
        brvcc->old_pop = atmvcc->pop;
 
549
        barrier();
 
550
        atmvcc->push = br2684_push;
 
551
        atmvcc->pop = br2684_pop;
 
552
 
 
553
        __skb_queue_head_init(&queue);
 
554
        rq = &sk_atm(atmvcc)->sk_receive_queue;
 
555
 
 
556
        spin_lock_irqsave(&rq->lock, flags);
 
557
        skb_queue_splice_init(rq, &queue);
 
558
        spin_unlock_irqrestore(&rq->lock, flags);
 
559
 
 
560
        skb_queue_walk_safe(&queue, skb, tmp) {
 
561
                struct net_device *dev;
 
562
 
 
563
                br2684_push(atmvcc, skb);
 
564
                dev = skb->dev;
 
565
 
 
566
                dev->stats.rx_bytes -= skb->len;
 
567
                dev->stats.rx_packets--;
 
568
        }
 
569
 
 
570
        /* initialize netdev carrier state */
 
571
        if (atmvcc->dev->signal == ATM_PHY_SIG_LOST)
 
572
                netif_carrier_off(net_dev);
 
573
        else
 
574
                netif_carrier_on(net_dev);
 
575
 
 
576
        __module_get(THIS_MODULE);
 
577
        return 0;
 
578
 
 
579
error:
 
580
        write_unlock_irq(&devs_lock);
 
581
        kfree(brvcc);
 
582
        return err;
 
583
}
 
584
 
 
585
static const struct net_device_ops br2684_netdev_ops = {
 
586
        .ndo_start_xmit         = br2684_start_xmit,
 
587
        .ndo_set_mac_address    = br2684_mac_addr,
 
588
        .ndo_change_mtu         = eth_change_mtu,
 
589
        .ndo_validate_addr      = eth_validate_addr,
 
590
};
 
591
 
 
592
static const struct net_device_ops br2684_netdev_ops_routed = {
 
593
        .ndo_start_xmit         = br2684_start_xmit,
 
594
        .ndo_set_mac_address    = br2684_mac_addr,
 
595
        .ndo_change_mtu         = eth_change_mtu
 
596
};
 
597
 
 
598
static void br2684_setup(struct net_device *netdev)
 
599
{
 
600
        struct br2684_dev *brdev = BRPRIV(netdev);
 
601
 
 
602
        ether_setup(netdev);
 
603
        brdev->net_dev = netdev;
 
604
 
 
605
        netdev->netdev_ops = &br2684_netdev_ops;
 
606
 
 
607
        INIT_LIST_HEAD(&brdev->brvccs);
 
608
}
 
609
 
 
610
static void br2684_setup_routed(struct net_device *netdev)
 
611
{
 
612
        struct br2684_dev *brdev = BRPRIV(netdev);
 
613
 
 
614
        brdev->net_dev = netdev;
 
615
        netdev->hard_header_len = 0;
 
616
        netdev->netdev_ops = &br2684_netdev_ops_routed;
 
617
        netdev->addr_len = 0;
 
618
        netdev->mtu = 1500;
 
619
        netdev->type = ARPHRD_PPP;
 
620
        netdev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
 
621
        netdev->tx_queue_len = 100;
 
622
        INIT_LIST_HEAD(&brdev->brvccs);
 
623
}
 
624
 
 
625
static int br2684_create(void __user *arg)
 
626
{
 
627
        int err;
 
628
        struct net_device *netdev;
 
629
        struct br2684_dev *brdev;
 
630
        struct atm_newif_br2684 ni;
 
631
        enum br2684_payload payload;
 
632
 
 
633
        pr_debug("\n");
 
634
 
 
635
        if (copy_from_user(&ni, arg, sizeof ni))
 
636
                return -EFAULT;
 
637
 
 
638
        if (ni.media & BR2684_FLAG_ROUTED)
 
639
                payload = p_routed;
 
640
        else
 
641
                payload = p_bridged;
 
642
        ni.media &= 0xffff;     /* strip flags */
 
643
 
 
644
        if (ni.media != BR2684_MEDIA_ETHERNET || ni.mtu != 1500)
 
645
                return -EINVAL;
 
646
 
 
647
        netdev = alloc_netdev(sizeof(struct br2684_dev),
 
648
                              ni.ifname[0] ? ni.ifname : "nas%d",
 
649
                              (payload == p_routed) ?
 
650
                              br2684_setup_routed : br2684_setup);
 
651
        if (!netdev)
 
652
                return -ENOMEM;
 
653
 
 
654
        brdev = BRPRIV(netdev);
 
655
 
 
656
        pr_debug("registered netdev %s\n", netdev->name);
 
657
        /* open, stop, do_ioctl ? */
 
658
        err = register_netdev(netdev);
 
659
        if (err < 0) {
 
660
                pr_err("register_netdev failed\n");
 
661
                free_netdev(netdev);
 
662
                return err;
 
663
        }
 
664
 
 
665
        write_lock_irq(&devs_lock);
 
666
 
 
667
        brdev->payload = payload;
 
668
 
 
669
        if (list_empty(&br2684_devs)) {
 
670
                /* 1st br2684 device */
 
671
                brdev->number = 1;
 
672
        } else
 
673
                brdev->number = BRPRIV(list_entry_brdev(br2684_devs.prev))->number + 1;
 
674
 
 
675
        list_add_tail(&brdev->br2684_devs, &br2684_devs);
 
676
        write_unlock_irq(&devs_lock);
 
677
        return 0;
 
678
}
 
679
 
 
680
/*
 
681
 * This handles ioctls actually performed on our vcc - we must return
 
682
 * -ENOIOCTLCMD for any unrecognized ioctl
 
683
 */
 
684
static int br2684_ioctl(struct socket *sock, unsigned int cmd,
 
685
                        unsigned long arg)
 
686
{
 
687
        struct atm_vcc *atmvcc = ATM_SD(sock);
 
688
        void __user *argp = (void __user *)arg;
 
689
        atm_backend_t b;
 
690
 
 
691
        int err;
 
692
        switch (cmd) {
 
693
        case ATM_SETBACKEND:
 
694
        case ATM_NEWBACKENDIF:
 
695
                err = get_user(b, (atm_backend_t __user *) argp);
 
696
                if (err)
 
697
                        return -EFAULT;
 
698
                if (b != ATM_BACKEND_BR2684)
 
699
                        return -ENOIOCTLCMD;
 
700
                if (!capable(CAP_NET_ADMIN))
 
701
                        return -EPERM;
 
702
                if (cmd == ATM_SETBACKEND)
 
703
                        return br2684_regvcc(atmvcc, argp);
 
704
                else
 
705
                        return br2684_create(argp);
 
706
#ifdef CONFIG_ATM_BR2684_IPFILTER
 
707
        case BR2684_SETFILT:
 
708
                if (atmvcc->push != br2684_push)
 
709
                        return -ENOIOCTLCMD;
 
710
                if (!capable(CAP_NET_ADMIN))
 
711
                        return -EPERM;
 
712
                err = br2684_setfilt(atmvcc, argp);
 
713
 
 
714
                return err;
 
715
#endif /* CONFIG_ATM_BR2684_IPFILTER */
 
716
        }
 
717
        return -ENOIOCTLCMD;
 
718
}
 
719
 
 
720
static struct atm_ioctl br2684_ioctl_ops = {
 
721
        .owner = THIS_MODULE,
 
722
        .ioctl = br2684_ioctl,
 
723
};
 
724
 
 
725
#ifdef CONFIG_PROC_FS
 
726
static void *br2684_seq_start(struct seq_file *seq, loff_t * pos)
 
727
        __acquires(devs_lock)
 
728
{
 
729
        read_lock(&devs_lock);
 
730
        return seq_list_start(&br2684_devs, *pos);
 
731
}
 
732
 
 
733
static void *br2684_seq_next(struct seq_file *seq, void *v, loff_t * pos)
 
734
{
 
735
        return seq_list_next(v, &br2684_devs, pos);
 
736
}
 
737
 
 
738
static void br2684_seq_stop(struct seq_file *seq, void *v)
 
739
        __releases(devs_lock)
 
740
{
 
741
        read_unlock(&devs_lock);
 
742
}
 
743
 
 
744
static int br2684_seq_show(struct seq_file *seq, void *v)
 
745
{
 
746
        const struct br2684_dev *brdev = list_entry(v, struct br2684_dev,
 
747
                                                    br2684_devs);
 
748
        const struct net_device *net_dev = brdev->net_dev;
 
749
        const struct br2684_vcc *brvcc;
 
750
 
 
751
        seq_printf(seq, "dev %.16s: num=%d, mac=%pM (%s)\n",
 
752
                   net_dev->name,
 
753
                   brdev->number,
 
754
                   net_dev->dev_addr,
 
755
                   brdev->mac_was_set ? "set" : "auto");
 
756
 
 
757
        list_for_each_entry(brvcc, &brdev->brvccs, brvccs) {
 
758
                seq_printf(seq, "  vcc %d.%d.%d: encaps=%s payload=%s"
 
759
                           ", failed copies %u/%u"
 
760
                           "\n", brvcc->atmvcc->dev->number,
 
761
                           brvcc->atmvcc->vpi, brvcc->atmvcc->vci,
 
762
                           (brvcc->encaps == e_llc) ? "LLC" : "VC",
 
763
                           (brdev->payload == p_bridged) ? "bridged" : "routed",
 
764
                           brvcc->copies_failed, brvcc->copies_needed);
 
765
#ifdef CONFIG_ATM_BR2684_IPFILTER
 
766
#define b1(var, byte)   ((u8 *) &brvcc->filter.var)[byte]
 
767
#define bs(var)         b1(var, 0), b1(var, 1), b1(var, 2), b1(var, 3)
 
768
                if (brvcc->filter.netmask != 0)
 
769
                        seq_printf(seq, "    filter=%d.%d.%d.%d/"
 
770
                                   "%d.%d.%d.%d\n", bs(prefix), bs(netmask));
 
771
#undef bs
 
772
#undef b1
 
773
#endif /* CONFIG_ATM_BR2684_IPFILTER */
 
774
        }
 
775
        return 0;
 
776
}
 
777
 
 
778
static const struct seq_operations br2684_seq_ops = {
 
779
        .start = br2684_seq_start,
 
780
        .next = br2684_seq_next,
 
781
        .stop = br2684_seq_stop,
 
782
        .show = br2684_seq_show,
 
783
};
 
784
 
 
785
static int br2684_proc_open(struct inode *inode, struct file *file)
 
786
{
 
787
        return seq_open(file, &br2684_seq_ops);
 
788
}
 
789
 
 
790
static const struct file_operations br2684_proc_ops = {
 
791
        .owner = THIS_MODULE,
 
792
        .open = br2684_proc_open,
 
793
        .read = seq_read,
 
794
        .llseek = seq_lseek,
 
795
        .release = seq_release,
 
796
};
 
797
 
 
798
extern struct proc_dir_entry *atm_proc_root;    /* from proc.c */
 
799
#endif /* CONFIG_PROC_FS */
 
800
 
 
801
static int __init br2684_init(void)
 
802
{
 
803
#ifdef CONFIG_PROC_FS
 
804
        struct proc_dir_entry *p;
 
805
        p = proc_create("br2684", 0, atm_proc_root, &br2684_proc_ops);
 
806
        if (p == NULL)
 
807
                return -ENOMEM;
 
808
#endif
 
809
        register_atm_ioctl(&br2684_ioctl_ops);
 
810
        register_atmdevice_notifier(&atm_dev_notifier);
 
811
        return 0;
 
812
}
 
813
 
 
814
static void __exit br2684_exit(void)
 
815
{
 
816
        struct net_device *net_dev;
 
817
        struct br2684_dev *brdev;
 
818
        struct br2684_vcc *brvcc;
 
819
        deregister_atm_ioctl(&br2684_ioctl_ops);
 
820
 
 
821
#ifdef CONFIG_PROC_FS
 
822
        remove_proc_entry("br2684", atm_proc_root);
 
823
#endif
 
824
 
 
825
 
 
826
        unregister_atmdevice_notifier(&atm_dev_notifier);
 
827
 
 
828
        while (!list_empty(&br2684_devs)) {
 
829
                net_dev = list_entry_brdev(br2684_devs.next);
 
830
                brdev = BRPRIV(net_dev);
 
831
                while (!list_empty(&brdev->brvccs)) {
 
832
                        brvcc = list_entry_brvcc(brdev->brvccs.next);
 
833
                        br2684_close_vcc(brvcc);
 
834
                }
 
835
 
 
836
                list_del(&brdev->br2684_devs);
 
837
                unregister_netdev(net_dev);
 
838
                free_netdev(net_dev);
 
839
        }
 
840
}
 
841
 
 
842
module_init(br2684_init);
 
843
module_exit(br2684_exit);
 
844
 
 
845
MODULE_AUTHOR("Marcell GAL");
 
846
MODULE_DESCRIPTION("RFC2684 bridged protocols over ATM/AAL5");
 
847
MODULE_LICENSE("GPL");