2 * af_can.c - Protocol family CAN core module
3 * (used by different CAN protocol modules)
5 * Copyright (c) 2002-2007 Volkswagen Group Electronic Research
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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.
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.
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
41 * Send feedback to <socketcan-users@lists.berlios.de>
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>
66 static __initdata
const char banner
[] = KERN_INFO
67 "can: controller area network core (" CAN_VERSION_STRING
")\n";
69 MODULE_DESCRIPTION("Controller Area Network PF_CAN core");
70 MODULE_LICENSE("Dual BSD/GPL");
71 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>, "
72 "Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
74 MODULE_ALIAS_NETPROTO(PF_CAN
);
76 static int stats_timer __read_mostly
= 1;
77 module_param(stats_timer
, int, S_IRUGO
);
78 MODULE_PARM_DESC(stats_timer
, "enable timer for statistics (default:on)");
80 HLIST_HEAD(can_rx_dev_list
);
81 static struct dev_rcv_lists can_rx_alldev_list
;
82 static DEFINE_SPINLOCK(can_rcvlists_lock
);
84 static struct kmem_cache
*rcv_cache __read_mostly
;
86 /* table of registered CAN protocols */
87 static struct can_proto
*proto_tab
[CAN_NPROTO
] __read_mostly
;
88 static DEFINE_SPINLOCK(proto_tab_lock
);
90 struct timer_list can_stattimer
; /* timer for statistics update */
91 struct s_stats can_stats
; /* packet statistics */
92 struct s_pstats can_pstats
; /* receive list statistics */
95 * af_can socket functions
98 static int can_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
100 struct sock
*sk
= sock
->sk
;
105 return sock_get_timestamp(sk
, (struct timeval __user
*)arg
);
112 static void can_sock_destruct(struct sock
*sk
)
114 skb_queue_purge(&sk
->sk_receive_queue
);
117 static int can_create(struct net
*net
, struct socket
*sock
, int protocol
)
120 struct can_proto
*cp
;
123 sock
->state
= SS_UNCONNECTED
;
125 if (protocol
< 0 || protocol
>= CAN_NPROTO
)
128 if (net
!= &init_net
)
129 return -EAFNOSUPPORT
;
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
);
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
141 if (err
&& printk_ratelimit())
142 printk(KERN_ERR
"can: request_module "
143 "(can-proto-%d) failed.\n", protocol
);
147 spin_lock(&proto_tab_lock
);
148 cp
= proto_tab
[protocol
];
149 if (cp
&& !try_module_get(cp
->prot
->owner
))
151 spin_unlock(&proto_tab_lock
);
153 /* check for available protocol and correct usage */
156 return -EPROTONOSUPPORT
;
158 if (cp
->type
!= sock
->type
) {
159 err
= -EPROTONOSUPPORT
;
163 if (cp
->capability
>= 0 && !capable(cp
->capability
)) {
170 sk
= sk_alloc(net
, PF_CAN
, GFP_KERNEL
, cp
->prot
);
176 sock_init_data(sock
, sk
);
177 sk
->sk_destruct
= can_sock_destruct
;
179 if (sk
->sk_prot
->init
)
180 err
= sk
->sk_prot
->init(sk
);
183 /* release sk on errors */
189 module_put(cp
->prot
->owner
);
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!)
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
210 int can_send(struct sk_buff
*skb
, int loop
)
212 struct sk_buff
*newskb
= NULL
;
213 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
216 if (skb
->len
!= sizeof(struct can_frame
) || cf
->can_dlc
> 8) {
221 if (skb
->dev
->type
!= ARPHRD_CAN
) {
226 if (!(skb
->dev
->flags
& IFF_UP
)) {
231 skb
->protocol
= htons(ETH_P_CAN
);
232 skb_reset_network_header(skb
);
233 skb_reset_transport_header(skb
);
236 /* local loopback of sent CAN frames */
238 /* indication for the CAN driver: do loopback */
239 skb
->pkt_type
= PACKET_LOOPBACK
;
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.
250 if (!(skb
->dev
->flags
& IFF_ECHO
)) {
252 * If the interface is not capable to do loopback
253 * itself, we do it here.
255 newskb
= skb_clone(skb
, GFP_ATOMIC
);
261 newskb
->sk
= skb
->sk
;
262 newskb
->ip_summed
= CHECKSUM_UNNECESSARY
;
263 newskb
->pkt_type
= PACKET_BROADCAST
;
266 /* indication for the CAN driver: no loopback required */
267 skb
->pkt_type
= PACKET_HOST
;
270 /* send to netdevice */
271 err
= dev_queue_xmit(skb
);
273 err
= net_xmit_errno(err
);
284 /* update statistics */
285 can_stats
.tx_frames
++;
286 can_stats
.tx_frames_delta
++;
290 EXPORT_SYMBOL(can_send
);
296 static struct dev_rcv_lists
*find_dev_rcv_lists(struct net_device
*dev
)
298 struct dev_rcv_lists
*d
= NULL
;
299 struct hlist_node
*n
;
302 * find receive list for this device
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.
314 hlist_for_each_entry_rcu(d
, n
, &can_rx_dev_list
, list
) {
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
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.
333 * A filter matches in general, when
335 * <received_can_id> & mask == can_id & mask
337 * so every bit set in the mask (even CAN_EFF_FLAG, CAN_RTR_FLAG) describe
338 * relevant bits for the filter.
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.
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.
349 static struct hlist_head
*find_rcv_list(canid_t
*can_id
, canid_t
*mask
,
350 struct dev_rcv_lists
*d
)
352 canid_t inv
= *can_id
& CAN_INV_FILTER
; /* save flag before masking */
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
];
361 /* with cleared CAN_ERR_FLAG we have a simple mask/value filterpair */
363 #define CAN_EFF_RTR_FLAGS (CAN_EFF_FLAG | CAN_RTR_FLAG)
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
);
369 /* reduce condition testing at receive time */
372 /* inverse can_id/can_mask filter */
374 return &d
->rx
[RX_INV
];
376 /* mask == 0 => no condition testing at receive time */
378 return &d
->rx
[RX_ALL
];
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
)) {
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
];
390 if (*mask
== (CAN_SFF_MASK
| CAN_EFF_RTR_FLAGS
))
391 return &d
->rx_sff
[*can_id
];
395 /* default: filter via can_id/can_mask */
396 return &d
->rx
[RX_FIL
];
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
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
412 * <received_can_id> & mask == can_id & mask
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).
419 * -ENOMEM on missing cache mem to create subscription entry
420 * -ENODEV unknown device
422 int can_rx_register(struct net_device
*dev
, canid_t can_id
, canid_t mask
,
423 void (*func
)(struct sk_buff
*, void *), void *data
,
427 struct hlist_head
*rl
;
428 struct dev_rcv_lists
*d
;
431 /* insert new receiver (dev,canid,mask) -> (func,data) */
433 r
= kmem_cache_alloc(rcv_cache
, GFP_KERNEL
);
437 spin_lock(&can_rcvlists_lock
);
439 d
= find_dev_rcv_lists(dev
);
441 rl
= find_rcv_list(&can_id
, &mask
, d
);
450 hlist_add_head_rcu(&r
->list
, rl
);
453 can_pstats
.rcv_entries
++;
454 if (can_pstats
.rcv_entries_max
< can_pstats
.rcv_entries
)
455 can_pstats
.rcv_entries_max
= can_pstats
.rcv_entries
;
457 kmem_cache_free(rcv_cache
, r
);
461 spin_unlock(&can_rcvlists_lock
);
465 EXPORT_SYMBOL(can_rx_register
);
468 * can_rx_delete_device - rcu callback for dev_rcv_lists structure removal
470 static void can_rx_delete_device(struct rcu_head
*rp
)
472 struct dev_rcv_lists
*d
= container_of(rp
, struct dev_rcv_lists
, rcu
);
478 * can_rx_delete_receiver - rcu callback for single receiver entry removal
480 static void can_rx_delete_receiver(struct rcu_head
*rp
)
482 struct receiver
*r
= container_of(rp
, struct receiver
, rcu
);
484 kmem_cache_free(rcv_cache
, r
);
488 * can_rx_unregister - unsubscribe CAN frames from a specific interface
489 * @dev: pointer to netdevice (NULL => unsubcribe from 'all' CAN devices list)
490 * @can_id: CAN identifier
492 * @func: callback function on filter match
493 * @data: returned parameter for callback function
496 * Removes subscription entry depending on given (subscription) values.
498 void can_rx_unregister(struct net_device
*dev
, canid_t can_id
, canid_t mask
,
499 void (*func
)(struct sk_buff
*, void *), void *data
)
501 struct receiver
*r
= NULL
;
502 struct hlist_head
*rl
;
503 struct hlist_node
*next
;
504 struct dev_rcv_lists
*d
;
506 spin_lock(&can_rcvlists_lock
);
508 d
= find_dev_rcv_lists(dev
);
510 printk(KERN_ERR
"BUG: receive list not found for "
511 "dev %s, id %03X, mask %03X\n",
512 DNAME(dev
), can_id
, mask
);
516 rl
= find_rcv_list(&can_id
, &mask
, d
);
519 * Search the receiver list for the item to delete. This should
520 * exist, since no receiver may be unregistered that hasn't
521 * been registered before.
524 hlist_for_each_entry_rcu(r
, next
, rl
, list
) {
525 if (r
->can_id
== can_id
&& r
->mask
== mask
526 && r
->func
== func
&& r
->data
== data
)
531 * Check for bugs in CAN protocol implementations:
532 * If no matching list item was found, the list cursor variable next
533 * will be NULL, while r will point to the last item of the list.
537 printk(KERN_ERR
"BUG: receive list entry not found for "
538 "dev %s, id %03X, mask %03X\n",
539 DNAME(dev
), can_id
, mask
);
545 hlist_del_rcu(&r
->list
);
548 if (can_pstats
.rcv_entries
> 0)
549 can_pstats
.rcv_entries
--;
551 /* remove device structure requested by NETDEV_UNREGISTER */
552 if (d
->remove_on_zero_entries
&& !d
->entries
)
553 hlist_del_rcu(&d
->list
);
558 spin_unlock(&can_rcvlists_lock
);
560 /* schedule the receiver item for deletion */
562 call_rcu(&r
->rcu
, can_rx_delete_receiver
);
564 /* schedule the device structure for deletion */
566 call_rcu(&d
->rcu
, can_rx_delete_device
);
568 EXPORT_SYMBOL(can_rx_unregister
);
570 static inline void deliver(struct sk_buff
*skb
, struct receiver
*r
)
572 struct sk_buff
*clone
= skb_clone(skb
, GFP_ATOMIC
);
576 r
->func(clone
, r
->data
);
581 static int can_rcv_filter(struct dev_rcv_lists
*d
, struct sk_buff
*skb
)
584 struct hlist_node
*n
;
586 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
587 canid_t can_id
= cf
->can_id
;
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
) {
603 /* check for unfiltered entries */
604 hlist_for_each_entry_rcu(r
, n
, &d
->rx
[RX_ALL
], list
) {
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
) {
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
) {
625 /* check CAN_ID specific entries */
626 if (can_id
& CAN_EFF_FLAG
) {
627 hlist_for_each_entry_rcu(r
, n
, &d
->rx
[RX_EFF
], list
) {
628 if (r
->can_id
== can_id
) {
634 can_id
&= CAN_SFF_MASK
;
635 hlist_for_each_entry_rcu(r
, n
, &d
->rx_sff
[can_id
], list
) {
644 static int can_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
645 struct packet_type
*pt
, struct net_device
*orig_dev
)
647 struct dev_rcv_lists
*d
;
648 struct can_frame
*cf
= (struct can_frame
*)skb
->data
;
651 if (dev
->type
!= ARPHRD_CAN
|| !net_eq(dev_net(dev
), &init_net
)) {
656 BUG_ON(skb
->len
!= sizeof(struct can_frame
) || cf
->can_dlc
> 8);
658 /* update statistics */
659 can_stats
.rx_frames
++;
660 can_stats
.rx_frames_delta
++;
664 /* deliver the packet to sockets listening on all devices */
665 matches
= can_rcv_filter(&can_rx_alldev_list
, skb
);
667 /* find receive list for this device */
668 d
= find_dev_rcv_lists(dev
);
670 matches
+= can_rcv_filter(d
, skb
);
674 /* free the skbuff allocated by the netdevice driver */
679 can_stats
.matches_delta
++;
686 * af_can protocol functions
690 * can_proto_register - register CAN transport protocol
691 * @cp: pointer to CAN protocol structure
695 * -EINVAL invalid (out of range) protocol number
696 * -EBUSY protocol already in use
697 * -ENOBUF if proto_register() fails
699 int can_proto_register(struct can_proto
*cp
)
701 int proto
= cp
->protocol
;
704 if (proto
< 0 || proto
>= CAN_NPROTO
) {
705 printk(KERN_ERR
"can: protocol number %d out of range\n",
710 err
= proto_register(cp
->prot
, 0);
714 spin_lock(&proto_tab_lock
);
715 if (proto_tab
[proto
]) {
716 printk(KERN_ERR
"can: protocol %d already registered\n",
720 proto_tab
[proto
] = cp
;
722 /* use generic ioctl function if not defined by module */
724 cp
->ops
->ioctl
= can_ioctl
;
726 spin_unlock(&proto_tab_lock
);
729 proto_unregister(cp
->prot
);
733 EXPORT_SYMBOL(can_proto_register
);
736 * can_proto_unregister - unregister CAN transport protocol
737 * @cp: pointer to CAN protocol structure
739 void can_proto_unregister(struct can_proto
*cp
)
741 int proto
= cp
->protocol
;
743 spin_lock(&proto_tab_lock
);
744 if (!proto_tab
[proto
]) {
745 printk(KERN_ERR
"BUG: can: protocol %d is not registered\n",
748 proto_tab
[proto
] = NULL
;
749 spin_unlock(&proto_tab_lock
);
751 proto_unregister(cp
->prot
);
753 EXPORT_SYMBOL(can_proto_unregister
);
756 * af_can notifier to create/remove CAN netdevice specific structs
758 static int can_notifier(struct notifier_block
*nb
, unsigned long msg
,
761 struct net_device
*dev
= (struct net_device
*)data
;
762 struct dev_rcv_lists
*d
;
764 if (!net_eq(dev_net(dev
), &init_net
))
767 if (dev
->type
!= ARPHRD_CAN
)
772 case NETDEV_REGISTER
:
775 * create new dev_rcv_lists for this device
777 * N.B. zeroing the struct is the correct initialization
778 * for the embedded hlist_head structs.
779 * Another list type, e.g. list_head, would require
780 * explicit initialization.
783 d
= kzalloc(sizeof(*d
), GFP_KERNEL
);
786 "can: allocation of receive list failed\n");
791 spin_lock(&can_rcvlists_lock
);
792 hlist_add_head_rcu(&d
->list
, &can_rx_dev_list
);
793 spin_unlock(&can_rcvlists_lock
);
797 case NETDEV_UNREGISTER
:
798 spin_lock(&can_rcvlists_lock
);
800 d
= find_dev_rcv_lists(dev
);
803 d
->remove_on_zero_entries
= 1;
806 hlist_del_rcu(&d
->list
);
808 printk(KERN_ERR
"can: notifier: receive list not "
809 "found for dev %s\n", dev
->name
);
811 spin_unlock(&can_rcvlists_lock
);
814 call_rcu(&d
->rcu
, can_rx_delete_device
);
823 * af_can module init/exit functions
826 static struct packet_type can_packet __read_mostly
= {
827 .type
= __constant_htons(ETH_P_CAN
),
832 static struct net_proto_family can_family_ops __read_mostly
= {
834 .create
= can_create
,
835 .owner
= THIS_MODULE
,
838 /* notifier block for netdevice event */
839 static struct notifier_block can_netdev_notifier __read_mostly
= {
840 .notifier_call
= can_notifier
,
843 static __init
int can_init(void)
847 rcv_cache
= kmem_cache_create("can_receiver", sizeof(struct receiver
),
853 * Insert can_rx_alldev_list for reception on all devices.
854 * This struct is zero initialized which is correct for the
855 * embedded hlist heads, the dev pointer, and the entries counter.
858 spin_lock(&can_rcvlists_lock
);
859 hlist_add_head_rcu(&can_rx_alldev_list
.list
, &can_rx_dev_list
);
860 spin_unlock(&can_rcvlists_lock
);
863 /* the statistics are updated every second (timer triggered) */
864 setup_timer(&can_stattimer
, can_stat_update
, 0);
865 mod_timer(&can_stattimer
, round_jiffies(jiffies
+ HZ
));
867 can_stattimer
.function
= NULL
;
871 /* protocol register */
872 sock_register(&can_family_ops
);
873 register_netdevice_notifier(&can_netdev_notifier
);
874 dev_add_pack(&can_packet
);
879 static __exit
void can_exit(void)
881 struct dev_rcv_lists
*d
;
882 struct hlist_node
*n
, *next
;
885 del_timer(&can_stattimer
);
889 /* protocol unregister */
890 dev_remove_pack(&can_packet
);
891 unregister_netdevice_notifier(&can_netdev_notifier
);
892 sock_unregister(PF_CAN
);
894 /* remove can_rx_dev_list */
895 spin_lock(&can_rcvlists_lock
);
896 hlist_del(&can_rx_alldev_list
.list
);
897 hlist_for_each_entry_safe(d
, n
, next
, &can_rx_dev_list
, list
) {
901 spin_unlock(&can_rcvlists_lock
);
903 kmem_cache_destroy(rcv_cache
);
906 module_init(can_init
);
907 module_exit(can_exit
);