1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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
67MODULE_DESCRIPTION("Controller Area Network PF_CAN core");
68MODULE_LICENSE("Dual BSD/GPL");
69MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>, "
70 "Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
71
72MODULE_ALIAS_NETPROTO(PF_CAN);
73
74static int stats_timer __read_mostly = 1;
75module_param(stats_timer, int, 0444);
76MODULE_PARM_DESC(stats_timer, "enable timer for statistics (default:on)");
77
78static struct kmem_cache *rcv_cache __read_mostly;
79
80
81static const struct can_proto __rcu *proto_tab[CAN_NPROTO] __read_mostly;
82static DEFINE_MUTEX(proto_tab_lock);
83
84static atomic_t skbcounter = ATOMIC_INIT(0);
85
86
87
88
89
90int can_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
91{
92 switch (cmd) {
93 default:
94 return -ENOIOCTLCMD;
95 }
96}
97EXPORT_SYMBOL(can_ioctl);
98
99static void can_sock_destruct(struct sock *sk)
100{
101 skb_queue_purge(&sk->sk_receive_queue);
102 skb_queue_purge(&sk->sk_error_queue);
103}
104
105static const struct can_proto *can_get_proto(int protocol)
106{
107 const struct can_proto *cp;
108
109 rcu_read_lock();
110 cp = rcu_dereference(proto_tab[protocol]);
111 if (cp && !try_module_get(cp->prot->owner))
112 cp = NULL;
113 rcu_read_unlock();
114
115 return cp;
116}
117
118static inline void can_put_proto(const struct can_proto *cp)
119{
120 module_put(cp->prot->owner);
121}
122
123static int can_create(struct net *net, struct socket *sock, int protocol,
124 int kern)
125{
126 struct sock *sk;
127 const struct can_proto *cp;
128 int err = 0;
129
130 sock->state = SS_UNCONNECTED;
131
132 if (protocol < 0 || protocol >= CAN_NPROTO)
133 return -EINVAL;
134
135 cp = can_get_proto(protocol);
136
137#ifdef CONFIG_MODULES
138 if (!cp) {
139
140
141 err = request_module("can-proto-%d", protocol);
142
143
144
145
146
147
148 if (err)
149 printk_ratelimited(KERN_ERR "can: request_module "
150 "(can-proto-%d) failed.\n", protocol);
151
152 cp = can_get_proto(protocol);
153 }
154#endif
155
156
157
158 if (!cp)
159 return -EPROTONOSUPPORT;
160
161 if (cp->type != sock->type) {
162 err = -EPROTOTYPE;
163 goto errout;
164 }
165
166 sock->ops = cp->ops;
167
168 sk = sk_alloc(net, PF_CAN, GFP_KERNEL, cp->prot, kern);
169 if (!sk) {
170 err = -ENOMEM;
171 goto errout;
172 }
173
174 sock_init_data(sock, sk);
175 sk->sk_destruct = can_sock_destruct;
176
177 if (sk->sk_prot->init)
178 err = sk->sk_prot->init(sk);
179
180 if (err) {
181
182 sock_orphan(sk);
183 sock_put(sk);
184 }
185
186 errout:
187 can_put_proto(cp);
188 return err;
189}
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211int can_send(struct sk_buff *skb, int loop)
212{
213 struct sk_buff *newskb = NULL;
214 struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
215 struct s_stats *can_stats = dev_net(skb->dev)->can.can_stats;
216 int err = -EINVAL;
217
218 if (skb->len == CAN_MTU) {
219 skb->protocol = htons(ETH_P_CAN);
220 if (unlikely(cfd->len > CAN_MAX_DLEN))
221 goto inval_skb;
222 } else if (skb->len == CANFD_MTU) {
223 skb->protocol = htons(ETH_P_CANFD);
224 if (unlikely(cfd->len > CANFD_MAX_DLEN))
225 goto inval_skb;
226 } else
227 goto inval_skb;
228
229
230
231
232
233
234 if (unlikely(skb->len > skb->dev->mtu && cfd->len > CAN_MAX_DLEN)) {
235 err = -EMSGSIZE;
236 goto inval_skb;
237 }
238
239 if (unlikely(skb->dev->type != ARPHRD_CAN)) {
240 err = -EPERM;
241 goto inval_skb;
242 }
243
244 if (unlikely(!(skb->dev->flags & IFF_UP))) {
245 err = -ENETDOWN;
246 goto inval_skb;
247 }
248
249 skb->ip_summed = CHECKSUM_UNNECESSARY;
250
251 skb_reset_mac_header(skb);
252 skb_reset_network_header(skb);
253 skb_reset_transport_header(skb);
254
255 if (loop) {
256
257
258
259 skb->pkt_type = PACKET_LOOPBACK;
260
261
262
263
264
265
266
267
268
269
270 if (!(skb->dev->flags & IFF_ECHO)) {
271
272
273
274
275 newskb = skb_clone(skb, GFP_ATOMIC);
276 if (!newskb) {
277 kfree_skb(skb);
278 return -ENOMEM;
279 }
280
281 can_skb_set_owner(newskb, skb->sk);
282 newskb->ip_summed = CHECKSUM_UNNECESSARY;
283 newskb->pkt_type = PACKET_BROADCAST;
284 }
285 } else {
286
287 skb->pkt_type = PACKET_HOST;
288 }
289
290
291 err = dev_queue_xmit(skb);
292 if (err > 0)
293 err = net_xmit_errno(err);
294
295 if (err) {
296 kfree_skb(newskb);
297 return err;
298 }
299
300 if (newskb)
301 netif_rx_ni(newskb);
302
303
304 can_stats->tx_frames++;
305 can_stats->tx_frames_delta++;
306
307 return 0;
308
309inval_skb:
310 kfree_skb(skb);
311 return err;
312}
313EXPORT_SYMBOL(can_send);
314
315
316
317
318
319static struct can_dev_rcv_lists *find_dev_rcv_lists(struct net *net,
320 struct net_device *dev)
321{
322 if (!dev)
323 return net->can.can_rx_alldev_list;
324 else
325 return (struct can_dev_rcv_lists *)dev->ml_priv;
326}
327
328
329
330
331
332
333
334
335
336
337
338
339
340static unsigned int effhash(canid_t can_id)
341{
342 unsigned int hash;
343
344 hash = can_id;
345 hash ^= can_id >> CAN_EFF_RCV_HASH_BITS;
346 hash ^= can_id >> (2 * CAN_EFF_RCV_HASH_BITS);
347
348 return hash & ((1 << CAN_EFF_RCV_HASH_BITS) - 1);
349}
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378static struct hlist_head *find_rcv_list(canid_t *can_id, canid_t *mask,
379 struct can_dev_rcv_lists *d)
380{
381 canid_t inv = *can_id & CAN_INV_FILTER;
382
383
384 if (*mask & CAN_ERR_FLAG) {
385
386 *mask &= CAN_ERR_MASK;
387 return &d->rx[RX_ERR];
388 }
389
390
391
392#define CAN_EFF_RTR_FLAGS (CAN_EFF_FLAG | CAN_RTR_FLAG)
393
394
395 if ((*mask & CAN_EFF_FLAG) && !(*can_id & CAN_EFF_FLAG))
396 *mask &= (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS);
397
398
399 *can_id &= *mask;
400
401
402 if (inv)
403 return &d->rx[RX_INV];
404
405
406 if (!(*mask))
407 return &d->rx[RX_ALL];
408
409
410 if (((*mask & CAN_EFF_RTR_FLAGS) == CAN_EFF_RTR_FLAGS) &&
411 !(*can_id & CAN_RTR_FLAG)) {
412
413 if (*can_id & CAN_EFF_FLAG) {
414 if (*mask == (CAN_EFF_MASK | CAN_EFF_RTR_FLAGS))
415 return &d->rx_eff[effhash(*can_id)];
416 } else {
417 if (*mask == (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS))
418 return &d->rx_sff[*can_id];
419 }
420 }
421
422
423 return &d->rx[RX_FIL];
424}
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456int can_rx_register(struct net *net, struct net_device *dev, canid_t can_id,
457 canid_t mask, void (*func)(struct sk_buff *, void *),
458 void *data, char *ident, struct sock *sk)
459{
460 struct receiver *r;
461 struct hlist_head *rl;
462 struct can_dev_rcv_lists *d;
463 struct s_pstats *can_pstats = net->can.can_pstats;
464 int err = 0;
465
466
467
468 if (dev && dev->type != ARPHRD_CAN)
469 return -ENODEV;
470
471 if (dev && !net_eq(net, dev_net(dev)))
472 return -ENODEV;
473
474 r = kmem_cache_alloc(rcv_cache, GFP_KERNEL);
475 if (!r)
476 return -ENOMEM;
477
478 spin_lock(&net->can.can_rcvlists_lock);
479
480 d = find_dev_rcv_lists(net, dev);
481 if (d) {
482 rl = find_rcv_list(&can_id, &mask, d);
483
484 r->can_id = can_id;
485 r->mask = mask;
486 r->matches = 0;
487 r->func = func;
488 r->data = data;
489 r->ident = ident;
490 r->sk = sk;
491
492 hlist_add_head_rcu(&r->list, rl);
493 d->entries++;
494
495 can_pstats->rcv_entries++;
496 if (can_pstats->rcv_entries_max < can_pstats->rcv_entries)
497 can_pstats->rcv_entries_max = can_pstats->rcv_entries;
498 } else {
499 kmem_cache_free(rcv_cache, r);
500 err = -ENODEV;
501 }
502
503 spin_unlock(&net->can.can_rcvlists_lock);
504
505 return err;
506}
507EXPORT_SYMBOL(can_rx_register);
508
509
510
511
512static void can_rx_delete_receiver(struct rcu_head *rp)
513{
514 struct receiver *r = container_of(rp, struct receiver, rcu);
515 struct sock *sk = r->sk;
516
517 kmem_cache_free(rcv_cache, r);
518 if (sk)
519 sock_put(sk);
520}
521
522
523
524
525
526
527
528
529
530
531
532
533void can_rx_unregister(struct net *net, struct net_device *dev, canid_t can_id,
534 canid_t mask, void (*func)(struct sk_buff *, void *),
535 void *data)
536{
537 struct receiver *r = NULL;
538 struct hlist_head *rl;
539 struct s_pstats *can_pstats = net->can.can_pstats;
540 struct can_dev_rcv_lists *d;
541
542 if (dev && dev->type != ARPHRD_CAN)
543 return;
544
545 if (dev && !net_eq(net, dev_net(dev)))
546 return;
547
548 spin_lock(&net->can.can_rcvlists_lock);
549
550 d = find_dev_rcv_lists(net, dev);
551 if (!d) {
552 pr_err("BUG: receive list not found for "
553 "dev %s, id %03X, mask %03X\n",
554 DNAME(dev), can_id, mask);
555 goto out;
556 }
557
558 rl = find_rcv_list(&can_id, &mask, d);
559
560
561
562
563
564
565
566 hlist_for_each_entry_rcu(r, rl, list) {
567 if (r->can_id == can_id && r->mask == mask &&
568 r->func == func && r->data == data)
569 break;
570 }
571
572
573
574
575
576
577 if (!r) {
578 WARN(1, "BUG: receive list entry not found for dev %s, "
579 "id %03X, mask %03X\n", DNAME(dev), can_id, mask);
580 goto out;
581 }
582
583 hlist_del_rcu(&r->list);
584 d->entries--;
585
586 if (can_pstats->rcv_entries > 0)
587 can_pstats->rcv_entries--;
588
589
590 if (d->remove_on_zero_entries && !d->entries) {
591 kfree(d);
592 dev->ml_priv = NULL;
593 }
594
595 out:
596 spin_unlock(&net->can.can_rcvlists_lock);
597
598
599 if (r) {
600 if (r->sk)
601 sock_hold(r->sk);
602 call_rcu(&r->rcu, can_rx_delete_receiver);
603 }
604}
605EXPORT_SYMBOL(can_rx_unregister);
606
607static inline void deliver(struct sk_buff *skb, struct receiver *r)
608{
609 r->func(skb, r->data);
610 r->matches++;
611}
612
613static int can_rcv_filter(struct can_dev_rcv_lists *d, struct sk_buff *skb)
614{
615 struct receiver *r;
616 int matches = 0;
617 struct can_frame *cf = (struct can_frame *)skb->data;
618 canid_t can_id = cf->can_id;
619
620 if (d->entries == 0)
621 return 0;
622
623 if (can_id & CAN_ERR_FLAG) {
624
625 hlist_for_each_entry_rcu(r, &d->rx[RX_ERR], list) {
626 if (can_id & r->mask) {
627 deliver(skb, r);
628 matches++;
629 }
630 }
631 return matches;
632 }
633
634
635 hlist_for_each_entry_rcu(r, &d->rx[RX_ALL], list) {
636 deliver(skb, r);
637 matches++;
638 }
639
640
641 hlist_for_each_entry_rcu(r, &d->rx[RX_FIL], list) {
642 if ((can_id & r->mask) == r->can_id) {
643 deliver(skb, r);
644 matches++;
645 }
646 }
647
648
649 hlist_for_each_entry_rcu(r, &d->rx[RX_INV], list) {
650 if ((can_id & r->mask) != r->can_id) {
651 deliver(skb, r);
652 matches++;
653 }
654 }
655
656
657 if (can_id & CAN_RTR_FLAG)
658 return matches;
659
660 if (can_id & CAN_EFF_FLAG) {
661 hlist_for_each_entry_rcu(r, &d->rx_eff[effhash(can_id)], list) {
662 if (r->can_id == can_id) {
663 deliver(skb, r);
664 matches++;
665 }
666 }
667 } else {
668 can_id &= CAN_SFF_MASK;
669 hlist_for_each_entry_rcu(r, &d->rx_sff[can_id], list) {
670 deliver(skb, r);
671 matches++;
672 }
673 }
674
675 return matches;
676}
677
678static void can_receive(struct sk_buff *skb, struct net_device *dev)
679{
680 struct can_dev_rcv_lists *d;
681 struct net *net = dev_net(dev);
682 struct s_stats *can_stats = net->can.can_stats;
683 int matches;
684
685
686 can_stats->rx_frames++;
687 can_stats->rx_frames_delta++;
688
689
690 while (!(can_skb_prv(skb)->skbcnt))
691 can_skb_prv(skb)->skbcnt = atomic_inc_return(&skbcounter);
692
693 rcu_read_lock();
694
695
696 matches = can_rcv_filter(net->can.can_rx_alldev_list, skb);
697
698
699 d = find_dev_rcv_lists(net, dev);
700 if (d)
701 matches += can_rcv_filter(d, skb);
702
703 rcu_read_unlock();
704
705
706 consume_skb(skb);
707
708 if (matches > 0) {
709 can_stats->matches++;
710 can_stats->matches_delta++;
711 }
712}
713
714static int can_rcv(struct sk_buff *skb, struct net_device *dev,
715 struct packet_type *pt, struct net_device *orig_dev)
716{
717 struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
718
719 if (unlikely(dev->type != ARPHRD_CAN || skb->len != CAN_MTU ||
720 cfd->len > CAN_MAX_DLEN)) {
721 pr_warn_once("PF_CAN: dropped non conform CAN skbuf: dev type %d, len %d, datalen %d\n",
722 dev->type, skb->len, cfd->len);
723 kfree_skb(skb);
724 return NET_RX_DROP;
725 }
726
727 can_receive(skb, dev);
728 return NET_RX_SUCCESS;
729}
730
731static int canfd_rcv(struct sk_buff *skb, struct net_device *dev,
732 struct packet_type *pt, struct net_device *orig_dev)
733{
734 struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
735
736 if (unlikely(dev->type != ARPHRD_CAN || skb->len != CANFD_MTU ||
737 cfd->len > CANFD_MAX_DLEN)) {
738 pr_warn_once("PF_CAN: dropped non conform CAN FD skbuf: dev type %d, len %d, datalen %d\n",
739 dev->type, skb->len, cfd->len);
740 kfree_skb(skb);
741 return NET_RX_DROP;
742 }
743
744 can_receive(skb, dev);
745 return NET_RX_SUCCESS;
746}
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762int can_proto_register(const struct can_proto *cp)
763{
764 int proto = cp->protocol;
765 int err = 0;
766
767 if (proto < 0 || proto >= CAN_NPROTO) {
768 pr_err("can: protocol number %d out of range\n", proto);
769 return -EINVAL;
770 }
771
772 err = proto_register(cp->prot, 0);
773 if (err < 0)
774 return err;
775
776 mutex_lock(&proto_tab_lock);
777
778 if (rcu_access_pointer(proto_tab[proto])) {
779 pr_err("can: protocol %d already registered\n", proto);
780 err = -EBUSY;
781 } else
782 RCU_INIT_POINTER(proto_tab[proto], cp);
783
784 mutex_unlock(&proto_tab_lock);
785
786 if (err < 0)
787 proto_unregister(cp->prot);
788
789 return err;
790}
791EXPORT_SYMBOL(can_proto_register);
792
793
794
795
796
797void can_proto_unregister(const struct can_proto *cp)
798{
799 int proto = cp->protocol;
800
801 mutex_lock(&proto_tab_lock);
802 BUG_ON(rcu_access_pointer(proto_tab[proto]) != cp);
803 RCU_INIT_POINTER(proto_tab[proto], NULL);
804 mutex_unlock(&proto_tab_lock);
805
806 synchronize_rcu();
807
808 proto_unregister(cp->prot);
809}
810EXPORT_SYMBOL(can_proto_unregister);
811
812
813
814
815static int can_notifier(struct notifier_block *nb, unsigned long msg,
816 void *ptr)
817{
818 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
819 struct can_dev_rcv_lists *d;
820
821 if (dev->type != ARPHRD_CAN)
822 return NOTIFY_DONE;
823
824 switch (msg) {
825
826 case NETDEV_REGISTER:
827
828
829 d = kzalloc(sizeof(*d), GFP_KERNEL);
830 if (!d)
831 return NOTIFY_DONE;
832 BUG_ON(dev->ml_priv);
833 dev->ml_priv = d;
834
835 break;
836
837 case NETDEV_UNREGISTER:
838 spin_lock(&dev_net(dev)->can.can_rcvlists_lock);
839
840 d = dev->ml_priv;
841 if (d) {
842 if (d->entries)
843 d->remove_on_zero_entries = 1;
844 else {
845 kfree(d);
846 dev->ml_priv = NULL;
847 }
848 } else
849 pr_err("can: notifier: receive list not found for dev "
850 "%s\n", dev->name);
851
852 spin_unlock(&dev_net(dev)->can.can_rcvlists_lock);
853
854 break;
855 }
856
857 return NOTIFY_DONE;
858}
859
860static int can_pernet_init(struct net *net)
861{
862 spin_lock_init(&net->can.can_rcvlists_lock);
863 net->can.can_rx_alldev_list =
864 kzalloc(sizeof(struct can_dev_rcv_lists), GFP_KERNEL);
865 if (!net->can.can_rx_alldev_list)
866 goto out;
867 net->can.can_stats = kzalloc(sizeof(struct s_stats), GFP_KERNEL);
868 if (!net->can.can_stats)
869 goto out_free_alldev_list;
870 net->can.can_pstats = kzalloc(sizeof(struct s_pstats), GFP_KERNEL);
871 if (!net->can.can_pstats)
872 goto out_free_can_stats;
873
874 if (IS_ENABLED(CONFIG_PROC_FS)) {
875
876 if (stats_timer) {
877 timer_setup(&net->can.can_stattimer, can_stat_update,
878 0);
879 mod_timer(&net->can.can_stattimer,
880 round_jiffies(jiffies + HZ));
881 }
882 net->can.can_stats->jiffies_init = jiffies;
883 can_init_proc(net);
884 }
885
886 return 0;
887
888 out_free_can_stats:
889 kfree(net->can.can_stats);
890 out_free_alldev_list:
891 kfree(net->can.can_rx_alldev_list);
892 out:
893 return -ENOMEM;
894}
895
896static void can_pernet_exit(struct net *net)
897{
898 struct net_device *dev;
899
900 if (IS_ENABLED(CONFIG_PROC_FS)) {
901 can_remove_proc(net);
902 if (stats_timer)
903 del_timer_sync(&net->can.can_stattimer);
904 }
905
906
907 rcu_read_lock();
908 for_each_netdev_rcu(net, dev) {
909 if (dev->type == ARPHRD_CAN && dev->ml_priv) {
910 struct can_dev_rcv_lists *d = dev->ml_priv;
911
912 BUG_ON(d->entries);
913 kfree(d);
914 dev->ml_priv = NULL;
915 }
916 }
917 rcu_read_unlock();
918
919 kfree(net->can.can_rx_alldev_list);
920 kfree(net->can.can_stats);
921 kfree(net->can.can_pstats);
922}
923
924
925
926
927
928static struct packet_type can_packet __read_mostly = {
929 .type = cpu_to_be16(ETH_P_CAN),
930 .func = can_rcv,
931};
932
933static struct packet_type canfd_packet __read_mostly = {
934 .type = cpu_to_be16(ETH_P_CANFD),
935 .func = canfd_rcv,
936};
937
938static const struct net_proto_family can_family_ops = {
939 .family = PF_CAN,
940 .create = can_create,
941 .owner = THIS_MODULE,
942};
943
944
945static struct notifier_block can_netdev_notifier __read_mostly = {
946 .notifier_call = can_notifier,
947};
948
949static struct pernet_operations can_pernet_ops __read_mostly = {
950 .init = can_pernet_init,
951 .exit = can_pernet_exit,
952};
953
954static __init int can_init(void)
955{
956 int err;
957
958
959 BUILD_BUG_ON(offsetof(struct can_frame, can_dlc) !=
960 offsetof(struct canfd_frame, len) ||
961 offsetof(struct can_frame, data) !=
962 offsetof(struct canfd_frame, data));
963
964 pr_info("can: controller area network core (" CAN_VERSION_STRING ")\n");
965
966 rcv_cache = kmem_cache_create("can_receiver", sizeof(struct receiver),
967 0, 0, NULL);
968 if (!rcv_cache)
969 return -ENOMEM;
970
971 err = register_pernet_subsys(&can_pernet_ops);
972 if (err)
973 goto out_pernet;
974
975
976 err = sock_register(&can_family_ops);
977 if (err)
978 goto out_sock;
979 err = register_netdevice_notifier(&can_netdev_notifier);
980 if (err)
981 goto out_notifier;
982
983 dev_add_pack(&can_packet);
984 dev_add_pack(&canfd_packet);
985
986 return 0;
987
988out_notifier:
989 sock_unregister(PF_CAN);
990out_sock:
991 unregister_pernet_subsys(&can_pernet_ops);
992out_pernet:
993 kmem_cache_destroy(rcv_cache);
994
995 return err;
996}
997
998static __exit void can_exit(void)
999{
1000
1001 dev_remove_pack(&canfd_packet);
1002 dev_remove_pack(&can_packet);
1003 unregister_netdevice_notifier(&can_netdev_notifier);
1004 sock_unregister(PF_CAN);
1005
1006 unregister_pernet_subsys(&can_pernet_ops);
1007
1008 rcu_barrier();
1009
1010 kmem_cache_destroy(rcv_cache);
1011}
1012
1013module_init(can_init);
1014module_exit(can_exit);
1015