Root/net/decnet/dn_neigh.c

1/*
2 * DECnet An implementation of the DECnet protocol suite for the LINUX
3 * operating system. DECnet is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * DECnet Neighbour Functions (Adjacency Database and
7 * On-Ethernet Cache)
8 *
9 * Author: Steve Whitehouse <SteveW@ACM.org>
10 *
11 *
12 * Changes:
13 * Steve Whitehouse : Fixed router listing routine
14 * Steve Whitehouse : Added error_report functions
15 * Steve Whitehouse : Added default router detection
16 * Steve Whitehouse : Hop counts in outgoing messages
17 * Steve Whitehouse : Fixed src/dst in outgoing messages so
18 * forwarding now stands a good chance of
19 * working.
20 * Steve Whitehouse : Fixed neighbour states (for now anyway).
21 * Steve Whitehouse : Made error_report functions dummies. This
22 * is not the right place to return skbs.
23 * Steve Whitehouse : Convert to seq_file
24 *
25 */
26
27#include <linux/net.h>
28#include <linux/module.h>
29#include <linux/socket.h>
30#include <linux/if_arp.h>
31#include <linux/slab.h>
32#include <linux/if_ether.h>
33#include <linux/init.h>
34#include <linux/proc_fs.h>
35#include <linux/string.h>
36#include <linux/netfilter_decnet.h>
37#include <linux/spinlock.h>
38#include <linux/seq_file.h>
39#include <linux/rcupdate.h>
40#include <linux/jhash.h>
41#include <linux/atomic.h>
42#include <net/net_namespace.h>
43#include <net/neighbour.h>
44#include <net/dst.h>
45#include <net/flow.h>
46#include <net/dn.h>
47#include <net/dn_dev.h>
48#include <net/dn_neigh.h>
49#include <net/dn_route.h>
50
51static int dn_neigh_construct(struct neighbour *);
52static void dn_long_error_report(struct neighbour *, struct sk_buff *);
53static void dn_short_error_report(struct neighbour *, struct sk_buff *);
54static int dn_long_output(struct neighbour *, struct sk_buff *);
55static int dn_short_output(struct neighbour *, struct sk_buff *);
56static int dn_phase3_output(struct neighbour *, struct sk_buff *);
57
58
59/*
60 * For talking to broadcast devices: Ethernet & PPP
61 */
62static const struct neigh_ops dn_long_ops = {
63    .family = AF_DECnet,
64    .error_report = dn_long_error_report,
65    .output = dn_long_output,
66    .connected_output = dn_long_output,
67};
68
69/*
70 * For talking to pointopoint and multidrop devices: DDCMP and X.25
71 */
72static const struct neigh_ops dn_short_ops = {
73    .family = AF_DECnet,
74    .error_report = dn_short_error_report,
75    .output = dn_short_output,
76    .connected_output = dn_short_output,
77};
78
79/*
80 * For talking to DECnet phase III nodes
81 */
82static const struct neigh_ops dn_phase3_ops = {
83    .family = AF_DECnet,
84    .error_report = dn_short_error_report, /* Can use short version here */
85    .output = dn_phase3_output,
86    .connected_output = dn_phase3_output,
87};
88
89static u32 dn_neigh_hash(const void *pkey,
90             const struct net_device *dev,
91             __u32 *hash_rnd)
92{
93    return jhash_2words(*(__u16 *)pkey, 0, hash_rnd[0]);
94}
95
96struct neigh_table dn_neigh_table = {
97    .family = PF_DECnet,
98    .entry_size = sizeof(struct dn_neigh),
99    .key_len = sizeof(__le16),
100    .hash = dn_neigh_hash,
101    .constructor = dn_neigh_construct,
102    .id = "dn_neigh_cache",
103    .parms ={
104        .tbl = &dn_neigh_table,
105        .base_reachable_time = 30 * HZ,
106        .retrans_time = 1 * HZ,
107        .gc_staletime = 60 * HZ,
108        .reachable_time = 30 * HZ,
109        .delay_probe_time = 5 * HZ,
110        .queue_len_bytes = 64*1024,
111        .ucast_probes = 0,
112        .app_probes = 0,
113        .mcast_probes = 0,
114        .anycast_delay = 0,
115        .proxy_delay = 0,
116        .proxy_qlen = 0,
117        .locktime = 1 * HZ,
118    },
119    .gc_interval = 30 * HZ,
120    .gc_thresh1 = 128,
121    .gc_thresh2 = 512,
122    .gc_thresh3 = 1024,
123};
124
125static int dn_neigh_construct(struct neighbour *neigh)
126{
127    struct net_device *dev = neigh->dev;
128    struct dn_neigh *dn = (struct dn_neigh *)neigh;
129    struct dn_dev *dn_db;
130    struct neigh_parms *parms;
131
132    rcu_read_lock();
133    dn_db = rcu_dereference(dev->dn_ptr);
134    if (dn_db == NULL) {
135        rcu_read_unlock();
136        return -EINVAL;
137    }
138
139    parms = dn_db->neigh_parms;
140    if (!parms) {
141        rcu_read_unlock();
142        return -EINVAL;
143    }
144
145    __neigh_parms_put(neigh->parms);
146    neigh->parms = neigh_parms_clone(parms);
147
148    if (dn_db->use_long)
149        neigh->ops = &dn_long_ops;
150    else
151        neigh->ops = &dn_short_ops;
152    rcu_read_unlock();
153
154    if (dn->flags & DN_NDFLAG_P3)
155        neigh->ops = &dn_phase3_ops;
156
157    neigh->nud_state = NUD_NOARP;
158    neigh->output = neigh->ops->connected_output;
159
160    if ((dev->type == ARPHRD_IPGRE) || (dev->flags & IFF_POINTOPOINT))
161        memcpy(neigh->ha, dev->broadcast, dev->addr_len);
162    else if ((dev->type == ARPHRD_ETHER) || (dev->type == ARPHRD_LOOPBACK))
163        dn_dn2eth(neigh->ha, dn->addr);
164    else {
165        if (net_ratelimit())
166            printk(KERN_DEBUG "Trying to create neigh for hw %d\n", dev->type);
167        return -EINVAL;
168    }
169
170    /*
171     * Make an estimate of the remote block size by assuming that its
172     * two less then the device mtu, which it true for ethernet (and
173     * other things which support long format headers) since there is
174     * an extra length field (of 16 bits) which isn't part of the
175     * ethernet headers and which the DECnet specs won't admit is part
176     * of the DECnet routing headers either.
177     *
178     * If we over estimate here its no big deal, the NSP negotiations
179     * will prevent us from sending packets which are too large for the
180     * remote node to handle. In any case this figure is normally updated
181     * by a hello message in most cases.
182     */
183    dn->blksize = dev->mtu - 2;
184
185    return 0;
186}
187
188static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
189{
190    printk(KERN_DEBUG "dn_long_error_report: called\n");
191    kfree_skb(skb);
192}
193
194
195static void dn_short_error_report(struct neighbour *neigh, struct sk_buff *skb)
196{
197    printk(KERN_DEBUG "dn_short_error_report: called\n");
198    kfree_skb(skb);
199}
200
201static int dn_neigh_output_packet(struct sk_buff *skb)
202{
203    struct dst_entry *dst = skb_dst(skb);
204    struct dn_route *rt = (struct dn_route *)dst;
205    struct neighbour *neigh = dst_get_neighbour_noref(dst);
206    struct net_device *dev = neigh->dev;
207    char mac_addr[ETH_ALEN];
208    unsigned int seq;
209    int err;
210
211    dn_dn2eth(mac_addr, rt->rt_local_src);
212    do {
213        seq = read_seqbegin(&neigh->ha_lock);
214        err = dev_hard_header(skb, dev, ntohs(skb->protocol),
215                      neigh->ha, mac_addr, skb->len);
216    } while (read_seqretry(&neigh->ha_lock, seq));
217
218    if (err >= 0)
219        err = dev_queue_xmit(skb);
220    else {
221        kfree_skb(skb);
222        err = -EINVAL;
223    }
224    return err;
225}
226
227static int dn_long_output(struct neighbour *neigh, struct sk_buff *skb)
228{
229    struct net_device *dev = neigh->dev;
230    int headroom = dev->hard_header_len + sizeof(struct dn_long_packet) + 3;
231    unsigned char *data;
232    struct dn_long_packet *lp;
233    struct dn_skb_cb *cb = DN_SKB_CB(skb);
234
235
236    if (skb_headroom(skb) < headroom) {
237        struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom);
238        if (skb2 == NULL) {
239            if (net_ratelimit())
240                printk(KERN_CRIT "dn_long_output: no memory\n");
241            kfree_skb(skb);
242            return -ENOBUFS;
243        }
244        kfree_skb(skb);
245        skb = skb2;
246        if (net_ratelimit())
247            printk(KERN_INFO "dn_long_output: Increasing headroom\n");
248    }
249
250    data = skb_push(skb, sizeof(struct dn_long_packet) + 3);
251    lp = (struct dn_long_packet *)(data+3);
252
253    *((__le16 *)data) = cpu_to_le16(skb->len - 2);
254    *(data + 2) = 1 | DN_RT_F_PF; /* Padding */
255
256    lp->msgflg = DN_RT_PKT_LONG|(cb->rt_flags&(DN_RT_F_IE|DN_RT_F_RQR|DN_RT_F_RTS));
257    lp->d_area = lp->d_subarea = 0;
258    dn_dn2eth(lp->d_id, cb->dst);
259    lp->s_area = lp->s_subarea = 0;
260    dn_dn2eth(lp->s_id, cb->src);
261    lp->nl2 = 0;
262    lp->visit_ct = cb->hops & 0x3f;
263    lp->s_class = 0;
264    lp->pt = 0;
265
266    skb_reset_network_header(skb);
267
268    return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL,
269               neigh->dev, dn_neigh_output_packet);
270}
271
272static int dn_short_output(struct neighbour *neigh, struct sk_buff *skb)
273{
274    struct net_device *dev = neigh->dev;
275    int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
276    struct dn_short_packet *sp;
277    unsigned char *data;
278    struct dn_skb_cb *cb = DN_SKB_CB(skb);
279
280
281    if (skb_headroom(skb) < headroom) {
282        struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom);
283        if (skb2 == NULL) {
284            if (net_ratelimit())
285                printk(KERN_CRIT "dn_short_output: no memory\n");
286            kfree_skb(skb);
287            return -ENOBUFS;
288        }
289        kfree_skb(skb);
290        skb = skb2;
291        if (net_ratelimit())
292            printk(KERN_INFO "dn_short_output: Increasing headroom\n");
293    }
294
295    data = skb_push(skb, sizeof(struct dn_short_packet) + 2);
296    *((__le16 *)data) = cpu_to_le16(skb->len - 2);
297    sp = (struct dn_short_packet *)(data+2);
298
299    sp->msgflg = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS));
300    sp->dstnode = cb->dst;
301    sp->srcnode = cb->src;
302    sp->forward = cb->hops & 0x3f;
303
304    skb_reset_network_header(skb);
305
306    return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL,
307               neigh->dev, dn_neigh_output_packet);
308}
309
310/*
311 * Phase 3 output is the same is short output, execpt that
312 * it clears the area bits before transmission.
313 */
314static int dn_phase3_output(struct neighbour *neigh, struct sk_buff *skb)
315{
316    struct net_device *dev = neigh->dev;
317    int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
318    struct dn_short_packet *sp;
319    unsigned char *data;
320    struct dn_skb_cb *cb = DN_SKB_CB(skb);
321
322    if (skb_headroom(skb) < headroom) {
323        struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom);
324        if (skb2 == NULL) {
325            if (net_ratelimit())
326                printk(KERN_CRIT "dn_phase3_output: no memory\n");
327            kfree_skb(skb);
328            return -ENOBUFS;
329        }
330        kfree_skb(skb);
331        skb = skb2;
332        if (net_ratelimit())
333            printk(KERN_INFO "dn_phase3_output: Increasing headroom\n");
334    }
335
336    data = skb_push(skb, sizeof(struct dn_short_packet) + 2);
337    *((__le16 *)data) = cpu_to_le16(skb->len - 2);
338    sp = (struct dn_short_packet *)(data + 2);
339
340    sp->msgflg = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS));
341    sp->dstnode = cb->dst & cpu_to_le16(0x03ff);
342    sp->srcnode = cb->src & cpu_to_le16(0x03ff);
343    sp->forward = cb->hops & 0x3f;
344
345    skb_reset_network_header(skb);
346
347    return NF_HOOK(NFPROTO_DECNET, NF_DN_POST_ROUTING, skb, NULL,
348               neigh->dev, dn_neigh_output_packet);
349}
350
351/*
352 * Unfortunately, the neighbour code uses the device in its hash
353 * function, so we don't get any advantage from it. This function
354 * basically does a neigh_lookup(), but without comparing the device
355 * field. This is required for the On-Ethernet cache
356 */
357
358/*
359 * Pointopoint link receives a hello message
360 */
361void dn_neigh_pointopoint_hello(struct sk_buff *skb)
362{
363    kfree_skb(skb);
364}
365
366/*
367 * Ethernet router hello message received
368 */
369int dn_neigh_router_hello(struct sk_buff *skb)
370{
371    struct rtnode_hello_message *msg = (struct rtnode_hello_message *)skb->data;
372
373    struct neighbour *neigh;
374    struct dn_neigh *dn;
375    struct dn_dev *dn_db;
376    __le16 src;
377
378    src = dn_eth2dn(msg->id);
379
380    neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1);
381
382    dn = (struct dn_neigh *)neigh;
383
384    if (neigh) {
385        write_lock(&neigh->lock);
386
387        neigh->used = jiffies;
388        dn_db = rcu_dereference(neigh->dev->dn_ptr);
389
390        if (!(neigh->nud_state & NUD_PERMANENT)) {
391            neigh->updated = jiffies;
392
393            if (neigh->dev->type == ARPHRD_ETHER)
394                memcpy(neigh->ha, &eth_hdr(skb)->h_source, ETH_ALEN);
395
396            dn->blksize = le16_to_cpu(msg->blksize);
397            dn->priority = msg->priority;
398
399            dn->flags &= ~DN_NDFLAG_P3;
400
401            switch (msg->iinfo & DN_RT_INFO_TYPE) {
402            case DN_RT_INFO_L1RT:
403                dn->flags &=~DN_NDFLAG_R2;
404                dn->flags |= DN_NDFLAG_R1;
405                break;
406            case DN_RT_INFO_L2RT:
407                dn->flags |= DN_NDFLAG_R2;
408            }
409        }
410
411        /* Only use routers in our area */
412        if ((le16_to_cpu(src)>>10) == (le16_to_cpu((decnet_address))>>10)) {
413            if (!dn_db->router) {
414                dn_db->router = neigh_clone(neigh);
415            } else {
416                if (msg->priority > ((struct dn_neigh *)dn_db->router)->priority)
417                    neigh_release(xchg(&dn_db->router, neigh_clone(neigh)));
418            }
419        }
420        write_unlock(&neigh->lock);
421        neigh_release(neigh);
422    }
423
424    kfree_skb(skb);
425    return 0;
426}
427
428/*
429 * Endnode hello message received
430 */
431int dn_neigh_endnode_hello(struct sk_buff *skb)
432{
433    struct endnode_hello_message *msg = (struct endnode_hello_message *)skb->data;
434    struct neighbour *neigh;
435    struct dn_neigh *dn;
436    __le16 src;
437
438    src = dn_eth2dn(msg->id);
439
440    neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1);
441
442    dn = (struct dn_neigh *)neigh;
443
444    if (neigh) {
445        write_lock(&neigh->lock);
446
447        neigh->used = jiffies;
448
449        if (!(neigh->nud_state & NUD_PERMANENT)) {
450            neigh->updated = jiffies;
451
452            if (neigh->dev->type == ARPHRD_ETHER)
453                memcpy(neigh->ha, &eth_hdr(skb)->h_source, ETH_ALEN);
454            dn->flags &= ~(DN_NDFLAG_R1 | DN_NDFLAG_R2);
455            dn->blksize = le16_to_cpu(msg->blksize);
456            dn->priority = 0;
457        }
458
459        write_unlock(&neigh->lock);
460        neigh_release(neigh);
461    }
462
463    kfree_skb(skb);
464    return 0;
465}
466
467static char *dn_find_slot(char *base, int max, int priority)
468{
469    int i;
470    unsigned char *min = NULL;
471
472    base += 6; /* skip first id */
473
474    for(i = 0; i < max; i++) {
475        if (!min || (*base < *min))
476            min = base;
477        base += 7; /* find next priority */
478    }
479
480    if (!min)
481        return NULL;
482
483    return (*min < priority) ? (min - 6) : NULL;
484}
485
486struct elist_cb_state {
487    struct net_device *dev;
488    unsigned char *ptr;
489    unsigned char *rs;
490    int t, n;
491};
492
493static void neigh_elist_cb(struct neighbour *neigh, void *_info)
494{
495    struct elist_cb_state *s = _info;
496    struct dn_neigh *dn;
497
498    if (neigh->dev != s->dev)
499        return;
500
501    dn = (struct dn_neigh *) neigh;
502    if (!(dn->flags & (DN_NDFLAG_R1|DN_NDFLAG_R2)))
503        return;
504
505    if (s->t == s->n)
506        s->rs = dn_find_slot(s->ptr, s->n, dn->priority);
507    else
508        s->t++;
509    if (s->rs == NULL)
510        return;
511
512    dn_dn2eth(s->rs, dn->addr);
513    s->rs += 6;
514    *(s->rs) = neigh->nud_state & NUD_CONNECTED ? 0x80 : 0x0;
515    *(s->rs) |= dn->priority;
516    s->rs++;
517}
518
519int dn_neigh_elist(struct net_device *dev, unsigned char *ptr, int n)
520{
521    struct elist_cb_state state;
522
523    state.dev = dev;
524    state.t = 0;
525    state.n = n;
526    state.ptr = ptr;
527    state.rs = ptr;
528
529    neigh_for_each(&dn_neigh_table, neigh_elist_cb, &state);
530
531    return state.t;
532}
533
534
535#ifdef CONFIG_PROC_FS
536
537static inline void dn_neigh_format_entry(struct seq_file *seq,
538                     struct neighbour *n)
539{
540    struct dn_neigh *dn = (struct dn_neigh *) n;
541    char buf[DN_ASCBUF_LEN];
542
543    read_lock(&n->lock);
544    seq_printf(seq, "%-7s %s%s%s %02x %02d %07ld %-8s\n",
545           dn_addr2asc(le16_to_cpu(dn->addr), buf),
546           (dn->flags&DN_NDFLAG_R1) ? "1" : "-",
547           (dn->flags&DN_NDFLAG_R2) ? "2" : "-",
548           (dn->flags&DN_NDFLAG_P3) ? "3" : "-",
549           dn->n.nud_state,
550           atomic_read(&dn->n.refcnt),
551           dn->blksize,
552           (dn->n.dev) ? dn->n.dev->name : "?");
553    read_unlock(&n->lock);
554}
555
556static int dn_neigh_seq_show(struct seq_file *seq, void *v)
557{
558    if (v == SEQ_START_TOKEN) {
559        seq_puts(seq, "Addr Flags State Use Blksize Dev\n");
560    } else {
561        dn_neigh_format_entry(seq, v);
562    }
563
564    return 0;
565}
566
567static void *dn_neigh_seq_start(struct seq_file *seq, loff_t *pos)
568{
569    return neigh_seq_start(seq, pos, &dn_neigh_table,
570                   NEIGH_SEQ_NEIGH_ONLY);
571}
572
573static const struct seq_operations dn_neigh_seq_ops = {
574    .start = dn_neigh_seq_start,
575    .next = neigh_seq_next,
576    .stop = neigh_seq_stop,
577    .show = dn_neigh_seq_show,
578};
579
580static int dn_neigh_seq_open(struct inode *inode, struct file *file)
581{
582    return seq_open_net(inode, file, &dn_neigh_seq_ops,
583                sizeof(struct neigh_seq_state));
584}
585
586static const struct file_operations dn_neigh_seq_fops = {
587    .owner = THIS_MODULE,
588    .open = dn_neigh_seq_open,
589    .read = seq_read,
590    .llseek = seq_lseek,
591    .release = seq_release_net,
592};
593
594#endif
595
596void __init dn_neigh_init(void)
597{
598    neigh_table_init(&dn_neigh_table);
599    proc_net_fops_create(&init_net, "decnet_neigh", S_IRUGO, &dn_neigh_seq_fops);
600}
601
602void __exit dn_neigh_cleanup(void)
603{
604    proc_net_remove(&init_net, "decnet_neigh");
605    neigh_table_clear(&dn_neigh_table);
606}
607

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive