blob: 51adc4c2b86036cbccde3024d27482e9ad8b94d4 [file] [log] [blame]
Oliver Hartkopp0d665482007-11-16 15:52:17 -08001/*
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
Eric Paris3f378b62009-11-05 22:18:14 -0800117static int can_create(struct net *net, struct socket *sock, int protocol,
118 int kern)
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800119{
120 struct sock *sk;
121 struct can_proto *cp;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800122 int err = 0;
123
124 sock->state = SS_UNCONNECTED;
125
126 if (protocol < 0 || protocol >= CAN_NPROTO)
127 return -EINVAL;
128
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800129 if (!net_eq(net, &init_net))
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800130 return -EAFNOSUPPORT;
131
Johannes Berg95a5afc2008-10-16 15:24:51 -0700132#ifdef CONFIG_MODULES
133 /* try to load protocol module kernel is modular */
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800134 if (!proto_tab[protocol]) {
Urs Thuermann5423dd62008-02-07 18:04:21 -0800135 err = request_module("can-proto-%d", protocol);
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800136
137 /*
138 * In case of error we only print a message but don't
139 * return the error code immediately. Below we will
140 * return -EPROTONOSUPPORT
141 */
Urs Thuermann5423dd62008-02-07 18:04:21 -0800142 if (err && printk_ratelimit())
143 printk(KERN_ERR "can: request_module "
144 "(can-proto-%d) failed.\n", protocol);
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800145 }
Urs Thuermann5423dd62008-02-07 18:04:21 -0800146#endif
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800147
148 spin_lock(&proto_tab_lock);
149 cp = proto_tab[protocol];
150 if (cp && !try_module_get(cp->prot->owner))
151 cp = NULL;
152 spin_unlock(&proto_tab_lock);
153
154 /* check for available protocol and correct usage */
155
156 if (!cp)
157 return -EPROTONOSUPPORT;
158
159 if (cp->type != sock->type) {
160 err = -EPROTONOSUPPORT;
161 goto errout;
162 }
163
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800164 sock->ops = cp->ops;
165
166 sk = sk_alloc(net, PF_CAN, GFP_KERNEL, cp->prot);
167 if (!sk) {
168 err = -ENOMEM;
169 goto errout;
170 }
171
172 sock_init_data(sock, sk);
173 sk->sk_destruct = can_sock_destruct;
174
175 if (sk->sk_prot->init)
176 err = sk->sk_prot->init(sk);
177
178 if (err) {
179 /* release sk on errors */
180 sock_orphan(sk);
181 sock_put(sk);
182 }
183
184 errout:
185 module_put(cp->prot->owner);
186 return err;
187}
188
189/*
190 * af_can tx path
191 */
192
193/**
194 * can_send - transmit a CAN frame (optional with local loopback)
195 * @skb: pointer to socket buffer with CAN frame in data section
196 * @loop: loopback for listeners on local CAN sockets (recommended default!)
197 *
Oliver Hartkopp481a8192009-09-15 01:31:34 -0700198 * Due to the loopback this routine must not be called from hardirq context.
199 *
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800200 * Return:
201 * 0 on success
202 * -ENETDOWN when the selected interface is down
203 * -ENOBUFS on full driver queue (see net_xmit_errno())
204 * -ENOMEM when local loopback failed at calling skb_clone()
205 * -EPERM when trying to send on a non-CAN interface
Oliver Hartkopp7f2d38e2008-07-05 23:38:43 -0700206 * -EINVAL when the skb->data does not contain a valid CAN frame
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800207 */
208int can_send(struct sk_buff *skb, int loop)
209{
Oliver Hartkoppc2ab7ac2008-05-08 02:49:55 -0700210 struct sk_buff *newskb = NULL;
Oliver Hartkopp7f2d38e2008-07-05 23:38:43 -0700211 struct can_frame *cf = (struct can_frame *)skb->data;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800212 int err;
213
Oliver Hartkopp7f2d38e2008-07-05 23:38:43 -0700214 if (skb->len != sizeof(struct can_frame) || cf->can_dlc > 8) {
215 kfree_skb(skb);
216 return -EINVAL;
217 }
218
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800219 if (skb->dev->type != ARPHRD_CAN) {
220 kfree_skb(skb);
221 return -EPERM;
222 }
223
224 if (!(skb->dev->flags & IFF_UP)) {
225 kfree_skb(skb);
226 return -ENETDOWN;
227 }
228
229 skb->protocol = htons(ETH_P_CAN);
230 skb_reset_network_header(skb);
231 skb_reset_transport_header(skb);
232
233 if (loop) {
234 /* local loopback of sent CAN frames */
235
236 /* indication for the CAN driver: do loopback */
237 skb->pkt_type = PACKET_LOOPBACK;
238
239 /*
240 * The reference to the originating sock may be required
241 * by the receiving socket to check whether the frame is
242 * its own. Example: can_raw sockopt CAN_RAW_RECV_OWN_MSGS
243 * Therefore we have to ensure that skb->sk remains the
244 * reference to the originating sock by restoring skb->sk
245 * after each skb_clone() or skb_orphan() usage.
246 */
247
248 if (!(skb->dev->flags & IFF_ECHO)) {
249 /*
250 * If the interface is not capable to do loopback
251 * itself, we do it here.
252 */
Oliver Hartkoppc2ab7ac2008-05-08 02:49:55 -0700253 newskb = skb_clone(skb, GFP_ATOMIC);
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800254 if (!newskb) {
255 kfree_skb(skb);
256 return -ENOMEM;
257 }
258
259 newskb->sk = skb->sk;
260 newskb->ip_summed = CHECKSUM_UNNECESSARY;
261 newskb->pkt_type = PACKET_BROADCAST;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800262 }
263 } else {
264 /* indication for the CAN driver: no loopback required */
265 skb->pkt_type = PACKET_HOST;
266 }
267
268 /* send to netdevice */
269 err = dev_queue_xmit(skb);
270 if (err > 0)
271 err = net_xmit_errno(err);
272
Oliver Hartkoppc2ab7ac2008-05-08 02:49:55 -0700273 if (err) {
Wei Yongjunce030ed2009-02-25 00:35:44 +0000274 kfree_skb(newskb);
Oliver Hartkoppc2ab7ac2008-05-08 02:49:55 -0700275 return err;
276 }
277
278 if (newskb)
Oliver Hartkopp481a8192009-09-15 01:31:34 -0700279 netif_rx_ni(newskb);
Oliver Hartkoppc2ab7ac2008-05-08 02:49:55 -0700280
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800281 /* update statistics */
282 can_stats.tx_frames++;
283 can_stats.tx_frames_delta++;
284
Oliver Hartkoppc2ab7ac2008-05-08 02:49:55 -0700285 return 0;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800286}
287EXPORT_SYMBOL(can_send);
288
289/*
290 * af_can rx path
291 */
292
293static struct dev_rcv_lists *find_dev_rcv_lists(struct net_device *dev)
294{
295 struct dev_rcv_lists *d = NULL;
296 struct hlist_node *n;
297
298 /*
299 * find receive list for this device
300 *
301 * The hlist_for_each_entry*() macros curse through the list
302 * using the pointer variable n and set d to the containing
303 * struct in each list iteration. Therefore, after list
304 * iteration, d is unmodified when the list is empty, and it
305 * points to last list element, when the list is non-empty
306 * but no match in the loop body is found. I.e. d is *not*
307 * NULL when no match is found. We can, however, use the
308 * cursor variable n to decide if a match was found.
309 */
310
311 hlist_for_each_entry_rcu(d, n, &can_rx_dev_list, list) {
312 if (d->dev == dev)
313 break;
314 }
315
316 return n ? d : NULL;
317}
318
Oliver Hartkoppd253eee2008-12-03 15:52:35 -0800319/**
320 * find_rcv_list - determine optimal filterlist inside device filter struct
321 * @can_id: pointer to CAN identifier of a given can_filter
322 * @mask: pointer to CAN mask of a given can_filter
323 * @d: pointer to the device filter struct
324 *
325 * Description:
326 * Returns the optimal filterlist to reduce the filter handling in the
327 * receive path. This function is called by service functions that need
328 * to register or unregister a can_filter in the filter lists.
329 *
330 * A filter matches in general, when
331 *
332 * <received_can_id> & mask == can_id & mask
333 *
334 * so every bit set in the mask (even CAN_EFF_FLAG, CAN_RTR_FLAG) describe
335 * relevant bits for the filter.
336 *
337 * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
338 * filter for error frames (CAN_ERR_FLAG bit set in mask). For error frames
339 * there is a special filterlist and a special rx path filter handling.
340 *
341 * Return:
342 * Pointer to optimal filterlist for the given can_id/mask pair.
343 * Constistency checked mask.
344 * Reduced can_id to have a preprocessed filter compare value.
345 */
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800346static struct hlist_head *find_rcv_list(canid_t *can_id, canid_t *mask,
347 struct dev_rcv_lists *d)
348{
349 canid_t inv = *can_id & CAN_INV_FILTER; /* save flag before masking */
350
Oliver Hartkoppd253eee2008-12-03 15:52:35 -0800351 /* filter for error frames in extra filterlist */
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800352 if (*mask & CAN_ERR_FLAG) {
Oliver Hartkoppd253eee2008-12-03 15:52:35 -0800353 /* clear CAN_ERR_FLAG in filter entry */
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800354 *mask &= CAN_ERR_MASK;
355 return &d->rx[RX_ERR];
356 }
357
Oliver Hartkoppd253eee2008-12-03 15:52:35 -0800358 /* with cleared CAN_ERR_FLAG we have a simple mask/value filterpair */
359
360#define CAN_EFF_RTR_FLAGS (CAN_EFF_FLAG | CAN_RTR_FLAG)
361
362 /* ensure valid values in can_mask for 'SFF only' frame filtering */
363 if ((*mask & CAN_EFF_FLAG) && !(*can_id & CAN_EFF_FLAG))
364 *mask &= (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS);
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800365
366 /* reduce condition testing at receive time */
367 *can_id &= *mask;
368
369 /* inverse can_id/can_mask filter */
370 if (inv)
371 return &d->rx[RX_INV];
372
373 /* mask == 0 => no condition testing at receive time */
374 if (!(*mask))
375 return &d->rx[RX_ALL];
376
Oliver Hartkoppd253eee2008-12-03 15:52:35 -0800377 /* extra filterlists for the subscription of a single non-RTR can_id */
Joe Perchesf64f9e72009-11-29 16:55:45 -0800378 if (((*mask & CAN_EFF_RTR_FLAGS) == CAN_EFF_RTR_FLAGS) &&
379 !(*can_id & CAN_RTR_FLAG)) {
Oliver Hartkoppd253eee2008-12-03 15:52:35 -0800380
381 if (*can_id & CAN_EFF_FLAG) {
382 if (*mask == (CAN_EFF_MASK | CAN_EFF_RTR_FLAGS)) {
383 /* RFC: a future use-case for hash-tables? */
384 return &d->rx[RX_EFF];
385 }
386 } else {
387 if (*mask == (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS))
388 return &d->rx_sff[*can_id];
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800389 }
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800390 }
391
392 /* default: filter via can_id/can_mask */
393 return &d->rx[RX_FIL];
394}
395
396/**
397 * can_rx_register - subscribe CAN frames from a specific interface
398 * @dev: pointer to netdevice (NULL => subcribe from 'all' CAN devices list)
399 * @can_id: CAN identifier (see description)
400 * @mask: CAN mask (see description)
401 * @func: callback function on filter match
402 * @data: returned parameter for callback function
403 * @ident: string for calling module indentification
404 *
405 * Description:
406 * Invokes the callback function with the received sk_buff and the given
407 * parameter 'data' on a matching receive filter. A filter matches, when
408 *
409 * <received_can_id> & mask == can_id & mask
410 *
411 * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
412 * filter for error frames (CAN_ERR_FLAG bit set in mask).
413 *
Oliver Hartkopp1fa17d42009-01-06 11:07:54 -0800414 * The provided pointer to the sk_buff is guaranteed to be valid as long as
415 * the callback function is running. The callback function must *not* free
416 * the given sk_buff while processing it's task. When the given sk_buff is
417 * needed after the end of the callback function it must be cloned inside
418 * the callback function with skb_clone().
419 *
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800420 * Return:
421 * 0 on success
422 * -ENOMEM on missing cache mem to create subscription entry
423 * -ENODEV unknown device
424 */
425int can_rx_register(struct net_device *dev, canid_t can_id, canid_t mask,
426 void (*func)(struct sk_buff *, void *), void *data,
427 char *ident)
428{
429 struct receiver *r;
430 struct hlist_head *rl;
431 struct dev_rcv_lists *d;
432 int err = 0;
433
434 /* insert new receiver (dev,canid,mask) -> (func,data) */
435
436 r = kmem_cache_alloc(rcv_cache, GFP_KERNEL);
437 if (!r)
438 return -ENOMEM;
439
440 spin_lock(&can_rcvlists_lock);
441
442 d = find_dev_rcv_lists(dev);
443 if (d) {
444 rl = find_rcv_list(&can_id, &mask, d);
445
446 r->can_id = can_id;
447 r->mask = mask;
448 r->matches = 0;
449 r->func = func;
450 r->data = data;
451 r->ident = ident;
452
453 hlist_add_head_rcu(&r->list, rl);
454 d->entries++;
455
456 can_pstats.rcv_entries++;
457 if (can_pstats.rcv_entries_max < can_pstats.rcv_entries)
458 can_pstats.rcv_entries_max = can_pstats.rcv_entries;
459 } else {
460 kmem_cache_free(rcv_cache, r);
461 err = -ENODEV;
462 }
463
464 spin_unlock(&can_rcvlists_lock);
465
466 return err;
467}
468EXPORT_SYMBOL(can_rx_register);
469
470/*
471 * can_rx_delete_device - rcu callback for dev_rcv_lists structure removal
472 */
473static void can_rx_delete_device(struct rcu_head *rp)
474{
475 struct dev_rcv_lists *d = container_of(rp, struct dev_rcv_lists, rcu);
476
477 kfree(d);
478}
479
480/*
481 * can_rx_delete_receiver - rcu callback for single receiver entry removal
482 */
483static void can_rx_delete_receiver(struct rcu_head *rp)
484{
485 struct receiver *r = container_of(rp, struct receiver, rcu);
486
487 kmem_cache_free(rcv_cache, r);
488}
489
490/**
491 * can_rx_unregister - unsubscribe CAN frames from a specific interface
492 * @dev: pointer to netdevice (NULL => unsubcribe from 'all' CAN devices list)
493 * @can_id: CAN identifier
494 * @mask: CAN mask
495 * @func: callback function on filter match
496 * @data: returned parameter for callback function
497 *
498 * Description:
499 * Removes subscription entry depending on given (subscription) values.
500 */
501void can_rx_unregister(struct net_device *dev, canid_t can_id, canid_t mask,
502 void (*func)(struct sk_buff *, void *), void *data)
503{
504 struct receiver *r = NULL;
505 struct hlist_head *rl;
506 struct hlist_node *next;
507 struct dev_rcv_lists *d;
508
509 spin_lock(&can_rcvlists_lock);
510
511 d = find_dev_rcv_lists(dev);
512 if (!d) {
513 printk(KERN_ERR "BUG: receive list not found for "
514 "dev %s, id %03X, mask %03X\n",
515 DNAME(dev), can_id, mask);
516 goto out;
517 }
518
519 rl = find_rcv_list(&can_id, &mask, d);
520
521 /*
522 * Search the receiver list for the item to delete. This should
523 * exist, since no receiver may be unregistered that hasn't
524 * been registered before.
525 */
526
527 hlist_for_each_entry_rcu(r, next, rl, list) {
Joe Perchesf64f9e72009-11-29 16:55:45 -0800528 if (r->can_id == can_id && r->mask == mask &&
529 r->func == func && r->data == data)
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800530 break;
531 }
532
533 /*
534 * Check for bugs in CAN protocol implementations:
535 * If no matching list item was found, the list cursor variable next
536 * will be NULL, while r will point to the last item of the list.
537 */
538
539 if (!next) {
540 printk(KERN_ERR "BUG: receive list entry not found for "
541 "dev %s, id %03X, mask %03X\n",
542 DNAME(dev), can_id, mask);
543 r = NULL;
544 d = NULL;
545 goto out;
546 }
547
548 hlist_del_rcu(&r->list);
549 d->entries--;
550
551 if (can_pstats.rcv_entries > 0)
552 can_pstats.rcv_entries--;
553
554 /* remove device structure requested by NETDEV_UNREGISTER */
555 if (d->remove_on_zero_entries && !d->entries)
556 hlist_del_rcu(&d->list);
557 else
558 d = NULL;
559
560 out:
561 spin_unlock(&can_rcvlists_lock);
562
563 /* schedule the receiver item for deletion */
564 if (r)
565 call_rcu(&r->rcu, can_rx_delete_receiver);
566
567 /* schedule the device structure for deletion */
568 if (d)
569 call_rcu(&d->rcu, can_rx_delete_device);
570}
571EXPORT_SYMBOL(can_rx_unregister);
572
573static inline void deliver(struct sk_buff *skb, struct receiver *r)
574{
Oliver Hartkopp1fa17d42009-01-06 11:07:54 -0800575 r->func(skb, r->data);
576 r->matches++;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800577}
578
579static int can_rcv_filter(struct dev_rcv_lists *d, struct sk_buff *skb)
580{
581 struct receiver *r;
582 struct hlist_node *n;
583 int matches = 0;
584 struct can_frame *cf = (struct can_frame *)skb->data;
585 canid_t can_id = cf->can_id;
586
587 if (d->entries == 0)
588 return 0;
589
590 if (can_id & CAN_ERR_FLAG) {
591 /* check for error frame entries only */
592 hlist_for_each_entry_rcu(r, n, &d->rx[RX_ERR], list) {
593 if (can_id & r->mask) {
594 deliver(skb, r);
595 matches++;
596 }
597 }
598 return matches;
599 }
600
601 /* check for unfiltered entries */
602 hlist_for_each_entry_rcu(r, n, &d->rx[RX_ALL], list) {
603 deliver(skb, r);
604 matches++;
605 }
606
607 /* check for can_id/mask entries */
608 hlist_for_each_entry_rcu(r, n, &d->rx[RX_FIL], list) {
609 if ((can_id & r->mask) == r->can_id) {
610 deliver(skb, r);
611 matches++;
612 }
613 }
614
615 /* check for inverted can_id/mask entries */
616 hlist_for_each_entry_rcu(r, n, &d->rx[RX_INV], list) {
617 if ((can_id & r->mask) != r->can_id) {
618 deliver(skb, r);
619 matches++;
620 }
621 }
622
Oliver Hartkoppf706644d2008-12-04 15:01:08 -0800623 /* check filterlists for single non-RTR can_ids */
624 if (can_id & CAN_RTR_FLAG)
625 return matches;
626
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800627 if (can_id & CAN_EFF_FLAG) {
628 hlist_for_each_entry_rcu(r, n, &d->rx[RX_EFF], list) {
629 if (r->can_id == can_id) {
630 deliver(skb, r);
631 matches++;
632 }
633 }
634 } else {
635 can_id &= CAN_SFF_MASK;
636 hlist_for_each_entry_rcu(r, n, &d->rx_sff[can_id], list) {
637 deliver(skb, r);
638 matches++;
639 }
640 }
641
642 return matches;
643}
644
645static int can_rcv(struct sk_buff *skb, struct net_device *dev,
646 struct packet_type *pt, struct net_device *orig_dev)
647{
648 struct dev_rcv_lists *d;
Oliver Hartkopp7f2d38e2008-07-05 23:38:43 -0700649 struct can_frame *cf = (struct can_frame *)skb->data;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800650 int matches;
651
Oliver Hartkopp1758c092009-08-13 22:54:25 +0000652 if (!net_eq(dev_net(dev), &init_net))
653 goto drop;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800654
Oliver Hartkopp1758c092009-08-13 22:54:25 +0000655 if (WARN_ONCE(dev->type != ARPHRD_CAN ||
656 skb->len != sizeof(struct can_frame) ||
657 cf->can_dlc > 8,
658 "PF_CAN: dropped non conform skbuf: "
659 "dev type %d, len %d, can_dlc %d\n",
660 dev->type, skb->len, cf->can_dlc))
661 goto drop;
Oliver Hartkopp7f2d38e2008-07-05 23:38:43 -0700662
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800663 /* update statistics */
664 can_stats.rx_frames++;
665 can_stats.rx_frames_delta++;
666
667 rcu_read_lock();
668
669 /* deliver the packet to sockets listening on all devices */
670 matches = can_rcv_filter(&can_rx_alldev_list, skb);
671
672 /* find receive list for this device */
673 d = find_dev_rcv_lists(dev);
674 if (d)
675 matches += can_rcv_filter(d, skb);
676
677 rcu_read_unlock();
678
Oliver Hartkopp62bcaa12009-04-17 01:38:46 -0700679 /* consume the skbuff allocated by the netdevice driver */
680 consume_skb(skb);
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800681
682 if (matches > 0) {
683 can_stats.matches++;
684 can_stats.matches_delta++;
685 }
686
Oliver Hartkopp6ca8b992009-08-29 06:45:09 +0000687 return NET_RX_SUCCESS;
Oliver Hartkopp1758c092009-08-13 22:54:25 +0000688
689drop:
690 kfree_skb(skb);
Oliver Hartkopp6ca8b992009-08-29 06:45:09 +0000691 return NET_RX_DROP;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800692}
693
694/*
695 * af_can protocol functions
696 */
697
698/**
699 * can_proto_register - register CAN transport protocol
700 * @cp: pointer to CAN protocol structure
701 *
702 * Return:
703 * 0 on success
704 * -EINVAL invalid (out of range) protocol number
705 * -EBUSY protocol already in use
706 * -ENOBUF if proto_register() fails
707 */
708int can_proto_register(struct can_proto *cp)
709{
710 int proto = cp->protocol;
711 int err = 0;
712
713 if (proto < 0 || proto >= CAN_NPROTO) {
714 printk(KERN_ERR "can: protocol number %d out of range\n",
715 proto);
716 return -EINVAL;
717 }
718
Urs Thuermanna2fea5f2008-02-07 18:04:45 -0800719 err = proto_register(cp->prot, 0);
720 if (err < 0)
721 return err;
722
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800723 spin_lock(&proto_tab_lock);
724 if (proto_tab[proto]) {
725 printk(KERN_ERR "can: protocol %d already registered\n",
726 proto);
727 err = -EBUSY;
Urs Thuermanna2fea5f2008-02-07 18:04:45 -0800728 } else {
729 proto_tab[proto] = cp;
730
731 /* use generic ioctl function if not defined by module */
732 if (!cp->ops->ioctl)
733 cp->ops->ioctl = can_ioctl;
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800734 }
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800735 spin_unlock(&proto_tab_lock);
736
Urs Thuermanna2fea5f2008-02-07 18:04:45 -0800737 if (err < 0)
738 proto_unregister(cp->prot);
739
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800740 return err;
741}
742EXPORT_SYMBOL(can_proto_register);
743
744/**
745 * can_proto_unregister - unregister CAN transport protocol
746 * @cp: pointer to CAN protocol structure
747 */
748void can_proto_unregister(struct can_proto *cp)
749{
750 int proto = cp->protocol;
751
752 spin_lock(&proto_tab_lock);
753 if (!proto_tab[proto]) {
754 printk(KERN_ERR "BUG: can: protocol %d is not registered\n",
755 proto);
756 }
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800757 proto_tab[proto] = NULL;
758 spin_unlock(&proto_tab_lock);
Urs Thuermanna2fea5f2008-02-07 18:04:45 -0800759
760 proto_unregister(cp->prot);
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800761}
762EXPORT_SYMBOL(can_proto_unregister);
763
764/*
765 * af_can notifier to create/remove CAN netdevice specific structs
766 */
767static int can_notifier(struct notifier_block *nb, unsigned long msg,
768 void *data)
769{
770 struct net_device *dev = (struct net_device *)data;
771 struct dev_rcv_lists *d;
772
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -0700773 if (!net_eq(dev_net(dev), &init_net))
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800774 return NOTIFY_DONE;
775
776 if (dev->type != ARPHRD_CAN)
777 return NOTIFY_DONE;
778
779 switch (msg) {
780
781 case NETDEV_REGISTER:
782
783 /*
784 * create new dev_rcv_lists for this device
785 *
786 * N.B. zeroing the struct is the correct initialization
787 * for the embedded hlist_head structs.
788 * Another list type, e.g. list_head, would require
789 * explicit initialization.
790 */
791
792 d = kzalloc(sizeof(*d), GFP_KERNEL);
793 if (!d) {
794 printk(KERN_ERR
795 "can: allocation of receive list failed\n");
796 return NOTIFY_DONE;
797 }
798 d->dev = dev;
799
800 spin_lock(&can_rcvlists_lock);
801 hlist_add_head_rcu(&d->list, &can_rx_dev_list);
802 spin_unlock(&can_rcvlists_lock);
803
804 break;
805
806 case NETDEV_UNREGISTER:
807 spin_lock(&can_rcvlists_lock);
808
809 d = find_dev_rcv_lists(dev);
810 if (d) {
811 if (d->entries) {
812 d->remove_on_zero_entries = 1;
813 d = NULL;
814 } else
815 hlist_del_rcu(&d->list);
816 } else
817 printk(KERN_ERR "can: notifier: receive list not "
818 "found for dev %s\n", dev->name);
819
820 spin_unlock(&can_rcvlists_lock);
821
822 if (d)
823 call_rcu(&d->rcu, can_rx_delete_device);
824
825 break;
826 }
827
828 return NOTIFY_DONE;
829}
830
831/*
832 * af_can module init/exit functions
833 */
834
835static struct packet_type can_packet __read_mostly = {
Harvey Harrison09640e62009-02-01 00:45:17 -0800836 .type = cpu_to_be16(ETH_P_CAN),
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800837 .dev = NULL,
838 .func = can_rcv,
839};
840
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +0000841static const struct net_proto_family can_family_ops = {
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800842 .family = PF_CAN,
843 .create = can_create,
844 .owner = THIS_MODULE,
845};
846
847/* notifier block for netdevice event */
848static struct notifier_block can_netdev_notifier __read_mostly = {
849 .notifier_call = can_notifier,
850};
851
852static __init int can_init(void)
853{
854 printk(banner);
855
856 rcv_cache = kmem_cache_create("can_receiver", sizeof(struct receiver),
857 0, 0, NULL);
858 if (!rcv_cache)
859 return -ENOMEM;
860
861 /*
862 * Insert can_rx_alldev_list for reception on all devices.
863 * This struct is zero initialized which is correct for the
864 * embedded hlist heads, the dev pointer, and the entries counter.
865 */
866
867 spin_lock(&can_rcvlists_lock);
868 hlist_add_head_rcu(&can_rx_alldev_list.list, &can_rx_dev_list);
869 spin_unlock(&can_rcvlists_lock);
870
871 if (stats_timer) {
872 /* the statistics are updated every second (timer triggered) */
873 setup_timer(&can_stattimer, can_stat_update, 0);
874 mod_timer(&can_stattimer, round_jiffies(jiffies + HZ));
875 } else
876 can_stattimer.function = NULL;
877
878 can_init_proc();
879
880 /* protocol register */
881 sock_register(&can_family_ops);
882 register_netdevice_notifier(&can_netdev_notifier);
883 dev_add_pack(&can_packet);
884
885 return 0;
886}
887
888static __exit void can_exit(void)
889{
890 struct dev_rcv_lists *d;
891 struct hlist_node *n, *next;
892
893 if (stats_timer)
894 del_timer(&can_stattimer);
895
896 can_remove_proc();
897
898 /* protocol unregister */
899 dev_remove_pack(&can_packet);
900 unregister_netdevice_notifier(&can_netdev_notifier);
901 sock_unregister(PF_CAN);
902
903 /* remove can_rx_dev_list */
904 spin_lock(&can_rcvlists_lock);
905 hlist_del(&can_rx_alldev_list.list);
906 hlist_for_each_entry_safe(d, n, next, &can_rx_dev_list, list) {
907 hlist_del(&d->list);
908 kfree(d);
909 }
910 spin_unlock(&can_rcvlists_lock);
911
Jesper Dangaard Brouer382bfee2009-06-08 03:11:38 +0000912 rcu_barrier(); /* Wait for completion of call_rcu()'s */
913
Oliver Hartkopp0d665482007-11-16 15:52:17 -0800914 kmem_cache_destroy(rcv_cache);
915}
916
917module_init(can_init);
918module_exit(can_exit);