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