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