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