i386/linux/linux-2.3.21/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  *
  22  */
  23
  24 #include <linux/config.h>
  25 #include <linux/net.h>
  26 #include <linux/socket.h>
  27 #include <linux/if_arp.h>
  28 #include <linux/if_ether.h>
  29 #include <linux/init.h>
  30 #include <linux/proc_fs.h>
  31 #include <linux/string.h>
  32 #include <linux/netfilter_decnet.h>
  33 #include <linux/spinlock.h>
  34 #include <asm/atomic.h>
  35 #include <net/neighbour.h>
  36 #include <net/dst.h>
  37 #include <net/dn.h>
  38 #include <net/dn_dev.h>
  39 #include <net/dn_neigh.h>
  40 #include <net/dn_route.h>
  41
  42 static u32 dn_neigh_hash(const void *pkey, const struct net_device *dev);
  43 static int dn_neigh_construct(struct neighbour *);
  44 static void dn_long_error_report(struct neighbour *, struct sk_buff *);
  45 static void dn_short_error_report(struct neighbour *, struct sk_buff *);
  46 static int dn_long_output(struct sk_buff *);
  47 static int dn_short_output(struct sk_buff *);
  48 static int dn_phase3_output(struct sk_buff *);
  49
  50
  51 /*
  52  * For talking to broadcast devices: Ethernet & PPP
  53  */
  54 static struct neigh_ops dn_long_ops = {
  55         AF_DECnet,
  56         NULL,
  57         NULL,
  58         dn_long_error_report,
  59         dn_long_output,
  60         dn_long_output,
  61         dev_queue_xmit,
  62         dev_queue_xmit
  63 };
  64
  65 /*
  66  * For talking to pointopoint and multidrop devices: DDCMP and X.25
  67  */
  68 static struct neigh_ops dn_short_ops = {
  69         AF_DECnet,
  70         NULL,
  71         NULL,
  72         dn_short_error_report,
  73         dn_short_output,
  74         dn_short_output,
  75         dev_queue_xmit,
  76         dev_queue_xmit
  77 };
  78
  79 /*
  80  * For talking to DECnet phase III nodes
  81  */
  82 static struct neigh_ops dn_phase3_ops = {
  83         AF_DECnet,
  84         NULL,
  85         NULL,
  86         dn_short_error_report, /* Can use short version here */
  87         dn_phase3_output,
  88         dn_phase3_output,
  89         dev_queue_xmit,
  90         dev_queue_xmit
  91 };
  92
  93 struct neigh_table dn_neigh_table = {
  94         NULL,
  95         PF_DECnet,
  96         sizeof(struct dn_neigh),
  97         sizeof(dn_address),
  98         dn_neigh_hash,
  99         dn_neigh_construct,
 100         NULL, /* pconstructor */
 101         NULL, /* pdestructor */
 102         NULL, /* proxyredo */
 103         "dn_neigh_cache",
 104         {
 105                 NULL,
 106                 NULL,
 107                 &dn_neigh_table,
 108                 0,
 109                 NULL,
 110                 NULL,
 111                 30 * HZ,        /* base_reachable_time */
 112                 1 * HZ,         /* retrans_time */
 113                 60 * HZ,        /* gc_staletime */
 114                 30 * HZ,        /* reachable_time */
 115                 5 * HZ,         /* delay_probe_time */
 116                 3,      /* queue_len */
 117                 0,      /* ucast_probes */
 118                 0,      /* app_probes */
 119                 0,      /* mcast_probes */
 120                 0,      /* anycast_delay */
 121                 0,      /* proxy_delay */
 122                 0,      /* proxy_qlen */
 123                 1 * HZ, /* locktime */
 124         },
 125         30 * HZ,        /* gc_interval */
 126         128,            /* gc_thresh1 */
 127         512,            /* gc_thresh2 */
 128         1024,           /* gc_thresh3 */
 129
 130 };
 131
 132 static u32 dn_neigh_hash(const void *pkey, const struct net_device *dev)
 133 {
 134         u32 hash_val;
 135
 136         hash_val = *(dn_address *)pkey;
 137         hash_val ^= (hash_val >> 10);
 138         hash_val ^= (hash_val >> 3);
 139
 140         return hash_val & NEIGH_HASHMASK;
 141 }
 142
 143 static int dn_neigh_construct(struct neighbour *neigh)
 144 {
 145         struct net_device *dev = neigh->dev;
 146         struct dn_neigh *dn = (struct dn_neigh *)neigh;
 147         struct dn_dev *dn_db = (struct dn_dev *)dev->dn_ptr;
 148
 149         if (dn_db == NULL)
 150                 return -EINVAL;
 151
 152         if (dn_db->neigh_parms)
 153                 neigh->parms = dn_db->neigh_parms;
 154
 155         if (dn_db->use_long)
 156                 neigh->ops = &dn_long_ops;
 157         else
 158                 neigh->ops = &dn_short_ops;
 159
 160         if (dn->flags & DN_NDFLAG_P3)
 161                 neigh->ops = &dn_phase3_ops;
 162
 163         neigh->nud_state = NUD_NOARP;
 164         neigh->output = neigh->ops->connected_output;
 165
 166         if ((dev->type == ARPHRD_IPGRE) || (dev->flags & IFF_POINTOPOINT))
 167                 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
 168         else if ((dev->type == ARPHRD_ETHER) || (dev->type == ARPHRD_LOOPBACK))
 169                 dn_dn2eth(neigh->ha, dn->addr);
 170         else {
 171                 if (net_ratelimit())
 172                         printk(KERN_DEBUG "Trying to create neigh for hw %d\n",  dev->type);
 173                 return -EINVAL;
 174         }
 175
 176         dn->blksize = 230;
 177
 178         return 0;
 179 }
 180
 181 static void dn_long_error_report(struct neighbour *neigh, struct sk_buff *skb)
 182 {
 183         struct dn_skb_cb *cb = (struct dn_skb_cb *)skb->cb;
 184         unsigned char *ptr;
 185
 186         printk(KERN_DEBUG "dn_long_error_report: called\n");
 187
 188         if (!(cb->rt_flags & DN_RT_F_RQR)) {
 189                 kfree_skb(skb);
 190                 return;
 191         }
 192
 193         skb_push(skb, skb->data - skb->nh.raw);
 194         ptr = skb->data;
 195
 196         *(unsigned short *)ptr = dn_htons(skb->len - 2);
 197         ptr += 2;
 198
 199         if (*ptr & DN_RT_F_PF) {
 200                 char padlen = (*ptr & ~DN_RT_F_PF);
 201                 ptr += padlen;
 202         }
 203
 204         *ptr++ |= (cb->rt_flags & ~DN_RT_F_RQR) | DN_RT_F_RTS;
 205
 206         ptr += 2;
 207         dn_dn2eth(ptr, dn_ntohs(cb->src));
 208         ptr += 8;
 209         dn_dn2eth(ptr, dn_ntohs(cb->dst));
 210         ptr += 6;
 211         *ptr = 0;
 212
 213         skb->dst->neighbour->ops->queue_xmit(skb);
 214 }
 215
 216
 217 static void dn_short_error_report(struct neighbour *neigh, struct sk_buff *skb)
 218 {
 219         struct dn_skb_cb *cb = (struct dn_skb_cb *)skb->cb;
 220         unsigned char *ptr;
 221
 222         printk(KERN_DEBUG "dn_short_error_report: called\n");
 223
 224         if (!(cb->rt_flags & DN_RT_F_RQR)) {
 225                 kfree_skb(skb);
 226                 return;
 227         }
 228
 229         skb_push(skb, skb->data - skb->nh.raw);
 230         ptr = skb->data;
 231
 232         *(unsigned short *)ptr = dn_htons(skb->len - 2);
 233         ptr += 2;
 234         *ptr++ = (cb->rt_flags & ~DN_RT_F_RQR) | DN_RT_F_RTS;
 235
 236         *(dn_address *)ptr = cb->src;
 237         ptr += 2;
 238         *(dn_address *)ptr = cb->dst;
 239         ptr += 2;
 240         *ptr = 0;
 241
 242         skb->dst->neighbour->ops->queue_xmit(skb);
 243 }
 244
 245 static int dn_neigh_output_packet(struct sk_buff *skb)
 246 {
 247         struct dst_entry *dst = skb->dst;
 248         struct neighbour *neigh = dst->neighbour;
 249         struct net_device *dev = neigh->dev;
 250
 251         if (!dev->hard_header || dev->hard_header(skb, dev, ntohs(skb->protocol), neigh->ha, NULL, skb->len) >= 0)
 252                 return neigh->ops->queue_xmit(skb);
 253
 254         if (net_ratelimit())
 255                 printk(KERN_DEBUG "dn_neigh_output_packet: oops, can't send packet\n");
 256
 257         kfree_skb(skb);
 258         return -EINVAL;
 259 }
 260
 261 static int dn_long_output(struct sk_buff *skb)
 262 {
 263         struct dst_entry *dst = skb->dst;
 264         struct neighbour *neigh = dst->neighbour;
 265         struct net_device *dev = neigh->dev;
 266         int headroom = dev->hard_header_len + sizeof(struct dn_long_packet) + 3;
 267         unsigned char *data;
 268         struct dn_long_packet *lp;
 269         struct dn_skb_cb *cb = (struct dn_skb_cb *)skb->cb;
 270
 271
 272         if (skb_headroom(skb) < headroom) {
 273                 struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom);
 274                 if (skb2 == NULL) {
 275                         if (net_ratelimit())
 276                                 printk(KERN_CRIT "dn_long_output: no memory\n");
 277                         kfree_skb(skb);
 278                         return -ENOBUFS;
 279                 }
 280                 kfree_skb(skb);
 281                 skb = skb2;
 282                 if (net_ratelimit())
 283                         printk(KERN_INFO "dn_long_output: Increasing headroom\n");
 284         }
 285
 286         data = skb_push(skb, sizeof(struct dn_long_packet) + 3);
 287         lp = (struct dn_long_packet *)(data+3);
 288
 289         *((unsigned short *)data) = dn_htons(skb->len - 2);
 290         *(data + 2) = 1 | DN_RT_F_PF; /* Padding */
 291
 292         lp->msgflg   = DN_RT_PKT_LONG|(cb->rt_flags&(DN_RT_F_IE|DN_RT_F_RQR|DN_RT_F_RTS));
 293         lp->d_area   = lp->d_subarea = 0;
 294         dn_dn2eth(lp->d_id, dn_ntohs(cb->dst));
 295         lp->s_area   = lp->s_subarea = 0;
 296         dn_dn2eth(lp->s_id, dn_ntohs(cb->src));
 297         lp->nl2      = 0;
 298         lp->visit_ct = cb->hops & 0x3f;
 299         lp->s_class  = 0;
 300         lp->pt       = 0;
 301
 302         skb->nh.raw = skb->data;
 303
 304         return NF_HOOK(PF_DECnet, NF_DN_POST_ROUTING, skb, NULL, neigh->dev, dn_neigh_output_packet);
 305 }
 306
 307 static int dn_short_output(struct sk_buff *skb)
 308 {
 309         struct dst_entry *dst = skb->dst;
 310         struct neighbour *neigh = dst->neighbour;
 311         struct net_device *dev = neigh->dev;
 312         int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
 313         struct dn_short_packet *sp;
 314         unsigned char *data;
 315         struct dn_skb_cb *cb = (struct dn_skb_cb *)skb->cb;
 316
 317
 318         if (skb_headroom(skb) < headroom) {
 319                 struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom);
 320                 if (skb2 == NULL) {
 321                         if (net_ratelimit())
 322                                 printk(KERN_CRIT "dn_short_output: no memory\n");
 323                         kfree_skb(skb);
 324                         return -ENOBUFS;
 325                 }
 326                 kfree_skb(skb);
 327                 skb = skb2;
 328                 if (net_ratelimit())
 329                         printk(KERN_INFO "dn_short_output: Increasing headroom\n");
 330         }
 331
 332         data = skb_push(skb, sizeof(struct dn_short_packet) + 2);
 333         *((unsigned short *)data) = dn_htons(skb->len - 2);
 334         sp = (struct dn_short_packet *)(data+2);
 335
 336         sp->msgflg     = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS));
 337         sp->dstnode    = cb->dst;
 338         sp->srcnode    = cb->src;
 339         sp->forward    = cb->hops & 0x3f;
 340
 341         skb->nh.raw = skb->data;
 342
 343         return NF_HOOK(PF_DECnet, NF_DN_POST_ROUTING, skb, NULL, neigh->dev, dn_neigh_output_packet);
 344 }
 345
 346 /*
 347  * Phase 3 output is the same is short output, execpt that
 348  * it clears the area bits before transmission.
 349  */
 350 static int dn_phase3_output(struct sk_buff *skb)
 351 {
 352         struct dst_entry *dst = skb->dst;
 353         struct neighbour *neigh = dst->neighbour;
 354         struct net_device *dev = neigh->dev;
 355         int headroom = dev->hard_header_len + sizeof(struct dn_short_packet) + 2;
 356         struct dn_short_packet *sp;
 357         unsigned char *data;
 358         struct dn_skb_cb *cb = (struct dn_skb_cb *)skb->cb;
 359
 360         if (skb_headroom(skb) < headroom) {
 361                 struct sk_buff *skb2 = skb_realloc_headroom(skb, headroom);
 362                 if (skb2 == NULL) {
 363                         if (net_ratelimit())
 364                                 printk(KERN_CRIT "dn_phase3_output: no memory\n");
 365                         kfree_skb(skb);
 366                         return -ENOBUFS;
 367                 }
 368                 kfree_skb(skb);
 369                 skb = skb2;
 370                 if (net_ratelimit())
 371                         printk(KERN_INFO "dn_phase3_output: Increasing headroom\n");
 372         }
 373
 374         data = skb_push(skb, sizeof(struct dn_short_packet) + 2);
 375         ((unsigned short *)data) = dn_htons(skb->len - 2);
 376         sp = (struct dn_short_packet *)(data + 2);
 377
 378         sp->msgflg   = DN_RT_PKT_SHORT|(cb->rt_flags&(DN_RT_F_RQR|DN_RT_F_RTS));
 379         sp->dstnode  = cb->dst & dn_htons(0x03ff);
 380         sp->srcnode  = cb->src & dn_htons(0x03ff);
 381         sp->forward  = cb->hops & 0x3f;
 382
 383         skb->nh.raw = skb->data;
 384
 385         return NF_HOOK(PF_DECnet, NF_DN_POST_ROUTING, skb, NULL, neigh->dev, dn_neigh_output_packet);
 386 }
 387
 388 /*
 389  * Unfortunately, the neighbour code uses the device in its hash
 390  * function, so we don't get any advantage from it. This function
 391  * basically does a neigh_lookup(), but without comparing the device
 392  * field. This is required for the On-Ethernet cache
 393  */
 394 struct neighbour *dn_neigh_lookup(struct neigh_table *tbl, void *ptr)
 395 {
 396         struct neighbour *neigh;
 397         u32 hash_val;
 398
 399         hash_val = tbl->hash(ptr, NULL);
 400
 401         read_lock_bh(&tbl->lock);
 402         for(neigh = tbl->hash_buckets[hash_val]; neigh != NULL; neigh = neigh->next) {
 403                 if (memcmp(neigh->primary_key, ptr, tbl->key_len) == 0) {
 404                         atomic_inc(&neigh->refcnt);
 405                         read_unlock_bh(&tbl->lock);
 406                         return neigh;
 407                 }
 408         }
 409         read_unlock_bh(&tbl->lock);
 410
 411         return NULL;
 412 }
 413
 414
 415 /*
 416  * Any traffic on a pointopoint link causes the timer to be reset
 417  * for the entry in the neighbour table.
 418  */
 419 void dn_neigh_pointopoint_notify(struct sk_buff *skb)
 420 {
 421         return;
 422 }
 423
 424 /*
 425  * Pointopoint link receives a hello message
 426  */
 427 void dn_neigh_pointopoint_hello(struct sk_buff *skb)
 428 {
 429         kfree_skb(skb);
 430 }
 431
 432 /*
 433  * Ethernet router hello message received
 434  */
 435 void dn_neigh_router_hello(struct sk_buff *skb)
 436 {
 437         struct rtnode_hello_message *msg = (struct rtnode_hello_message *)skb->data;
 438
 439         struct neighbour *neigh;
 440         struct dn_neigh *dn;
 441         struct dn_dev *dn_db;
 442         dn_address src;
 443
 444         src = dn_eth2dn(msg->id);
 445
 446         neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1);
 447
 448         dn = (struct dn_neigh *)neigh;
 449
 450         if (neigh) {
 451                 write_lock(&neigh->lock);
 452
 453                 neigh->used = jiffies;
 454                 dn_db = (struct dn_dev *)neigh->dev->dn_ptr;
 455
 456                 if (!(neigh->nud_state & NUD_PERMANENT)) {
 457                         neigh->updated = jiffies;
 458
 459                         if (neigh->dev->type == ARPHRD_ETHER)
 460                                 memcpy(neigh->ha, &skb->mac.ethernet->h_source, ETH_ALEN);
 461
 462                         dn->blksize  = dn_ntohs(msg->blksize);
 463                         dn->priority = msg->priority;
 464
 465                         dn->flags &= ~DN_NDFLAG_P3;
 466
 467                         switch(msg->iinfo & DN_RT_INFO_TYPE) {
 468                                 case DN_RT_INFO_L1RT:
 469                                         dn->flags &=~DN_NDFLAG_R2;
 470                                         dn->flags |= DN_NDFLAG_R1;
 471                                         break;
 472                                 case DN_RT_INFO_L2RT:
 473                                         dn->flags |= DN_NDFLAG_R2;
 474                         }
 475                 }
 476
 477                 if (!dn_db->router) {
 478                         dn_db->router = neigh_clone(neigh);
 479                 } else {
 480                         if (msg->priority > ((struct dn_neigh *)dn_db->router)->priority)
 481                                 neigh_release(xchg(&dn_db->router, neigh_clone(neigh)));
 482                 }
 483                 write_unlock(&neigh->lock);
 484                 neigh_release(neigh);
 485         }
 486
 487         kfree_skb(skb);
 488 }
 489
 490 /*
 491  * Endnode hello message received
 492  */
 493 void dn_neigh_endnode_hello(struct sk_buff *skb)
 494 {
 495         struct endnode_hello_message *msg = (struct endnode_hello_message *)skb->data;
 496         struct neighbour *neigh;
 497         struct dn_neigh *dn;
 498         dn_address src;
 499
 500         src = dn_eth2dn(msg->id);
 501
 502         neigh = __neigh_lookup(&dn_neigh_table, &src, skb->dev, 1);
 503
 504         dn = (struct dn_neigh *)neigh;
 505
 506         if (neigh) {
 507                 write_lock(&neigh->lock);
 508
 509                 neigh->used = jiffies;
 510
 511                 if (!(neigh->nud_state & NUD_PERMANENT)) {
 512                         neigh->updated = jiffies;
 513
 514                         if (neigh->dev->type == ARPHRD_ETHER)
 515                                 memcpy(neigh->ha, &skb->mac.ethernet->h_source, ETH_ALEN);
 516                         dn->flags   &= ~(DN_NDFLAG_R1 | DN_NDFLAG_R2);
 517                         dn->blksize  = dn_ntohs(msg->blksize);
 518                         dn->priority = 0;
 519                 }
 520
 521                 write_unlock(&neigh->lock);
 522                 neigh_release(neigh);
 523         }
 524
 525         kfree_skb(skb);
 526 }
 527
 528
 529 #ifdef CONFIG_DECNET_ROUTER
 530 static char *dn_find_slot(char *base, int max, int priority)
 531 {
 532         int i;
 533         unsigned char *min = NULL;
 534
 535         base += 6; /* skip first id */
 536
 537         for(i = 0; i < max; i++) {
 538                 if (!min || (*base < *min))
 539                         min = base;
 540                 base += 7; /* find next priority */
 541         }
 542
 543         if (!min)
 544                 return NULL;
 545
 546         return (*min < priority) ? (min - 6) : NULL;
 547 }
 548
 549 int dn_neigh_elist(struct net_device *dev, unsigned char *ptr, int n)
 550 {
 551         int t = 0;
 552         int i;
 553         struct neighbour *neigh;
 554         struct dn_neigh *dn;
 555         struct neigh_table *tbl = &dn_neigh_table;
 556         unsigned char *rs = ptr;
 557
 558         read_lock_bh(&tbl->lock);
 559
 560         for(i = 0; i < NEIGH_HASHMASK; i++) {
 561                 for(neigh = tbl->hash_buckets[i]; neigh != NULL; neigh = neigh->next) {
 562                         if (neigh->dev != dev)
 563                                 continue;
 564                         dn = (struct dn_neigh *)neigh;
 565                         if (!(dn->flags & (DN_NDFLAG_R1|DN_NDFLAG_R2)))
 566                                 continue;
 567                         if (decnet_node_type == DN_RT_INFO_L1RT && (dn->flags & DN_NDFLAG_R2))
 568                                 continue;
 569                         if (t == n)
 570                                 rs = dn_find_slot(ptr, n, dn->priority);
 571                         else
 572                                 t++;
 573                         if (rs == NULL)
 574                                 continue;
 575                         dn_dn2eth(rs, dn->addr);
 576                         rs += 6;
 577                         *rs = neigh->nud_state & NUD_CONNECTED ? 0x80 : 0x0;
 578                         *rs |= dn->priority;
 579                         rs++;
 580                 }
 581         }
 582
 583         read_unlock_bh(&tbl->lock);
 584
 585         return t;
 586 }
 587 #endif /* CONFIG_DECNET_ROUTER */
 588
 589
 590
 591 #ifdef CONFIG_PROC_FS
 592 int dn_neigh_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
 593 {
 594         int len     = 0;
 595         off_t pos   = 0;
 596         off_t begin = 0;
 597         struct neighbour *n;
 598         int i;
 599         char buf[DN_ASCBUF_LEN];
 600
 601         len += sprintf(buffer + len, "Addr    Flags State Use Blksize Dev\n");
 602
 603         for(i=0;i <= NEIGH_HASHMASK; i++) {
 604                 read_lock_bh(&dn_neigh_table.lock);
 605                 n = dn_neigh_table.hash_buckets[i];
 606                 for(; n != NULL; n = n->next) {
 607                         struct dn_neigh *dn = (struct dn_neigh *)n;
 608
 609                         read_lock(&n->lock);
 610                         len += sprintf(buffer+len, "%-7s %s%s%s   %02x    %02d  %07ld %-8s\n",
 611                                         dn_addr2asc(dn_ntohs(dn->addr), buf),
 612                                         (dn->flags&DN_NDFLAG_R1) ? "1" : "-",
 613                                         (dn->flags&DN_NDFLAG_R2) ? "2" : "-",
 614                                         (dn->flags&DN_NDFLAG_P3) ? "3" : "-",
 615                                         dn->n.nud_state,
 616                                         atomic_read(&dn->n.refcnt),
 617                                         dn->blksize,
 618                                         (dn->n.dev) ? dn->n.dev->name : "?");
 619                         read_unlock(&n->lock);
 620
 621                         pos = begin + len;
 622
 623                         if (pos < offset) {
 624                                 len = 0;
 625                                 begin = pos;
 626                         }
 627
 628                         if (pos > offset + length) {
 629                                 read_unlock_bh(&dn_neigh_table.lock);
 630                                 goto done;
 631                         }
 632                 }
 633                 read_unlock_bh(&dn_neigh_table.lock);
 634         }
 635
 636 done:
 637
 638         *start = buffer + (offset - begin);
 639         len   -= offset - begin;
 640
 641         if (len > length) len = length;
 642
 643         return len;
 644 }
 645
 646 static struct proc_dir_entry proc_net_dn_neigh = {
 647         PROC_NET_DN_ADJ, 12, "decnet_neigh",
 648         S_IFREG | S_IRUGO, 1, 0, 0,
 649         0, &proc_net_inode_operations,
 650         dn_neigh_get_info
 651 };
 652
 653 #endif
 654
 655 void __init dn_neigh_init(void)
 656 {
 657         neigh_table_init(&dn_neigh_table);
 658
 659 #ifdef CONFIG_PROC_FS
 660         proc_net_register(&proc_net_dn_neigh);
 661 #endif /* CONFIG_PROC_FS */
 662 }
 663
 664 #ifdef CONFIG_DECNET_MODULE
 665 void dn_neigh_cleanup(void)
 666 {
 667 #ifdef CONFIG_PROC_FS
 668         proc_net_unregister(PROC_NET_DN_ADJ);
 669 #endif /* CONFIG_PROC_FS */
 670         neigh_table_clear(&dn_neigh_table);
 671 }
 672 #endif /* CONFIG_DECNET_MODULE */