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