1 /* net/atm/clip.c - RFC1577 Classical IP over ATM */
3 /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
6 #include <linux/config.h>
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/proc_fs.h>
29 #include <linux/seq_file.h>
30 #include <linux/rcupdate.h>
31 #include <linux/jhash.h>
32 #include <net/route.h> /* for struct rtable and routing */
33 #include <net/icmp.h> /* icmp_send */
34 #include <asm/param.h> /* for HZ */
35 #include <asm/byteorder.h> /* for htons etc. */
36 #include <asm/system.h> /* save/restore_flags */
37 #include <asm/uaccess.h>
38 #include <asm/atomic.h>
41 #include "resources.h"
43 #include <net/atmclip.h>
47 #define DPRINTK(format,args...) printk(format,##args)
49 #define DPRINTK(format,args...)
53 static struct net_device
*clip_devs
;
54 static struct atm_vcc
*atmarpd
;
55 static struct neigh_table clip_tbl
;
56 static struct timer_list idle_timer
;
57 static int start_timer
= 1;
60 static int to_atmarpd(enum atmarp_ctrl_type type
,int itf
,unsigned long ip
)
63 struct atmarp_ctrl
*ctrl
;
66 DPRINTK("to_atmarpd(%d)\n",type
);
67 if (!atmarpd
) return -EUNATCH
;
68 skb
= alloc_skb(sizeof(struct atmarp_ctrl
),GFP_ATOMIC
);
69 if (!skb
) return -ENOMEM
;
70 ctrl
= (struct atmarp_ctrl
*) skb_put(skb
,sizeof(struct atmarp_ctrl
));
74 atm_force_charge(atmarpd
,skb
->truesize
);
77 skb_queue_tail(&sk
->sk_receive_queue
, skb
);
78 sk
->sk_data_ready(sk
, skb
->len
);
83 static void link_vcc(struct clip_vcc
*clip_vcc
,struct atmarp_entry
*entry
)
85 DPRINTK("link_vcc %p to entry %p (neigh %p)\n",clip_vcc
,entry
,
87 clip_vcc
->entry
= entry
;
88 clip_vcc
->xoff
= 0; /* @@@ may overrun buffer by one packet */
89 clip_vcc
->next
= entry
->vccs
;
90 entry
->vccs
= clip_vcc
;
91 entry
->neigh
->used
= jiffies
;
95 static void unlink_clip_vcc(struct clip_vcc
*clip_vcc
)
97 struct atmarp_entry
*entry
= clip_vcc
->entry
;
98 struct clip_vcc
**walk
;
101 printk(KERN_CRIT
"!clip_vcc->entry (clip_vcc %p)\n",clip_vcc
);
104 spin_lock_bh(&entry
->neigh
->dev
->xmit_lock
); /* block clip_start_xmit() */
105 entry
->neigh
->used
= jiffies
;
106 for (walk
= &entry
->vccs
; *walk
; walk
= &(*walk
)->next
)
107 if (*walk
== clip_vcc
) {
110 *walk
= clip_vcc
->next
; /* atomic */
111 clip_vcc
->entry
= NULL
;
113 netif_wake_queue(entry
->neigh
->dev
);
116 entry
->expires
= jiffies
-1;
117 /* force resolution or expiration */
118 error
= neigh_update(entry
->neigh
, NULL
, NUD_NONE
,
119 NEIGH_UPDATE_F_ADMIN
);
121 printk(KERN_CRIT
"unlink_clip_vcc: "
122 "neigh_update failed with %d\n",error
);
125 printk(KERN_CRIT
"ATMARP: unlink_clip_vcc failed (entry %p, vcc "
126 "0x%p)\n",entry
,clip_vcc
);
128 spin_unlock_bh(&entry
->neigh
->dev
->xmit_lock
);
131 /* The neighbour entry n->lock is held. */
132 static int neigh_check_cb(struct neighbour
*n
)
134 struct atmarp_entry
*entry
= NEIGH2ENTRY(n
);
137 for (cv
= entry
->vccs
; cv
; cv
= cv
->next
) {
138 unsigned long exp
= cv
->last_use
+ cv
->idle_timeout
;
140 if (cv
->idle_timeout
&& time_after(jiffies
, exp
)) {
141 DPRINTK("releasing vcc %p->%p of entry %p\n",
143 vcc_release_async(cv
->vcc
, -ETIMEDOUT
);
147 if (entry
->vccs
|| time_before(jiffies
, entry
->expires
))
150 if (atomic_read(&n
->refcnt
) > 1) {
153 DPRINTK("destruction postponed with ref %d\n",
154 atomic_read(&n
->refcnt
));
156 while ((skb
= skb_dequeue(&n
->arp_queue
)) != NULL
)
162 DPRINTK("expired neigh %p\n",n
);
166 static void idle_timer_check(unsigned long dummy
)
168 write_lock(&clip_tbl
.lock
);
169 __neigh_for_each_release(&clip_tbl
, neigh_check_cb
);
170 mod_timer(&idle_timer
, jiffies
+CLIP_CHECK_INTERVAL
*HZ
);
171 write_unlock(&clip_tbl
.lock
);
174 static int clip_arp_rcv(struct sk_buff
*skb
)
178 DPRINTK("clip_arp_rcv\n");
179 vcc
= ATM_SKB(skb
)->vcc
;
180 if (!vcc
|| !atm_charge(vcc
,skb
->truesize
)) {
181 dev_kfree_skb_any(skb
);
184 DPRINTK("pushing to %p\n",vcc
);
185 DPRINTK("using %p\n",CLIP_VCC(vcc
)->old_push
);
186 CLIP_VCC(vcc
)->old_push(vcc
,skb
);
190 static const unsigned char llc_oui
[] = {
191 0xaa, /* DSAP: non-ISO */
192 0xaa, /* SSAP: non-ISO */
193 0x03, /* Ctrl: Unnumbered Information Command PDU */
194 0x00, /* OUI: EtherType */
198 static void clip_push(struct atm_vcc
*vcc
,struct sk_buff
*skb
)
200 struct clip_vcc
*clip_vcc
= CLIP_VCC(vcc
);
202 DPRINTK("clip push\n");
204 DPRINTK("removing VCC %p\n",clip_vcc
);
205 if (clip_vcc
->entry
) 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
->mac
.raw
= skb
->data
;
219 if (!clip_vcc
->encap
|| skb
->len
< RFC1483LLC_LEN
|| memcmp(skb
->data
,
220 llc_oui
,sizeof(llc_oui
))) skb
->protocol
= htons(ETH_P_IP
);
222 skb
->protocol
= ((u16
*) skb
->data
)[3];
223 skb_pull(skb
,RFC1483LLC_LEN
);
224 if (skb
->protocol
== htons(ETH_P_ARP
)) {
225 PRIV(skb
->dev
)->stats
.rx_packets
++;
226 PRIV(skb
->dev
)->stats
.rx_bytes
+= skb
->len
;
231 clip_vcc
->last_use
= jiffies
;
232 PRIV(skb
->dev
)->stats
.rx_packets
++;
233 PRIV(skb
->dev
)->stats
.rx_bytes
+= skb
->len
;
234 memset(ATM_SKB(skb
), 0, sizeof(struct atm_skb_data
));
240 * Note: these spinlocks _must_not_ block on non-SMP. The only goal is that
241 * 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 DPRINTK("clip_pop(vcc %p)\n",vcc
);
253 clip_vcc
->old_pop(vcc
,skb
);
254 /* skb->dev == NULL in outbound ARP packets */
256 spin_lock_irqsave(&PRIV(dev
)->xoff_lock
,flags
);
257 if (atm_may_send(vcc
,0)) {
258 old
= xchg(&clip_vcc
->xoff
,0);
259 if (old
) netif_wake_queue(dev
);
261 spin_unlock_irqrestore(&PRIV(dev
)->xoff_lock
,flags
);
265 static void clip_neigh_destroy(struct neighbour
*neigh
)
267 DPRINTK("clip_neigh_destroy (neigh %p)\n",neigh
);
268 if (NEIGH2ENTRY(neigh
)->vccs
)
269 printk(KERN_CRIT
"clip_neigh_destroy: vccs != NULL !!!\n");
270 NEIGH2ENTRY(neigh
)->vccs
= (void *) 0xdeadbeef;
274 static void clip_neigh_solicit(struct neighbour
*neigh
,struct sk_buff
*skb
)
276 DPRINTK("clip_neigh_solicit (neigh %p, skb %p)\n",neigh
,skb
);
277 to_atmarpd(act_need
,PRIV(neigh
->dev
)->number
,NEIGH2ENTRY(neigh
)->ip
);
281 static void clip_neigh_error(struct neighbour
*neigh
,struct sk_buff
*skb
)
283 #ifndef CONFIG_ATM_CLIP_NO_ICMP
284 icmp_send(skb
,ICMP_DEST_UNREACH
,ICMP_HOST_UNREACH
,0);
290 static struct neigh_ops clip_neigh_ops
= {
292 .solicit
= clip_neigh_solicit
,
293 .error_report
= clip_neigh_error
,
294 .output
= dev_queue_xmit
,
295 .connected_output
= dev_queue_xmit
,
296 .hh_output
= dev_queue_xmit
,
297 .queue_xmit
= dev_queue_xmit
,
301 static int clip_constructor(struct neighbour
*neigh
)
303 struct atmarp_entry
*entry
= NEIGH2ENTRY(neigh
);
304 struct net_device
*dev
= neigh
->dev
;
305 struct in_device
*in_dev
;
306 struct neigh_parms
*parms
;
308 DPRINTK("clip_constructor (neigh %p, entry %p)\n",neigh
,entry
);
309 neigh
->type
= inet_addr_type(entry
->ip
);
310 if (neigh
->type
!= RTN_UNICAST
) return -EINVAL
;
313 in_dev
= __in_dev_get_rcu(dev
);
319 parms
= in_dev
->arp_parms
;
320 __neigh_parms_put(neigh
->parms
);
321 neigh
->parms
= neigh_parms_clone(parms
);
324 neigh
->ops
= &clip_neigh_ops
;
325 neigh
->output
= neigh
->nud_state
& NUD_VALID
?
326 neigh
->ops
->connected_output
: neigh
->ops
->output
;
327 entry
->neigh
= neigh
;
329 entry
->expires
= jiffies
-1;
333 static u32
clip_hash(const void *pkey
, const struct net_device
*dev
)
335 return jhash_2words(*(u32
*)pkey
, dev
->ifindex
, clip_tbl
.hash_rnd
);
338 static struct neigh_table clip_tbl
= {
340 .entry_size
= sizeof(struct neighbour
)+sizeof(struct atmarp_entry
),
343 .constructor
= clip_constructor
,
344 .id
= "clip_arp_cache",
346 /* parameters are copied from ARP ... */
349 .neigh_destructor
= clip_neigh_destroy
,
350 .base_reachable_time
= 30 * HZ
,
351 .retrans_time
= 1 * HZ
,
352 .gc_staletime
= 60 * HZ
,
353 .reachable_time
= 30 * HZ
,
354 .delay_probe_time
= 5 * HZ
,
358 .anycast_delay
= 1 * HZ
,
359 .proxy_delay
= (8 * HZ
) / 10,
363 .gc_interval
= 30 * HZ
,
370 /* @@@ copy bh locking from arp.c -- need to bh-enable atm code before */
373 * We play with the resolve flag: 0 and 1 have the usual meaning, but -1 means
374 * to allocate the neighbour entry but not to ask atmarpd for resolution. Also,
375 * don't increment the usage count. This is used to create entries in
380 static int clip_encap(struct atm_vcc
*vcc
,int mode
)
382 CLIP_VCC(vcc
)->encap
= mode
;
387 static int clip_start_xmit(struct sk_buff
*skb
,struct net_device
*dev
)
389 struct clip_priv
*clip_priv
= PRIV(dev
);
390 struct atmarp_entry
*entry
;
395 DPRINTK("clip_start_xmit (skb %p)\n",skb
);
397 printk(KERN_ERR
"clip_start_xmit: skb->dst == NULL\n");
399 clip_priv
->stats
.tx_dropped
++;
402 if (!skb
->dst
->neighbour
) {
404 skb
->dst
->neighbour
= clip_find_neighbour(skb
->dst
,1);
405 if (!skb
->dst
->neighbour
) {
406 dev_kfree_skb(skb
); /* lost that one */
407 clip_priv
->stats
.tx_dropped
++;
411 printk(KERN_ERR
"clip_start_xmit: NO NEIGHBOUR !\n");
413 clip_priv
->stats
.tx_dropped
++;
416 entry
= NEIGH2ENTRY(skb
->dst
->neighbour
);
418 if (time_after(jiffies
, entry
->expires
)) {
419 /* should be resolved */
420 entry
->expires
= jiffies
+ATMARP_RETRY_DELAY
*HZ
;
421 to_atmarpd(act_need
,PRIV(dev
)->number
,entry
->ip
);
423 if (entry
->neigh
->arp_queue
.qlen
< ATMARP_MAX_UNRES_PACKETS
)
424 skb_queue_tail(&entry
->neigh
->arp_queue
,skb
);
427 clip_priv
->stats
.tx_dropped
++;
431 DPRINTK("neigh %p, vccs %p\n",entry
,entry
->vccs
);
432 ATM_SKB(skb
)->vcc
= vcc
= entry
->vccs
->vcc
;
433 DPRINTK("using neighbour %p, vcc %p\n",skb
->dst
->neighbour
,vcc
);
434 if (entry
->vccs
->encap
) {
437 here
= skb_push(skb
,RFC1483LLC_LEN
);
438 memcpy(here
,llc_oui
,sizeof(llc_oui
));
439 ((u16
*) here
)[3] = skb
->protocol
;
441 atomic_add(skb
->truesize
, &sk_atm(vcc
)->sk_wmem_alloc
);
442 ATM_SKB(skb
)->atm_options
= vcc
->atm_options
;
443 entry
->vccs
->last_use
= jiffies
;
444 DPRINTK("atm_skb(%p)->vcc(%p)->dev(%p)\n",skb
,vcc
,vcc
->dev
);
445 old
= xchg(&entry
->vccs
->xoff
,1); /* assume XOFF ... */
447 printk(KERN_WARNING
"clip_start_xmit: XOFF->XOFF transition\n");
450 clip_priv
->stats
.tx_packets
++;
451 clip_priv
->stats
.tx_bytes
+= skb
->len
;
452 (void) vcc
->send(vcc
,skb
);
453 if (atm_may_send(vcc
,0)) {
454 entry
->vccs
->xoff
= 0;
457 spin_lock_irqsave(&clip_priv
->xoff_lock
,flags
);
458 netif_stop_queue(dev
); /* XOFF -> throttle immediately */
460 if (!entry
->vccs
->xoff
)
461 netif_start_queue(dev
);
462 /* Oh, we just raced with clip_pop. netif_start_queue should be
463 good enough, because nothing should really be asleep because
464 of the brief netif_stop_queue. If this isn't true or if it
465 changes, use netif_wake_queue instead. */
466 spin_unlock_irqrestore(&clip_priv
->xoff_lock
,flags
);
471 static struct net_device_stats
*clip_get_stats(struct net_device
*dev
)
473 return &PRIV(dev
)->stats
;
477 static int clip_mkip(struct atm_vcc
*vcc
,int timeout
)
479 struct clip_vcc
*clip_vcc
;
480 struct sk_buff_head copy
;
483 if (!vcc
->push
) return -EBADFD
;
484 clip_vcc
= kmalloc(sizeof(struct clip_vcc
),GFP_KERNEL
);
485 if (!clip_vcc
) return -ENOMEM
;
486 DPRINTK("mkip clip_vcc %p vcc %p\n",clip_vcc
,vcc
);
488 vcc
->user_back
= clip_vcc
;
489 set_bit(ATM_VF_IS_CLIP
, &vcc
->flags
);
490 clip_vcc
->entry
= NULL
;
493 clip_vcc
->last_use
= jiffies
;
494 clip_vcc
->idle_timeout
= timeout
*HZ
;
495 clip_vcc
->old_push
= vcc
->push
;
496 clip_vcc
->old_pop
= vcc
->pop
;
497 vcc
->push
= clip_push
;
499 skb_queue_head_init(©
);
500 skb_migrate(&sk_atm(vcc
)->sk_receive_queue
, ©
);
501 /* re-process everything received between connection setup and MKIP */
502 while ((skb
= skb_dequeue(©
)) != NULL
)
504 atm_return(vcc
,skb
->truesize
);
508 unsigned int len
= skb
->len
;
511 PRIV(skb
->dev
)->stats
.rx_packets
--;
512 PRIV(skb
->dev
)->stats
.rx_bytes
-= len
;
518 static int clip_setentry(struct atm_vcc
*vcc
,u32 ip
)
520 struct neighbour
*neigh
;
521 struct atmarp_entry
*entry
;
523 struct clip_vcc
*clip_vcc
;
524 struct flowi fl
= { .nl_u
= { .ip4_u
= { .daddr
= ip
, .tos
= 1 } } };
527 if (vcc
->push
!= clip_push
) {
528 printk(KERN_WARNING
"clip_setentry: non-CLIP VCC\n");
531 clip_vcc
= CLIP_VCC(vcc
);
533 if (!clip_vcc
->entry
) {
534 printk(KERN_ERR
"hiding hidden ATMARP entry\n");
537 DPRINTK("setentry: remove\n");
538 unlink_clip_vcc(clip_vcc
);
541 error
= ip_route_output_key(&rt
,&fl
);
542 if (error
) return error
;
543 neigh
= __neigh_lookup(&clip_tbl
,&ip
,rt
->u
.dst
.dev
,1);
547 entry
= NEIGH2ENTRY(neigh
);
548 if (entry
!= clip_vcc
->entry
) {
549 if (!clip_vcc
->entry
) DPRINTK("setentry: add\n");
551 DPRINTK("setentry: update\n");
552 unlink_clip_vcc(clip_vcc
);
554 link_vcc(clip_vcc
,entry
);
556 error
= neigh_update(neigh
, llc_oui
, NUD_PERMANENT
,
557 NEIGH_UPDATE_F_OVERRIDE
|NEIGH_UPDATE_F_ADMIN
);
558 neigh_release(neigh
);
563 static void clip_setup(struct net_device
*dev
)
565 dev
->hard_start_xmit
= clip_start_xmit
;
567 dev
->get_stats
= clip_get_stats
;
568 dev
->type
= ARPHRD_ATM
;
569 dev
->hard_header_len
= RFC1483LLC_LEN
;
570 dev
->mtu
= RFC1626_MTU
;
571 dev
->tx_queue_len
= 100; /* "normal" queue (packets) */
572 /* When using a "real" qdisc, the qdisc determines the queue */
573 /* length. tx_queue_len is only used for the default case, */
574 /* without any more elaborate queuing. 100 is a reasonable */
575 /* compromise between decent burst-tolerance and protection */
576 /* against memory hogs. */
580 static int clip_create(int number
)
582 struct net_device
*dev
;
583 struct clip_priv
*clip_priv
;
587 for (dev
= clip_devs
; dev
; dev
= PRIV(dev
)->next
)
588 if (PRIV(dev
)->number
== number
) return -EEXIST
;
592 for (dev
= clip_devs
; dev
; dev
= PRIV(dev
)->next
)
593 if (PRIV(dev
)->number
>= number
)
594 number
= PRIV(dev
)->number
+1;
596 dev
= alloc_netdev(sizeof(struct clip_priv
), "", clip_setup
);
599 clip_priv
= PRIV(dev
);
600 sprintf(dev
->name
,"atm%d",number
);
601 spin_lock_init(&clip_priv
->xoff_lock
);
602 clip_priv
->number
= number
;
603 error
= register_netdev(dev
);
608 clip_priv
->next
= clip_devs
;
610 DPRINTK("registered (net:%s)\n",dev
->name
);
615 static int clip_device_event(struct notifier_block
*this,unsigned long event
,
618 struct net_device
*dev
= arg
;
620 if (event
== NETDEV_UNREGISTER
) {
621 neigh_ifdown(&clip_tbl
, dev
);
625 /* ignore non-CLIP devices */
626 if (dev
->type
!= ARPHRD_ATM
|| dev
->hard_start_xmit
!= clip_start_xmit
)
631 DPRINTK("clip_device_event NETDEV_UP\n");
632 (void) to_atmarpd(act_up
,PRIV(dev
)->number
,0);
634 case NETDEV_GOING_DOWN
:
635 DPRINTK("clip_device_event NETDEV_DOWN\n");
636 (void) to_atmarpd(act_down
,PRIV(dev
)->number
,0);
639 case NETDEV_CHANGEMTU
:
640 DPRINTK("clip_device_event NETDEV_CHANGE*\n");
641 (void) to_atmarpd(act_change
,PRIV(dev
)->number
,0);
644 case NETDEV_REGISTER
:
646 DPRINTK("clip_device_event %ld\n",event
);
650 printk(KERN_WARNING
"clip_device_event: unknown event "
658 static int clip_inet_event(struct notifier_block
*this,unsigned long event
,
661 struct in_device
*in_dev
;
663 in_dev
= ((struct in_ifaddr
*) ifa
)->ifa_dev
;
664 if (!in_dev
|| !in_dev
->dev
) {
665 printk(KERN_WARNING
"clip_inet_event: no device\n");
669 * Transitions are of the down-change-up type, so it's sufficient to
670 * handle the change on up.
672 if (event
!= NETDEV_UP
) return NOTIFY_DONE
;
673 return clip_device_event(this,NETDEV_CHANGE
,in_dev
->dev
);
677 static struct notifier_block clip_dev_notifier
= {
685 static struct notifier_block clip_inet_notifier
= {
693 static void atmarpd_close(struct atm_vcc
*vcc
)
695 DPRINTK("atmarpd_close\n");
699 skb_queue_purge(&sk_atm(vcc
)->sk_receive_queue
);
703 module_put(THIS_MODULE
);
707 static struct atmdev_ops atmarpd_dev_ops
= {
708 .close
= atmarpd_close
712 static struct atm_dev atmarpd_dev
= {
713 .ops
= &atmarpd_dev_ops
,
716 .lock
= SPIN_LOCK_UNLOCKED
720 static int atm_init_atmarp(struct atm_vcc
*vcc
)
730 init_timer(&idle_timer
);
731 idle_timer
.expires
= jiffies
+CLIP_CHECK_INTERVAL
*HZ
;
732 idle_timer
.function
= idle_timer_check
;
733 add_timer(&idle_timer
);
736 set_bit(ATM_VF_META
,&vcc
->flags
);
737 set_bit(ATM_VF_READY
,&vcc
->flags
);
738 /* allow replies and avoid getting closed if signaling dies */
739 vcc
->dev
= &atmarpd_dev
;
740 vcc_insert_socket(sk_atm(vcc
));
742 vcc
->pop
= NULL
; /* crash */
743 vcc
->push_oam
= NULL
; /* crash */
748 static int clip_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
750 struct atm_vcc
*vcc
= ATM_SD(sock
);
757 case ATMARP_SETENTRY
:
759 if (!capable(CAP_NET_ADMIN
))
768 err
= clip_create(arg
);
771 err
= atm_init_atmarp(vcc
);
773 sock
->state
= SS_CONNECTED
;
774 __module_get(THIS_MODULE
);
778 err
= clip_mkip(vcc
,arg
);
780 case ATMARP_SETENTRY
:
781 err
= clip_setentry(vcc
, arg
);
784 err
= clip_encap(vcc
, arg
);
790 static struct atm_ioctl clip_ioctl_ops
= {
791 .owner
= THIS_MODULE
,
795 #ifdef CONFIG_PROC_FS
797 static void svc_addr(struct seq_file
*seq
, struct sockaddr_atmsvc
*addr
)
799 static int code
[] = { 1,2,10,6,1,0 };
800 static int e164
[] = { 1,8,4,6,1,0 };
802 if (*addr
->sas_addr
.pub
) {
803 seq_printf(seq
, "%s", addr
->sas_addr
.pub
);
804 if (*addr
->sas_addr
.prv
)
806 } else if (!*addr
->sas_addr
.prv
) {
807 seq_printf(seq
, "%s", "(none)");
810 if (*addr
->sas_addr
.prv
) {
811 unsigned char *prv
= addr
->sas_addr
.prv
;
815 fields
= *prv
== ATM_AFI_E164
? e164
: code
;
816 for (i
= 0; fields
[i
]; i
++) {
817 for (j
= fields
[i
]; j
; j
--)
818 seq_printf(seq
, "%02X", *prv
++);
825 /* This means the neighbour entry has no attached VCC objects. */
826 #define SEQ_NO_VCC_TOKEN ((void *) 2)
828 static void atmarp_info(struct seq_file
*seq
, struct net_device
*dev
,
829 struct atmarp_entry
*entry
, struct clip_vcc
*clip_vcc
)
835 svc
= ((clip_vcc
== SEQ_NO_VCC_TOKEN
) ||
836 (sk_atm(clip_vcc
->vcc
)->sk_family
== AF_ATMSVC
));
838 llc
= ((clip_vcc
== SEQ_NO_VCC_TOKEN
) ||
841 if (clip_vcc
== SEQ_NO_VCC_TOKEN
)
842 exp
= entry
->neigh
->used
;
844 exp
= clip_vcc
->last_use
;
846 exp
= (jiffies
- exp
) / HZ
;
848 seq_printf(seq
, "%-6s%-4s%-4s%5ld ",
851 llc
? "LLC" : "NULL",
854 off
= scnprintf(buf
, sizeof(buf
) - 1, "%d.%d.%d.%d",
859 seq_printf(seq
, "%s", buf
);
861 if (clip_vcc
== SEQ_NO_VCC_TOKEN
) {
862 if (time_before(jiffies
, entry
->expires
))
863 seq_printf(seq
, "(resolving)\n");
865 seq_printf(seq
, "(expired, ref %d)\n",
866 atomic_read(&entry
->neigh
->refcnt
));
868 seq_printf(seq
, "%d.%d.%d\n",
869 clip_vcc
->vcc
->dev
->number
,
873 svc_addr(seq
, &clip_vcc
->vcc
->remote
);
878 struct clip_seq_state
{
879 /* This member must be first. */
880 struct neigh_seq_state ns
;
882 /* Local to clip specific iteration. */
883 struct clip_vcc
*vcc
;
886 static struct clip_vcc
*clip_seq_next_vcc(struct atmarp_entry
*e
,
887 struct clip_vcc
*curr
)
892 return SEQ_NO_VCC_TOKEN
;
895 if (curr
== SEQ_NO_VCC_TOKEN
)
903 static void *clip_seq_vcc_walk(struct clip_seq_state
*state
,
904 struct atmarp_entry
*e
, loff_t
*pos
)
906 struct clip_vcc
*vcc
= state
->vcc
;
908 vcc
= clip_seq_next_vcc(e
, vcc
);
909 if (vcc
&& pos
!= NULL
) {
911 vcc
= clip_seq_next_vcc(e
, vcc
);
922 static void *clip_seq_sub_iter(struct neigh_seq_state
*_state
,
923 struct neighbour
*n
, loff_t
*pos
)
925 struct clip_seq_state
*state
= (struct clip_seq_state
*) _state
;
927 return clip_seq_vcc_walk(state
, NEIGH2ENTRY(n
), pos
);
930 static void *clip_seq_start(struct seq_file
*seq
, loff_t
*pos
)
932 return neigh_seq_start(seq
, pos
, &clip_tbl
, NEIGH_SEQ_NEIGH_ONLY
);
935 static int clip_seq_show(struct seq_file
*seq
, void *v
)
937 static char atm_arp_banner
[] =
938 "IPitf TypeEncp Idle IP address ATM address\n";
940 if (v
== SEQ_START_TOKEN
) {
941 seq_puts(seq
, atm_arp_banner
);
943 struct clip_seq_state
*state
= seq
->private;
944 struct neighbour
*n
= v
;
945 struct clip_vcc
*vcc
= state
->vcc
;
947 atmarp_info(seq
, n
->dev
, NEIGH2ENTRY(n
), vcc
);
952 static struct seq_operations arp_seq_ops
= {
953 .start
= clip_seq_start
,
954 .next
= neigh_seq_next
,
955 .stop
= neigh_seq_stop
,
956 .show
= clip_seq_show
,
959 static int arp_seq_open(struct inode
*inode
, struct file
*file
)
961 struct clip_seq_state
*state
;
962 struct seq_file
*seq
;
965 state
= kmalloc(sizeof(*state
), GFP_KERNEL
);
970 memset(state
, 0, sizeof(*state
));
971 state
->ns
.neigh_sub_iter
= clip_seq_sub_iter
;
973 rc
= seq_open(file
, &arp_seq_ops
);
977 seq
= file
->private_data
;
978 seq
->private = state
;
987 static struct file_operations arp_seq_fops
= {
988 .open
= arp_seq_open
,
991 .release
= seq_release_private
,
996 static int __init
atm_clip_init(void)
998 neigh_table_init(&clip_tbl
);
1000 clip_tbl_hook
= &clip_tbl
;
1001 register_atm_ioctl(&clip_ioctl_ops
);
1002 register_netdevice_notifier(&clip_dev_notifier
);
1003 register_inetaddr_notifier(&clip_inet_notifier
);
1005 #ifdef CONFIG_PROC_FS
1007 struct proc_dir_entry
*p
;
1009 p
= create_proc_entry("arp", S_IRUGO
, atm_proc_root
);
1011 p
->proc_fops
= &arp_seq_fops
;
1018 static void __exit
atm_clip_exit(void)
1020 struct net_device
*dev
, *next
;
1022 remove_proc_entry("arp", atm_proc_root
);
1024 unregister_inetaddr_notifier(&clip_inet_notifier
);
1025 unregister_netdevice_notifier(&clip_dev_notifier
);
1027 deregister_atm_ioctl(&clip_ioctl_ops
);
1029 /* First, stop the idle timer, so it stops banging
1032 if (start_timer
== 0)
1033 del_timer(&idle_timer
);
1035 /* Next, purge the table, so that the device
1036 * unregister loop below does not hang due to
1037 * device references remaining in the table.
1039 neigh_ifdown(&clip_tbl
, NULL
);
1043 next
= PRIV(dev
)->next
;
1044 unregister_netdev(dev
);
1049 /* Now it is safe to fully shutdown whole table. */
1050 neigh_table_clear(&clip_tbl
);
1052 clip_tbl_hook
= NULL
;
1055 module_init(atm_clip_init
);
1056 module_exit(atm_clip_exit
);
1058 MODULE_LICENSE("GPL");