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                kfree_skb(newskb);
 277                return err;
 278        }
 279
 280        if (newskb)
 281                netif_rx(newskb);
 282
 283        /* update statistics */
 284        can_stats.tx_frames++;
 285        can_stats.tx_frames_delta++;
 286
 287        return 0;
 288}
 289EXPORT_SYMBOL(can_send);
 290
 291/*
 292 * af_can rx path
 293 */
 294
 295static struct dev_rcv_lists *find_dev_rcv_lists(struct net_device *dev)
 296{
 297        struct dev_rcv_lists *d = NULL;
 298        struct hlist_node *n;
 299
 300        /*
 301         * find receive list for this device
 302         *
 303         * The hlist_for_each_entry*() macros curse through the list
 304         * using the pointer variable n and set d to the containing
 305         * struct in each list iteration.  Therefore, after list
 306         * iteration, d is unmodified when the list is empty, and it
 307         * points to last list element, when the list is non-empty
 308         * but no match in the loop body is found.  I.e. d is *not*
 309         * NULL when no match is found.  We can, however, use the
 310         * cursor variable n to decide if a match was found.
 311         */
 312
 313        hlist_for_each_entry_rcu(d, n, &can_rx_dev_list, list) {
 314                if (d->dev == dev)
 315                        break;
 316        }
 317
 318        return n ? d : NULL;
 319}
 320
 321/**
 322 * find_rcv_list - determine optimal filterlist inside device filter struct
 323 * @can_id: pointer to CAN identifier of a given can_filter
 324 * @mask: pointer to CAN mask of a given can_filter
 325 * @d: pointer to the device filter struct
 326 *
 327 * Description:
 328 *  Returns the optimal filterlist to reduce the filter handling in the
 329 *  receive path. This function is called by service functions that need
 330 *  to register or unregister a can_filter in the filter lists.
 331 *
 332 *  A filter matches in general, when
 333 *
 334 *          <received_can_id> & mask == can_id & mask
 335 *
 336 *  so every bit set in the mask (even CAN_EFF_FLAG, CAN_RTR_FLAG) describe
 337 *  relevant bits for the filter.
 338 *
 339 *  The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
 340 *  filter for error frames (CAN_ERR_FLAG bit set in mask). For error frames
 341 *  there is a special filterlist and a special rx path filter handling.
 342 *
 343 * Return:
 344 *  Pointer to optimal filterlist for the given can_id/mask pair.
 345 *  Constistency checked mask.
 346 *  Reduced can_id to have a preprocessed filter compare value.
 347 */
 348static struct hlist_head *find_rcv_list(canid_t *can_id, canid_t *mask,
 349                                        struct dev_rcv_lists *d)
 350{
 351        canid_t inv = *can_id & CAN_INV_FILTER; /* save flag before masking */
 352
 353        /* filter for error frames in extra filterlist */
 354        if (*mask & CAN_ERR_FLAG) {
 355                /* clear CAN_ERR_FLAG in filter entry */
 356                *mask &= CAN_ERR_MASK;
 357                return &d->rx[RX_ERR];
 358        }
 359
 360        /* with cleared CAN_ERR_FLAG we have a simple mask/value filterpair */
 361
 362#define CAN_EFF_RTR_FLAGS (CAN_EFF_FLAG | CAN_RTR_FLAG)
 363
 364        /* ensure valid values in can_mask for 'SFF only' frame filtering */
 365        if ((*mask & CAN_EFF_FLAG) && !(*can_id & CAN_EFF_FLAG))
 366                *mask &= (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS);
 367
 368        /* reduce condition testing at receive time */
 369        *can_id &= *mask;
 370
 371        /* inverse can_id/can_mask filter */
 372        if (inv)
 373                return &d->rx[RX_INV];
 374
 375        /* mask == 0 => no condition testing at receive time */
 376        if (!(*mask))
 377                return &d->rx[RX_ALL];
 378
 379        /* extra filterlists for the subscription of a single non-RTR can_id */
 380        if (((*mask & CAN_EFF_RTR_FLAGS) == CAN_EFF_RTR_FLAGS)
 381            && !(*can_id & CAN_RTR_FLAG)) {
 382
 383                if (*can_id & CAN_EFF_FLAG) {
 384                        if (*mask == (CAN_EFF_MASK | CAN_EFF_RTR_FLAGS)) {
 385                                /* RFC: a future use-case for hash-tables? */
 386                                return &d->rx[RX_EFF];
 387                        }
 388                } else {
 389                        if (*mask == (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS))
 390                                return &d->rx_sff[*can_id];
 391                }
 392        }
 393
 394        /* default: filter via can_id/can_mask */
 395        return &d->rx[RX_FIL];
 396}
 397
 398/**
 399 * can_rx_register - subscribe CAN frames from a specific interface
 400 * @dev: pointer to netdevice (NULL => subcribe from 'all' CAN devices list)
 401 * @can_id: CAN identifier (see description)
 402 * @mask: CAN mask (see description)
 403 * @func: callback function on filter match
 404 * @data: returned parameter for callback function
 405 * @ident: string for calling module indentification
 406 *
 407 * Description:
 408 *  Invokes the callback function with the received sk_buff and the given
 409 *  parameter 'data' on a matching receive filter. A filter matches, when
 410 *
 411 *          <received_can_id> & mask == can_id & mask
 412 *
 413 *  The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
 414 *  filter for error frames (CAN_ERR_FLAG bit set in mask).
 415 *
 416 *  The provided pointer to the sk_buff is guaranteed to be valid as long as
 417 *  the callback function is running. The callback function must *not* free
 418 *  the given sk_buff while processing it's task. When the given sk_buff is
 419 *  needed after the end of the callback function it must be cloned inside
 420 *  the callback function with skb_clone().
 421 *
 422 * Return:
 423 *  0 on success
 424 *  -ENOMEM on missing cache mem to create subscription entry
 425 *  -ENODEV unknown device
 426 */
 427int can_rx_register(struct net_device *dev, canid_t can_id, canid_t mask,
 428                    void (*func)(struct sk_buff *, void *), void *data,
 429                    char *ident)
 430{
 431        struct receiver *r;
 432        struct hlist_head *rl;
 433        struct dev_rcv_lists *d;
 434        int err = 0;
 435
 436        /* insert new receiver  (dev,canid,mask) -> (func,data) */
 437
 438        r = kmem_cache_alloc(rcv_cache, GFP_KERNEL);
 439        if (!r)
 440                return -ENOMEM;
 441
 442        spin_lock(&can_rcvlists_lock);
 443
 444        d = find_dev_rcv_lists(dev);
 445        if (d) {
 446                rl = find_rcv_list(&can_id, &mask, d);
 447
 448                r->can_id  = can_id;
 449                r->mask    = mask;
 450                r->matches = 0;
 451                r->func    = func;
 452                r->data    = data;
 453                r->ident   = ident;
 454
 455                hlist_add_head_rcu(&r->list, rl);
 456                d->entries++;
 457
 458                can_pstats.rcv_entries++;
 459                if (can_pstats.rcv_entries_max < can_pstats.rcv_entries)
 460                        can_pstats.rcv_entries_max = can_pstats.rcv_entries;
 461        } else {
 462                kmem_cache_free(rcv_cache, r);
 463                err = -ENODEV;
 464        }
 465
 466        spin_unlock(&can_rcvlists_lock);
 467
 468        return err;
 469}
 470EXPORT_SYMBOL(can_rx_register);
 471
 472/*
 473 * can_rx_delete_device - rcu callback for dev_rcv_lists structure removal
 474 */
 475static void can_rx_delete_device(struct rcu_head *rp)
 476{
 477        struct dev_rcv_lists *d = container_of(rp, struct dev_rcv_lists, rcu);
 478
 479        kfree(d);
 480}
 481
 482/*
 483 * can_rx_delete_receiver - rcu callback for single receiver entry removal
 484 */
 485static void can_rx_delete_receiver(struct rcu_head *rp)
 486{
 487        struct receiver *r = container_of(rp, struct receiver, rcu);
 488
 489        kmem_cache_free(rcv_cache, r);
 490}
 491
 492/**
 493 * can_rx_unregister - unsubscribe CAN frames from a specific interface
 494 * @dev: pointer to netdevice (NULL => unsubcribe from 'all' CAN devices list)
 495 * @can_id: CAN identifier
 496 * @mask: CAN mask
 497 * @func: callback function on filter match
 498 * @data: returned parameter for callback function
 499 *
 500 * Description:
 501 *  Removes subscription entry depending on given (subscription) values.
 502 */
 503void can_rx_unregister(struct net_device *dev, canid_t can_id, canid_t mask,
 504                       void (*func)(struct sk_buff *, void *), void *data)
 505{
 506        struct receiver *r = NULL;
 507        struct hlist_head *rl;
 508        struct hlist_node *next;
 509        struct dev_rcv_lists *d;
 510
 511        spin_lock(&can_rcvlists_lock);
 512
 513        d = find_dev_rcv_lists(dev);
 514        if (!d) {
 515                printk(KERN_ERR "BUG: receive list not found for "
 516                       "dev %s, id %03X, mask %03X\n",
 517                       DNAME(dev), can_id, mask);
 518                goto out;
 519        }
 520
 521        rl = find_rcv_list(&can_id, &mask, d);
 522
 523        /*
 524         * Search the receiver list for the item to delete.  This should
 525         * exist, since no receiver may be unregistered that hasn't
 526         * been registered before.
 527         */
 528
 529        hlist_for_each_entry_rcu(r, next, rl, list) {
 530                if (r->can_id == can_id && r->mask == mask
 531                    && r->func == func && r->data == data)
 532                        break;
 533        }
 534
 535        /*
 536         * Check for bugs in CAN protocol implementations:
 537         * If no matching list item was found, the list cursor variable next
 538         * will be NULL, while r will point to the last item of the list.
 539         */
 540
 541        if (!next) {
 542                printk(KERN_ERR "BUG: receive list entry not found for "
 543                       "dev %s, id %03X, mask %03X\n",
 544                       DNAME(dev), can_id, mask);
 545                r = NULL;
 546                d = NULL;
 547                goto out;
 548        }
 549
 550        hlist_del_rcu(&r->list);
 551        d->entries--;
 552
 553        if (can_pstats.rcv_entries > 0)
 554                can_pstats.rcv_entries--;
 555
 556        /* remove device structure requested by NETDEV_UNREGISTER */
 557        if (d->remove_on_zero_entries && !d->entries)
 558                hlist_del_rcu(&d->list);
 559        else
 560                d = NULL;
 561
 562 out:
 563        spin_unlock(&can_rcvlists_lock);
 564
 565        /* schedule the receiver item for deletion */
 566        if (r)
 567                call_rcu(&r->rcu, can_rx_delete_receiver);
 568
 569        /* schedule the device structure for deletion */
 570        if (d)
 571                call_rcu(&d->rcu, can_rx_delete_device);
 572}
 573EXPORT_SYMBOL(can_rx_unregister);
 574
 575static inline void deliver(struct sk_buff *skb, struct receiver *r)
 576{
 577        r->func(skb, r->data);
 578        r->matches++;
 579}
 580
 581static int can_rcv_filter(struct dev_rcv_lists *d, struct sk_buff *skb)
 582{
 583        struct receiver *r;
 584        struct hlist_node *n;
 585        int matches = 0;
 586        struct can_frame *cf = (struct can_frame *)skb->data;
 587        canid_t can_id = cf->can_id;
 588
 589        if (d->entries == 0)
 590                return 0;
 591
 592        if (can_id & CAN_ERR_FLAG) {
 593                /* check for error frame entries only */
 594                hlist_for_each_entry_rcu(r, n, &d->rx[RX_ERR], list) {
 595                        if (can_id & r->mask) {
 596                                deliver(skb, r);
 597                                matches++;
 598                        }
 599                }
 600                return matches;
 601        }
 602
 603        /* check for unfiltered entries */
 604        hlist_for_each_entry_rcu(r, n, &d->rx[RX_ALL], list) {
 605                deliver(skb, r);
 606                matches++;
 607        }
 608
 609        /* check for can_id/mask entries */
 610        hlist_for_each_entry_rcu(r, n, &d->rx[RX_FIL], list) {
 611                if ((can_id & r->mask) == r->can_id) {
 612                        deliver(skb, r);
 613                        matches++;
 614                }
 615        }
 616
 617        /* check for inverted can_id/mask entries */
 618        hlist_for_each_entry_rcu(r, n, &d->rx[RX_INV], list) {
 619                if ((can_id & r->mask) != r->can_id) {
 620                        deliver(skb, r);
 621                        matches++;
 622                }
 623        }
 624
 625        /* check filterlists for single non-RTR can_ids */
 626        if (can_id & CAN_RTR_FLAG)
 627                return matches;
 628
 629        if (can_id & CAN_EFF_FLAG) {
 630                hlist_for_each_entry_rcu(r, n, &d->rx[RX_EFF], list) {
 631                        if (r->can_id == can_id) {
 632                                deliver(skb, r);
 633                                matches++;
 634                        }
 635                }
 636        } else {
 637                can_id &= CAN_SFF_MASK;
 638                hlist_for_each_entry_rcu(r, n, &d->rx_sff[can_id], list) {
 639                        deliver(skb, r);
 640                        matches++;
 641                }
 642        }
 643
 644        return matches;
 645}
 646
 647static int can_rcv(struct sk_buff *skb, struct net_device *dev,
 648                   struct packet_type *pt, struct net_device *orig_dev)
 649{
 650        struct dev_rcv_lists *d;
 651        struct can_frame *cf = (struct can_frame *)skb->data;
 652        int matches;
 653
 654        if (dev->type != ARPHRD_CAN || !net_eq(dev_net(dev), &init_net)) {
 655                kfree_skb(skb);
 656                return 0;
 657        }
 658
 659        BUG_ON(skb->len != sizeof(struct can_frame) || cf->can_dlc > 8);
 660
 661        /* update statistics */
 662        can_stats.rx_frames++;
 663        can_stats.rx_frames_delta++;
 664
 665        rcu_read_lock();
 666
 667        /* deliver the packet to sockets listening on all devices */
 668        matches = can_rcv_filter(&can_rx_alldev_list, skb);
 669
 670        /* find receive list for this device */
 671        d = find_dev_rcv_lists(dev);
 672        if (d)
 673                matches += can_rcv_filter(d, skb);
 674
 675        rcu_read_unlock();
 676
 677        /* consume the skbuff allocated by the netdevice driver */
 678        consume_skb(skb);
 679
 680        if (matches > 0) {
 681                can_stats.matches++;
 682                can_stats.matches_delta++;
 683        }
 684
 685        return 0;
 686}
 687
 688/*
 689 * af_can protocol functions
 690 */
 691
 692/**
 693 * can_proto_register - register CAN transport protocol
 694 * @cp: pointer to CAN protocol structure
 695 *
 696 * Return:
 697 *  0 on success
 698 *  -EINVAL invalid (out of range) protocol number
 699 *  -EBUSY  protocol already in use
 700 *  -ENOBUF if proto_register() fails
 701 */
 702int can_proto_register(struct can_proto *cp)
 703{
 704        int proto = cp->protocol;
 705        int err = 0;
 706
 707        if (proto < 0 || proto >= CAN_NPROTO) {
 708                printk(KERN_ERR "can: protocol number %d out of range\n",
 709                       proto);
 710                return -EINVAL;
 711        }
 712
 713        err = proto_register(cp->prot, 0);
 714        if (err < 0)
 715                return err;
 716
 717        spin_lock(&proto_tab_lock);
 718        if (proto_tab[proto]) {
 719                printk(KERN_ERR "can: protocol %d already registered\n",
 720                       proto);
 721                err = -EBUSY;
 722        } else {
 723                proto_tab[proto] = cp;
 724
 725                /* use generic ioctl function if not defined by module */
 726                if (!cp->ops->ioctl)
 727                        cp->ops->ioctl = can_ioctl;
 728        }
 729        spin_unlock(&proto_tab_lock);
 730
 731        if (err < 0)
 732                proto_unregister(cp->prot);
 733
 734        return err;
 735}
 736EXPORT_SYMBOL(can_proto_register);
 737
 738/**
 739 * can_proto_unregister - unregister CAN transport protocol
 740 * @cp: pointer to CAN protocol structure
 741 */
 742void can_proto_unregister(struct can_proto *cp)
 743{
 744        int proto = cp->protocol;
 745
 746        spin_lock(&proto_tab_lock);
 747        if (!proto_tab[proto]) {
 748                printk(KERN_ERR "BUG: can: protocol %d is not registered\n",
 749                       proto);
 750        }
 751        proto_tab[proto] = NULL;
 752        spin_unlock(&proto_tab_lock);
 753
 754        proto_unregister(cp->prot);
 755}
 756EXPORT_SYMBOL(can_proto_unregister);
 757
 758/*
 759 * af_can notifier to create/remove CAN netdevice specific structs
 760 */
 761static int can_notifier(struct notifier_block *nb, unsigned long msg,
 762                        void *data)
 763{
 764        struct net_device *dev = (struct net_device *)data;
 765        struct dev_rcv_lists *d;
 766
 767        if (!net_eq(dev_net(dev), &init_net))
 768                return NOTIFY_DONE;
 769
 770        if (dev->type != ARPHRD_CAN)
 771                return NOTIFY_DONE;
 772
 773        switch (msg) {
 774
 775        case NETDEV_REGISTER:
 776
 777                /*
 778                 * create new dev_rcv_lists for this device
 779                 *
 780                 * N.B. zeroing the struct is the correct initialization
 781                 * for the embedded hlist_head structs.
 782                 * Another list type, e.g. list_head, would require
 783                 * explicit initialization.
 784                 */
 785
 786                d = kzalloc(sizeof(*d), GFP_KERNEL);
 787                if (!d) {
 788                        printk(KERN_ERR
 789                               "can: allocation of receive list failed\n");
 790                        return NOTIFY_DONE;
 791                }
 792                d->dev = dev;
 793
 794                spin_lock(&can_rcvlists_lock);
 795                hlist_add_head_rcu(&d->list, &can_rx_dev_list);
 796                spin_unlock(&can_rcvlists_lock);
 797
 798                break;
 799
 800        case NETDEV_UNREGISTER:
 801                spin_lock(&can_rcvlists_lock);
 802
 803                d = find_dev_rcv_lists(dev);
 804                if (d) {
 805                        if (d->entries) {
 806                                d->remove_on_zero_entries = 1;
 807                                d = NULL;
 808                        } else
 809                                hlist_del_rcu(&d->list);
 810                } else
 811                        printk(KERN_ERR "can: notifier: receive list not "
 812                               "found for dev %s\n", dev->name);
 813
 814                spin_unlock(&can_rcvlists_lock);
 815
 816                if (d)
 817                        call_rcu(&d->rcu, can_rx_delete_device);
 818
 819                break;
 820        }
 821
 822        return NOTIFY_DONE;
 823}
 824
 825/*
 826 * af_can module init/exit functions
 827 */
 828
 829static struct packet_type can_packet __read_mostly = {
 830        .type = cpu_to_be16(ETH_P_CAN),
 831        .dev  = NULL,
 832        .func = can_rcv,
 833};
 834
 835static struct net_proto_family can_family_ops __read_mostly = {
 836        .family = PF_CAN,
 837        .create = can_create,
 838        .owner  = THIS_MODULE,
 839};
 840
 841/* notifier block for netdevice event */
 842static struct notifier_block can_netdev_notifier __read_mostly = {
 843        .notifier_call = can_notifier,
 844};
 845
 846static __init int can_init(void)
 847{
 848        printk(banner);
 849
 850        rcv_cache = kmem_cache_create("can_receiver", sizeof(struct receiver),
 851                                      0, 0, NULL);
 852        if (!rcv_cache)
 853                return -ENOMEM;
 854
 855        /*
 856         * Insert can_rx_alldev_list for reception on all devices.
 857         * This struct is zero initialized which is correct for the
 858         * embedded hlist heads, the dev pointer, and the entries counter.
 859         */
 860
 861        spin_lock(&can_rcvlists_lock);
 862        hlist_add_head_rcu(&can_rx_alldev_list.list, &can_rx_dev_list);
 863        spin_unlock(&can_rcvlists_lock);
 864
 865        if (stats_timer) {
 866                /* the statistics are updated every second (timer triggered) */
 867                setup_timer(&can_stattimer, can_stat_update, 0);
 868                mod_timer(&can_stattimer, round_jiffies(jiffies + HZ));
 869        } else
 870                can_stattimer.function = NULL;
 871
 872        can_init_proc();
 873
 874        /* protocol register */
 875        sock_register(&can_family_ops);
 876        register_netdevice_notifier(&can_netdev_notifier);
 877        dev_add_pack(&can_packet);
 878
 879        return 0;
 880}
 881
 882static __exit void can_exit(void)
 883{
 884        struct dev_rcv_lists *d;
 885        struct hlist_node *n, *next;
 886
 887        if (stats_timer)
 888                del_timer(&can_stattimer);
 889
 890        can_remove_proc();
 891
 892        /* protocol unregister */
 893        dev_remove_pack(&can_packet);
 894        unregister_netdevice_notifier(&can_netdev_notifier);
 895        sock_unregister(PF_CAN);
 896
 897        /* remove can_rx_dev_list */
 898        spin_lock(&can_rcvlists_lock);
 899        hlist_del(&can_rx_alldev_list.list);
 900        hlist_for_each_entry_safe(d, n, next, &can_rx_dev_list, list) {
 901                hlist_del(&d->list);
 902                kfree(d);
 903        }
 904        spin_unlock(&can_rcvlists_lock);
 905
 906        kmem_cache_destroy(rcv_cache);
 907}
 908
 909module_init(can_init);
 910module_exit(can_exit);
 911