1 /* net/atm/clip.c - RFC1577 Classical IP over ATM */
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
5 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
7 #include <linux/string.h>
8 #include <linux/errno.h>
9 #include <linux/kernel.h> /* for UINT_MAX */
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/netdevice.h>
13 #include <linux/skbuff.h>
14 #include <linux/wait.h>
15 #include <linux/timer.h>
16 #include <linux/if_arp.h> /* for some manifest constants */
17 #include <linux/notifier.h>
18 #include <linux/atm.h>
19 #include <linux/atmdev.h>
20 #include <linux/atmclip.h>
21 #include <linux/atmarp.h>
22 #include <linux/capability.h>
23 #include <linux/ip.h> /* for net/route.h */
24 #include <linux/in.h> /* for struct sockaddr_in */
25 #include <linux/if.h> /* for IFF_UP */
26 #include <linux/inetdevice.h>
27 #include <linux/bitops.h>
28 #include <linux/poison.h>
29 #include <linux/proc_fs.h>
30 #include <linux/seq_file.h>
31 #include <linux/rcupdate.h>
32 #include <linux/jhash.h>
33 #include <linux/slab.h>
34 #include <net/route.h> /* for struct rtable and routing */
35 #include <net/icmp.h> /* icmp_send */
37 #include <linux/param.h> /* for HZ */
38 #include <linux/uaccess.h>
39 #include <asm/byteorder.h> /* for htons etc. */
40 #include <asm/system.h> /* save/restore_flags */
41 #include <linux/atomic.h>
44 #include "resources.h"
45 #include <net/atmclip.h>
47 static struct net_device
*clip_devs
;
48 static struct atm_vcc
*atmarpd
;
49 static struct timer_list idle_timer
;
50 static const struct neigh_ops clip_neigh_ops
;
52 static int to_atmarpd(enum atmarp_ctrl_type type
, int itf
, __be32 ip
)
55 struct atmarp_ctrl
*ctrl
;
58 pr_debug("(%d)\n", type
);
61 skb
= alloc_skb(sizeof(struct atmarp_ctrl
), GFP_ATOMIC
);
64 ctrl
= (struct atmarp_ctrl
*)skb_put(skb
, sizeof(struct atmarp_ctrl
));
68 atm_force_charge(atmarpd
, skb
->truesize
);
71 skb_queue_tail(&sk
->sk_receive_queue
, skb
);
72 sk
->sk_data_ready(sk
, skb
->len
);
76 static void link_vcc(struct clip_vcc
*clip_vcc
, struct atmarp_entry
*entry
)
78 pr_debug("%p to entry %p (neigh %p)\n", clip_vcc
, entry
, entry
->neigh
);
79 clip_vcc
->entry
= entry
;
80 clip_vcc
->xoff
= 0; /* @@@ may overrun buffer by one packet */
81 clip_vcc
->next
= entry
->vccs
;
82 entry
->vccs
= clip_vcc
;
83 entry
->neigh
->used
= jiffies
;
86 static void unlink_clip_vcc(struct clip_vcc
*clip_vcc
)
88 struct atmarp_entry
*entry
= clip_vcc
->entry
;
89 struct clip_vcc
**walk
;
92 pr_crit("!clip_vcc->entry (clip_vcc %p)\n", clip_vcc
);
95 netif_tx_lock_bh(entry
->neigh
->dev
); /* block clip_start_xmit() */
96 entry
->neigh
->used
= jiffies
;
97 for (walk
= &entry
->vccs
; *walk
; walk
= &(*walk
)->next
)
98 if (*walk
== clip_vcc
) {
101 *walk
= clip_vcc
->next
; /* atomic */
102 clip_vcc
->entry
= NULL
;
104 netif_wake_queue(entry
->neigh
->dev
);
107 entry
->expires
= jiffies
- 1;
108 /* force resolution or expiration */
109 error
= neigh_update(entry
->neigh
, NULL
, NUD_NONE
,
110 NEIGH_UPDATE_F_ADMIN
);
112 pr_crit("neigh_update failed with %d\n", error
);
115 pr_crit("ATMARP: failed (entry %p, vcc 0x%p)\n", entry
, clip_vcc
);
117 netif_tx_unlock_bh(entry
->neigh
->dev
);
120 /* The neighbour entry n->lock is held. */
121 static int neigh_check_cb(struct neighbour
*n
)
123 struct atmarp_entry
*entry
= neighbour_priv(n
);
126 if (n
->ops
!= &clip_neigh_ops
)
128 for (cv
= entry
->vccs
; cv
; cv
= cv
->next
) {
129 unsigned long exp
= cv
->last_use
+ cv
->idle_timeout
;
131 if (cv
->idle_timeout
&& time_after(jiffies
, exp
)) {
132 pr_debug("releasing vcc %p->%p of entry %p\n",
134 vcc_release_async(cv
->vcc
, -ETIMEDOUT
);
138 if (entry
->vccs
|| time_before(jiffies
, entry
->expires
))
141 if (atomic_read(&n
->refcnt
) > 1) {
144 pr_debug("destruction postponed with ref %d\n",
145 atomic_read(&n
->refcnt
));
147 while ((skb
= skb_dequeue(&n
->arp_queue
)) != NULL
)
153 pr_debug("expired neigh %p\n", n
);
157 static void idle_timer_check(unsigned long dummy
)
159 write_lock(&arp_tbl
.lock
);
160 __neigh_for_each_release(&arp_tbl
, neigh_check_cb
);
161 mod_timer(&idle_timer
, jiffies
+ CLIP_CHECK_INTERVAL
* HZ
);
162 write_unlock(&arp_tbl
.lock
);
165 static int clip_arp_rcv(struct sk_buff
*skb
)
170 vcc
= ATM_SKB(skb
)->vcc
;
171 if (!vcc
|| !atm_charge(vcc
, skb
->truesize
)) {
172 dev_kfree_skb_any(skb
);
175 pr_debug("pushing to %p\n", vcc
);
176 pr_debug("using %p\n", CLIP_VCC(vcc
)->old_push
);
177 CLIP_VCC(vcc
)->old_push(vcc
, skb
);
181 static const unsigned char llc_oui
[] = {
182 0xaa, /* DSAP: non-ISO */
183 0xaa, /* SSAP: non-ISO */
184 0x03, /* Ctrl: Unnumbered Information Command PDU */
185 0x00, /* OUI: EtherType */
190 static void clip_push(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
192 struct clip_vcc
*clip_vcc
= CLIP_VCC(vcc
);
197 atm_return(vcc
, skb
->truesize
);
203 pr_debug("removing VCC %p\n", clip_vcc
);
205 unlink_clip_vcc(clip_vcc
);
206 clip_vcc
->old_push(vcc
, NULL
); /* pass on the bad news */
210 atm_return(vcc
, skb
->truesize
);
211 skb
->dev
= clip_vcc
->entry
? clip_vcc
->entry
->neigh
->dev
: clip_devs
;
212 /* clip_vcc->entry == NULL if we don't have an IP address yet */
214 dev_kfree_skb_any(skb
);
217 ATM_SKB(skb
)->vcc
= vcc
;
218 skb_reset_mac_header(skb
);
219 if (!clip_vcc
->encap
||
220 skb
->len
< RFC1483LLC_LEN
||
221 memcmp(skb
->data
, llc_oui
, sizeof(llc_oui
)))
222 skb
->protocol
= htons(ETH_P_IP
);
224 skb
->protocol
= ((__be16
*)skb
->data
)[3];
225 skb_pull(skb
, RFC1483LLC_LEN
);
226 if (skb
->protocol
== htons(ETH_P_ARP
)) {
227 skb
->dev
->stats
.rx_packets
++;
228 skb
->dev
->stats
.rx_bytes
+= skb
->len
;
233 clip_vcc
->last_use
= jiffies
;
234 skb
->dev
->stats
.rx_packets
++;
235 skb
->dev
->stats
.rx_bytes
+= skb
->len
;
236 memset(ATM_SKB(skb
), 0, sizeof(struct atm_skb_data
));
241 * Note: these spinlocks _must_not_ block on non-SMP. The only goal is that
242 * clip_pop is atomic with respect to the critical section in clip_start_xmit.
245 static void clip_pop(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
247 struct clip_vcc
*clip_vcc
= CLIP_VCC(vcc
);
248 struct net_device
*dev
= skb
->dev
;
252 pr_debug("(vcc %p)\n", vcc
);
253 clip_vcc
->old_pop(vcc
, skb
);
254 /* skb->dev == NULL in outbound ARP packets */
257 spin_lock_irqsave(&PRIV(dev
)->xoff_lock
, flags
);
258 if (atm_may_send(vcc
, 0)) {
259 old
= xchg(&clip_vcc
->xoff
, 0);
261 netif_wake_queue(dev
);
263 spin_unlock_irqrestore(&PRIV(dev
)->xoff_lock
, flags
);
266 static void clip_neigh_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
268 __be32
*ip
= (__be32
*) neigh
->primary_key
;
270 pr_debug("(neigh %p, skb %p)\n", neigh
, skb
);
271 to_atmarpd(act_need
, PRIV(neigh
->dev
)->number
, *ip
);
274 static void clip_neigh_error(struct neighbour
*neigh
, struct sk_buff
*skb
)
276 #ifndef CONFIG_ATM_CLIP_NO_ICMP
277 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_HOST_UNREACH
, 0);
282 static const struct neigh_ops clip_neigh_ops
= {
284 .solicit
= clip_neigh_solicit
,
285 .error_report
= clip_neigh_error
,
286 .output
= neigh_direct_output
,
287 .connected_output
= neigh_direct_output
,
290 static int clip_constructor(struct neighbour
*neigh
)
292 struct atmarp_entry
*entry
= neighbour_priv(neigh
);
294 if (neigh
->tbl
->family
!= AF_INET
)
297 if (neigh
->type
!= RTN_UNICAST
)
300 neigh
->nud_state
= NUD_NONE
;
301 neigh
->ops
= &clip_neigh_ops
;
302 neigh
->output
= neigh
->ops
->output
;
303 entry
->neigh
= neigh
;
305 entry
->expires
= jiffies
- 1;
310 /* @@@ copy bh locking from arp.c -- need to bh-enable atm code before */
313 * We play with the resolve flag: 0 and 1 have the usual meaning, but -1 means
314 * to allocate the neighbour entry but not to ask atmarpd for resolution. Also,
315 * don't increment the usage count. This is used to create entries in
319 static int clip_encap(struct atm_vcc
*vcc
, int mode
)
321 CLIP_VCC(vcc
)->encap
= mode
;
325 static netdev_tx_t
clip_start_xmit(struct sk_buff
*skb
,
326 struct net_device
*dev
)
328 struct clip_priv
*clip_priv
= PRIV(dev
);
329 struct dst_entry
*dst
= skb_dst(skb
);
330 struct atmarp_entry
*entry
;
338 pr_debug("(skb %p)\n", skb
);
340 pr_err("skb_dst(skb) == NULL\n");
342 dev
->stats
.tx_dropped
++;
345 rt
= (struct rtable
*) dst
;
347 daddr
= &rt
->rt_gateway
;
349 daddr
= &ip_hdr(skb
)->daddr
;
350 n
= dst_neigh_lookup(dst
, daddr
);
352 pr_err("NO NEIGHBOUR !\n");
354 dev
->stats
.tx_dropped
++;
357 entry
= neighbour_priv(n
);
359 if (time_after(jiffies
, entry
->expires
)) {
360 /* should be resolved */
361 entry
->expires
= jiffies
+ ATMARP_RETRY_DELAY
* HZ
;
362 to_atmarpd(act_need
, PRIV(dev
)->number
, *((__be32
*)n
->primary_key
));
364 if (entry
->neigh
->arp_queue
.qlen
< ATMARP_MAX_UNRES_PACKETS
)
365 skb_queue_tail(&entry
->neigh
->arp_queue
, skb
);
368 dev
->stats
.tx_dropped
++;
370 goto out_release_neigh
;
372 pr_debug("neigh %p, vccs %p\n", entry
, entry
->vccs
);
373 ATM_SKB(skb
)->vcc
= vcc
= entry
->vccs
->vcc
;
374 pr_debug("using neighbour %p, vcc %p\n", n
, vcc
);
375 if (entry
->vccs
->encap
) {
378 here
= skb_push(skb
, RFC1483LLC_LEN
);
379 memcpy(here
, llc_oui
, sizeof(llc_oui
));
380 ((__be16
*) here
)[3] = skb
->protocol
;
382 atomic_add(skb
->truesize
, &sk_atm(vcc
)->sk_wmem_alloc
);
383 ATM_SKB(skb
)->atm_options
= vcc
->atm_options
;
384 entry
->vccs
->last_use
= jiffies
;
385 pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb
, vcc
, vcc
->dev
);
386 old
= xchg(&entry
->vccs
->xoff
, 1); /* assume XOFF ... */
388 pr_warning("XOFF->XOFF transition\n");
389 goto out_release_neigh
;
391 dev
->stats
.tx_packets
++;
392 dev
->stats
.tx_bytes
+= skb
->len
;
394 if (atm_may_send(vcc
, 0)) {
395 entry
->vccs
->xoff
= 0;
396 goto out_release_neigh
;
398 spin_lock_irqsave(&clip_priv
->xoff_lock
, flags
);
399 netif_stop_queue(dev
); /* XOFF -> throttle immediately */
401 if (!entry
->vccs
->xoff
)
402 netif_start_queue(dev
);
403 /* Oh, we just raced with clip_pop. netif_start_queue should be
404 good enough, because nothing should really be asleep because
405 of the brief netif_stop_queue. If this isn't true or if it
406 changes, use netif_wake_queue instead. */
407 spin_unlock_irqrestore(&clip_priv
->xoff_lock
, flags
);
413 static int clip_mkip(struct atm_vcc
*vcc
, int timeout
)
415 struct clip_vcc
*clip_vcc
;
419 clip_vcc
= kmalloc(sizeof(struct clip_vcc
), GFP_KERNEL
);
422 pr_debug("%p vcc %p\n", clip_vcc
, vcc
);
424 vcc
->user_back
= clip_vcc
;
425 set_bit(ATM_VF_IS_CLIP
, &vcc
->flags
);
426 clip_vcc
->entry
= NULL
;
429 clip_vcc
->last_use
= jiffies
;
430 clip_vcc
->idle_timeout
= timeout
* HZ
;
431 clip_vcc
->old_push
= vcc
->push
;
432 clip_vcc
->old_pop
= vcc
->pop
;
433 vcc
->push
= clip_push
;
436 /* re-process everything received between connection setup and MKIP */
437 vcc_process_recv_queue(vcc
);
442 static int clip_setentry(struct atm_vcc
*vcc
, __be32 ip
)
444 struct neighbour
*neigh
;
445 struct atmarp_entry
*entry
;
447 struct clip_vcc
*clip_vcc
;
450 if (vcc
->push
!= clip_push
) {
451 pr_warning("non-CLIP VCC\n");
454 clip_vcc
= CLIP_VCC(vcc
);
456 if (!clip_vcc
->entry
) {
457 pr_err("hiding hidden ATMARP entry\n");
460 pr_debug("remove\n");
461 unlink_clip_vcc(clip_vcc
);
464 rt
= ip_route_output(&init_net
, ip
, 0, 1, 0);
467 neigh
= __neigh_lookup(&arp_tbl
, &ip
, rt
->dst
.dev
, 1);
471 entry
= neighbour_priv(neigh
);
472 if (entry
!= clip_vcc
->entry
) {
473 if (!clip_vcc
->entry
)
476 pr_debug("update\n");
477 unlink_clip_vcc(clip_vcc
);
479 link_vcc(clip_vcc
, entry
);
481 error
= neigh_update(neigh
, llc_oui
, NUD_PERMANENT
,
482 NEIGH_UPDATE_F_OVERRIDE
| NEIGH_UPDATE_F_ADMIN
);
483 neigh_release(neigh
);
487 static const struct net_device_ops clip_netdev_ops
= {
488 .ndo_start_xmit
= clip_start_xmit
,
489 .ndo_neigh_construct
= clip_constructor
,
492 static void clip_setup(struct net_device
*dev
)
494 dev
->netdev_ops
= &clip_netdev_ops
;
495 dev
->type
= ARPHRD_ATM
;
496 dev
->neigh_priv_len
= sizeof(struct atmarp_entry
);
497 dev
->hard_header_len
= RFC1483LLC_LEN
;
498 dev
->mtu
= RFC1626_MTU
;
499 dev
->tx_queue_len
= 100; /* "normal" queue (packets) */
500 /* When using a "real" qdisc, the qdisc determines the queue */
501 /* length. tx_queue_len is only used for the default case, */
502 /* without any more elaborate queuing. 100 is a reasonable */
503 /* compromise between decent burst-tolerance and protection */
504 /* against memory hogs. */
505 dev
->priv_flags
&= ~IFF_XMIT_DST_RELEASE
;
508 static int clip_create(int number
)
510 struct net_device
*dev
;
511 struct clip_priv
*clip_priv
;
515 for (dev
= clip_devs
; dev
; dev
= PRIV(dev
)->next
)
516 if (PRIV(dev
)->number
== number
)
520 for (dev
= clip_devs
; dev
; dev
= PRIV(dev
)->next
)
521 if (PRIV(dev
)->number
>= number
)
522 number
= PRIV(dev
)->number
+ 1;
524 dev
= alloc_netdev(sizeof(struct clip_priv
), "", clip_setup
);
527 clip_priv
= PRIV(dev
);
528 sprintf(dev
->name
, "atm%d", number
);
529 spin_lock_init(&clip_priv
->xoff_lock
);
530 clip_priv
->number
= number
;
531 error
= register_netdev(dev
);
536 clip_priv
->next
= clip_devs
;
538 pr_debug("registered (net:%s)\n", dev
->name
);
542 static int clip_device_event(struct notifier_block
*this, unsigned long event
,
545 struct net_device
*dev
= arg
;
547 if (!net_eq(dev_net(dev
), &init_net
))
550 if (event
== NETDEV_UNREGISTER
)
553 /* ignore non-CLIP devices */
554 if (dev
->type
!= ARPHRD_ATM
|| dev
->netdev_ops
!= &clip_netdev_ops
)
559 pr_debug("NETDEV_UP\n");
560 to_atmarpd(act_up
, PRIV(dev
)->number
, 0);
562 case NETDEV_GOING_DOWN
:
563 pr_debug("NETDEV_DOWN\n");
564 to_atmarpd(act_down
, PRIV(dev
)->number
, 0);
567 case NETDEV_CHANGEMTU
:
568 pr_debug("NETDEV_CHANGE*\n");
569 to_atmarpd(act_change
, PRIV(dev
)->number
, 0);
575 static int clip_inet_event(struct notifier_block
*this, unsigned long event
,
578 struct in_device
*in_dev
;
580 in_dev
= ((struct in_ifaddr
*)ifa
)->ifa_dev
;
582 * Transitions are of the down-change-up type, so it's sufficient to
583 * handle the change on up.
585 if (event
!= NETDEV_UP
)
587 return clip_device_event(this, NETDEV_CHANGE
, in_dev
->dev
);
590 static struct notifier_block clip_dev_notifier
= {
591 .notifier_call
= clip_device_event
,
596 static struct notifier_block clip_inet_notifier
= {
597 .notifier_call
= clip_inet_event
,
602 static void atmarpd_close(struct atm_vcc
*vcc
)
608 skb_queue_purge(&sk_atm(vcc
)->sk_receive_queue
);
611 pr_debug("(done)\n");
612 module_put(THIS_MODULE
);
615 static struct atmdev_ops atmarpd_dev_ops
= {
616 .close
= atmarpd_close
620 static struct atm_dev atmarpd_dev
= {
621 .ops
= &atmarpd_dev_ops
,
624 .lock
= __SPIN_LOCK_UNLOCKED(atmarpd_dev
.lock
)
628 static int atm_init_atmarp(struct atm_vcc
*vcc
)
636 mod_timer(&idle_timer
, jiffies
+ CLIP_CHECK_INTERVAL
* HZ
);
639 set_bit(ATM_VF_META
, &vcc
->flags
);
640 set_bit(ATM_VF_READY
, &vcc
->flags
);
641 /* allow replies and avoid getting closed if signaling dies */
642 vcc
->dev
= &atmarpd_dev
;
643 vcc_insert_socket(sk_atm(vcc
));
645 vcc
->pop
= NULL
; /* crash */
646 vcc
->push_oam
= NULL
; /* crash */
651 static int clip_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
653 struct atm_vcc
*vcc
= ATM_SD(sock
);
660 case ATMARP_SETENTRY
:
662 if (!capable(CAP_NET_ADMIN
))
671 err
= clip_create(arg
);
674 err
= atm_init_atmarp(vcc
);
676 sock
->state
= SS_CONNECTED
;
677 __module_get(THIS_MODULE
);
681 err
= clip_mkip(vcc
, arg
);
683 case ATMARP_SETENTRY
:
684 err
= clip_setentry(vcc
, (__force __be32
)arg
);
687 err
= clip_encap(vcc
, arg
);
693 static struct atm_ioctl clip_ioctl_ops
= {
694 .owner
= THIS_MODULE
,
698 #ifdef CONFIG_PROC_FS
700 static void svc_addr(struct seq_file
*seq
, struct sockaddr_atmsvc
*addr
)
702 static int code
[] = { 1, 2, 10, 6, 1, 0 };
703 static int e164
[] = { 1, 8, 4, 6, 1, 0 };
705 if (*addr
->sas_addr
.pub
) {
706 seq_printf(seq
, "%s", addr
->sas_addr
.pub
);
707 if (*addr
->sas_addr
.prv
)
709 } else if (!*addr
->sas_addr
.prv
) {
710 seq_printf(seq
, "%s", "(none)");
713 if (*addr
->sas_addr
.prv
) {
714 unsigned char *prv
= addr
->sas_addr
.prv
;
718 fields
= *prv
== ATM_AFI_E164
? e164
: code
;
719 for (i
= 0; fields
[i
]; i
++) {
720 for (j
= fields
[i
]; j
; j
--)
721 seq_printf(seq
, "%02X", *prv
++);
728 /* This means the neighbour entry has no attached VCC objects. */
729 #define SEQ_NO_VCC_TOKEN ((void *) 2)
731 static void atmarp_info(struct seq_file
*seq
, struct neighbour
*n
,
732 struct atmarp_entry
*entry
, struct clip_vcc
*clip_vcc
)
734 struct net_device
*dev
= n
->dev
;
739 svc
= ((clip_vcc
== SEQ_NO_VCC_TOKEN
) ||
740 (sk_atm(clip_vcc
->vcc
)->sk_family
== AF_ATMSVC
));
742 llc
= ((clip_vcc
== SEQ_NO_VCC_TOKEN
) || clip_vcc
->encap
);
744 if (clip_vcc
== SEQ_NO_VCC_TOKEN
)
745 exp
= entry
->neigh
->used
;
747 exp
= clip_vcc
->last_use
;
749 exp
= (jiffies
- exp
) / HZ
;
751 seq_printf(seq
, "%-6s%-4s%-4s%5ld ",
752 dev
->name
, svc
? "SVC" : "PVC", llc
? "LLC" : "NULL", exp
);
754 off
= scnprintf(buf
, sizeof(buf
) - 1, "%pI4", n
->primary_key
);
758 seq_printf(seq
, "%s", buf
);
760 if (clip_vcc
== SEQ_NO_VCC_TOKEN
) {
761 if (time_before(jiffies
, entry
->expires
))
762 seq_printf(seq
, "(resolving)\n");
764 seq_printf(seq
, "(expired, ref %d)\n",
765 atomic_read(&entry
->neigh
->refcnt
));
767 seq_printf(seq
, "%d.%d.%d\n",
768 clip_vcc
->vcc
->dev
->number
,
769 clip_vcc
->vcc
->vpi
, clip_vcc
->vcc
->vci
);
771 svc_addr(seq
, &clip_vcc
->vcc
->remote
);
776 struct clip_seq_state
{
777 /* This member must be first. */
778 struct neigh_seq_state ns
;
780 /* Local to clip specific iteration. */
781 struct clip_vcc
*vcc
;
784 static struct clip_vcc
*clip_seq_next_vcc(struct atmarp_entry
*e
,
785 struct clip_vcc
*curr
)
790 return SEQ_NO_VCC_TOKEN
;
793 if (curr
== SEQ_NO_VCC_TOKEN
)
801 static void *clip_seq_vcc_walk(struct clip_seq_state
*state
,
802 struct atmarp_entry
*e
, loff_t
* pos
)
804 struct clip_vcc
*vcc
= state
->vcc
;
806 vcc
= clip_seq_next_vcc(e
, vcc
);
807 if (vcc
&& pos
!= NULL
) {
809 vcc
= clip_seq_next_vcc(e
, vcc
);
820 static void *clip_seq_sub_iter(struct neigh_seq_state
*_state
,
821 struct neighbour
*n
, loff_t
* pos
)
823 struct clip_seq_state
*state
= (struct clip_seq_state
*)_state
;
825 if (n
->dev
->type
!= ARPHRD_ATM
)
828 return clip_seq_vcc_walk(state
, neighbour_priv(n
), pos
);
831 static void *clip_seq_start(struct seq_file
*seq
, loff_t
* pos
)
833 struct clip_seq_state
*state
= seq
->private;
834 state
->ns
.neigh_sub_iter
= clip_seq_sub_iter
;
835 return neigh_seq_start(seq
, pos
, &arp_tbl
, NEIGH_SEQ_NEIGH_ONLY
);
838 static int clip_seq_show(struct seq_file
*seq
, void *v
)
840 static char atm_arp_banner
[] =
841 "IPitf TypeEncp Idle IP address ATM address\n";
843 if (v
== SEQ_START_TOKEN
) {
844 seq_puts(seq
, atm_arp_banner
);
846 struct clip_seq_state
*state
= seq
->private;
847 struct clip_vcc
*vcc
= state
->vcc
;
848 struct neighbour
*n
= v
;
850 atmarp_info(seq
, n
, neighbour_priv(n
), vcc
);
855 static const struct seq_operations arp_seq_ops
= {
856 .start
= clip_seq_start
,
857 .next
= neigh_seq_next
,
858 .stop
= neigh_seq_stop
,
859 .show
= clip_seq_show
,
862 static int arp_seq_open(struct inode
*inode
, struct file
*file
)
864 return seq_open_net(inode
, file
, &arp_seq_ops
,
865 sizeof(struct clip_seq_state
));
868 static const struct file_operations arp_seq_fops
= {
869 .open
= arp_seq_open
,
872 .release
= seq_release_net
,
877 static void atm_clip_exit_noproc(void);
879 static int __init
atm_clip_init(void)
881 register_atm_ioctl(&clip_ioctl_ops
);
882 register_netdevice_notifier(&clip_dev_notifier
);
883 register_inetaddr_notifier(&clip_inet_notifier
);
885 setup_timer(&idle_timer
, idle_timer_check
, 0);
887 #ifdef CONFIG_PROC_FS
889 struct proc_dir_entry
*p
;
891 p
= proc_create("arp", S_IRUGO
, atm_proc_root
, &arp_seq_fops
);
893 pr_err("Unable to initialize /proc/net/atm/arp\n");
894 atm_clip_exit_noproc();
903 static void atm_clip_exit_noproc(void)
905 struct net_device
*dev
, *next
;
907 unregister_inetaddr_notifier(&clip_inet_notifier
);
908 unregister_netdevice_notifier(&clip_dev_notifier
);
910 deregister_atm_ioctl(&clip_ioctl_ops
);
912 /* First, stop the idle timer, so it stops banging
915 del_timer_sync(&idle_timer
);
919 next
= PRIV(dev
)->next
;
920 unregister_netdev(dev
);
926 static void __exit
atm_clip_exit(void)
928 remove_proc_entry("arp", atm_proc_root
);
930 atm_clip_exit_noproc();
933 module_init(atm_clip_init
);
934 module_exit(atm_clip_exit
);
935 MODULE_AUTHOR("Werner Almesberger");
936 MODULE_DESCRIPTION("Classical/IP over ATM interface");
937 MODULE_LICENSE("GPL");