kernel/2.6/net/can/af_can.c

   1 /*
   2  * af_can.c - Protocol family CAN core module
   3  *            (used by different CAN protocol modules)
   4  *
   5  * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of Volkswagen nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * Alternatively, provided that this notice is retained in full, this
  21  * software may be distributed under the terms of the GNU General
  22  * Public License ("GPL") version 2, in which case the provisions of the
  23  * GPL apply INSTEAD OF those given above.
  24  *
  25  * The provided data structures and external interfaces from this code
  26  * are not restricted to be used by modules with a GPL compatible license.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  31  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  32  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  33  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  34  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  35  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  36  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  37  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  38  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  39  * DAMAGE.
  40  *
  41  * Send feedback to <socketcan-users@lists.berlios.de>
  42  *
  43  */
  44
  45 #include <linux/module.h>
  46 #include <linux/version.h>
  47 #include <linux/init.h>
  48 #include <linux/kmod.h>
  49 #include <linux/slab.h>
  50 #include <linux/list.h>
  51 #include <linux/spinlock.h>
  52 #include <linux/rcupdate.h>
  53 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,18)
  54 #include <linux/uaccess.h>
  55 #else
  56 #include <asm/uaccess.h>
  57 #endif
  58 #include <linux/net.h>
  59 #include <linux/netdevice.h>
  60 #include <linux/socket.h>
  61 #include <linux/if_ether.h>
  62 #include <linux/if_arp.h>
  63 #include <linux/skbuff.h>
  64 #include <linux/can.h>
  65 #include <linux/can/core.h>
  66 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
  67 #include <net/net_namespace.h>
  68 #endif
  69 #include <net/sock.h>
  70
  71 #include "af_can.h"
  72 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
  73 #include "compat.h"
  74 #endif
  75
  76 #include <linux/can/version.h> /* for RCSID. Removed by mkpatch script */
  77 RCSID("$Id$");
  78
  79 static __initdata const char banner[] = KERN_INFO
  80         "can: controller area network core (" CAN_VERSION_STRING ")\n";
  81
  82 MODULE_DESCRIPTION("Controller Area Network PF_CAN core");
  83 MODULE_LICENSE("Dual BSD/GPL");
  84 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>, "
  85               "Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
  86
  87 MODULE_ALIAS_NETPROTO(PF_CAN);
  88
  89 static int stats_timer __read_mostly = 1;
  90 module_param(stats_timer, int, S_IRUGO);
  91 MODULE_PARM_DESC(stats_timer, "enable timer for statistics (default:on)");
  92
  93 HLIST_HEAD(can_rx_dev_list);
  94 static struct dev_rcv_lists can_rx_alldev_list;
  95 static DEFINE_SPINLOCK(can_rcvlists_lock);
  96
  97 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
  98 static struct kmem_cache *rcv_cache __read_mostly;
  99 #else
 100 static kmem_cache_t *rcv_cache;
 101 #endif
 102
 103 /* table of registered CAN protocols */
 104 static struct can_proto *proto_tab[CAN_NPROTO] __read_mostly;
 105 static DEFINE_SPINLOCK(proto_tab_lock);
 106
 107 struct timer_list can_stattimer;   /* timer for statistics update */
 108 struct s_stats    can_stats;       /* packet statistics */
 109 struct s_pstats   can_pstats;      /* receive list statistics */
 110
 111 /*
 112  * af_can socket functions
 113  */
 114
 115 static int can_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 116 {
 117         struct sock *sk = sock->sk;
 118
 119         switch (cmd) {
 120
 121         case SIOCGSTAMP:
 122                 return sock_get_timestamp(sk, (struct timeval __user *)arg);
 123
 124         default:
 125 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,16)
 126                 return -ENOIOCTLCMD;
 127 #else
 128                 return dev_ioctl(cmd, (void __user *)arg);
 129 #endif
 130         }
 131 }
 132
 133 static void can_sock_destruct(struct sock *sk)
 134 {
 135         skb_queue_purge(&sk->sk_receive_queue);
 136 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
 137         if (sk->sk_protinfo)
 138                 kfree(sk->sk_protinfo);
 139 #endif
 140 }
 141
 142 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
 143 static int can_create(struct net *net, struct socket *sock, int protocol)
 144 #else
 145 static int can_create(struct socket *sock, int protocol)
 146 #endif
 147 {
 148         struct sock *sk;
 149         struct can_proto *cp;
 150         int err = 0;
 151
 152         sock->state = SS_UNCONNECTED;
 153
 154         if (protocol < 0 || protocol >= CAN_NPROTO)
 155                 return -EINVAL;
 156
 157 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
 158         if (net != &init_net)
 159                 return -EAFNOSUPPORT;
 160 #endif
 161
 162         /* try to load protocol module, when CONFIG_KMOD is defined */
 163         if (!proto_tab[protocol]) {
 164                 err = request_module("can-proto-%d", protocol);
 165
 166                 /*
 167                  * In case of error we only print a message but don't
 168                  * return the error code immediately.  Below we will
 169                  * return -EPROTONOSUPPORT
 170                  */
 171                 if (err == -ENOSYS) {
 172                         if (printk_ratelimit())
 173                                 printk(KERN_INFO "can: request_module()"
 174                                        " not implemented.\n");
 175                 } else if (err) {
 176                         if (printk_ratelimit())
 177                                 printk(KERN_ERR "can: request_module "
 178                                        "(can-proto-%d) failed.\n", protocol);
 179                 }
 180         }
 181
 182         spin_lock(&proto_tab_lock);
 183         cp = proto_tab[protocol];
 184 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 185         if (cp && !try_module_get(cp->prot->owner))
 186                 cp = NULL;
 187 #else
 188         if (cp && !try_module_get(cp->owner))
 189                 cp = NULL;
 190 #endif
 191         spin_unlock(&proto_tab_lock);
 192
 193         /* check for available protocol and correct usage */
 194
 195         if (!cp)
 196                 return -EPROTONOSUPPORT;
 197
 198         if (cp->type != sock->type) {
 199                 err = -EPROTONOSUPPORT;
 200                 goto errout;
 201         }
 202
 203         if (cp->capability >= 0 && !capable(cp->capability)) {
 204                 err = -EPERM;
 205                 goto errout;
 206         }
 207
 208         sock->ops = cp->ops;
 209
 210 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
 211         sk = sk_alloc(net, PF_CAN, GFP_KERNEL, cp->prot);
 212 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 213         sk = sk_alloc(PF_CAN, GFP_KERNEL, cp->prot, 1);
 214 #else
 215         sk = sk_alloc(PF_CAN, GFP_KERNEL, 1, 0);
 216 #endif
 217         if (!sk) {
 218                 err = -ENOMEM;
 219                 goto errout;
 220         }
 221
 222 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
 223         if (cp->obj_size) {
 224                 sk->sk_protinfo = kmalloc(cp->obj_size, GFP_KERNEL);
 225                 if (!sk->sk_protinfo) {
 226                         sk_free(sk);
 227                         err = -ENOMEM;
 228                         goto errout;
 229                 }
 230         }
 231         sk_set_owner(sk, proto_tab[protocol]->owner);
 232 #endif
 233
 234         sock_init_data(sock, sk);
 235         sk->sk_destruct = can_sock_destruct;
 236
 237 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 238         if (sk->sk_prot->init)
 239                 err = sk->sk_prot->init(sk);
 240 #else
 241         if (cp->init)
 242                 err = cp->init(sk);
 243 #endif
 244
 245         if (err) {
 246                 /* release sk on errors */
 247                 sock_orphan(sk);
 248                 sock_put(sk);
 249         }
 250
 251  errout:
 252 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 253         module_put(cp->prot->owner);
 254 #else
 255         module_put(cp->owner);
 256 #endif
 257         return err;
 258 }
 259
 260 /*
 261  * af_can tx path
 262  */
 263
 264 /**
 265  * can_send - transmit a CAN frame (optional with local loopback)
 266  * @skb: pointer to socket buffer with CAN frame in data section
 267  * @loop: loopback for listeners on local CAN sockets (recommended default!)
 268  *
 269  * Return:
 270  *  0 on success
 271  *  -ENETDOWN when the selected interface is down
 272  *  -ENOBUFS on full driver queue (see net_xmit_errno())
 273  *  -ENOMEM when local loopback failed at calling skb_clone()
 274  *  -EPERM when trying to send on a non-CAN interface
 275  */
 276 int can_send(struct sk_buff *skb, int loop)
 277 {
 278         int err;
 279
 280         if (skb->dev->type != ARPHRD_CAN) {
 281                 kfree_skb(skb);
 282                 return -EPERM;
 283         }
 284
 285         if (!(skb->dev->flags & IFF_UP)) {
 286                 kfree_skb(skb);
 287                 return -ENETDOWN;
 288         }
 289
 290         skb->protocol = htons(ETH_P_CAN);
 291 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
 292         skb_reset_network_header(skb);
 293         skb_reset_transport_header(skb);
 294 #else
 295         skb->nh.raw = skb->data;
 296         skb->h.raw  = skb->data;
 297 #endif
 298
 299         if (loop) {
 300                 /* local loopback of sent CAN frames */
 301
 302                 /* indication for the CAN driver: do loopback */
 303                 skb->pkt_type = PACKET_LOOPBACK;
 304
 305                 /*
 306                  * The reference to the originating sock may be required
 307                  * by the receiving socket to check whether the frame is
 308                  * its own. Example: can_raw sockopt CAN_RAW_RECV_OWN_MSGS
 309                  * Therefore we have to ensure that skb->sk remains the
 310                  * reference to the originating sock by restoring skb->sk
 311                  * after each skb_clone() or skb_orphan() usage.
 312                  */
 313
 314 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)
 315 #define IFF_ECHO IFF_LOOPBACK
 316 #endif
 317                 if (!(skb->dev->flags & IFF_ECHO)) {
 318                         /*
 319                          * If the interface is not capable to do loopback
 320                          * itself, we do it here.
 321                          */
 322                         struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
 323
 324                         if (!newskb) {
 325                                 kfree_skb(skb);
 326                                 return -ENOMEM;
 327                         }
 328
 329                         newskb->sk = skb->sk;
 330                         newskb->ip_summed = CHECKSUM_UNNECESSARY;
 331                         newskb->pkt_type = PACKET_BROADCAST;
 332                         netif_rx(newskb);
 333                 }
 334         } else {
 335                 /* indication for the CAN driver: no loopback required */
 336                 skb->pkt_type = PACKET_HOST;
 337         }
 338
 339         /* send to netdevice */
 340         err = dev_queue_xmit(skb);
 341         if (err > 0)
 342                 err = net_xmit_errno(err);
 343
 344         /* update statistics */
 345         can_stats.tx_frames++;
 346         can_stats.tx_frames_delta++;
 347
 348         return err;
 349 }
 350 EXPORT_SYMBOL(can_send);
 351
 352 /*
 353  * af_can rx path
 354  */
 355
 356 static struct dev_rcv_lists *find_dev_rcv_lists(struct net_device *dev)
 357 {
 358         struct dev_rcv_lists *d = NULL;
 359         struct hlist_node *n;
 360
 361         /*
 362          * find receive list for this device
 363          *
 364          * The hlist_for_each_entry*() macros curse through the list
 365          * using the pointer variable n and set d to the containing
 366          * struct in each list iteration.  Therefore, after list
 367          * iteration, d is unmodified when the list is empty, and it
 368          * points to last list element, when the list is non-empty
 369          * but no match in the loop body is found.  I.e. d is *not*
 370          * NULL when no match is found.  We can, however, use the
 371          * cursor variable n to decide if a match was found.
 372          */
 373
 374         hlist_for_each_entry_rcu(d, n, &can_rx_dev_list, list) {
 375                 if (d->dev == dev)
 376                         break;
 377         }
 378
 379         return n ? d : NULL;
 380 }
 381
 382 static struct hlist_head *find_rcv_list(canid_t *can_id, canid_t *mask,
 383                                         struct dev_rcv_lists *d)
 384 {
 385         canid_t inv = *can_id & CAN_INV_FILTER; /* save flag before masking */
 386
 387         /* filter error frames */
 388         if (*mask & CAN_ERR_FLAG) {
 389                 /* clear CAN_ERR_FLAG in list entry */
 390                 *mask &= CAN_ERR_MASK;
 391                 return &d->rx[RX_ERR];
 392         }
 393
 394         /* ensure valid values in can_mask */
 395         if (*mask & CAN_EFF_FLAG)
 396                 *mask &= (CAN_EFF_MASK | CAN_EFF_FLAG | CAN_RTR_FLAG);
 397         else
 398                 *mask &= (CAN_SFF_MASK | CAN_RTR_FLAG);
 399
 400         /* reduce condition testing at receive time */
 401         *can_id &= *mask;
 402
 403         /* inverse can_id/can_mask filter */
 404         if (inv)
 405                 return &d->rx[RX_INV];
 406
 407         /* mask == 0 => no condition testing at receive time */
 408         if (!(*mask))
 409                 return &d->rx[RX_ALL];
 410
 411         /* use extra filterset for the subscription of exactly *ONE* can_id */
 412         if (*can_id & CAN_EFF_FLAG) {
 413                 if (*mask == (CAN_EFF_MASK | CAN_EFF_FLAG)) {
 414                         /* RFC: a use-case for hash-tables in the future? */
 415                         return &d->rx[RX_EFF];
 416                 }
 417         } else {
 418                 if (*mask == CAN_SFF_MASK)
 419                         return &d->rx_sff[*can_id];
 420         }
 421
 422         /* default: filter via can_id/can_mask */
 423         return &d->rx[RX_FIL];
 424 }
 425
 426 /**
 427  * can_rx_register - subscribe CAN frames from a specific interface
 428  * @dev: pointer to netdevice (NULL => subcribe from 'all' CAN devices list)
 429  * @can_id: CAN identifier (see description)
 430  * @mask: CAN mask (see description)
 431  * @func: callback function on filter match
 432  * @data: returned parameter for callback function
 433  * @ident: string for calling module indentification
 434  *
 435  * Description:
 436  *  Invokes the callback function with the received sk_buff and the given
 437  *  parameter 'data' on a matching receive filter. A filter matches, when
 438  *
 439  *          <received_can_id> & mask == can_id & mask
 440  *
 441  *  The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
 442  *  filter for error frames (CAN_ERR_FLAG bit set in mask).
 443  *
 444  * Return:
 445  *  0 on success
 446  *  -ENOMEM on missing cache mem to create subscription entry
 447  *  -ENODEV unknown device
 448  */
 449 int can_rx_register(struct net_device *dev, canid_t can_id, canid_t mask,
 450                     void (*func)(struct sk_buff *, void *), void *data,
 451                     char *ident)
 452 {
 453         struct receiver *r;
 454         struct hlist_head *rl;
 455         struct dev_rcv_lists *d;
 456         int err = 0;
 457
 458         /* insert new receiver  (dev,canid,mask) -> (func,data) */
 459
 460         r = kmem_cache_alloc(rcv_cache, GFP_KERNEL);
 461         if (!r)
 462                 return -ENOMEM;
 463
 464         spin_lock(&can_rcvlists_lock);
 465
 466         d = find_dev_rcv_lists(dev);
 467         if (d) {
 468                 rl = find_rcv_list(&can_id, &mask, d);
 469
 470                 r->can_id  = can_id;
 471                 r->mask    = mask;
 472                 r->matches = 0;
 473                 r->func    = func;
 474                 r->data    = data;
 475                 r->ident   = ident;
 476
 477                 hlist_add_head_rcu(&r->list, rl);
 478                 d->entries++;
 479
 480                 can_pstats.rcv_entries++;
 481                 if (can_pstats.rcv_entries_max < can_pstats.rcv_entries)
 482                         can_pstats.rcv_entries_max = can_pstats.rcv_entries;
 483         } else {
 484                 kmem_cache_free(rcv_cache, r);
 485                 err = -ENODEV;
 486         }
 487
 488         spin_unlock(&can_rcvlists_lock);
 489
 490         return err;
 491 }
 492 EXPORT_SYMBOL(can_rx_register);
 493
 494 /*
 495  * can_rx_delete_device - rcu callback for dev_rcv_lists structure removal
 496  */
 497 static void can_rx_delete_device(struct rcu_head *rp)
 498 {
 499         struct dev_rcv_lists *d = container_of(rp, struct dev_rcv_lists, rcu);
 500
 501         kfree(d);
 502 }
 503
 504 /*
 505  * can_rx_delete_receiver - rcu callback for single receiver entry removal
 506  */
 507 static void can_rx_delete_receiver(struct rcu_head *rp)
 508 {
 509         struct receiver *r = container_of(rp, struct receiver, rcu);
 510
 511         kmem_cache_free(rcv_cache, r);
 512 }
 513
 514 /**
 515  * can_rx_unregister - unsubscribe CAN frames from a specific interface
 516  * @dev: pointer to netdevice (NULL => unsubcribe from 'all' CAN devices list)
 517  * @can_id: CAN identifier
 518  * @mask: CAN mask
 519  * @func: callback function on filter match
 520  * @data: returned parameter for callback function
 521  *
 522  * Description:
 523  *  Removes subscription entry depending on given (subscription) values.
 524  */
 525 void can_rx_unregister(struct net_device *dev, canid_t can_id, canid_t mask,
 526                        void (*func)(struct sk_buff *, void *), void *data)
 527 {
 528         struct receiver *r = NULL;
 529         struct hlist_head *rl;
 530         struct hlist_node *next;
 531         struct dev_rcv_lists *d;
 532
 533         spin_lock(&can_rcvlists_lock);
 534
 535         d = find_dev_rcv_lists(dev);
 536         if (!d) {
 537                 printk(KERN_ERR "BUG: receive list not found for "
 538                        "dev %s, id %03X, mask %03X\n",
 539                        DNAME(dev), can_id, mask);
 540                 goto out;
 541         }
 542
 543         rl = find_rcv_list(&can_id, &mask, d);
 544
 545         /*
 546          * Search the receiver list for the item to delete.  This should
 547          * exist, since no receiver may be unregistered that hasn't
 548          * been registered before.
 549          */
 550
 551         hlist_for_each_entry_rcu(r, next, rl, list) {
 552                 if (r->can_id == can_id && r->mask == mask
 553                     && r->func == func && r->data == data)
 554                         break;
 555         }
 556
 557         /*
 558          * Check for bugs in CAN protocol implementations:
 559          * If no matching list item was found, the list cursor variable next
 560          * will be NULL, while r will point to the last item of the list.
 561          */
 562
 563         if (!next) {
 564                 printk(KERN_ERR "BUG: receive list entry not found for "
 565                        "dev %s, id %03X, mask %03X\n",
 566                        DNAME(dev), can_id, mask);
 567                 r = NULL;
 568                 d = NULL;
 569                 goto out;
 570         }
 571
 572         hlist_del_rcu(&r->list);
 573         d->entries--;
 574
 575         if (can_pstats.rcv_entries > 0)
 576                 can_pstats.rcv_entries--;
 577
 578         /* remove device structure requested by NETDEV_UNREGISTER */
 579         if (d->remove_on_zero_entries && !d->entries)
 580                 hlist_del_rcu(&d->list);
 581         else
 582                 d = NULL;
 583
 584  out:
 585         spin_unlock(&can_rcvlists_lock);
 586
 587         /* schedule the receiver item for deletion */
 588         if (r)
 589                 call_rcu(&r->rcu, can_rx_delete_receiver);
 590
 591         /* schedule the device structure for deletion */
 592         if (d)
 593                 call_rcu(&d->rcu, can_rx_delete_device);
 594 }
 595 EXPORT_SYMBOL(can_rx_unregister);
 596
 597 static inline void deliver(struct sk_buff *skb, struct receiver *r)
 598 {
 599         struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
 600
 601         if (clone) {
 602                 clone->sk = skb->sk;
 603                 r->func(clone, r->data);
 604                 r->matches++;
 605         }
 606 }
 607
 608 static int can_rcv_filter(struct dev_rcv_lists *d, struct sk_buff *skb)
 609 {
 610         struct receiver *r;
 611         struct hlist_node *n;
 612         int matches = 0;
 613         struct can_frame *cf = (struct can_frame *)skb->data;
 614         canid_t can_id = cf->can_id;
 615
 616         if (d->entries == 0)
 617                 return 0;
 618
 619         if (can_id & CAN_ERR_FLAG) {
 620                 /* check for error frame entries only */
 621                 hlist_for_each_entry_rcu(r, n, &d->rx[RX_ERR], list) {
 622                         if (can_id & r->mask) {
 623                                 deliver(skb, r);
 624                                 matches++;
 625                         }
 626                 }
 627                 return matches;
 628         }
 629
 630         /* check for unfiltered entries */
 631         hlist_for_each_entry_rcu(r, n, &d->rx[RX_ALL], list) {
 632                 deliver(skb, r);
 633                 matches++;
 634         }
 635
 636         /* check for can_id/mask entries */
 637         hlist_for_each_entry_rcu(r, n, &d->rx[RX_FIL], list) {
 638                 if ((can_id & r->mask) == r->can_id) {
 639                         deliver(skb, r);
 640                         matches++;
 641                 }
 642         }
 643
 644         /* check for inverted can_id/mask entries */
 645         hlist_for_each_entry_rcu(r, n, &d->rx[RX_INV], list) {
 646                 if ((can_id & r->mask) != r->can_id) {
 647                         deliver(skb, r);
 648                         matches++;
 649                 }
 650         }
 651
 652         /* check CAN_ID specific entries */
 653         if (can_id & CAN_EFF_FLAG) {
 654                 hlist_for_each_entry_rcu(r, n, &d->rx[RX_EFF], list) {
 655                         if (r->can_id == can_id) {
 656                                 deliver(skb, r);
 657                                 matches++;
 658                         }
 659                 }
 660         } else {
 661                 can_id &= CAN_SFF_MASK;
 662                 hlist_for_each_entry_rcu(r, n, &d->rx_sff[can_id], list) {
 663                         deliver(skb, r);
 664                         matches++;
 665                 }
 666         }
 667
 668         return matches;
 669 }
 670
 671 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14)
 672 static int can_rcv(struct sk_buff *skb, struct net_device *dev,
 673                    struct packet_type *pt, struct net_device *orig_dev)
 674 #else
 675 static int can_rcv(struct sk_buff *skb, struct net_device *dev,
 676                    struct packet_type *pt)
 677 #endif
 678 {
 679         struct dev_rcv_lists *d;
 680         int matches;
 681
 682 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
 683         if (dev->type != ARPHRD_CAN || dev->nd_net != &init_net) {
 684 #else
 685         if (dev->type != ARPHRD_CAN) {
 686 #endif
 687                 kfree_skb(skb);
 688                 return 0;
 689         }
 690
 691         /* update statistics */
 692         can_stats.rx_frames++;
 693         can_stats.rx_frames_delta++;
 694
 695         rcu_read_lock();
 696
 697         /* deliver the packet to sockets listening on all devices */
 698         matches = can_rcv_filter(&can_rx_alldev_list, skb);
 699
 700         /* find receive list for this device */
 701         d = find_dev_rcv_lists(dev);
 702         if (d)
 703                 matches += can_rcv_filter(d, skb);
 704
 705         rcu_read_unlock();
 706
 707         /* free the skbuff allocated by the netdevice driver */
 708         kfree_skb(skb);
 709
 710         if (matches > 0) {
 711                 can_stats.matches++;
 712                 can_stats.matches_delta++;
 713         }
 714
 715         return 0;
 716 }
 717
 718 /*
 719  * af_can protocol functions
 720  */
 721
 722 /**
 723  * can_proto_register - register CAN transport protocol
 724  * @cp: pointer to CAN protocol structure
 725  *
 726  * Return:
 727  *  0 on success
 728  *  -EINVAL invalid (out of range) protocol number
 729  *  -EBUSY  protocol already in use
 730  *  -ENOBUF if proto_register() fails
 731  */
 732 int can_proto_register(struct can_proto *cp)
 733 {
 734         int proto = cp->protocol;
 735         int err = 0;
 736
 737         if (proto < 0 || proto >= CAN_NPROTO) {
 738                 printk(KERN_ERR "can: protocol number %d out of range\n",
 739                        proto);
 740                 return -EINVAL;
 741         }
 742
 743 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 744         err = proto_register(cp->prot, 0);
 745         if (err < 0)
 746                 return err;
 747 #endif
 748
 749         spin_lock(&proto_tab_lock);
 750         if (proto_tab[proto]) {
 751                 printk(KERN_ERR "can: protocol %d already registered\n",
 752                        proto);
 753                 err = -EBUSY;
 754         } else {
 755                 proto_tab[proto] = cp;
 756
 757                 /* use generic ioctl function if not defined by module */
 758                 if (!cp->ops->ioctl)
 759                         cp->ops->ioctl = can_ioctl;
 760         }
 761         spin_unlock(&proto_tab_lock);
 762
 763 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 764         if (err < 0)
 765                 proto_unregister(cp->prot);
 766 #endif
 767
 768         return err;
 769 }
 770 EXPORT_SYMBOL(can_proto_register);
 771
 772 /**
 773  * can_proto_unregister - unregister CAN transport protocol
 774  * @cp: pointer to CAN protocol structure
 775  */
 776 void can_proto_unregister(struct can_proto *cp)
 777 {
 778         int proto = cp->protocol;
 779
 780         spin_lock(&proto_tab_lock);
 781         if (!proto_tab[proto]) {
 782                 printk(KERN_ERR "BUG: can: protocol %d is not registered\n",
 783                        proto);
 784         }
 785         proto_tab[proto] = NULL;
 786         spin_unlock(&proto_tab_lock);
 787
 788 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,12)
 789         proto_unregister(cp->prot);
 790 #endif
 791 }
 792 EXPORT_SYMBOL(can_proto_unregister);
 793
 794 /*
 795  * af_can notifier to create/remove CAN netdevice specific structs
 796  */
 797 static int can_notifier(struct notifier_block *nb, unsigned long msg,
 798                         void *data)
 799 {
 800         struct net_device *dev = (struct net_device *)data;
 801         struct dev_rcv_lists *d;
 802
 803 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
 804         if (dev->nd_net != &init_net)
 805                 return NOTIFY_DONE;
 806 #endif
 807
 808         if (dev->type != ARPHRD_CAN)
 809                 return NOTIFY_DONE;
 810
 811         switch (msg) {
 812
 813         case NETDEV_REGISTER:
 814
 815                 /*
 816                  * create new dev_rcv_lists for this device
 817                  *
 818                  * N.B. zeroing the struct is the correct initialization
 819                  * for the embedded hlist_head structs.
 820                  * Another list type, e.g. list_head, would require
 821                  * explicit initialization.
 822                  */
 823
 824                 d = kzalloc(sizeof(*d), GFP_KERNEL);
 825                 if (!d) {
 826                         printk(KERN_ERR
 827                                "can: allocation of receive list failed\n");
 828                         return NOTIFY_DONE;
 829                 }
 830                 d->dev = dev;
 831
 832                 spin_lock(&can_rcvlists_lock);
 833                 hlist_add_head_rcu(&d->list, &can_rx_dev_list);
 834                 spin_unlock(&can_rcvlists_lock);
 835
 836                 break;
 837
 838         case NETDEV_UNREGISTER:
 839                 spin_lock(&can_rcvlists_lock);
 840
 841                 d = find_dev_rcv_lists(dev);
 842                 if (d) {
 843                         if (d->entries) {
 844                                 d->remove_on_zero_entries = 1;
 845                                 d = NULL;
 846                         } else
 847                                 hlist_del_rcu(&d->list);
 848                 } else
 849                         printk(KERN_ERR "can: notifier: receive list not "
 850                                "found for dev %s\n", dev->name);
 851
 852                 spin_unlock(&can_rcvlists_lock);
 853
 854                 if (d)
 855                         call_rcu(&d->rcu, can_rx_delete_device);
 856
 857                 break;
 858         }
 859
 860         return NOTIFY_DONE;
 861 }
 862
 863 /*
 864  * af_can module init/exit functions
 865  */
 866
 867 static struct packet_type can_packet __read_mostly = {
 868         .type = __constant_htons(ETH_P_CAN),
 869         .dev  = NULL,
 870         .func = can_rcv,
 871 };
 872
 873 static struct net_proto_family can_family_ops __read_mostly = {
 874         .family = PF_CAN,
 875         .create = can_create,
 876         .owner  = THIS_MODULE,
 877 };
 878
 879 /* notifier block for netdevice event */
 880 static struct notifier_block can_netdev_notifier __read_mostly = {
 881         .notifier_call = can_notifier,
 882 };
 883
 884 static __init int can_init(void)
 885 {
 886         printk(banner);
 887
 888 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
 889         rcv_cache = kmem_cache_create("can_receiver", sizeof(struct receiver),
 890                                       0, 0, NULL);
 891 #else
 892         rcv_cache = kmem_cache_create("can_receiver", sizeof(struct receiver),
 893                                       0, 0, NULL, NULL);
 894 #endif
 895         if (!rcv_cache)
 896                 return -ENOMEM;
 897
 898         /*
 899          * Insert can_rx_alldev_list for reception on all devices.
 900          * This struct is zero initialized which is correct for the
 901          * embedded hlist heads, the dev pointer, and the entries counter.
 902          */
 903
 904         spin_lock(&can_rcvlists_lock);
 905         hlist_add_head_rcu(&can_rx_alldev_list.list, &can_rx_dev_list);
 906         spin_unlock(&can_rcvlists_lock);
 907
 908         if (stats_timer) {
 909                 /* the statistics are updated every second (timer triggered) */
 910                 setup_timer(&can_stattimer, can_stat_update, 0);
 911                 mod_timer(&can_stattimer, round_jiffies(jiffies + HZ));
 912         } else
 913                 can_stattimer.function = NULL;
 914
 915         can_init_proc();
 916
 917         /* protocol register */
 918         sock_register(&can_family_ops);
 919         register_netdevice_notifier(&can_netdev_notifier);
 920         dev_add_pack(&can_packet);
 921
 922         return 0;
 923 }
 924
 925 static __exit void can_exit(void)
 926 {
 927         struct dev_rcv_lists *d;
 928         struct hlist_node *n, *next;
 929
 930         if (stats_timer)
 931                 del_timer(&can_stattimer);
 932
 933         can_remove_proc();
 934
 935         /* protocol unregister */
 936         dev_remove_pack(&can_packet);
 937         unregister_netdevice_notifier(&can_netdev_notifier);
 938         sock_unregister(PF_CAN);
 939
 940         /* remove can_rx_dev_list */
 941         spin_lock(&can_rcvlists_lock);
 942         hlist_del(&can_rx_alldev_list.list);
 943         hlist_for_each_entry_safe(d, n, next, &can_rx_dev_list, list) {
 944                 hlist_del(&d->list);
 945                 kfree(d);
 946         }
 947         spin_unlock(&can_rcvlists_lock);
 948
 949         kmem_cache_destroy(rcv_cache);
 950 }
 951
 952 module_init(can_init);
 953 module_exit(can_exit);