br2684.c 22 KB

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