1 /* net/atm/clip.c - RFC1577 Classical IP over ATM */
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
5 #include <linux/string.h>
6 #include <linux/errno.h>
7 #include <linux/kernel.h> /* for UINT_MAX */
8 #include <linux/module.h>
9 #include <linux/init.h>
10 #include <linux/netdevice.h>
11 #include <linux/skbuff.h>
12 #include <linux/wait.h>
13 #include <linux/timer.h>
14 #include <linux/if_arp.h> /* for some manifest constants */
15 #include <linux/notifier.h>
16 #include <linux/atm.h>
17 #include <linux/atmdev.h>
18 #include <linux/atmclip.h>
19 #include <linux/atmarp.h>
20 #include <linux/capability.h>
21 #include <linux/ip.h> /* for net/route.h */
22 #include <linux/in.h> /* for struct sockaddr_in */
23 #include <linux/if.h> /* for IFF_UP */
24 #include <linux/inetdevice.h>
25 #include <linux/bitops.h>
26 #include <linux/poison.h>
27 #include <linux/proc_fs.h>
28 #include <linux/seq_file.h>
29 #include <linux/rcupdate.h>
30 #include <linux/jhash.h>
31 #include <net/route.h> /* for struct rtable and routing */
32 #include <net/icmp.h> /* icmp_send */
33 #include <asm/param.h> /* for HZ */
34 #include <asm/byteorder.h> /* for htons etc. */
35 #include <asm/system.h> /* save/restore_flags */
36 #include <asm/uaccess.h>
37 #include <asm/atomic.h>
40 #include "resources.h"
41 #include <net/atmclip.h>
43 static struct net_device
*clip_devs
;
44 static struct atm_vcc
*atmarpd
;
45 static struct neigh_table clip_tbl
;
46 static struct timer_list idle_timer
;
48 static int to_atmarpd(enum atmarp_ctrl_type type
, int itf
, __be32 ip
)
51 struct atmarp_ctrl
*ctrl
;
54 pr_debug("to_atmarpd(%d)\n", type
);
57 skb
= alloc_skb(sizeof(struct atmarp_ctrl
),GFP_ATOMIC
);
60 ctrl
= (struct atmarp_ctrl
*) skb_put(skb
,sizeof(struct atmarp_ctrl
));
64 atm_force_charge(atmarpd
, skb
->truesize
);
67 skb_queue_tail(&sk
->sk_receive_queue
, skb
);
68 sk
->sk_data_ready(sk
, skb
->len
);
72 static void link_vcc(struct clip_vcc
*clip_vcc
, struct atmarp_entry
*entry
)
74 pr_debug("link_vcc %p to entry %p (neigh %p)\n", clip_vcc
, entry
,
76 clip_vcc
->entry
= entry
;
77 clip_vcc
->xoff
= 0; /* @@@ may overrun buffer by one packet */
78 clip_vcc
->next
= entry
->vccs
;
79 entry
->vccs
= clip_vcc
;
80 entry
->neigh
->used
= jiffies
;
83 static void unlink_clip_vcc(struct clip_vcc
*clip_vcc
)
85 struct atmarp_entry
*entry
= clip_vcc
->entry
;
86 struct clip_vcc
**walk
;
89 printk(KERN_CRIT
"!clip_vcc->entry (clip_vcc %p)\n", clip_vcc
);
92 netif_tx_lock_bh(entry
->neigh
->dev
); /* block clip_start_xmit() */
93 entry
->neigh
->used
= jiffies
;
94 for (walk
= &entry
->vccs
; *walk
; walk
= &(*walk
)->next
)
95 if (*walk
== clip_vcc
) {
98 *walk
= clip_vcc
->next
; /* atomic */
99 clip_vcc
->entry
= NULL
;
101 netif_wake_queue(entry
->neigh
->dev
);
104 entry
->expires
= jiffies
- 1;
105 /* force resolution or expiration */
106 error
= neigh_update(entry
->neigh
, NULL
, NUD_NONE
,
107 NEIGH_UPDATE_F_ADMIN
);
109 printk(KERN_CRIT
"unlink_clip_vcc: "
110 "neigh_update failed with %d\n", error
);
113 printk(KERN_CRIT
"ATMARP: unlink_clip_vcc failed (entry %p, vcc "
114 "0x%p)\n", entry
, clip_vcc
);
116 netif_tx_unlock_bh(entry
->neigh
->dev
);
119 /* The neighbour entry n->lock is held. */
120 static int neigh_check_cb(struct neighbour
*n
)
122 struct atmarp_entry
*entry
= NEIGH2ENTRY(n
);
125 for (cv
= entry
->vccs
; cv
; cv
= cv
->next
) {
126 unsigned long exp
= cv
->last_use
+ cv
->idle_timeout
;
128 if (cv
->idle_timeout
&& time_after(jiffies
, exp
)) {
129 pr_debug("releasing vcc %p->%p of entry %p\n",
131 vcc_release_async(cv
->vcc
, -ETIMEDOUT
);
135 if (entry
->vccs
|| time_before(jiffies
, entry
->expires
))
138 if (atomic_read(&n
->refcnt
) > 1) {
141 pr_debug("destruction postponed with ref %d\n",
142 atomic_read(&n
->refcnt
));
144 while ((skb
= skb_dequeue(&n
->arp_queue
)) != NULL
)
150 pr_debug("expired neigh %p\n", n
);
154 static void idle_timer_check(unsigned long dummy
)
156 write_lock(&clip_tbl
.lock
);
157 __neigh_for_each_release(&clip_tbl
, neigh_check_cb
);
158 mod_timer(&idle_timer
, jiffies
+ CLIP_CHECK_INTERVAL
* HZ
);
159 write_unlock(&clip_tbl
.lock
);
162 static int clip_arp_rcv(struct sk_buff
*skb
)
166 pr_debug("clip_arp_rcv\n");
167 vcc
= ATM_SKB(skb
)->vcc
;
168 if (!vcc
|| !atm_charge(vcc
, skb
->truesize
)) {
169 dev_kfree_skb_any(skb
);
172 pr_debug("pushing to %p\n", vcc
);
173 pr_debug("using %p\n", CLIP_VCC(vcc
)->old_push
);
174 CLIP_VCC(vcc
)->old_push(vcc
, skb
);
178 static const unsigned char llc_oui
[] = {
179 0xaa, /* DSAP: non-ISO */
180 0xaa, /* SSAP: non-ISO */
181 0x03, /* Ctrl: Unnumbered Information Command PDU */
182 0x00, /* OUI: EtherType */
187 static void clip_push(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
189 struct clip_vcc
*clip_vcc
= CLIP_VCC(vcc
);
191 pr_debug("clip push\n");
193 pr_debug("removing VCC %p\n", clip_vcc
);
195 unlink_clip_vcc(clip_vcc
);
196 clip_vcc
->old_push(vcc
, NULL
); /* pass on the bad news */
200 atm_return(vcc
, skb
->truesize
);
201 skb
->dev
= clip_vcc
->entry
? clip_vcc
->entry
->neigh
->dev
: clip_devs
;
202 /* clip_vcc->entry == NULL if we don't have an IP address yet */
204 dev_kfree_skb_any(skb
);
207 ATM_SKB(skb
)->vcc
= vcc
;
208 skb_reset_mac_header(skb
);
210 || skb
->len
< RFC1483LLC_LEN
211 || memcmp(skb
->data
, llc_oui
, sizeof (llc_oui
)))
212 skb
->protocol
= htons(ETH_P_IP
);
214 skb
->protocol
= ((__be16
*) skb
->data
)[3];
215 skb_pull(skb
, RFC1483LLC_LEN
);
216 if (skb
->protocol
== htons(ETH_P_ARP
)) {
217 PRIV(skb
->dev
)->stats
.rx_packets
++;
218 PRIV(skb
->dev
)->stats
.rx_bytes
+= skb
->len
;
223 clip_vcc
->last_use
= jiffies
;
224 PRIV(skb
->dev
)->stats
.rx_packets
++;
225 PRIV(skb
->dev
)->stats
.rx_bytes
+= skb
->len
;
226 memset(ATM_SKB(skb
), 0, sizeof(struct atm_skb_data
));
231 * Note: these spinlocks _must_not_ block on non-SMP. The only goal is that
232 * clip_pop is atomic with respect to the critical section in clip_start_xmit.
235 static void clip_pop(struct atm_vcc
*vcc
, struct sk_buff
*skb
)
237 struct clip_vcc
*clip_vcc
= CLIP_VCC(vcc
);
238 struct net_device
*dev
= skb
->dev
;
242 pr_debug("clip_pop(vcc %p)\n", vcc
);
243 clip_vcc
->old_pop(vcc
, skb
);
244 /* skb->dev == NULL in outbound ARP packets */
247 spin_lock_irqsave(&PRIV(dev
)->xoff_lock
, flags
);
248 if (atm_may_send(vcc
, 0)) {
249 old
= xchg(&clip_vcc
->xoff
, 0);
251 netif_wake_queue(dev
);
253 spin_unlock_irqrestore(&PRIV(dev
)->xoff_lock
, flags
);
256 static void clip_neigh_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
258 pr_debug("clip_neigh_solicit (neigh %p, skb %p)\n", neigh
, skb
);
259 to_atmarpd(act_need
, PRIV(neigh
->dev
)->number
, NEIGH2ENTRY(neigh
)->ip
);
262 static void clip_neigh_error(struct neighbour
*neigh
, struct sk_buff
*skb
)
264 #ifndef CONFIG_ATM_CLIP_NO_ICMP
265 icmp_send(skb
, ICMP_DEST_UNREACH
, ICMP_HOST_UNREACH
, 0);
270 static struct neigh_ops clip_neigh_ops
= {
272 .solicit
= clip_neigh_solicit
,
273 .error_report
= clip_neigh_error
,
274 .output
= dev_queue_xmit
,
275 .connected_output
= dev_queue_xmit
,
276 .hh_output
= dev_queue_xmit
,
277 .queue_xmit
= dev_queue_xmit
,
280 static int clip_constructor(struct neighbour
*neigh
)
282 struct atmarp_entry
*entry
= NEIGH2ENTRY(neigh
);
283 struct net_device
*dev
= neigh
->dev
;
284 struct in_device
*in_dev
;
285 struct neigh_parms
*parms
;
287 pr_debug("clip_constructor (neigh %p, entry %p)\n", neigh
, entry
);
288 neigh
->type
= inet_addr_type(&init_net
, entry
->ip
);
289 if (neigh
->type
!= RTN_UNICAST
)
293 in_dev
= __in_dev_get_rcu(dev
);
299 parms
= in_dev
->arp_parms
;
300 __neigh_parms_put(neigh
->parms
);
301 neigh
->parms
= neigh_parms_clone(parms
);
304 neigh
->ops
= &clip_neigh_ops
;
305 neigh
->output
= neigh
->nud_state
& NUD_VALID
?
306 neigh
->ops
->connected_output
: neigh
->ops
->output
;
307 entry
->neigh
= neigh
;
309 entry
->expires
= jiffies
- 1;
313 static u32
clip_hash(const void *pkey
, const struct net_device
*dev
)
315 return jhash_2words(*(u32
*) pkey
, dev
->ifindex
, clip_tbl
.hash_rnd
);
318 static struct neigh_table clip_tbl
= {
320 .entry_size
= sizeof(struct neighbour
)+sizeof(struct atmarp_entry
),
323 .constructor
= clip_constructor
,
324 .id
= "clip_arp_cache",
326 /* parameters are copied from ARP ... */
329 .base_reachable_time
= 30 * HZ
,
330 .retrans_time
= 1 * HZ
,
331 .gc_staletime
= 60 * HZ
,
332 .reachable_time
= 30 * HZ
,
333 .delay_probe_time
= 5 * HZ
,
337 .anycast_delay
= 1 * HZ
,
338 .proxy_delay
= (8 * HZ
) / 10,
342 .gc_interval
= 30 * HZ
,
348 /* @@@ copy bh locking from arp.c -- need to bh-enable atm code before */
351 * We play with the resolve flag: 0 and 1 have the usual meaning, but -1 means
352 * to allocate the neighbour entry but not to ask atmarpd for resolution. Also,
353 * don't increment the usage count. This is used to create entries in
357 static int clip_encap(struct atm_vcc
*vcc
, int mode
)
359 CLIP_VCC(vcc
)->encap
= mode
;
363 static int clip_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
365 struct clip_priv
*clip_priv
= PRIV(dev
);
366 struct atmarp_entry
*entry
;
371 pr_debug("clip_start_xmit (skb %p)\n", skb
);
373 printk(KERN_ERR
"clip_start_xmit: skb->dst == NULL\n");
375 clip_priv
->stats
.tx_dropped
++;
378 if (!skb
->dst
->neighbour
) {
380 skb
->dst
->neighbour
= clip_find_neighbour(skb
->dst
, 1);
381 if (!skb
->dst
->neighbour
) {
382 dev_kfree_skb(skb
); /* lost that one */
383 clip_priv
->stats
.tx_dropped
++;
387 printk(KERN_ERR
"clip_start_xmit: NO NEIGHBOUR !\n");
389 clip_priv
->stats
.tx_dropped
++;
392 entry
= NEIGH2ENTRY(skb
->dst
->neighbour
);
394 if (time_after(jiffies
, entry
->expires
)) {
395 /* should be resolved */
396 entry
->expires
= jiffies
+ ATMARP_RETRY_DELAY
* HZ
;
397 to_atmarpd(act_need
, PRIV(dev
)->number
, entry
->ip
);
399 if (entry
->neigh
->arp_queue
.qlen
< ATMARP_MAX_UNRES_PACKETS
)
400 skb_queue_tail(&entry
->neigh
->arp_queue
, skb
);
403 clip_priv
->stats
.tx_dropped
++;
407 pr_debug("neigh %p, vccs %p\n", entry
, entry
->vccs
);
408 ATM_SKB(skb
)->vcc
= vcc
= entry
->vccs
->vcc
;
409 pr_debug("using neighbour %p, vcc %p\n", skb
->dst
->neighbour
, vcc
);
410 if (entry
->vccs
->encap
) {
413 here
= skb_push(skb
, RFC1483LLC_LEN
);
414 memcpy(here
, llc_oui
, sizeof(llc_oui
));
415 ((__be16
*) here
)[3] = skb
->protocol
;
417 atomic_add(skb
->truesize
, &sk_atm(vcc
)->sk_wmem_alloc
);
418 ATM_SKB(skb
)->atm_options
= vcc
->atm_options
;
419 entry
->vccs
->last_use
= jiffies
;
420 pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb
, vcc
, vcc
->dev
);
421 old
= xchg(&entry
->vccs
->xoff
, 1); /* assume XOFF ... */
423 printk(KERN_WARNING
"clip_start_xmit: XOFF->XOFF transition\n");
426 clip_priv
->stats
.tx_packets
++;
427 clip_priv
->stats
.tx_bytes
+= skb
->len
;
429 if (atm_may_send(vcc
, 0)) {
430 entry
->vccs
->xoff
= 0;
433 spin_lock_irqsave(&clip_priv
->xoff_lock
, flags
);
434 netif_stop_queue(dev
); /* XOFF -> throttle immediately */
436 if (!entry
->vccs
->xoff
)
437 netif_start_queue(dev
);
438 /* Oh, we just raced with clip_pop. netif_start_queue should be
439 good enough, because nothing should really be asleep because
440 of the brief netif_stop_queue. If this isn't true or if it
441 changes, use netif_wake_queue instead. */
442 spin_unlock_irqrestore(&clip_priv
->xoff_lock
, flags
);
446 static struct net_device_stats
*clip_get_stats(struct net_device
*dev
)
448 return &PRIV(dev
)->stats
;
451 static int clip_mkip(struct atm_vcc
*vcc
, int timeout
)
453 struct clip_vcc
*clip_vcc
;
455 struct sk_buff_head
*rq
;
460 clip_vcc
= kmalloc(sizeof(struct clip_vcc
), GFP_KERNEL
);
463 pr_debug("mkip clip_vcc %p vcc %p\n", clip_vcc
, vcc
);
465 vcc
->user_back
= clip_vcc
;
466 set_bit(ATM_VF_IS_CLIP
, &vcc
->flags
);
467 clip_vcc
->entry
= NULL
;
470 clip_vcc
->last_use
= jiffies
;
471 clip_vcc
->idle_timeout
= timeout
* HZ
;
472 clip_vcc
->old_push
= vcc
->push
;
473 clip_vcc
->old_pop
= vcc
->pop
;
474 vcc
->push
= clip_push
;
477 rq
= &sk_atm(vcc
)->sk_receive_queue
;
479 spin_lock_irqsave(&rq
->lock
, flags
);
480 if (skb_queue_empty(rq
)) {
483 /* NULL terminate the list. */
484 rq
->prev
->next
= NULL
;
487 rq
->prev
= rq
->next
= (struct sk_buff
*)rq
;
489 spin_unlock_irqrestore(&rq
->lock
, flags
);
491 /* re-process everything received between connection setup and MKIP */
493 struct sk_buff
*next
= skb
->next
;
495 skb
->next
= skb
->prev
= NULL
;
497 atm_return(vcc
, skb
->truesize
);
500 unsigned int len
= skb
->len
;
504 PRIV(skb
->dev
)->stats
.rx_packets
--;
505 PRIV(skb
->dev
)->stats
.rx_bytes
-= len
;
514 static int clip_setentry(struct atm_vcc
*vcc
, __be32 ip
)
516 struct neighbour
*neigh
;
517 struct atmarp_entry
*entry
;
519 struct clip_vcc
*clip_vcc
;
520 struct flowi fl
= { .nl_u
= { .ip4_u
= { .daddr
= ip
, .tos
= 1}} };
523 if (vcc
->push
!= clip_push
) {
524 printk(KERN_WARNING
"clip_setentry: non-CLIP VCC\n");
527 clip_vcc
= CLIP_VCC(vcc
);
529 if (!clip_vcc
->entry
) {
530 printk(KERN_ERR
"hiding hidden ATMARP entry\n");
533 pr_debug("setentry: remove\n");
534 unlink_clip_vcc(clip_vcc
);
537 error
= ip_route_output_key(&init_net
, &rt
, &fl
);
540 neigh
= __neigh_lookup(&clip_tbl
, &ip
, rt
->u
.dst
.dev
, 1);
544 entry
= NEIGH2ENTRY(neigh
);
545 if (entry
!= clip_vcc
->entry
) {
546 if (!clip_vcc
->entry
)
547 pr_debug("setentry: add\n");
549 pr_debug("setentry: update\n");
550 unlink_clip_vcc(clip_vcc
);
552 link_vcc(clip_vcc
, entry
);
554 error
= neigh_update(neigh
, llc_oui
, NUD_PERMANENT
,
555 NEIGH_UPDATE_F_OVERRIDE
| NEIGH_UPDATE_F_ADMIN
);
556 neigh_release(neigh
);
560 static void clip_setup(struct net_device
*dev
)
562 dev
->hard_start_xmit
= clip_start_xmit
;
564 dev
->get_stats
= clip_get_stats
;
565 dev
->type
= ARPHRD_ATM
;
566 dev
->hard_header_len
= RFC1483LLC_LEN
;
567 dev
->mtu
= RFC1626_MTU
;
568 dev
->tx_queue_len
= 100; /* "normal" queue (packets) */
569 /* When using a "real" qdisc, the qdisc determines the queue */
570 /* length. tx_queue_len is only used for the default case, */
571 /* without any more elaborate queuing. 100 is a reasonable */
572 /* compromise between decent burst-tolerance and protection */
573 /* against memory hogs. */
576 static int clip_create(int number
)
578 struct net_device
*dev
;
579 struct clip_priv
*clip_priv
;
583 for (dev
= clip_devs
; dev
; dev
= PRIV(dev
)->next
)
584 if (PRIV(dev
)->number
== number
)
588 for (dev
= clip_devs
; dev
; dev
= PRIV(dev
)->next
)
589 if (PRIV(dev
)->number
>= number
)
590 number
= PRIV(dev
)->number
+ 1;
592 dev
= alloc_netdev(sizeof(struct clip_priv
), "", clip_setup
);
595 clip_priv
= PRIV(dev
);
596 sprintf(dev
->name
, "atm%d", number
);
597 spin_lock_init(&clip_priv
->xoff_lock
);
598 clip_priv
->number
= number
;
599 error
= register_netdev(dev
);
604 clip_priv
->next
= clip_devs
;
606 pr_debug("registered (net:%s)\n", dev
->name
);
610 static int clip_device_event(struct notifier_block
*this, unsigned long event
,
613 struct net_device
*dev
= arg
;
615 if (dev_net(dev
) != &init_net
)
618 if (event
== NETDEV_UNREGISTER
) {
619 neigh_ifdown(&clip_tbl
, dev
);
623 /* ignore non-CLIP devices */
624 if (dev
->type
!= ARPHRD_ATM
|| dev
->hard_start_xmit
!= clip_start_xmit
)
629 pr_debug("clip_device_event NETDEV_UP\n");
630 to_atmarpd(act_up
, PRIV(dev
)->number
, 0);
632 case NETDEV_GOING_DOWN
:
633 pr_debug("clip_device_event NETDEV_DOWN\n");
634 to_atmarpd(act_down
, PRIV(dev
)->number
, 0);
637 case NETDEV_CHANGEMTU
:
638 pr_debug("clip_device_event NETDEV_CHANGE*\n");
639 to_atmarpd(act_change
, PRIV(dev
)->number
, 0);
645 static int clip_inet_event(struct notifier_block
*this, unsigned long event
,
648 struct in_device
*in_dev
;
650 in_dev
= ((struct in_ifaddr
*)ifa
)->ifa_dev
;
652 * Transitions are of the down-change-up type, so it's sufficient to
653 * handle the change on up.
655 if (event
!= NETDEV_UP
)
657 return clip_device_event(this, NETDEV_CHANGE
, in_dev
->dev
);
661 static struct notifier_block clip_dev_notifier
= {
662 .notifier_call
= clip_device_event
,
667 static struct notifier_block clip_inet_notifier
= {
668 .notifier_call
= clip_inet_event
,
673 static void atmarpd_close(struct atm_vcc
*vcc
)
675 pr_debug("atmarpd_close\n");
679 skb_queue_purge(&sk_atm(vcc
)->sk_receive_queue
);
682 pr_debug("(done)\n");
683 module_put(THIS_MODULE
);
687 static struct atmdev_ops atmarpd_dev_ops
= {
688 .close
= atmarpd_close
692 static struct atm_dev atmarpd_dev
= {
693 .ops
= &atmarpd_dev_ops
,
696 .lock
= __SPIN_LOCK_UNLOCKED(atmarpd_dev
.lock
)
700 static int atm_init_atmarp(struct atm_vcc
*vcc
)
708 mod_timer(&idle_timer
, jiffies
+CLIP_CHECK_INTERVAL
*HZ
);
711 set_bit(ATM_VF_META
,&vcc
->flags
);
712 set_bit(ATM_VF_READY
,&vcc
->flags
);
713 /* allow replies and avoid getting closed if signaling dies */
714 vcc
->dev
= &atmarpd_dev
;
715 vcc_insert_socket(sk_atm(vcc
));
717 vcc
->pop
= NULL
; /* crash */
718 vcc
->push_oam
= NULL
; /* crash */
723 static int clip_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
725 struct atm_vcc
*vcc
= ATM_SD(sock
);
732 case ATMARP_SETENTRY
:
734 if (!capable(CAP_NET_ADMIN
))
743 err
= clip_create(arg
);
746 err
= atm_init_atmarp(vcc
);
748 sock
->state
= SS_CONNECTED
;
749 __module_get(THIS_MODULE
);
753 err
= clip_mkip(vcc
, arg
);
755 case ATMARP_SETENTRY
:
756 err
= clip_setentry(vcc
, (__force __be32
)arg
);
759 err
= clip_encap(vcc
, arg
);
765 static struct atm_ioctl clip_ioctl_ops
= {
766 .owner
= THIS_MODULE
,
770 #ifdef CONFIG_PROC_FS
772 static void svc_addr(struct seq_file
*seq
, struct sockaddr_atmsvc
*addr
)
774 static int code
[] = { 1, 2, 10, 6, 1, 0 };
775 static int e164
[] = { 1, 8, 4, 6, 1, 0 };
777 if (*addr
->sas_addr
.pub
) {
778 seq_printf(seq
, "%s", addr
->sas_addr
.pub
);
779 if (*addr
->sas_addr
.prv
)
781 } else if (!*addr
->sas_addr
.prv
) {
782 seq_printf(seq
, "%s", "(none)");
785 if (*addr
->sas_addr
.prv
) {
786 unsigned char *prv
= addr
->sas_addr
.prv
;
790 fields
= *prv
== ATM_AFI_E164
? e164
: code
;
791 for (i
= 0; fields
[i
]; i
++) {
792 for (j
= fields
[i
]; j
; j
--)
793 seq_printf(seq
, "%02X", *prv
++);
800 /* This means the neighbour entry has no attached VCC objects. */
801 #define SEQ_NO_VCC_TOKEN ((void *) 2)
803 static void atmarp_info(struct seq_file
*seq
, struct net_device
*dev
,
804 struct atmarp_entry
*entry
, struct clip_vcc
*clip_vcc
)
810 svc
= ((clip_vcc
== SEQ_NO_VCC_TOKEN
) ||
811 (sk_atm(clip_vcc
->vcc
)->sk_family
== AF_ATMSVC
));
813 llc
= ((clip_vcc
== SEQ_NO_VCC_TOKEN
) || clip_vcc
->encap
);
815 if (clip_vcc
== SEQ_NO_VCC_TOKEN
)
816 exp
= entry
->neigh
->used
;
818 exp
= clip_vcc
->last_use
;
820 exp
= (jiffies
- exp
) / HZ
;
822 seq_printf(seq
, "%-6s%-4s%-4s%5ld ",
823 dev
->name
, svc
? "SVC" : "PVC", llc
? "LLC" : "NULL", exp
);
825 off
= scnprintf(buf
, sizeof(buf
) - 1, "%d.%d.%d.%d",
830 seq_printf(seq
, "%s", buf
);
832 if (clip_vcc
== SEQ_NO_VCC_TOKEN
) {
833 if (time_before(jiffies
, entry
->expires
))
834 seq_printf(seq
, "(resolving)\n");
836 seq_printf(seq
, "(expired, ref %d)\n",
837 atomic_read(&entry
->neigh
->refcnt
));
839 seq_printf(seq
, "%d.%d.%d\n",
840 clip_vcc
->vcc
->dev
->number
,
841 clip_vcc
->vcc
->vpi
, clip_vcc
->vcc
->vci
);
843 svc_addr(seq
, &clip_vcc
->vcc
->remote
);
848 struct clip_seq_state
{
849 /* This member must be first. */
850 struct neigh_seq_state ns
;
852 /* Local to clip specific iteration. */
853 struct clip_vcc
*vcc
;
856 static struct clip_vcc
*clip_seq_next_vcc(struct atmarp_entry
*e
,
857 struct clip_vcc
*curr
)
862 return SEQ_NO_VCC_TOKEN
;
865 if (curr
== SEQ_NO_VCC_TOKEN
)
873 static void *clip_seq_vcc_walk(struct clip_seq_state
*state
,
874 struct atmarp_entry
*e
, loff_t
* pos
)
876 struct clip_vcc
*vcc
= state
->vcc
;
878 vcc
= clip_seq_next_vcc(e
, vcc
);
879 if (vcc
&& pos
!= NULL
) {
881 vcc
= clip_seq_next_vcc(e
, vcc
);
892 static void *clip_seq_sub_iter(struct neigh_seq_state
*_state
,
893 struct neighbour
*n
, loff_t
* pos
)
895 struct clip_seq_state
*state
= (struct clip_seq_state
*)_state
;
897 return clip_seq_vcc_walk(state
, NEIGH2ENTRY(n
), pos
);
900 static void *clip_seq_start(struct seq_file
*seq
, loff_t
* pos
)
902 struct clip_seq_state
*state
= seq
->private;
903 state
->ns
.neigh_sub_iter
= clip_seq_sub_iter
;
904 return neigh_seq_start(seq
, pos
, &clip_tbl
, NEIGH_SEQ_NEIGH_ONLY
);
907 static int clip_seq_show(struct seq_file
*seq
, void *v
)
909 static char atm_arp_banner
[] =
910 "IPitf TypeEncp Idle IP address ATM address\n";
912 if (v
== SEQ_START_TOKEN
) {
913 seq_puts(seq
, atm_arp_banner
);
915 struct clip_seq_state
*state
= seq
->private;
916 struct neighbour
*n
= v
;
917 struct clip_vcc
*vcc
= state
->vcc
;
919 atmarp_info(seq
, n
->dev
, NEIGH2ENTRY(n
), vcc
);
924 static const struct seq_operations arp_seq_ops
= {
925 .start
= clip_seq_start
,
926 .next
= neigh_seq_next
,
927 .stop
= neigh_seq_stop
,
928 .show
= clip_seq_show
,
931 static int arp_seq_open(struct inode
*inode
, struct file
*file
)
933 return seq_open_net(inode
, file
, &arp_seq_ops
,
934 sizeof(struct clip_seq_state
));
937 static const struct file_operations arp_seq_fops
= {
938 .open
= arp_seq_open
,
941 .release
= seq_release_net
,
946 static void atm_clip_exit_noproc(void);
948 static int __init
atm_clip_init(void)
950 neigh_table_init_no_netlink(&clip_tbl
);
952 clip_tbl_hook
= &clip_tbl
;
953 register_atm_ioctl(&clip_ioctl_ops
);
954 register_netdevice_notifier(&clip_dev_notifier
);
955 register_inetaddr_notifier(&clip_inet_notifier
);
957 setup_timer(&idle_timer
, idle_timer_check
, 0);
959 #ifdef CONFIG_PROC_FS
961 struct proc_dir_entry
*p
;
963 p
= proc_create("arp", S_IRUGO
, atm_proc_root
, &arp_seq_fops
);
965 printk(KERN_ERR
"Unable to initialize "
966 "/proc/net/atm/arp\n");
967 atm_clip_exit_noproc();
976 static void atm_clip_exit_noproc(void)
978 struct net_device
*dev
, *next
;
980 unregister_inetaddr_notifier(&clip_inet_notifier
);
981 unregister_netdevice_notifier(&clip_dev_notifier
);
983 deregister_atm_ioctl(&clip_ioctl_ops
);
985 /* First, stop the idle timer, so it stops banging
988 del_timer_sync(&idle_timer
);
990 /* Next, purge the table, so that the device
991 * unregister loop below does not hang due to
992 * device references remaining in the table.
994 neigh_ifdown(&clip_tbl
, NULL
);
998 next
= PRIV(dev
)->next
;
999 unregister_netdev(dev
);
1004 /* Now it is safe to fully shutdown whole table. */
1005 neigh_table_clear(&clip_tbl
);
1007 clip_tbl_hook
= NULL
;
1010 static void __exit
atm_clip_exit(void)
1012 remove_proc_entry("arp", atm_proc_root
);
1014 atm_clip_exit_noproc();
1017 module_init(atm_clip_init
);
1018 module_exit(atm_clip_exit
);
1019 MODULE_AUTHOR("Werner Almesberger");
1020 MODULE_DESCRIPTION("Classical/IP over ATM interface");
1021 MODULE_LICENSE("GPL");