lec.c 60 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291
  1. /*
  2. * lec.c: Lan Emulation driver
  3. *
  4. * Marko Kiiskila <mkiiskila@yahoo.com>
  5. */
  6. #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
  7. #include <linux/slab.h>
  8. #include <linux/kernel.h>
  9. #include <linux/bitops.h>
  10. #include <linux/capability.h>
  11. /* We are ethernet device */
  12. #include <linux/if_ether.h>
  13. #include <linux/netdevice.h>
  14. #include <linux/etherdevice.h>
  15. #include <net/sock.h>
  16. #include <linux/skbuff.h>
  17. #include <linux/ip.h>
  18. #include <asm/byteorder.h>
  19. #include <linux/uaccess.h>
  20. #include <net/arp.h>
  21. #include <net/dst.h>
  22. #include <linux/proc_fs.h>
  23. #include <linux/spinlock.h>
  24. #include <linux/seq_file.h>
  25. /* And atm device */
  26. #include <linux/atmdev.h>
  27. #include <linux/atmlec.h>
  28. /* Proxy LEC knows about bridging */
  29. #if IS_ENABLED(CONFIG_BRIDGE)
  30. #include "../bridge/br_private.h"
  31. static unsigned char bridge_ula_lec[] = { 0x01, 0x80, 0xc2, 0x00, 0x00 };
  32. #endif
  33. /* Modular too */
  34. #include <linux/module.h>
  35. #include <linux/init.h>
  36. /* Hardening for Spectre-v1 */
  37. #include <linux/nospec.h>
  38. #include "lec.h"
  39. #include "lec_arpc.h"
  40. #include "resources.h"
  41. #define DUMP_PACKETS 0 /*
  42. * 0 = None,
  43. * 1 = 30 first bytes
  44. * 2 = Whole packet
  45. */
  46. #define LEC_UNRES_QUE_LEN 8 /*
  47. * number of tx packets to queue for a
  48. * single destination while waiting for SVC
  49. */
  50. static int lec_open(struct net_device *dev);
  51. static netdev_tx_t lec_start_xmit(struct sk_buff *skb,
  52. struct net_device *dev);
  53. static int lec_close(struct net_device *dev);
  54. static struct lec_arp_table *lec_arp_find(struct lec_priv *priv,
  55. const unsigned char *mac_addr);
  56. static int lec_arp_remove(struct lec_priv *priv,
  57. struct lec_arp_table *to_remove);
  58. /* LANE2 functions */
  59. static void lane2_associate_ind(struct net_device *dev, const u8 *mac_address,
  60. const u8 *tlvs, u32 sizeoftlvs);
  61. static int lane2_resolve(struct net_device *dev, const u8 *dst_mac, int force,
  62. u8 **tlvs, u32 *sizeoftlvs);
  63. static int lane2_associate_req(struct net_device *dev, const u8 *lan_dst,
  64. const u8 *tlvs, u32 sizeoftlvs);
  65. static int lec_addr_delete(struct lec_priv *priv, const unsigned char *atm_addr,
  66. unsigned long permanent);
  67. static void lec_arp_check_empties(struct lec_priv *priv,
  68. struct atm_vcc *vcc, struct sk_buff *skb);
  69. static void lec_arp_destroy(struct lec_priv *priv);
  70. static void lec_arp_init(struct lec_priv *priv);
  71. static struct atm_vcc *lec_arp_resolve(struct lec_priv *priv,
  72. const unsigned char *mac_to_find,
  73. int is_rdesc,
  74. struct lec_arp_table **ret_entry);
  75. static void lec_arp_update(struct lec_priv *priv, const unsigned char *mac_addr,
  76. const unsigned char *atm_addr,
  77. unsigned long remoteflag,
  78. unsigned int targetless_le_arp);
  79. static void lec_flush_complete(struct lec_priv *priv, unsigned long tran_id);
  80. static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc);
  81. static void lec_set_flush_tran_id(struct lec_priv *priv,
  82. const unsigned char *atm_addr,
  83. unsigned long tran_id);
  84. static void lec_vcc_added(struct lec_priv *priv,
  85. const struct atmlec_ioc *ioc_data,
  86. struct atm_vcc *vcc,
  87. void (*old_push)(struct atm_vcc *vcc,
  88. struct sk_buff *skb));
  89. static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc);
  90. /* must be done under lec_arp_lock */
  91. static inline void lec_arp_hold(struct lec_arp_table *entry)
  92. {
  93. atomic_inc(&entry->usage);
  94. }
  95. static inline void lec_arp_put(struct lec_arp_table *entry)
  96. {
  97. if (atomic_dec_and_test(&entry->usage))
  98. kfree(entry);
  99. }
  100. static struct lane2_ops lane2_ops = {
  101. lane2_resolve, /* resolve, spec 3.1.3 */
  102. lane2_associate_req, /* associate_req, spec 3.1.4 */
  103. NULL /* associate indicator, spec 3.1.5 */
  104. };
  105. static unsigned char bus_mac[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
  106. /* Device structures */
  107. static struct net_device *dev_lec[MAX_LEC_ITF];
  108. #if IS_ENABLED(CONFIG_BRIDGE)
  109. static void lec_handle_bridge(struct sk_buff *skb, struct net_device *dev)
  110. {
  111. char *buff;
  112. struct lec_priv *priv;
  113. /*
  114. * Check if this is a BPDU. If so, ask zeppelin to send
  115. * LE_TOPOLOGY_REQUEST with the same value of Topology Change bit
  116. * as the Config BPDU has
  117. */
  118. buff = skb->data + skb->dev->hard_header_len;
  119. if (*buff++ == 0x42 && *buff++ == 0x42 && *buff++ == 0x03) {
  120. struct sock *sk;
  121. struct sk_buff *skb2;
  122. struct atmlec_msg *mesg;
  123. skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
  124. if (skb2 == NULL)
  125. return;
  126. skb2->len = sizeof(struct atmlec_msg);
  127. mesg = (struct atmlec_msg *)skb2->data;
  128. mesg->type = l_topology_change;
  129. buff += 4;
  130. mesg->content.normal.flag = *buff & 0x01;
  131. /* 0x01 is topology change */
  132. priv = netdev_priv(dev);
  133. atm_force_charge(priv->lecd, skb2->truesize);
  134. sk = sk_atm(priv->lecd);
  135. skb_queue_tail(&sk->sk_receive_queue, skb2);
  136. sk->sk_data_ready(sk);
  137. }
  138. }
  139. #endif /* IS_ENABLED(CONFIG_BRIDGE) */
  140. /*
  141. * Open/initialize the netdevice. This is called (in the current kernel)
  142. * sometime after booting when the 'ifconfig' program is run.
  143. *
  144. * This routine should set everything up anew at each open, even
  145. * registers that "should" only need to be set once at boot, so that
  146. * there is non-reboot way to recover if something goes wrong.
  147. */
  148. static int lec_open(struct net_device *dev)
  149. {
  150. netif_start_queue(dev);
  151. return 0;
  152. }
  153. static void
  154. lec_send(struct atm_vcc *vcc, struct sk_buff *skb)
  155. {
  156. struct net_device *dev = skb->dev;
  157. ATM_SKB(skb)->vcc = vcc;
  158. ATM_SKB(skb)->atm_options = vcc->atm_options;
  159. atomic_add(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
  160. if (vcc->send(vcc, skb) < 0) {
  161. dev->stats.tx_dropped++;
  162. return;
  163. }
  164. dev->stats.tx_packets++;
  165. dev->stats.tx_bytes += skb->len;
  166. }
  167. static void lec_tx_timeout(struct net_device *dev)
  168. {
  169. pr_info("%s\n", dev->name);
  170. netif_trans_update(dev);
  171. netif_wake_queue(dev);
  172. }
  173. static netdev_tx_t lec_start_xmit(struct sk_buff *skb,
  174. struct net_device *dev)
  175. {
  176. struct sk_buff *skb2;
  177. struct lec_priv *priv = netdev_priv(dev);
  178. struct lecdatahdr_8023 *lec_h;
  179. struct atm_vcc *vcc;
  180. struct lec_arp_table *entry;
  181. unsigned char *dst;
  182. int min_frame_size;
  183. int is_rdesc;
  184. pr_debug("called\n");
  185. if (!priv->lecd) {
  186. pr_info("%s:No lecd attached\n", dev->name);
  187. dev->stats.tx_errors++;
  188. netif_stop_queue(dev);
  189. kfree_skb(skb);
  190. return NETDEV_TX_OK;
  191. }
  192. pr_debug("skbuff head:%lx data:%lx tail:%lx end:%lx\n",
  193. (long)skb->head, (long)skb->data, (long)skb_tail_pointer(skb),
  194. (long)skb_end_pointer(skb));
  195. #if IS_ENABLED(CONFIG_BRIDGE)
  196. if (memcmp(skb->data, bridge_ula_lec, sizeof(bridge_ula_lec)) == 0)
  197. lec_handle_bridge(skb, dev);
  198. #endif
  199. /* Make sure we have room for lec_id */
  200. if (skb_headroom(skb) < 2) {
  201. pr_debug("reallocating skb\n");
  202. skb2 = skb_realloc_headroom(skb, LEC_HEADER_LEN);
  203. if (unlikely(!skb2)) {
  204. kfree_skb(skb);
  205. return NETDEV_TX_OK;
  206. }
  207. consume_skb(skb);
  208. skb = skb2;
  209. }
  210. skb_push(skb, 2);
  211. /* Put le header to place */
  212. lec_h = (struct lecdatahdr_8023 *)skb->data;
  213. lec_h->le_header = htons(priv->lecid);
  214. #if DUMP_PACKETS >= 2
  215. #define MAX_DUMP_SKB 99
  216. #elif DUMP_PACKETS >= 1
  217. #define MAX_DUMP_SKB 30
  218. #endif
  219. #if DUMP_PACKETS >= 1
  220. printk(KERN_DEBUG "%s: send datalen:%ld lecid:%4.4x\n",
  221. dev->name, skb->len, priv->lecid);
  222. print_hex_dump(KERN_DEBUG, "", DUMP_OFFSET, 16, 1,
  223. skb->data, min(skb->len, MAX_DUMP_SKB), true);
  224. #endif /* DUMP_PACKETS >= 1 */
  225. /* Minimum ethernet-frame size */
  226. min_frame_size = LEC_MINIMUM_8023_SIZE;
  227. if (skb->len < min_frame_size) {
  228. if ((skb->len + skb_tailroom(skb)) < min_frame_size) {
  229. skb2 = skb_copy_expand(skb, 0,
  230. min_frame_size - skb->truesize,
  231. GFP_ATOMIC);
  232. dev_kfree_skb(skb);
  233. if (skb2 == NULL) {
  234. dev->stats.tx_dropped++;
  235. return NETDEV_TX_OK;
  236. }
  237. skb = skb2;
  238. }
  239. skb_put(skb, min_frame_size - skb->len);
  240. }
  241. /* Send to right vcc */
  242. is_rdesc = 0;
  243. dst = lec_h->h_dest;
  244. entry = NULL;
  245. vcc = lec_arp_resolve(priv, dst, is_rdesc, &entry);
  246. pr_debug("%s:vcc:%p vcc_flags:%lx, entry:%p\n",
  247. dev->name, vcc, vcc ? vcc->flags : 0, entry);
  248. if (!vcc || !test_bit(ATM_VF_READY, &vcc->flags)) {
  249. if (entry && (entry->tx_wait.qlen < LEC_UNRES_QUE_LEN)) {
  250. pr_debug("%s:queuing packet, MAC address %pM\n",
  251. dev->name, lec_h->h_dest);
  252. skb_queue_tail(&entry->tx_wait, skb);
  253. } else {
  254. pr_debug("%s:tx queue full or no arp entry, dropping, MAC address: %pM\n",
  255. dev->name, lec_h->h_dest);
  256. dev->stats.tx_dropped++;
  257. dev_kfree_skb(skb);
  258. }
  259. goto out;
  260. }
  261. #if DUMP_PACKETS > 0
  262. printk(KERN_DEBUG "%s:sending to vpi:%d vci:%d\n",
  263. dev->name, vcc->vpi, vcc->vci);
  264. #endif /* DUMP_PACKETS > 0 */
  265. while (entry && (skb2 = skb_dequeue(&entry->tx_wait))) {
  266. pr_debug("emptying tx queue, MAC address %pM\n", lec_h->h_dest);
  267. lec_send(vcc, skb2);
  268. }
  269. lec_send(vcc, skb);
  270. if (!atm_may_send(vcc, 0)) {
  271. struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
  272. vpriv->xoff = 1;
  273. netif_stop_queue(dev);
  274. /*
  275. * vcc->pop() might have occurred in between, making
  276. * the vcc usuable again. Since xmit is serialized,
  277. * this is the only situation we have to re-test.
  278. */
  279. if (atm_may_send(vcc, 0))
  280. netif_wake_queue(dev);
  281. }
  282. out:
  283. if (entry)
  284. lec_arp_put(entry);
  285. netif_trans_update(dev);
  286. return NETDEV_TX_OK;
  287. }
  288. /* The inverse routine to net_open(). */
  289. static int lec_close(struct net_device *dev)
  290. {
  291. netif_stop_queue(dev);
  292. return 0;
  293. }
  294. static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
  295. {
  296. unsigned long flags;
  297. struct net_device *dev = (struct net_device *)vcc->proto_data;
  298. struct lec_priv *priv = netdev_priv(dev);
  299. struct atmlec_msg *mesg;
  300. struct lec_arp_table *entry;
  301. int i;
  302. char *tmp; /* FIXME */
  303. atomic_sub(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
  304. mesg = (struct atmlec_msg *)skb->data;
  305. tmp = skb->data;
  306. tmp += sizeof(struct atmlec_msg);
  307. pr_debug("%s: msg from zeppelin:%d\n", dev->name, mesg->type);
  308. switch (mesg->type) {
  309. case l_set_mac_addr:
  310. for (i = 0; i < 6; i++)
  311. dev->dev_addr[i] = mesg->content.normal.mac_addr[i];
  312. break;
  313. case l_del_mac_addr:
  314. for (i = 0; i < 6; i++)
  315. dev->dev_addr[i] = 0;
  316. break;
  317. case l_addr_delete:
  318. lec_addr_delete(priv, mesg->content.normal.atm_addr,
  319. mesg->content.normal.flag);
  320. break;
  321. case l_topology_change:
  322. priv->topology_change = mesg->content.normal.flag;
  323. break;
  324. case l_flush_complete:
  325. lec_flush_complete(priv, mesg->content.normal.flag);
  326. break;
  327. case l_narp_req: /* LANE2: see 7.1.35 in the lane2 spec */
  328. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  329. entry = lec_arp_find(priv, mesg->content.normal.mac_addr);
  330. lec_arp_remove(priv, entry);
  331. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  332. if (mesg->content.normal.no_source_le_narp)
  333. break;
  334. /* FALL THROUGH */
  335. case l_arp_update:
  336. lec_arp_update(priv, mesg->content.normal.mac_addr,
  337. mesg->content.normal.atm_addr,
  338. mesg->content.normal.flag,
  339. mesg->content.normal.targetless_le_arp);
  340. pr_debug("in l_arp_update\n");
  341. if (mesg->sizeoftlvs != 0) { /* LANE2 3.1.5 */
  342. pr_debug("LANE2 3.1.5, got tlvs, size %d\n",
  343. mesg->sizeoftlvs);
  344. lane2_associate_ind(dev, mesg->content.normal.mac_addr,
  345. tmp, mesg->sizeoftlvs);
  346. }
  347. break;
  348. case l_config:
  349. priv->maximum_unknown_frame_count =
  350. mesg->content.config.maximum_unknown_frame_count;
  351. priv->max_unknown_frame_time =
  352. (mesg->content.config.max_unknown_frame_time * HZ);
  353. priv->max_retry_count = mesg->content.config.max_retry_count;
  354. priv->aging_time = (mesg->content.config.aging_time * HZ);
  355. priv->forward_delay_time =
  356. (mesg->content.config.forward_delay_time * HZ);
  357. priv->arp_response_time =
  358. (mesg->content.config.arp_response_time * HZ);
  359. priv->flush_timeout = (mesg->content.config.flush_timeout * HZ);
  360. priv->path_switching_delay =
  361. (mesg->content.config.path_switching_delay * HZ);
  362. priv->lane_version = mesg->content.config.lane_version;
  363. /* LANE2 */
  364. priv->lane2_ops = NULL;
  365. if (priv->lane_version > 1)
  366. priv->lane2_ops = &lane2_ops;
  367. rtnl_lock();
  368. if (dev_set_mtu(dev, mesg->content.config.mtu))
  369. pr_info("%s: change_mtu to %d failed\n",
  370. dev->name, mesg->content.config.mtu);
  371. rtnl_unlock();
  372. priv->is_proxy = mesg->content.config.is_proxy;
  373. break;
  374. case l_flush_tran_id:
  375. lec_set_flush_tran_id(priv, mesg->content.normal.atm_addr,
  376. mesg->content.normal.flag);
  377. break;
  378. case l_set_lecid:
  379. priv->lecid =
  380. (unsigned short)(0xffff & mesg->content.normal.flag);
  381. break;
  382. case l_should_bridge:
  383. #if IS_ENABLED(CONFIG_BRIDGE)
  384. {
  385. pr_debug("%s: bridge zeppelin asks about %pM\n",
  386. dev->name, mesg->content.proxy.mac_addr);
  387. if (br_fdb_test_addr_hook == NULL)
  388. break;
  389. if (br_fdb_test_addr_hook(dev, mesg->content.proxy.mac_addr)) {
  390. /* hit from bridge table, send LE_ARP_RESPONSE */
  391. struct sk_buff *skb2;
  392. struct sock *sk;
  393. pr_debug("%s: entry found, responding to zeppelin\n",
  394. dev->name);
  395. skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
  396. if (skb2 == NULL)
  397. break;
  398. skb2->len = sizeof(struct atmlec_msg);
  399. skb_copy_to_linear_data(skb2, mesg, sizeof(*mesg));
  400. atm_force_charge(priv->lecd, skb2->truesize);
  401. sk = sk_atm(priv->lecd);
  402. skb_queue_tail(&sk->sk_receive_queue, skb2);
  403. sk->sk_data_ready(sk);
  404. }
  405. }
  406. #endif /* IS_ENABLED(CONFIG_BRIDGE) */
  407. break;
  408. default:
  409. pr_info("%s: Unknown message type %d\n", dev->name, mesg->type);
  410. dev_kfree_skb(skb);
  411. return -EINVAL;
  412. }
  413. dev_kfree_skb(skb);
  414. return 0;
  415. }
  416. static void lec_atm_close(struct atm_vcc *vcc)
  417. {
  418. struct sk_buff *skb;
  419. struct net_device *dev = (struct net_device *)vcc->proto_data;
  420. struct lec_priv *priv = netdev_priv(dev);
  421. priv->lecd = NULL;
  422. /* Do something needful? */
  423. netif_stop_queue(dev);
  424. lec_arp_destroy(priv);
  425. if (skb_peek(&sk_atm(vcc)->sk_receive_queue))
  426. pr_info("%s closing with messages pending\n", dev->name);
  427. while ((skb = skb_dequeue(&sk_atm(vcc)->sk_receive_queue))) {
  428. atm_return(vcc, skb->truesize);
  429. dev_kfree_skb(skb);
  430. }
  431. pr_info("%s: Shut down!\n", dev->name);
  432. module_put(THIS_MODULE);
  433. }
  434. static struct atmdev_ops lecdev_ops = {
  435. .close = lec_atm_close,
  436. .send = lec_atm_send
  437. };
  438. static struct atm_dev lecatm_dev = {
  439. .ops = &lecdev_ops,
  440. .type = "lec",
  441. .number = 999, /* dummy device number */
  442. .lock = __SPIN_LOCK_UNLOCKED(lecatm_dev.lock)
  443. };
  444. /*
  445. * LANE2: new argument struct sk_buff *data contains
  446. * the LE_ARP based TLVs introduced in the LANE2 spec
  447. */
  448. static int
  449. send_to_lecd(struct lec_priv *priv, atmlec_msg_type type,
  450. const unsigned char *mac_addr, const unsigned char *atm_addr,
  451. struct sk_buff *data)
  452. {
  453. struct sock *sk;
  454. struct sk_buff *skb;
  455. struct atmlec_msg *mesg;
  456. if (!priv || !priv->lecd)
  457. return -1;
  458. skb = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC);
  459. if (!skb)
  460. return -1;
  461. skb->len = sizeof(struct atmlec_msg);
  462. mesg = (struct atmlec_msg *)skb->data;
  463. memset(mesg, 0, sizeof(struct atmlec_msg));
  464. mesg->type = type;
  465. if (data != NULL)
  466. mesg->sizeoftlvs = data->len;
  467. if (mac_addr)
  468. ether_addr_copy(mesg->content.normal.mac_addr, mac_addr);
  469. else
  470. mesg->content.normal.targetless_le_arp = 1;
  471. if (atm_addr)
  472. memcpy(&mesg->content.normal.atm_addr, atm_addr, ATM_ESA_LEN);
  473. atm_force_charge(priv->lecd, skb->truesize);
  474. sk = sk_atm(priv->lecd);
  475. skb_queue_tail(&sk->sk_receive_queue, skb);
  476. sk->sk_data_ready(sk);
  477. if (data != NULL) {
  478. pr_debug("about to send %d bytes of data\n", data->len);
  479. atm_force_charge(priv->lecd, data->truesize);
  480. skb_queue_tail(&sk->sk_receive_queue, data);
  481. sk->sk_data_ready(sk);
  482. }
  483. return 0;
  484. }
  485. /* shamelessly stolen from drivers/net/net_init.c */
  486. static int lec_change_mtu(struct net_device *dev, int new_mtu)
  487. {
  488. if ((new_mtu < 68) || (new_mtu > 18190))
  489. return -EINVAL;
  490. dev->mtu = new_mtu;
  491. return 0;
  492. }
  493. static void lec_set_multicast_list(struct net_device *dev)
  494. {
  495. /*
  496. * by default, all multicast frames arrive over the bus.
  497. * eventually support selective multicast service
  498. */
  499. }
  500. static const struct net_device_ops lec_netdev_ops = {
  501. .ndo_open = lec_open,
  502. .ndo_stop = lec_close,
  503. .ndo_start_xmit = lec_start_xmit,
  504. .ndo_change_mtu = lec_change_mtu,
  505. .ndo_tx_timeout = lec_tx_timeout,
  506. .ndo_set_rx_mode = lec_set_multicast_list,
  507. };
  508. static const unsigned char lec_ctrl_magic[] = {
  509. 0xff,
  510. 0x00,
  511. 0x01,
  512. 0x01
  513. };
  514. #define LEC_DATA_DIRECT_8023 2
  515. #define LEC_DATA_DIRECT_8025 3
  516. static int lec_is_data_direct(struct atm_vcc *vcc)
  517. {
  518. return ((vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8023) ||
  519. (vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8025));
  520. }
  521. static void lec_push(struct atm_vcc *vcc, struct sk_buff *skb)
  522. {
  523. unsigned long flags;
  524. struct net_device *dev = (struct net_device *)vcc->proto_data;
  525. struct lec_priv *priv = netdev_priv(dev);
  526. #if DUMP_PACKETS > 0
  527. printk(KERN_DEBUG "%s: vcc vpi:%d vci:%d\n",
  528. dev->name, vcc->vpi, vcc->vci);
  529. #endif
  530. if (!skb) {
  531. pr_debug("%s: null skb\n", dev->name);
  532. lec_vcc_close(priv, vcc);
  533. return;
  534. }
  535. #if DUMP_PACKETS >= 2
  536. #define MAX_SKB_DUMP 99
  537. #elif DUMP_PACKETS >= 1
  538. #define MAX_SKB_DUMP 30
  539. #endif
  540. #if DUMP_PACKETS > 0
  541. printk(KERN_DEBUG "%s: rcv datalen:%ld lecid:%4.4x\n",
  542. dev->name, skb->len, priv->lecid);
  543. print_hex_dump(KERN_DEBUG, "", DUMP_OFFSET, 16, 1,
  544. skb->data, min(MAX_SKB_DUMP, skb->len), true);
  545. #endif /* DUMP_PACKETS > 0 */
  546. if (memcmp(skb->data, lec_ctrl_magic, 4) == 0) {
  547. /* Control frame, to daemon */
  548. struct sock *sk = sk_atm(vcc);
  549. pr_debug("%s: To daemon\n", dev->name);
  550. skb_queue_tail(&sk->sk_receive_queue, skb);
  551. sk->sk_data_ready(sk);
  552. } else { /* Data frame, queue to protocol handlers */
  553. struct lec_arp_table *entry;
  554. unsigned char *src, *dst;
  555. atm_return(vcc, skb->truesize);
  556. if (*(__be16 *) skb->data == htons(priv->lecid) ||
  557. !priv->lecd || !(dev->flags & IFF_UP)) {
  558. /*
  559. * Probably looping back, or if lecd is missing,
  560. * lecd has gone down
  561. */
  562. pr_debug("Ignoring frame...\n");
  563. dev_kfree_skb(skb);
  564. return;
  565. }
  566. dst = ((struct lecdatahdr_8023 *)skb->data)->h_dest;
  567. /*
  568. * If this is a Data Direct VCC, and the VCC does not match
  569. * the LE_ARP cache entry, delete the LE_ARP cache entry.
  570. */
  571. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  572. if (lec_is_data_direct(vcc)) {
  573. src = ((struct lecdatahdr_8023 *)skb->data)->h_source;
  574. entry = lec_arp_find(priv, src);
  575. if (entry && entry->vcc != vcc) {
  576. lec_arp_remove(priv, entry);
  577. lec_arp_put(entry);
  578. }
  579. }
  580. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  581. if (!(dst[0] & 0x01) && /* Never filter Multi/Broadcast */
  582. !priv->is_proxy && /* Proxy wants all the packets */
  583. memcmp(dst, dev->dev_addr, dev->addr_len)) {
  584. dev_kfree_skb(skb);
  585. return;
  586. }
  587. if (!hlist_empty(&priv->lec_arp_empty_ones))
  588. lec_arp_check_empties(priv, vcc, skb);
  589. skb_pull(skb, 2); /* skip lec_id */
  590. skb->protocol = eth_type_trans(skb, dev);
  591. dev->stats.rx_packets++;
  592. dev->stats.rx_bytes += skb->len;
  593. memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
  594. netif_rx(skb);
  595. }
  596. }
  597. static void lec_pop(struct atm_vcc *vcc, struct sk_buff *skb)
  598. {
  599. struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
  600. struct net_device *dev = skb->dev;
  601. if (vpriv == NULL) {
  602. pr_info("vpriv = NULL!?!?!?\n");
  603. return;
  604. }
  605. vpriv->old_pop(vcc, skb);
  606. if (vpriv->xoff && atm_may_send(vcc, 0)) {
  607. vpriv->xoff = 0;
  608. if (netif_running(dev) && netif_queue_stopped(dev))
  609. netif_wake_queue(dev);
  610. }
  611. }
  612. static int lec_vcc_attach(struct atm_vcc *vcc, void __user *arg)
  613. {
  614. struct lec_vcc_priv *vpriv;
  615. int bytes_left;
  616. struct atmlec_ioc ioc_data;
  617. /* Lecd must be up in this case */
  618. bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmlec_ioc));
  619. if (bytes_left != 0)
  620. pr_info("copy from user failed for %d bytes\n", bytes_left);
  621. if (ioc_data.dev_num < 0 || ioc_data.dev_num >= MAX_LEC_ITF)
  622. return -EINVAL;
  623. ioc_data.dev_num = array_index_nospec(ioc_data.dev_num, MAX_LEC_ITF);
  624. if (!dev_lec[ioc_data.dev_num])
  625. return -EINVAL;
  626. vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL);
  627. if (!vpriv)
  628. return -ENOMEM;
  629. vpriv->xoff = 0;
  630. vpriv->old_pop = vcc->pop;
  631. vcc->user_back = vpriv;
  632. vcc->pop = lec_pop;
  633. lec_vcc_added(netdev_priv(dev_lec[ioc_data.dev_num]),
  634. &ioc_data, vcc, vcc->push);
  635. vcc->proto_data = dev_lec[ioc_data.dev_num];
  636. vcc->push = lec_push;
  637. return 0;
  638. }
  639. static int lec_mcast_attach(struct atm_vcc *vcc, int arg)
  640. {
  641. if (arg < 0 || arg >= MAX_LEC_ITF || !dev_lec[arg])
  642. return -EINVAL;
  643. vcc->proto_data = dev_lec[arg];
  644. return lec_mcast_make(netdev_priv(dev_lec[arg]), vcc);
  645. }
  646. /* Initialize device. */
  647. static int lecd_attach(struct atm_vcc *vcc, int arg)
  648. {
  649. int i;
  650. struct lec_priv *priv;
  651. if (arg < 0)
  652. i = 0;
  653. else
  654. i = arg;
  655. if (arg >= MAX_LEC_ITF)
  656. return -EINVAL;
  657. if (!dev_lec[i]) {
  658. int size;
  659. size = sizeof(struct lec_priv);
  660. dev_lec[i] = alloc_etherdev(size);
  661. if (!dev_lec[i])
  662. return -ENOMEM;
  663. dev_lec[i]->netdev_ops = &lec_netdev_ops;
  664. snprintf(dev_lec[i]->name, IFNAMSIZ, "lec%d", i);
  665. if (register_netdev(dev_lec[i])) {
  666. free_netdev(dev_lec[i]);
  667. return -EINVAL;
  668. }
  669. priv = netdev_priv(dev_lec[i]);
  670. } else {
  671. priv = netdev_priv(dev_lec[i]);
  672. if (priv->lecd)
  673. return -EADDRINUSE;
  674. }
  675. lec_arp_init(priv);
  676. priv->itfnum = i; /* LANE2 addition */
  677. priv->lecd = vcc;
  678. vcc->dev = &lecatm_dev;
  679. vcc_insert_socket(sk_atm(vcc));
  680. vcc->proto_data = dev_lec[i];
  681. set_bit(ATM_VF_META, &vcc->flags);
  682. set_bit(ATM_VF_READY, &vcc->flags);
  683. /* Set default values to these variables */
  684. priv->maximum_unknown_frame_count = 1;
  685. priv->max_unknown_frame_time = (1 * HZ);
  686. priv->vcc_timeout_period = (1200 * HZ);
  687. priv->max_retry_count = 1;
  688. priv->aging_time = (300 * HZ);
  689. priv->forward_delay_time = (15 * HZ);
  690. priv->topology_change = 0;
  691. priv->arp_response_time = (1 * HZ);
  692. priv->flush_timeout = (4 * HZ);
  693. priv->path_switching_delay = (6 * HZ);
  694. if (dev_lec[i]->flags & IFF_UP)
  695. netif_start_queue(dev_lec[i]);
  696. __module_get(THIS_MODULE);
  697. return i;
  698. }
  699. #ifdef CONFIG_PROC_FS
  700. static const char *lec_arp_get_status_string(unsigned char status)
  701. {
  702. static const char *const lec_arp_status_string[] = {
  703. "ESI_UNKNOWN ",
  704. "ESI_ARP_PENDING ",
  705. "ESI_VC_PENDING ",
  706. "<Undefined> ",
  707. "ESI_FLUSH_PENDING ",
  708. "ESI_FORWARD_DIRECT"
  709. };
  710. if (status > ESI_FORWARD_DIRECT)
  711. status = 3; /* ESI_UNDEFINED */
  712. return lec_arp_status_string[status];
  713. }
  714. static void lec_info(struct seq_file *seq, struct lec_arp_table *entry)
  715. {
  716. int i;
  717. for (i = 0; i < ETH_ALEN; i++)
  718. seq_printf(seq, "%2.2x", entry->mac_addr[i] & 0xff);
  719. seq_printf(seq, " ");
  720. for (i = 0; i < ATM_ESA_LEN; i++)
  721. seq_printf(seq, "%2.2x", entry->atm_addr[i] & 0xff);
  722. seq_printf(seq, " %s %4.4x", lec_arp_get_status_string(entry->status),
  723. entry->flags & 0xffff);
  724. if (entry->vcc)
  725. seq_printf(seq, "%3d %3d ", entry->vcc->vpi, entry->vcc->vci);
  726. else
  727. seq_printf(seq, " ");
  728. if (entry->recv_vcc) {
  729. seq_printf(seq, " %3d %3d", entry->recv_vcc->vpi,
  730. entry->recv_vcc->vci);
  731. }
  732. seq_putc(seq, '\n');
  733. }
  734. struct lec_state {
  735. unsigned long flags;
  736. struct lec_priv *locked;
  737. struct hlist_node *node;
  738. struct net_device *dev;
  739. int itf;
  740. int arp_table;
  741. int misc_table;
  742. };
  743. static void *lec_tbl_walk(struct lec_state *state, struct hlist_head *tbl,
  744. loff_t *l)
  745. {
  746. struct hlist_node *e = state->node;
  747. if (!e)
  748. e = tbl->first;
  749. if (e == SEQ_START_TOKEN) {
  750. e = tbl->first;
  751. --*l;
  752. }
  753. for (; e; e = e->next) {
  754. if (--*l < 0)
  755. break;
  756. }
  757. state->node = e;
  758. return (*l < 0) ? state : NULL;
  759. }
  760. static void *lec_arp_walk(struct lec_state *state, loff_t *l,
  761. struct lec_priv *priv)
  762. {
  763. void *v = NULL;
  764. int p;
  765. for (p = state->arp_table; p < LEC_ARP_TABLE_SIZE; p++) {
  766. v = lec_tbl_walk(state, &priv->lec_arp_tables[p], l);
  767. if (v)
  768. break;
  769. }
  770. state->arp_table = p;
  771. return v;
  772. }
  773. static void *lec_misc_walk(struct lec_state *state, loff_t *l,
  774. struct lec_priv *priv)
  775. {
  776. struct hlist_head *lec_misc_tables[] = {
  777. &priv->lec_arp_empty_ones,
  778. &priv->lec_no_forward,
  779. &priv->mcast_fwds
  780. };
  781. void *v = NULL;
  782. int q;
  783. for (q = state->misc_table; q < ARRAY_SIZE(lec_misc_tables); q++) {
  784. v = lec_tbl_walk(state, lec_misc_tables[q], l);
  785. if (v)
  786. break;
  787. }
  788. state->misc_table = q;
  789. return v;
  790. }
  791. static void *lec_priv_walk(struct lec_state *state, loff_t *l,
  792. struct lec_priv *priv)
  793. {
  794. if (!state->locked) {
  795. state->locked = priv;
  796. spin_lock_irqsave(&priv->lec_arp_lock, state->flags);
  797. }
  798. if (!lec_arp_walk(state, l, priv) && !lec_misc_walk(state, l, priv)) {
  799. spin_unlock_irqrestore(&priv->lec_arp_lock, state->flags);
  800. state->locked = NULL;
  801. /* Partial state reset for the next time we get called */
  802. state->arp_table = state->misc_table = 0;
  803. }
  804. return state->locked;
  805. }
  806. static void *lec_itf_walk(struct lec_state *state, loff_t *l)
  807. {
  808. struct net_device *dev;
  809. void *v;
  810. dev = state->dev ? state->dev : dev_lec[state->itf];
  811. v = (dev && netdev_priv(dev)) ?
  812. lec_priv_walk(state, l, netdev_priv(dev)) : NULL;
  813. if (!v && dev) {
  814. dev_put(dev);
  815. /* Partial state reset for the next time we get called */
  816. dev = NULL;
  817. }
  818. state->dev = dev;
  819. return v;
  820. }
  821. static void *lec_get_idx(struct lec_state *state, loff_t l)
  822. {
  823. void *v = NULL;
  824. for (; state->itf < MAX_LEC_ITF; state->itf++) {
  825. v = lec_itf_walk(state, &l);
  826. if (v)
  827. break;
  828. }
  829. return v;
  830. }
  831. static void *lec_seq_start(struct seq_file *seq, loff_t *pos)
  832. {
  833. struct lec_state *state = seq->private;
  834. state->itf = 0;
  835. state->dev = NULL;
  836. state->locked = NULL;
  837. state->arp_table = 0;
  838. state->misc_table = 0;
  839. state->node = SEQ_START_TOKEN;
  840. return *pos ? lec_get_idx(state, *pos) : SEQ_START_TOKEN;
  841. }
  842. static void lec_seq_stop(struct seq_file *seq, void *v)
  843. {
  844. struct lec_state *state = seq->private;
  845. if (state->dev) {
  846. spin_unlock_irqrestore(&state->locked->lec_arp_lock,
  847. state->flags);
  848. dev_put(state->dev);
  849. }
  850. }
  851. static void *lec_seq_next(struct seq_file *seq, void *v, loff_t *pos)
  852. {
  853. struct lec_state *state = seq->private;
  854. v = lec_get_idx(state, 1);
  855. *pos += !!PTR_ERR(v);
  856. return v;
  857. }
  858. static int lec_seq_show(struct seq_file *seq, void *v)
  859. {
  860. static const char lec_banner[] =
  861. "Itf MAC ATM destination"
  862. " Status Flags "
  863. "VPI/VCI Recv VPI/VCI\n";
  864. if (v == SEQ_START_TOKEN)
  865. seq_puts(seq, lec_banner);
  866. else {
  867. struct lec_state *state = seq->private;
  868. struct net_device *dev = state->dev;
  869. struct lec_arp_table *entry = hlist_entry(state->node,
  870. struct lec_arp_table,
  871. next);
  872. seq_printf(seq, "%s ", dev->name);
  873. lec_info(seq, entry);
  874. }
  875. return 0;
  876. }
  877. static const struct seq_operations lec_seq_ops = {
  878. .start = lec_seq_start,
  879. .next = lec_seq_next,
  880. .stop = lec_seq_stop,
  881. .show = lec_seq_show,
  882. };
  883. static int lec_seq_open(struct inode *inode, struct file *file)
  884. {
  885. return seq_open_private(file, &lec_seq_ops, sizeof(struct lec_state));
  886. }
  887. static const struct file_operations lec_seq_fops = {
  888. .owner = THIS_MODULE,
  889. .open = lec_seq_open,
  890. .read = seq_read,
  891. .llseek = seq_lseek,
  892. .release = seq_release_private,
  893. };
  894. #endif
  895. static int lane_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  896. {
  897. struct atm_vcc *vcc = ATM_SD(sock);
  898. int err = 0;
  899. switch (cmd) {
  900. case ATMLEC_CTRL:
  901. case ATMLEC_MCAST:
  902. case ATMLEC_DATA:
  903. if (!capable(CAP_NET_ADMIN))
  904. return -EPERM;
  905. break;
  906. default:
  907. return -ENOIOCTLCMD;
  908. }
  909. switch (cmd) {
  910. case ATMLEC_CTRL:
  911. err = lecd_attach(vcc, (int)arg);
  912. if (err >= 0)
  913. sock->state = SS_CONNECTED;
  914. break;
  915. case ATMLEC_MCAST:
  916. err = lec_mcast_attach(vcc, (int)arg);
  917. break;
  918. case ATMLEC_DATA:
  919. err = lec_vcc_attach(vcc, (void __user *)arg);
  920. break;
  921. }
  922. return err;
  923. }
  924. static struct atm_ioctl lane_ioctl_ops = {
  925. .owner = THIS_MODULE,
  926. .ioctl = lane_ioctl,
  927. };
  928. static int __init lane_module_init(void)
  929. {
  930. #ifdef CONFIG_PROC_FS
  931. struct proc_dir_entry *p;
  932. p = proc_create("lec", S_IRUGO, atm_proc_root, &lec_seq_fops);
  933. if (!p) {
  934. pr_err("Unable to initialize /proc/net/atm/lec\n");
  935. return -ENOMEM;
  936. }
  937. #endif
  938. register_atm_ioctl(&lane_ioctl_ops);
  939. pr_info("lec.c: initialized\n");
  940. return 0;
  941. }
  942. static void __exit lane_module_cleanup(void)
  943. {
  944. int i;
  945. remove_proc_entry("lec", atm_proc_root);
  946. deregister_atm_ioctl(&lane_ioctl_ops);
  947. for (i = 0; i < MAX_LEC_ITF; i++) {
  948. if (dev_lec[i] != NULL) {
  949. unregister_netdev(dev_lec[i]);
  950. free_netdev(dev_lec[i]);
  951. dev_lec[i] = NULL;
  952. }
  953. }
  954. }
  955. module_init(lane_module_init);
  956. module_exit(lane_module_cleanup);
  957. /*
  958. * LANE2: 3.1.3, LE_RESOLVE.request
  959. * Non force allocates memory and fills in *tlvs, fills in *sizeoftlvs.
  960. * If sizeoftlvs == NULL the default TLVs associated with with this
  961. * lec will be used.
  962. * If dst_mac == NULL, targetless LE_ARP will be sent
  963. */
  964. static int lane2_resolve(struct net_device *dev, const u8 *dst_mac, int force,
  965. u8 **tlvs, u32 *sizeoftlvs)
  966. {
  967. unsigned long flags;
  968. struct lec_priv *priv = netdev_priv(dev);
  969. struct lec_arp_table *table;
  970. struct sk_buff *skb;
  971. int retval;
  972. if (force == 0) {
  973. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  974. table = lec_arp_find(priv, dst_mac);
  975. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  976. if (table == NULL)
  977. return -1;
  978. *tlvs = kmemdup(table->tlvs, table->sizeoftlvs, GFP_ATOMIC);
  979. if (*tlvs == NULL)
  980. return -1;
  981. *sizeoftlvs = table->sizeoftlvs;
  982. return 0;
  983. }
  984. if (sizeoftlvs == NULL)
  985. retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, NULL);
  986. else {
  987. skb = alloc_skb(*sizeoftlvs, GFP_ATOMIC);
  988. if (skb == NULL)
  989. return -1;
  990. skb->len = *sizeoftlvs;
  991. skb_copy_to_linear_data(skb, *tlvs, *sizeoftlvs);
  992. retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, skb);
  993. }
  994. return retval;
  995. }
  996. /*
  997. * LANE2: 3.1.4, LE_ASSOCIATE.request
  998. * Associate the *tlvs with the *lan_dst address.
  999. * Will overwrite any previous association
  1000. * Returns 1 for success, 0 for failure (out of memory)
  1001. *
  1002. */
  1003. static int lane2_associate_req(struct net_device *dev, const u8 *lan_dst,
  1004. const u8 *tlvs, u32 sizeoftlvs)
  1005. {
  1006. int retval;
  1007. struct sk_buff *skb;
  1008. struct lec_priv *priv = netdev_priv(dev);
  1009. if (!ether_addr_equal(lan_dst, dev->dev_addr))
  1010. return 0; /* not our mac address */
  1011. kfree(priv->tlvs); /* NULL if there was no previous association */
  1012. priv->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL);
  1013. if (priv->tlvs == NULL)
  1014. return 0;
  1015. priv->sizeoftlvs = sizeoftlvs;
  1016. skb = alloc_skb(sizeoftlvs, GFP_ATOMIC);
  1017. if (skb == NULL)
  1018. return 0;
  1019. skb->len = sizeoftlvs;
  1020. skb_copy_to_linear_data(skb, tlvs, sizeoftlvs);
  1021. retval = send_to_lecd(priv, l_associate_req, NULL, NULL, skb);
  1022. if (retval != 0)
  1023. pr_info("lec.c: lane2_associate_req() failed\n");
  1024. /*
  1025. * If the previous association has changed we must
  1026. * somehow notify other LANE entities about the change
  1027. */
  1028. return 1;
  1029. }
  1030. /*
  1031. * LANE2: 3.1.5, LE_ASSOCIATE.indication
  1032. *
  1033. */
  1034. static void lane2_associate_ind(struct net_device *dev, const u8 *mac_addr,
  1035. const u8 *tlvs, u32 sizeoftlvs)
  1036. {
  1037. #if 0
  1038. int i = 0;
  1039. #endif
  1040. struct lec_priv *priv = netdev_priv(dev);
  1041. #if 0 /*
  1042. * Why have the TLVs in LE_ARP entries
  1043. * since we do not use them? When you
  1044. * uncomment this code, make sure the
  1045. * TLVs get freed when entry is killed
  1046. */
  1047. struct lec_arp_table *entry = lec_arp_find(priv, mac_addr);
  1048. if (entry == NULL)
  1049. return; /* should not happen */
  1050. kfree(entry->tlvs);
  1051. entry->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL);
  1052. if (entry->tlvs == NULL)
  1053. return;
  1054. entry->sizeoftlvs = sizeoftlvs;
  1055. #endif
  1056. #if 0
  1057. pr_info("\n");
  1058. pr_info("dump of tlvs, sizeoftlvs=%d\n", sizeoftlvs);
  1059. while (i < sizeoftlvs)
  1060. pr_cont("%02x ", tlvs[i++]);
  1061. pr_cont("\n");
  1062. #endif
  1063. /* tell MPOA about the TLVs we saw */
  1064. if (priv->lane2_ops && priv->lane2_ops->associate_indicator) {
  1065. priv->lane2_ops->associate_indicator(dev, mac_addr,
  1066. tlvs, sizeoftlvs);
  1067. }
  1068. }
  1069. /*
  1070. * Here starts what used to lec_arpc.c
  1071. *
  1072. * lec_arpc.c was added here when making
  1073. * lane client modular. October 1997
  1074. */
  1075. #include <linux/types.h>
  1076. #include <linux/timer.h>
  1077. #include <linux/param.h>
  1078. #include <linux/atomic.h>
  1079. #include <linux/inetdevice.h>
  1080. #include <net/route.h>
  1081. #if 0
  1082. #define pr_debug(format, args...)
  1083. /*
  1084. #define pr_debug printk
  1085. */
  1086. #endif
  1087. #define DEBUG_ARP_TABLE 0
  1088. #define LEC_ARP_REFRESH_INTERVAL (3*HZ)
  1089. static void lec_arp_check_expire(struct work_struct *work);
  1090. static void lec_arp_expire_arp(unsigned long data);
  1091. /*
  1092. * Arp table funcs
  1093. */
  1094. #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE - 1))
  1095. /*
  1096. * Initialization of arp-cache
  1097. */
  1098. static void lec_arp_init(struct lec_priv *priv)
  1099. {
  1100. unsigned short i;
  1101. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++)
  1102. INIT_HLIST_HEAD(&priv->lec_arp_tables[i]);
  1103. INIT_HLIST_HEAD(&priv->lec_arp_empty_ones);
  1104. INIT_HLIST_HEAD(&priv->lec_no_forward);
  1105. INIT_HLIST_HEAD(&priv->mcast_fwds);
  1106. spin_lock_init(&priv->lec_arp_lock);
  1107. INIT_DELAYED_WORK(&priv->lec_arp_work, lec_arp_check_expire);
  1108. schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL);
  1109. }
  1110. static void lec_arp_clear_vccs(struct lec_arp_table *entry)
  1111. {
  1112. if (entry->vcc) {
  1113. struct atm_vcc *vcc = entry->vcc;
  1114. struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc);
  1115. struct net_device *dev = (struct net_device *)vcc->proto_data;
  1116. vcc->pop = vpriv->old_pop;
  1117. if (vpriv->xoff)
  1118. netif_wake_queue(dev);
  1119. kfree(vpriv);
  1120. vcc->user_back = NULL;
  1121. vcc->push = entry->old_push;
  1122. vcc_release_async(vcc, -EPIPE);
  1123. entry->vcc = NULL;
  1124. }
  1125. if (entry->recv_vcc) {
  1126. entry->recv_vcc->push = entry->old_recv_push;
  1127. vcc_release_async(entry->recv_vcc, -EPIPE);
  1128. entry->recv_vcc = NULL;
  1129. }
  1130. }
  1131. /*
  1132. * Insert entry to lec_arp_table
  1133. * LANE2: Add to the end of the list to satisfy 8.1.13
  1134. */
  1135. static inline void
  1136. lec_arp_add(struct lec_priv *priv, struct lec_arp_table *entry)
  1137. {
  1138. struct hlist_head *tmp;
  1139. tmp = &priv->lec_arp_tables[HASH(entry->mac_addr[ETH_ALEN - 1])];
  1140. hlist_add_head(&entry->next, tmp);
  1141. pr_debug("Added entry:%pM\n", entry->mac_addr);
  1142. }
  1143. /*
  1144. * Remove entry from lec_arp_table
  1145. */
  1146. static int
  1147. lec_arp_remove(struct lec_priv *priv, struct lec_arp_table *to_remove)
  1148. {
  1149. struct lec_arp_table *entry;
  1150. int i, remove_vcc = 1;
  1151. if (!to_remove)
  1152. return -1;
  1153. hlist_del(&to_remove->next);
  1154. del_timer(&to_remove->timer);
  1155. /*
  1156. * If this is the only MAC connected to this VCC,
  1157. * also tear down the VCC
  1158. */
  1159. if (to_remove->status >= ESI_FLUSH_PENDING) {
  1160. /*
  1161. * ESI_FLUSH_PENDING, ESI_FORWARD_DIRECT
  1162. */
  1163. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1164. hlist_for_each_entry(entry,
  1165. &priv->lec_arp_tables[i], next) {
  1166. if (memcmp(to_remove->atm_addr,
  1167. entry->atm_addr, ATM_ESA_LEN) == 0) {
  1168. remove_vcc = 0;
  1169. break;
  1170. }
  1171. }
  1172. }
  1173. if (remove_vcc)
  1174. lec_arp_clear_vccs(to_remove);
  1175. }
  1176. skb_queue_purge(&to_remove->tx_wait); /* FIXME: good place for this? */
  1177. pr_debug("Removed entry:%pM\n", to_remove->mac_addr);
  1178. return 0;
  1179. }
  1180. #if DEBUG_ARP_TABLE
  1181. static const char *get_status_string(unsigned char st)
  1182. {
  1183. switch (st) {
  1184. case ESI_UNKNOWN:
  1185. return "ESI_UNKNOWN";
  1186. case ESI_ARP_PENDING:
  1187. return "ESI_ARP_PENDING";
  1188. case ESI_VC_PENDING:
  1189. return "ESI_VC_PENDING";
  1190. case ESI_FLUSH_PENDING:
  1191. return "ESI_FLUSH_PENDING";
  1192. case ESI_FORWARD_DIRECT:
  1193. return "ESI_FORWARD_DIRECT";
  1194. }
  1195. return "<UNKNOWN>";
  1196. }
  1197. static void dump_arp_table(struct lec_priv *priv)
  1198. {
  1199. struct lec_arp_table *rulla;
  1200. char buf[256];
  1201. int i, j, offset;
  1202. pr_info("Dump %p:\n", priv);
  1203. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1204. hlist_for_each_entry(rulla,
  1205. &priv->lec_arp_tables[i], next) {
  1206. offset = 0;
  1207. offset += sprintf(buf, "%d: %p\n", i, rulla);
  1208. offset += sprintf(buf + offset, "Mac: %pM",
  1209. rulla->mac_addr);
  1210. offset += sprintf(buf + offset, " Atm:");
  1211. for (j = 0; j < ATM_ESA_LEN; j++) {
  1212. offset += sprintf(buf + offset,
  1213. "%2.2x ",
  1214. rulla->atm_addr[j] & 0xff);
  1215. }
  1216. offset += sprintf(buf + offset,
  1217. "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
  1218. rulla->vcc ? rulla->vcc->vpi : 0,
  1219. rulla->vcc ? rulla->vcc->vci : 0,
  1220. rulla->recv_vcc ? rulla->recv_vcc->
  1221. vpi : 0,
  1222. rulla->recv_vcc ? rulla->recv_vcc->
  1223. vci : 0, rulla->last_used,
  1224. rulla->timestamp, rulla->no_tries);
  1225. offset +=
  1226. sprintf(buf + offset,
  1227. "Flags:%x, Packets_flooded:%x, Status: %s ",
  1228. rulla->flags, rulla->packets_flooded,
  1229. get_status_string(rulla->status));
  1230. pr_info("%s\n", buf);
  1231. }
  1232. }
  1233. if (!hlist_empty(&priv->lec_no_forward))
  1234. pr_info("No forward\n");
  1235. hlist_for_each_entry(rulla, &priv->lec_no_forward, next) {
  1236. offset = 0;
  1237. offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr);
  1238. offset += sprintf(buf + offset, " Atm:");
  1239. for (j = 0; j < ATM_ESA_LEN; j++) {
  1240. offset += sprintf(buf + offset, "%2.2x ",
  1241. rulla->atm_addr[j] & 0xff);
  1242. }
  1243. offset += sprintf(buf + offset,
  1244. "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
  1245. rulla->vcc ? rulla->vcc->vpi : 0,
  1246. rulla->vcc ? rulla->vcc->vci : 0,
  1247. rulla->recv_vcc ? rulla->recv_vcc->vpi : 0,
  1248. rulla->recv_vcc ? rulla->recv_vcc->vci : 0,
  1249. rulla->last_used,
  1250. rulla->timestamp, rulla->no_tries);
  1251. offset += sprintf(buf + offset,
  1252. "Flags:%x, Packets_flooded:%x, Status: %s ",
  1253. rulla->flags, rulla->packets_flooded,
  1254. get_status_string(rulla->status));
  1255. pr_info("%s\n", buf);
  1256. }
  1257. if (!hlist_empty(&priv->lec_arp_empty_ones))
  1258. pr_info("Empty ones\n");
  1259. hlist_for_each_entry(rulla, &priv->lec_arp_empty_ones, next) {
  1260. offset = 0;
  1261. offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr);
  1262. offset += sprintf(buf + offset, " Atm:");
  1263. for (j = 0; j < ATM_ESA_LEN; j++) {
  1264. offset += sprintf(buf + offset, "%2.2x ",
  1265. rulla->atm_addr[j] & 0xff);
  1266. }
  1267. offset += sprintf(buf + offset,
  1268. "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
  1269. rulla->vcc ? rulla->vcc->vpi : 0,
  1270. rulla->vcc ? rulla->vcc->vci : 0,
  1271. rulla->recv_vcc ? rulla->recv_vcc->vpi : 0,
  1272. rulla->recv_vcc ? rulla->recv_vcc->vci : 0,
  1273. rulla->last_used,
  1274. rulla->timestamp, rulla->no_tries);
  1275. offset += sprintf(buf + offset,
  1276. "Flags:%x, Packets_flooded:%x, Status: %s ",
  1277. rulla->flags, rulla->packets_flooded,
  1278. get_status_string(rulla->status));
  1279. pr_info("%s", buf);
  1280. }
  1281. if (!hlist_empty(&priv->mcast_fwds))
  1282. pr_info("Multicast Forward VCCs\n");
  1283. hlist_for_each_entry(rulla, &priv->mcast_fwds, next) {
  1284. offset = 0;
  1285. offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr);
  1286. offset += sprintf(buf + offset, " Atm:");
  1287. for (j = 0; j < ATM_ESA_LEN; j++) {
  1288. offset += sprintf(buf + offset, "%2.2x ",
  1289. rulla->atm_addr[j] & 0xff);
  1290. }
  1291. offset += sprintf(buf + offset,
  1292. "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ",
  1293. rulla->vcc ? rulla->vcc->vpi : 0,
  1294. rulla->vcc ? rulla->vcc->vci : 0,
  1295. rulla->recv_vcc ? rulla->recv_vcc->vpi : 0,
  1296. rulla->recv_vcc ? rulla->recv_vcc->vci : 0,
  1297. rulla->last_used,
  1298. rulla->timestamp, rulla->no_tries);
  1299. offset += sprintf(buf + offset,
  1300. "Flags:%x, Packets_flooded:%x, Status: %s ",
  1301. rulla->flags, rulla->packets_flooded,
  1302. get_status_string(rulla->status));
  1303. pr_info("%s\n", buf);
  1304. }
  1305. }
  1306. #else
  1307. #define dump_arp_table(priv) do { } while (0)
  1308. #endif
  1309. /*
  1310. * Destruction of arp-cache
  1311. */
  1312. static void lec_arp_destroy(struct lec_priv *priv)
  1313. {
  1314. unsigned long flags;
  1315. struct hlist_node *next;
  1316. struct lec_arp_table *entry;
  1317. int i;
  1318. cancel_delayed_work_sync(&priv->lec_arp_work);
  1319. /*
  1320. * Remove all entries
  1321. */
  1322. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1323. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1324. hlist_for_each_entry_safe(entry, next,
  1325. &priv->lec_arp_tables[i], next) {
  1326. lec_arp_remove(priv, entry);
  1327. lec_arp_put(entry);
  1328. }
  1329. INIT_HLIST_HEAD(&priv->lec_arp_tables[i]);
  1330. }
  1331. hlist_for_each_entry_safe(entry, next,
  1332. &priv->lec_arp_empty_ones, next) {
  1333. del_timer_sync(&entry->timer);
  1334. lec_arp_clear_vccs(entry);
  1335. hlist_del(&entry->next);
  1336. lec_arp_put(entry);
  1337. }
  1338. INIT_HLIST_HEAD(&priv->lec_arp_empty_ones);
  1339. hlist_for_each_entry_safe(entry, next,
  1340. &priv->lec_no_forward, next) {
  1341. del_timer_sync(&entry->timer);
  1342. lec_arp_clear_vccs(entry);
  1343. hlist_del(&entry->next);
  1344. lec_arp_put(entry);
  1345. }
  1346. INIT_HLIST_HEAD(&priv->lec_no_forward);
  1347. hlist_for_each_entry_safe(entry, next, &priv->mcast_fwds, next) {
  1348. /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
  1349. lec_arp_clear_vccs(entry);
  1350. hlist_del(&entry->next);
  1351. lec_arp_put(entry);
  1352. }
  1353. INIT_HLIST_HEAD(&priv->mcast_fwds);
  1354. priv->mcast_vcc = NULL;
  1355. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1356. }
  1357. /*
  1358. * Find entry by mac_address
  1359. */
  1360. static struct lec_arp_table *lec_arp_find(struct lec_priv *priv,
  1361. const unsigned char *mac_addr)
  1362. {
  1363. struct hlist_head *head;
  1364. struct lec_arp_table *entry;
  1365. pr_debug("%pM\n", mac_addr);
  1366. head = &priv->lec_arp_tables[HASH(mac_addr[ETH_ALEN - 1])];
  1367. hlist_for_each_entry(entry, head, next) {
  1368. if (ether_addr_equal(mac_addr, entry->mac_addr))
  1369. return entry;
  1370. }
  1371. return NULL;
  1372. }
  1373. static struct lec_arp_table *make_entry(struct lec_priv *priv,
  1374. const unsigned char *mac_addr)
  1375. {
  1376. struct lec_arp_table *to_return;
  1377. to_return = kzalloc(sizeof(struct lec_arp_table), GFP_ATOMIC);
  1378. if (!to_return) {
  1379. pr_info("LEC: Arp entry kmalloc failed\n");
  1380. return NULL;
  1381. }
  1382. ether_addr_copy(to_return->mac_addr, mac_addr);
  1383. INIT_HLIST_NODE(&to_return->next);
  1384. setup_timer(&to_return->timer, lec_arp_expire_arp,
  1385. (unsigned long)to_return);
  1386. to_return->last_used = jiffies;
  1387. to_return->priv = priv;
  1388. skb_queue_head_init(&to_return->tx_wait);
  1389. atomic_set(&to_return->usage, 1);
  1390. return to_return;
  1391. }
  1392. /* Arp sent timer expired */
  1393. static void lec_arp_expire_arp(unsigned long data)
  1394. {
  1395. struct lec_arp_table *entry;
  1396. entry = (struct lec_arp_table *)data;
  1397. pr_debug("\n");
  1398. if (entry->status == ESI_ARP_PENDING) {
  1399. if (entry->no_tries <= entry->priv->max_retry_count) {
  1400. if (entry->is_rdesc)
  1401. send_to_lecd(entry->priv, l_rdesc_arp_xmt,
  1402. entry->mac_addr, NULL, NULL);
  1403. else
  1404. send_to_lecd(entry->priv, l_arp_xmt,
  1405. entry->mac_addr, NULL, NULL);
  1406. entry->no_tries++;
  1407. }
  1408. mod_timer(&entry->timer, jiffies + (1 * HZ));
  1409. }
  1410. }
  1411. /* Unknown/unused vcc expire, remove associated entry */
  1412. static void lec_arp_expire_vcc(unsigned long data)
  1413. {
  1414. unsigned long flags;
  1415. struct lec_arp_table *to_remove = (struct lec_arp_table *)data;
  1416. struct lec_priv *priv = to_remove->priv;
  1417. del_timer(&to_remove->timer);
  1418. pr_debug("%p %p: vpi:%d vci:%d\n",
  1419. to_remove, priv,
  1420. to_remove->vcc ? to_remove->recv_vcc->vpi : 0,
  1421. to_remove->vcc ? to_remove->recv_vcc->vci : 0);
  1422. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1423. hlist_del(&to_remove->next);
  1424. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1425. lec_arp_clear_vccs(to_remove);
  1426. lec_arp_put(to_remove);
  1427. }
  1428. static bool __lec_arp_check_expire(struct lec_arp_table *entry,
  1429. unsigned long now,
  1430. struct lec_priv *priv)
  1431. {
  1432. unsigned long time_to_check;
  1433. if ((entry->flags) & LEC_REMOTE_FLAG && priv->topology_change)
  1434. time_to_check = priv->forward_delay_time;
  1435. else
  1436. time_to_check = priv->aging_time;
  1437. pr_debug("About to expire: %lx - %lx > %lx\n",
  1438. now, entry->last_used, time_to_check);
  1439. if (time_after(now, entry->last_used + time_to_check) &&
  1440. !(entry->flags & LEC_PERMANENT_FLAG) &&
  1441. !(entry->mac_addr[0] & 0x01)) { /* LANE2: 7.1.20 */
  1442. /* Remove entry */
  1443. pr_debug("Entry timed out\n");
  1444. lec_arp_remove(priv, entry);
  1445. lec_arp_put(entry);
  1446. } else {
  1447. /* Something else */
  1448. if ((entry->status == ESI_VC_PENDING ||
  1449. entry->status == ESI_ARP_PENDING) &&
  1450. time_after_eq(now, entry->timestamp +
  1451. priv->max_unknown_frame_time)) {
  1452. entry->timestamp = jiffies;
  1453. entry->packets_flooded = 0;
  1454. if (entry->status == ESI_VC_PENDING)
  1455. send_to_lecd(priv, l_svc_setup,
  1456. entry->mac_addr,
  1457. entry->atm_addr,
  1458. NULL);
  1459. }
  1460. if (entry->status == ESI_FLUSH_PENDING &&
  1461. time_after_eq(now, entry->timestamp +
  1462. priv->path_switching_delay)) {
  1463. lec_arp_hold(entry);
  1464. return true;
  1465. }
  1466. }
  1467. return false;
  1468. }
  1469. /*
  1470. * Expire entries.
  1471. * 1. Re-set timer
  1472. * 2. For each entry, delete entries that have aged past the age limit.
  1473. * 3. For each entry, depending on the status of the entry, perform
  1474. * the following maintenance.
  1475. * a. If status is ESI_VC_PENDING or ESI_ARP_PENDING then if the
  1476. * tick_count is above the max_unknown_frame_time, clear
  1477. * the tick_count to zero and clear the packets_flooded counter
  1478. * to zero. This supports the packet rate limit per address
  1479. * while flooding unknowns.
  1480. * b. If the status is ESI_FLUSH_PENDING and the tick_count is greater
  1481. * than or equal to the path_switching_delay, change the status
  1482. * to ESI_FORWARD_DIRECT. This causes the flush period to end
  1483. * regardless of the progress of the flush protocol.
  1484. */
  1485. static void lec_arp_check_expire(struct work_struct *work)
  1486. {
  1487. unsigned long flags;
  1488. struct lec_priv *priv =
  1489. container_of(work, struct lec_priv, lec_arp_work.work);
  1490. struct hlist_node *next;
  1491. struct lec_arp_table *entry;
  1492. unsigned long now;
  1493. int i;
  1494. pr_debug("%p\n", priv);
  1495. now = jiffies;
  1496. restart:
  1497. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1498. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1499. hlist_for_each_entry_safe(entry, next,
  1500. &priv->lec_arp_tables[i], next) {
  1501. if (__lec_arp_check_expire(entry, now, priv)) {
  1502. struct sk_buff *skb;
  1503. struct atm_vcc *vcc = entry->vcc;
  1504. spin_unlock_irqrestore(&priv->lec_arp_lock,
  1505. flags);
  1506. while ((skb = skb_dequeue(&entry->tx_wait)))
  1507. lec_send(vcc, skb);
  1508. entry->last_used = jiffies;
  1509. entry->status = ESI_FORWARD_DIRECT;
  1510. lec_arp_put(entry);
  1511. goto restart;
  1512. }
  1513. }
  1514. }
  1515. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1516. schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL);
  1517. }
  1518. /*
  1519. * Try to find vcc where mac_address is attached.
  1520. *
  1521. */
  1522. static struct atm_vcc *lec_arp_resolve(struct lec_priv *priv,
  1523. const unsigned char *mac_to_find,
  1524. int is_rdesc,
  1525. struct lec_arp_table **ret_entry)
  1526. {
  1527. unsigned long flags;
  1528. struct lec_arp_table *entry;
  1529. struct atm_vcc *found;
  1530. if (mac_to_find[0] & 0x01) {
  1531. switch (priv->lane_version) {
  1532. case 1:
  1533. return priv->mcast_vcc;
  1534. case 2: /* LANE2 wants arp for multicast addresses */
  1535. if (ether_addr_equal(mac_to_find, bus_mac))
  1536. return priv->mcast_vcc;
  1537. break;
  1538. default:
  1539. break;
  1540. }
  1541. }
  1542. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1543. entry = lec_arp_find(priv, mac_to_find);
  1544. if (entry) {
  1545. if (entry->status == ESI_FORWARD_DIRECT) {
  1546. /* Connection Ok */
  1547. entry->last_used = jiffies;
  1548. lec_arp_hold(entry);
  1549. *ret_entry = entry;
  1550. found = entry->vcc;
  1551. goto out;
  1552. }
  1553. /*
  1554. * If the LE_ARP cache entry is still pending, reset count to 0
  1555. * so another LE_ARP request can be made for this frame.
  1556. */
  1557. if (entry->status == ESI_ARP_PENDING)
  1558. entry->no_tries = 0;
  1559. /*
  1560. * Data direct VC not yet set up, check to see if the unknown
  1561. * frame count is greater than the limit. If the limit has
  1562. * not been reached, allow the caller to send packet to
  1563. * BUS.
  1564. */
  1565. if (entry->status != ESI_FLUSH_PENDING &&
  1566. entry->packets_flooded <
  1567. priv->maximum_unknown_frame_count) {
  1568. entry->packets_flooded++;
  1569. pr_debug("Flooding..\n");
  1570. found = priv->mcast_vcc;
  1571. goto out;
  1572. }
  1573. /*
  1574. * We got here because entry->status == ESI_FLUSH_PENDING
  1575. * or BUS flood limit was reached for an entry which is
  1576. * in ESI_ARP_PENDING or ESI_VC_PENDING state.
  1577. */
  1578. lec_arp_hold(entry);
  1579. *ret_entry = entry;
  1580. pr_debug("entry->status %d entry->vcc %p\n", entry->status,
  1581. entry->vcc);
  1582. found = NULL;
  1583. } else {
  1584. /* No matching entry was found */
  1585. entry = make_entry(priv, mac_to_find);
  1586. pr_debug("Making entry\n");
  1587. if (!entry) {
  1588. found = priv->mcast_vcc;
  1589. goto out;
  1590. }
  1591. lec_arp_add(priv, entry);
  1592. /* We want arp-request(s) to be sent */
  1593. entry->packets_flooded = 1;
  1594. entry->status = ESI_ARP_PENDING;
  1595. entry->no_tries = 1;
  1596. entry->last_used = entry->timestamp = jiffies;
  1597. entry->is_rdesc = is_rdesc;
  1598. if (entry->is_rdesc)
  1599. send_to_lecd(priv, l_rdesc_arp_xmt, mac_to_find, NULL,
  1600. NULL);
  1601. else
  1602. send_to_lecd(priv, l_arp_xmt, mac_to_find, NULL, NULL);
  1603. entry->timer.expires = jiffies + (1 * HZ);
  1604. entry->timer.function = lec_arp_expire_arp;
  1605. add_timer(&entry->timer);
  1606. found = priv->mcast_vcc;
  1607. }
  1608. out:
  1609. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1610. return found;
  1611. }
  1612. static int
  1613. lec_addr_delete(struct lec_priv *priv, const unsigned char *atm_addr,
  1614. unsigned long permanent)
  1615. {
  1616. unsigned long flags;
  1617. struct hlist_node *next;
  1618. struct lec_arp_table *entry;
  1619. int i;
  1620. pr_debug("\n");
  1621. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1622. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1623. hlist_for_each_entry_safe(entry, next,
  1624. &priv->lec_arp_tables[i], next) {
  1625. if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN) &&
  1626. (permanent ||
  1627. !(entry->flags & LEC_PERMANENT_FLAG))) {
  1628. lec_arp_remove(priv, entry);
  1629. lec_arp_put(entry);
  1630. }
  1631. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1632. return 0;
  1633. }
  1634. }
  1635. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1636. return -1;
  1637. }
  1638. /*
  1639. * Notifies: Response to arp_request (atm_addr != NULL)
  1640. */
  1641. static void
  1642. lec_arp_update(struct lec_priv *priv, const unsigned char *mac_addr,
  1643. const unsigned char *atm_addr, unsigned long remoteflag,
  1644. unsigned int targetless_le_arp)
  1645. {
  1646. unsigned long flags;
  1647. struct hlist_node *next;
  1648. struct lec_arp_table *entry, *tmp;
  1649. int i;
  1650. pr_debug("%smac:%pM\n",
  1651. (targetless_le_arp) ? "targetless " : "", mac_addr);
  1652. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1653. entry = lec_arp_find(priv, mac_addr);
  1654. if (entry == NULL && targetless_le_arp)
  1655. goto out; /*
  1656. * LANE2: ignore targetless LE_ARPs for which
  1657. * we have no entry in the cache. 7.1.30
  1658. */
  1659. if (!hlist_empty(&priv->lec_arp_empty_ones)) {
  1660. hlist_for_each_entry_safe(entry, next,
  1661. &priv->lec_arp_empty_ones, next) {
  1662. if (memcmp(entry->atm_addr, atm_addr, ATM_ESA_LEN) == 0) {
  1663. hlist_del(&entry->next);
  1664. del_timer(&entry->timer);
  1665. tmp = lec_arp_find(priv, mac_addr);
  1666. if (tmp) {
  1667. del_timer(&tmp->timer);
  1668. tmp->status = ESI_FORWARD_DIRECT;
  1669. memcpy(tmp->atm_addr, atm_addr, ATM_ESA_LEN);
  1670. tmp->vcc = entry->vcc;
  1671. tmp->old_push = entry->old_push;
  1672. tmp->last_used = jiffies;
  1673. del_timer(&entry->timer);
  1674. lec_arp_put(entry);
  1675. entry = tmp;
  1676. } else {
  1677. entry->status = ESI_FORWARD_DIRECT;
  1678. ether_addr_copy(entry->mac_addr,
  1679. mac_addr);
  1680. entry->last_used = jiffies;
  1681. lec_arp_add(priv, entry);
  1682. }
  1683. if (remoteflag)
  1684. entry->flags |= LEC_REMOTE_FLAG;
  1685. else
  1686. entry->flags &= ~LEC_REMOTE_FLAG;
  1687. pr_debug("After update\n");
  1688. dump_arp_table(priv);
  1689. goto out;
  1690. }
  1691. }
  1692. }
  1693. entry = lec_arp_find(priv, mac_addr);
  1694. if (!entry) {
  1695. entry = make_entry(priv, mac_addr);
  1696. if (!entry)
  1697. goto out;
  1698. entry->status = ESI_UNKNOWN;
  1699. lec_arp_add(priv, entry);
  1700. /* Temporary, changes before end of function */
  1701. }
  1702. memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN);
  1703. del_timer(&entry->timer);
  1704. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1705. hlist_for_each_entry(tmp,
  1706. &priv->lec_arp_tables[i], next) {
  1707. if (entry != tmp &&
  1708. !memcmp(tmp->atm_addr, atm_addr, ATM_ESA_LEN)) {
  1709. /* Vcc to this host exists */
  1710. if (tmp->status > ESI_VC_PENDING) {
  1711. /*
  1712. * ESI_FLUSH_PENDING,
  1713. * ESI_FORWARD_DIRECT
  1714. */
  1715. entry->vcc = tmp->vcc;
  1716. entry->old_push = tmp->old_push;
  1717. }
  1718. entry->status = tmp->status;
  1719. break;
  1720. }
  1721. }
  1722. }
  1723. if (remoteflag)
  1724. entry->flags |= LEC_REMOTE_FLAG;
  1725. else
  1726. entry->flags &= ~LEC_REMOTE_FLAG;
  1727. if (entry->status == ESI_ARP_PENDING || entry->status == ESI_UNKNOWN) {
  1728. entry->status = ESI_VC_PENDING;
  1729. send_to_lecd(priv, l_svc_setup, entry->mac_addr, atm_addr, NULL);
  1730. }
  1731. pr_debug("After update2\n");
  1732. dump_arp_table(priv);
  1733. out:
  1734. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1735. }
  1736. /*
  1737. * Notifies: Vcc setup ready
  1738. */
  1739. static void
  1740. lec_vcc_added(struct lec_priv *priv, const struct atmlec_ioc *ioc_data,
  1741. struct atm_vcc *vcc,
  1742. void (*old_push) (struct atm_vcc *vcc, struct sk_buff *skb))
  1743. {
  1744. unsigned long flags;
  1745. struct lec_arp_table *entry;
  1746. int i, found_entry = 0;
  1747. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1748. /* Vcc for Multicast Forward. No timer, LANEv2 7.1.20 and 2.3.5.3 */
  1749. if (ioc_data->receive == 2) {
  1750. pr_debug("LEC_ARP: Attaching mcast forward\n");
  1751. #if 0
  1752. entry = lec_arp_find(priv, bus_mac);
  1753. if (!entry) {
  1754. pr_info("LEC_ARP: Multicast entry not found!\n");
  1755. goto out;
  1756. }
  1757. memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
  1758. entry->recv_vcc = vcc;
  1759. entry->old_recv_push = old_push;
  1760. #endif
  1761. entry = make_entry(priv, bus_mac);
  1762. if (entry == NULL)
  1763. goto out;
  1764. del_timer(&entry->timer);
  1765. memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
  1766. entry->recv_vcc = vcc;
  1767. entry->old_recv_push = old_push;
  1768. hlist_add_head(&entry->next, &priv->mcast_fwds);
  1769. goto out;
  1770. } else if (ioc_data->receive == 1) {
  1771. /*
  1772. * Vcc which we don't want to make default vcc,
  1773. * attach it anyway.
  1774. */
  1775. pr_debug("LEC_ARP:Attaching data direct, not default: %2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
  1776. ioc_data->atm_addr[0], ioc_data->atm_addr[1],
  1777. ioc_data->atm_addr[2], ioc_data->atm_addr[3],
  1778. ioc_data->atm_addr[4], ioc_data->atm_addr[5],
  1779. ioc_data->atm_addr[6], ioc_data->atm_addr[7],
  1780. ioc_data->atm_addr[8], ioc_data->atm_addr[9],
  1781. ioc_data->atm_addr[10], ioc_data->atm_addr[11],
  1782. ioc_data->atm_addr[12], ioc_data->atm_addr[13],
  1783. ioc_data->atm_addr[14], ioc_data->atm_addr[15],
  1784. ioc_data->atm_addr[16], ioc_data->atm_addr[17],
  1785. ioc_data->atm_addr[18], ioc_data->atm_addr[19]);
  1786. entry = make_entry(priv, bus_mac);
  1787. if (entry == NULL)
  1788. goto out;
  1789. memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
  1790. eth_zero_addr(entry->mac_addr);
  1791. entry->recv_vcc = vcc;
  1792. entry->old_recv_push = old_push;
  1793. entry->status = ESI_UNKNOWN;
  1794. entry->timer.expires = jiffies + priv->vcc_timeout_period;
  1795. entry->timer.function = lec_arp_expire_vcc;
  1796. hlist_add_head(&entry->next, &priv->lec_no_forward);
  1797. add_timer(&entry->timer);
  1798. dump_arp_table(priv);
  1799. goto out;
  1800. }
  1801. pr_debug("LEC_ARP:Attaching data direct, default: %2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x\n",
  1802. ioc_data->atm_addr[0], ioc_data->atm_addr[1],
  1803. ioc_data->atm_addr[2], ioc_data->atm_addr[3],
  1804. ioc_data->atm_addr[4], ioc_data->atm_addr[5],
  1805. ioc_data->atm_addr[6], ioc_data->atm_addr[7],
  1806. ioc_data->atm_addr[8], ioc_data->atm_addr[9],
  1807. ioc_data->atm_addr[10], ioc_data->atm_addr[11],
  1808. ioc_data->atm_addr[12], ioc_data->atm_addr[13],
  1809. ioc_data->atm_addr[14], ioc_data->atm_addr[15],
  1810. ioc_data->atm_addr[16], ioc_data->atm_addr[17],
  1811. ioc_data->atm_addr[18], ioc_data->atm_addr[19]);
  1812. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1813. hlist_for_each_entry(entry,
  1814. &priv->lec_arp_tables[i], next) {
  1815. if (memcmp
  1816. (ioc_data->atm_addr, entry->atm_addr,
  1817. ATM_ESA_LEN) == 0) {
  1818. pr_debug("LEC_ARP: Attaching data direct\n");
  1819. pr_debug("Currently -> Vcc: %d, Rvcc:%d\n",
  1820. entry->vcc ? entry->vcc->vci : 0,
  1821. entry->recv_vcc ? entry->recv_vcc->
  1822. vci : 0);
  1823. found_entry = 1;
  1824. del_timer(&entry->timer);
  1825. entry->vcc = vcc;
  1826. entry->old_push = old_push;
  1827. if (entry->status == ESI_VC_PENDING) {
  1828. if (priv->maximum_unknown_frame_count
  1829. == 0)
  1830. entry->status =
  1831. ESI_FORWARD_DIRECT;
  1832. else {
  1833. entry->timestamp = jiffies;
  1834. entry->status =
  1835. ESI_FLUSH_PENDING;
  1836. #if 0
  1837. send_to_lecd(priv, l_flush_xmt,
  1838. NULL,
  1839. entry->atm_addr,
  1840. NULL);
  1841. #endif
  1842. }
  1843. } else {
  1844. /*
  1845. * They were forming a connection
  1846. * to us, and we to them. Our
  1847. * ATM address is numerically lower
  1848. * than theirs, so we make connection
  1849. * we formed into default VCC (8.1.11).
  1850. * Connection they made gets torn
  1851. * down. This might confuse some
  1852. * clients. Can be changed if
  1853. * someone reports trouble...
  1854. */
  1855. ;
  1856. }
  1857. }
  1858. }
  1859. }
  1860. if (found_entry) {
  1861. pr_debug("After vcc was added\n");
  1862. dump_arp_table(priv);
  1863. goto out;
  1864. }
  1865. /*
  1866. * Not found, snatch address from first data packet that arrives
  1867. * from this vcc
  1868. */
  1869. entry = make_entry(priv, bus_mac);
  1870. if (!entry)
  1871. goto out;
  1872. entry->vcc = vcc;
  1873. entry->old_push = old_push;
  1874. memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
  1875. eth_zero_addr(entry->mac_addr);
  1876. entry->status = ESI_UNKNOWN;
  1877. hlist_add_head(&entry->next, &priv->lec_arp_empty_ones);
  1878. entry->timer.expires = jiffies + priv->vcc_timeout_period;
  1879. entry->timer.function = lec_arp_expire_vcc;
  1880. add_timer(&entry->timer);
  1881. pr_debug("After vcc was added\n");
  1882. dump_arp_table(priv);
  1883. out:
  1884. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1885. }
  1886. static void lec_flush_complete(struct lec_priv *priv, unsigned long tran_id)
  1887. {
  1888. unsigned long flags;
  1889. struct lec_arp_table *entry;
  1890. int i;
  1891. pr_debug("%lx\n", tran_id);
  1892. restart:
  1893. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1894. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1895. hlist_for_each_entry(entry,
  1896. &priv->lec_arp_tables[i], next) {
  1897. if (entry->flush_tran_id == tran_id &&
  1898. entry->status == ESI_FLUSH_PENDING) {
  1899. struct sk_buff *skb;
  1900. struct atm_vcc *vcc = entry->vcc;
  1901. lec_arp_hold(entry);
  1902. spin_unlock_irqrestore(&priv->lec_arp_lock,
  1903. flags);
  1904. while ((skb = skb_dequeue(&entry->tx_wait)))
  1905. lec_send(vcc, skb);
  1906. entry->last_used = jiffies;
  1907. entry->status = ESI_FORWARD_DIRECT;
  1908. lec_arp_put(entry);
  1909. pr_debug("LEC_ARP: Flushed\n");
  1910. goto restart;
  1911. }
  1912. }
  1913. }
  1914. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1915. dump_arp_table(priv);
  1916. }
  1917. static void
  1918. lec_set_flush_tran_id(struct lec_priv *priv,
  1919. const unsigned char *atm_addr, unsigned long tran_id)
  1920. {
  1921. unsigned long flags;
  1922. struct lec_arp_table *entry;
  1923. int i;
  1924. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1925. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++)
  1926. hlist_for_each_entry(entry,
  1927. &priv->lec_arp_tables[i], next) {
  1928. if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)) {
  1929. entry->flush_tran_id = tran_id;
  1930. pr_debug("Set flush transaction id to %lx for %p\n",
  1931. tran_id, entry);
  1932. }
  1933. }
  1934. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1935. }
  1936. static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc)
  1937. {
  1938. unsigned long flags;
  1939. unsigned char mac_addr[] = {
  1940. 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
  1941. };
  1942. struct lec_arp_table *to_add;
  1943. struct lec_vcc_priv *vpriv;
  1944. int err = 0;
  1945. vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL);
  1946. if (!vpriv)
  1947. return -ENOMEM;
  1948. vpriv->xoff = 0;
  1949. vpriv->old_pop = vcc->pop;
  1950. vcc->user_back = vpriv;
  1951. vcc->pop = lec_pop;
  1952. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1953. to_add = make_entry(priv, mac_addr);
  1954. if (!to_add) {
  1955. vcc->pop = vpriv->old_pop;
  1956. kfree(vpriv);
  1957. err = -ENOMEM;
  1958. goto out;
  1959. }
  1960. memcpy(to_add->atm_addr, vcc->remote.sas_addr.prv, ATM_ESA_LEN);
  1961. to_add->status = ESI_FORWARD_DIRECT;
  1962. to_add->flags |= LEC_PERMANENT_FLAG;
  1963. to_add->vcc = vcc;
  1964. to_add->old_push = vcc->push;
  1965. vcc->push = lec_push;
  1966. priv->mcast_vcc = vcc;
  1967. lec_arp_add(priv, to_add);
  1968. out:
  1969. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  1970. return err;
  1971. }
  1972. static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc)
  1973. {
  1974. unsigned long flags;
  1975. struct hlist_node *next;
  1976. struct lec_arp_table *entry;
  1977. int i;
  1978. pr_debug("LEC_ARP: lec_vcc_close vpi:%d vci:%d\n", vcc->vpi, vcc->vci);
  1979. dump_arp_table(priv);
  1980. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  1981. for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) {
  1982. hlist_for_each_entry_safe(entry, next,
  1983. &priv->lec_arp_tables[i], next) {
  1984. if (vcc == entry->vcc) {
  1985. lec_arp_remove(priv, entry);
  1986. lec_arp_put(entry);
  1987. if (priv->mcast_vcc == vcc)
  1988. priv->mcast_vcc = NULL;
  1989. }
  1990. }
  1991. }
  1992. hlist_for_each_entry_safe(entry, next,
  1993. &priv->lec_arp_empty_ones, next) {
  1994. if (entry->vcc == vcc) {
  1995. lec_arp_clear_vccs(entry);
  1996. del_timer(&entry->timer);
  1997. hlist_del(&entry->next);
  1998. lec_arp_put(entry);
  1999. }
  2000. }
  2001. hlist_for_each_entry_safe(entry, next,
  2002. &priv->lec_no_forward, next) {
  2003. if (entry->recv_vcc == vcc) {
  2004. lec_arp_clear_vccs(entry);
  2005. del_timer(&entry->timer);
  2006. hlist_del(&entry->next);
  2007. lec_arp_put(entry);
  2008. }
  2009. }
  2010. hlist_for_each_entry_safe(entry, next, &priv->mcast_fwds, next) {
  2011. if (entry->recv_vcc == vcc) {
  2012. lec_arp_clear_vccs(entry);
  2013. /* No timer, LANEv2 7.1.20 and 2.3.5.3 */
  2014. hlist_del(&entry->next);
  2015. lec_arp_put(entry);
  2016. }
  2017. }
  2018. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  2019. dump_arp_table(priv);
  2020. }
  2021. static void
  2022. lec_arp_check_empties(struct lec_priv *priv,
  2023. struct atm_vcc *vcc, struct sk_buff *skb)
  2024. {
  2025. unsigned long flags;
  2026. struct hlist_node *next;
  2027. struct lec_arp_table *entry, *tmp;
  2028. struct lecdatahdr_8023 *hdr = (struct lecdatahdr_8023 *)skb->data;
  2029. unsigned char *src = hdr->h_source;
  2030. spin_lock_irqsave(&priv->lec_arp_lock, flags);
  2031. hlist_for_each_entry_safe(entry, next,
  2032. &priv->lec_arp_empty_ones, next) {
  2033. if (vcc == entry->vcc) {
  2034. del_timer(&entry->timer);
  2035. ether_addr_copy(entry->mac_addr, src);
  2036. entry->status = ESI_FORWARD_DIRECT;
  2037. entry->last_used = jiffies;
  2038. /* We might have got an entry */
  2039. tmp = lec_arp_find(priv, src);
  2040. if (tmp) {
  2041. lec_arp_remove(priv, tmp);
  2042. lec_arp_put(tmp);
  2043. }
  2044. hlist_del(&entry->next);
  2045. lec_arp_add(priv, entry);
  2046. goto out;
  2047. }
  2048. }
  2049. pr_debug("LEC_ARP: Arp_check_empties: entry not found!\n");
  2050. out:
  2051. spin_unlock_irqrestore(&priv->lec_arp_lock, flags);
  2052. }
  2053. MODULE_LICENSE("GPL");