~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/can/af_can.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 static __initconst const char banner[] = KERN_INFO
 68         "can: controller area network core (" CAN_VERSION_STRING ")\n";
 69 
 70 MODULE_DESCRIPTION("Controller Area Network PF_CAN core");
 71 MODULE_LICENSE("Dual BSD/GPL");
 72 MODULE_AUTHOR("Urs Thuermann <urs.thuermann@volkswagen.de>, "
 73               "Oliver Hartkopp <oliver.hartkopp@volkswagen.de>");
 74 
 75 MODULE_ALIAS_NETPROTO(PF_CAN);
 76 
 77 static int stats_timer __read_mostly = 1;
 78 module_param(stats_timer, int, S_IRUGO);
 79 MODULE_PARM_DESC(stats_timer, "enable timer for statistics (default:on)");
 80 
 81 /* receive filters subscribed for 'all' CAN devices */
 82 struct dev_rcv_lists can_rx_alldev_list;
 83 static DEFINE_SPINLOCK(can_rcvlists_lock);
 84 
 85 static struct kmem_cache *rcv_cache __read_mostly;
 86 
 87 /* table of registered CAN protocols */
 88 static const struct can_proto *proto_tab[CAN_NPROTO] __read_mostly;
 89 static DEFINE_MUTEX(proto_tab_lock);
 90 
 91 struct timer_list can_stattimer;   /* timer for statistics update */
 92 struct s_stats    can_stats;       /* packet statistics */
 93 struct s_pstats   can_pstats;      /* receive list statistics */
 94 
 95 /*
 96  * af_can socket functions
 97  */
 98 
 99 int 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 }
112 EXPORT_SYMBOL(can_ioctl);
113 
114 static void can_sock_destruct(struct sock *sk)
115 {
116         skb_queue_purge(&sk->sk_receive_queue);
117 }
118 
119 static 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 
132 static inline void can_put_proto(const struct can_proto *cp)
133 {
134         module_put(cp->prot->owner);
135 }
136 
137 static 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  */
228 int 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 
322 inval_skb:
323         kfree_skb(skb);
324         return err;
325 }
326 EXPORT_SYMBOL(can_send);
327 
328 /*
329  * af_can rx path
330  */
331 
332 static 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  * find_rcv_list - determine optimal filterlist inside device filter struct
342  * @can_id: pointer to CAN identifier of a given can_filter
343  * @mask: pointer to CAN mask of a given can_filter
344  * @d: pointer to the device filter struct
345  *
346  * Description:
347  *  Returns the optimal filterlist to reduce the filter handling in the
348  *  receive path. This function is called by service functions that need
349  *  to register or unregister a can_filter in the filter lists.
350  *
351  *  A filter matches in general, when
352  *
353  *          <received_can_id> & mask == can_id & mask
354  *
355  *  so every bit set in the mask (even CAN_EFF_FLAG, CAN_RTR_FLAG) describe
356  *  relevant bits for the filter.
357  *
358  *  The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
359  *  filter for error messages (CAN_ERR_FLAG bit set in mask). For error msg
360  *  frames there is a special filterlist and a special rx path filter handling.
361  *
362  * Return:
363  *  Pointer to optimal filterlist for the given can_id/mask pair.
364  *  Constistency checked mask.
365  *  Reduced can_id to have a preprocessed filter compare value.
366  */
367 static struct hlist_head *find_rcv_list(canid_t *can_id, canid_t *mask,
368                                         struct dev_rcv_lists *d)
369 {
370         canid_t inv = *can_id & CAN_INV_FILTER; /* save flag before masking */
371 
372         /* filter for error message frames in extra filterlist */
373         if (*mask & CAN_ERR_FLAG) {
374                 /* clear CAN_ERR_FLAG in filter entry */
375                 *mask &= CAN_ERR_MASK;
376                 return &d->rx[RX_ERR];
377         }
378 
379         /* with cleared CAN_ERR_FLAG we have a simple mask/value filterpair */
380 
381 #define CAN_EFF_RTR_FLAGS (CAN_EFF_FLAG | CAN_RTR_FLAG)
382 
383         /* ensure valid values in can_mask for 'SFF only' frame filtering */
384         if ((*mask & CAN_EFF_FLAG) && !(*can_id & CAN_EFF_FLAG))
385                 *mask &= (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS);
386 
387         /* reduce condition testing at receive time */
388         *can_id &= *mask;
389 
390         /* inverse can_id/can_mask filter */
391         if (inv)
392                 return &d->rx[RX_INV];
393 
394         /* mask == 0 => no condition testing at receive time */
395         if (!(*mask))
396                 return &d->rx[RX_ALL];
397 
398         /* extra filterlists for the subscription of a single non-RTR can_id */
399         if (((*mask & CAN_EFF_RTR_FLAGS) == CAN_EFF_RTR_FLAGS) &&
400             !(*can_id & CAN_RTR_FLAG)) {
401 
402                 if (*can_id & CAN_EFF_FLAG) {
403                         if (*mask == (CAN_EFF_MASK | CAN_EFF_RTR_FLAGS)) {
404                                 /* RFC: a future use-case for hash-tables? */
405                                 return &d->rx[RX_EFF];
406                         }
407                 } else {
408                         if (*mask == (CAN_SFF_MASK | CAN_EFF_RTR_FLAGS))
409                                 return &d->rx_sff[*can_id];
410                 }
411         }
412 
413         /* default: filter via can_id/can_mask */
414         return &d->rx[RX_FIL];
415 }
416 
417 /**
418  * can_rx_register - subscribe CAN frames from a specific interface
419  * @dev: pointer to netdevice (NULL => subcribe from 'all' CAN devices list)
420  * @can_id: CAN identifier (see description)
421  * @mask: CAN mask (see description)
422  * @func: callback function on filter match
423  * @data: returned parameter for callback function
424  * @ident: string for calling module identification
425  *
426  * Description:
427  *  Invokes the callback function with the received sk_buff and the given
428  *  parameter 'data' on a matching receive filter. A filter matches, when
429  *
430  *          <received_can_id> & mask == can_id & mask
431  *
432  *  The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
433  *  filter for error message frames (CAN_ERR_FLAG bit set in mask).
434  *
435  *  The provided pointer to the sk_buff is guaranteed to be valid as long as
436  *  the callback function is running. The callback function must *not* free
437  *  the given sk_buff while processing it's task. When the given sk_buff is
438  *  needed after the end of the callback function it must be cloned inside
439  *  the callback function with skb_clone().
440  *
441  * Return:
442  *  0 on success
443  *  -ENOMEM on missing cache mem to create subscription entry
444  *  -ENODEV unknown device
445  */
446 int can_rx_register(struct net_device *dev, canid_t can_id, canid_t mask,
447                     void (*func)(struct sk_buff *, void *), void *data,
448                     char *ident)
449 {
450         struct receiver *r;
451         struct hlist_head *rl;
452         struct dev_rcv_lists *d;
453         int err = 0;
454 
455         /* insert new receiver  (dev,canid,mask) -> (func,data) */
456 
457         if (dev && dev->type != ARPHRD_CAN)
458                 return -ENODEV;
459 
460         r = kmem_cache_alloc(rcv_cache, GFP_KERNEL);
461         if (!r)
462                 return -ENOMEM;
463 
464         spin_lock(&can_rcvlists_lock);
465 
466         d = find_dev_rcv_lists(dev);
467         if (d) {
468                 rl = find_rcv_list(&can_id, &mask, d);
469 
470                 r->can_id  = can_id;
471                 r->mask    = mask;
472                 r->matches = 0;
473                 r->func    = func;
474                 r->data    = data;
475                 r->ident   = ident;
476 
477                 hlist_add_head_rcu(&r->list, rl);
478                 d->entries++;
479 
480                 can_pstats.rcv_entries++;
481                 if (can_pstats.rcv_entries_max < can_pstats.rcv_entries)
482                         can_pstats.rcv_entries_max = can_pstats.rcv_entries;
483         } else {
484                 kmem_cache_free(rcv_cache, r);
485                 err = -ENODEV;
486         }
487 
488         spin_unlock(&can_rcvlists_lock);
489 
490         return err;
491 }
492 EXPORT_SYMBOL(can_rx_register);
493 
494 /*
495  * can_rx_delete_receiver - rcu callback for single receiver entry removal
496  */
497 static void can_rx_delete_receiver(struct rcu_head *rp)
498 {
499         struct receiver *r = container_of(rp, struct receiver, rcu);
500 
501         kmem_cache_free(rcv_cache, r);
502 }
503 
504 /**
505  * can_rx_unregister - unsubscribe CAN frames from a specific interface
506  * @dev: pointer to netdevice (NULL => unsubcribe from 'all' CAN devices list)
507  * @can_id: CAN identifier
508  * @mask: CAN mask
509  * @func: callback function on filter match
510  * @data: returned parameter for callback function
511  *
512  * Description:
513  *  Removes subscription entry depending on given (subscription) values.
514  */
515 void can_rx_unregister(struct net_device *dev, canid_t can_id, canid_t mask,
516                        void (*func)(struct sk_buff *, void *), void *data)
517 {
518         struct receiver *r = NULL;
519         struct hlist_head *rl;
520         struct dev_rcv_lists *d;
521 
522         if (dev && dev->type != ARPHRD_CAN)
523                 return;
524 
525         spin_lock(&can_rcvlists_lock);
526 
527         d = find_dev_rcv_lists(dev);
528         if (!d) {
529                 pr_err("BUG: receive list not found for "
530                        "dev %s, id %03X, mask %03X\n",
531                        DNAME(dev), can_id, mask);
532                 goto out;
533         }
534 
535         rl = find_rcv_list(&can_id, &mask, d);
536 
537         /*
538          * Search the receiver list for the item to delete.  This should
539          * exist, since no receiver may be unregistered that hasn't
540          * been registered before.
541          */
542 
543         hlist_for_each_entry_rcu(r, rl, list) {
544                 if (r->can_id == can_id && r->mask == mask &&
545                     r->func == func && r->data == data)
546                         break;
547         }
548 
549         /*
550          * Check for bugs in CAN protocol implementations using af_can.c:
551          * 'r' will be NULL if no matching list item was found for removal.
552          */
553 
554         if (!r) {
555                 WARN(1, "BUG: receive list entry not found for dev %s, "
556                      "id %03X, mask %03X\n", DNAME(dev), can_id, mask);
557                 goto out;
558         }
559 
560         hlist_del_rcu(&r->list);
561         d->entries--;
562 
563         if (can_pstats.rcv_entries > 0)
564                 can_pstats.rcv_entries--;
565 
566         /* remove device structure requested by NETDEV_UNREGISTER */
567         if (d->remove_on_zero_entries && !d->entries) {
568                 kfree(d);
569                 dev->ml_priv = NULL;
570         }
571 
572  out:
573         spin_unlock(&can_rcvlists_lock);
574 
575         /* schedule the receiver item for deletion */
576         if (r)
577                 call_rcu(&r->rcu, can_rx_delete_receiver);
578 }
579 EXPORT_SYMBOL(can_rx_unregister);
580 
581 static inline void deliver(struct sk_buff *skb, struct receiver *r)
582 {
583         r->func(skb, r->data);
584         r->matches++;
585 }
586 
587 static int can_rcv_filter(struct dev_rcv_lists *d, struct sk_buff *skb)
588 {
589         struct receiver *r;
590         int matches = 0;
591         struct can_frame *cf = (struct can_frame *)skb->data;
592         canid_t can_id = cf->can_id;
593 
594         if (d->entries == 0)
595                 return 0;
596 
597         if (can_id & CAN_ERR_FLAG) {
598                 /* check for error message frame entries only */
599                 hlist_for_each_entry_rcu(r, &d->rx[RX_ERR], list) {
600                         if (can_id & r->mask) {
601                                 deliver(skb, r);
602                                 matches++;
603                         }
604                 }
605                 return matches;
606         }
607 
608         /* check for unfiltered entries */
609         hlist_for_each_entry_rcu(r, &d->rx[RX_ALL], list) {
610                 deliver(skb, r);
611                 matches++;
612         }
613 
614         /* check for can_id/mask entries */
615         hlist_for_each_entry_rcu(r, &d->rx[RX_FIL], list) {
616                 if ((can_id & r->mask) == r->can_id) {
617                         deliver(skb, r);
618                         matches++;
619                 }
620         }
621 
622         /* check for inverted can_id/mask entries */
623         hlist_for_each_entry_rcu(r, &d->rx[RX_INV], list) {
624                 if ((can_id & r->mask) != r->can_id) {
625                         deliver(skb, r);
626                         matches++;
627                 }
628         }
629 
630         /* check filterlists for single non-RTR can_ids */
631         if (can_id & CAN_RTR_FLAG)
632                 return matches;
633 
634         if (can_id & CAN_EFF_FLAG) {
635                 hlist_for_each_entry_rcu(r, &d->rx[RX_EFF], list) {
636                         if (r->can_id == can_id) {
637                                 deliver(skb, r);
638                                 matches++;
639                         }
640                 }
641         } else {
642                 can_id &= CAN_SFF_MASK;
643                 hlist_for_each_entry_rcu(r, &d->rx_sff[can_id], list) {
644                         deliver(skb, r);
645                         matches++;
646                 }
647         }
648 
649         return matches;
650 }
651 
652 static void can_receive(struct sk_buff *skb, struct net_device *dev)
653 {
654         struct dev_rcv_lists *d;
655         int matches;
656 
657         /* update statistics */
658         can_stats.rx_frames++;
659         can_stats.rx_frames_delta++;
660 
661         rcu_read_lock();
662 
663         /* deliver the packet to sockets listening on all devices */
664         matches = can_rcv_filter(&can_rx_alldev_list, skb);
665 
666         /* find receive list for this device */
667         d = find_dev_rcv_lists(dev);
668         if (d)
669                 matches += can_rcv_filter(d, skb);
670 
671         rcu_read_unlock();
672 
673         /* consume the skbuff allocated by the netdevice driver */
674         consume_skb(skb);
675 
676         if (matches > 0) {
677                 can_stats.matches++;
678                 can_stats.matches_delta++;
679         }
680 }
681 
682 static int can_rcv(struct sk_buff *skb, struct net_device *dev,
683                    struct packet_type *pt, struct net_device *orig_dev)
684 {
685         struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
686 
687         if (unlikely(!net_eq(dev_net(dev), &init_net)))
688                 goto drop;
689 
690         if (WARN_ONCE(dev->type != ARPHRD_CAN ||
691                       skb->len != CAN_MTU ||
692                       cfd->len > CAN_MAX_DLEN,
693                       "PF_CAN: dropped non conform CAN skbuf: "
694                       "dev type %d, len %d, datalen %d\n",
695                       dev->type, skb->len, cfd->len))
696                 goto drop;
697 
698         can_receive(skb, dev);
699         return NET_RX_SUCCESS;
700 
701 drop:
702         kfree_skb(skb);
703         return NET_RX_DROP;
704 }
705 
706 static int canfd_rcv(struct sk_buff *skb, struct net_device *dev,
707                    struct packet_type *pt, struct net_device *orig_dev)
708 {
709         struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
710 
711         if (unlikely(!net_eq(dev_net(dev), &init_net)))
712                 goto drop;
713 
714         if (WARN_ONCE(dev->type != ARPHRD_CAN ||
715                       skb->len != CANFD_MTU ||
716                       cfd->len > CANFD_MAX_DLEN,
717                       "PF_CAN: dropped non conform CAN FD skbuf: "
718                       "dev type %d, len %d, datalen %d\n",
719                       dev->type, skb->len, cfd->len))
720                 goto drop;
721 
722         can_receive(skb, dev);
723         return NET_RX_SUCCESS;
724 
725 drop:
726         kfree_skb(skb);
727         return NET_RX_DROP;
728 }
729 
730 /*
731  * af_can protocol functions
732  */
733 
734 /**
735  * can_proto_register - register CAN transport protocol
736  * @cp: pointer to CAN protocol structure
737  *
738  * Return:
739  *  0 on success
740  *  -EINVAL invalid (out of range) protocol number
741  *  -EBUSY  protocol already in use
742  *  -ENOBUF if proto_register() fails
743  */
744 int can_proto_register(const struct can_proto *cp)
745 {
746         int proto = cp->protocol;
747         int err = 0;
748 
749         if (proto < 0 || proto >= CAN_NPROTO) {
750                 pr_err("can: protocol number %d out of range\n", proto);
751                 return -EINVAL;
752         }
753 
754         err = proto_register(cp->prot, 0);
755         if (err < 0)
756                 return err;
757 
758         mutex_lock(&proto_tab_lock);
759 
760         if (proto_tab[proto]) {
761                 pr_err("can: protocol %d already registered\n", proto);
762                 err = -EBUSY;
763         } else
764                 RCU_INIT_POINTER(proto_tab[proto], cp);
765 
766         mutex_unlock(&proto_tab_lock);
767 
768         if (err < 0)
769                 proto_unregister(cp->prot);
770 
771         return err;
772 }
773 EXPORT_SYMBOL(can_proto_register);
774 
775 /**
776  * can_proto_unregister - unregister CAN transport protocol
777  * @cp: pointer to CAN protocol structure
778  */
779 void can_proto_unregister(const struct can_proto *cp)
780 {
781         int proto = cp->protocol;
782 
783         mutex_lock(&proto_tab_lock);
784         BUG_ON(proto_tab[proto] != cp);
785         RCU_INIT_POINTER(proto_tab[proto], NULL);
786         mutex_unlock(&proto_tab_lock);
787 
788         synchronize_rcu();
789 
790         proto_unregister(cp->prot);
791 }
792 EXPORT_SYMBOL(can_proto_unregister);
793 
794 /*
795  * af_can notifier to create/remove CAN netdevice specific structs
796  */
797 static int can_notifier(struct notifier_block *nb, unsigned long msg,
798                         void *ptr)
799 {
800         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
801         struct dev_rcv_lists *d;
802 
803         if (!net_eq(dev_net(dev), &init_net))
804                 return NOTIFY_DONE;
805 
806         if (dev->type != ARPHRD_CAN)
807                 return NOTIFY_DONE;
808 
809         switch (msg) {
810 
811         case NETDEV_REGISTER:
812 
813                 /* create new dev_rcv_lists for this device */
814                 d = kzalloc(sizeof(*d), GFP_KERNEL);
815                 if (!d)
816                         return NOTIFY_DONE;
817                 BUG_ON(dev->ml_priv);
818                 dev->ml_priv = d;
819 
820                 break;
821 
822         case NETDEV_UNREGISTER:
823                 spin_lock(&can_rcvlists_lock);
824 
825                 d = dev->ml_priv;
826                 if (d) {
827                         if (d->entries)
828                                 d->remove_on_zero_entries = 1;
829                         else {
830                                 kfree(d);
831                                 dev->ml_priv = NULL;
832                         }
833                 } else
834                         pr_err("can: notifier: receive list not found for dev "
835                                "%s\n", dev->name);
836 
837                 spin_unlock(&can_rcvlists_lock);
838 
839                 break;
840         }
841 
842         return NOTIFY_DONE;
843 }
844 
845 /*
846  * af_can module init/exit functions
847  */
848 
849 static struct packet_type can_packet __read_mostly = {
850         .type = cpu_to_be16(ETH_P_CAN),
851         .func = can_rcv,
852 };
853 
854 static struct packet_type canfd_packet __read_mostly = {
855         .type = cpu_to_be16(ETH_P_CANFD),
856         .func = canfd_rcv,
857 };
858 
859 static const struct net_proto_family can_family_ops = {
860         .family = PF_CAN,
861         .create = can_create,
862         .owner  = THIS_MODULE,
863 };
864 
865 /* notifier block for netdevice event */
866 static struct notifier_block can_netdev_notifier __read_mostly = {
867         .notifier_call = can_notifier,
868 };
869 
870 static __init int can_init(void)
871 {
872         /* check for correct padding to be able to use the structs similarly */
873         BUILD_BUG_ON(offsetof(struct can_frame, can_dlc) !=
874                      offsetof(struct canfd_frame, len) ||
875                      offsetof(struct can_frame, data) !=
876                      offsetof(struct canfd_frame, data));
877 
878         printk(banner);
879 
880         memset(&can_rx_alldev_list, 0, sizeof(can_rx_alldev_list));
881 
882         rcv_cache = kmem_cache_create("can_receiver", sizeof(struct receiver),
883                                       0, 0, NULL);
884         if (!rcv_cache)
885                 return -ENOMEM;
886 
887         if (stats_timer) {
888                 /* the statistics are updated every second (timer triggered) */
889                 setup_timer(&can_stattimer, can_stat_update, 0);
890                 mod_timer(&can_stattimer, round_jiffies(jiffies + HZ));
891         } else
892                 can_stattimer.function = NULL;
893 
894         can_init_proc();
895 
896         /* protocol register */
897         sock_register(&can_family_ops);
898         register_netdevice_notifier(&can_netdev_notifier);
899         dev_add_pack(&can_packet);
900         dev_add_pack(&canfd_packet);
901 
902         return 0;
903 }
904 
905 static __exit void can_exit(void)
906 {
907         struct net_device *dev;
908 
909         if (stats_timer)
910                 del_timer_sync(&can_stattimer);
911 
912         can_remove_proc();
913 
914         /* protocol unregister */
915         dev_remove_pack(&canfd_packet);
916         dev_remove_pack(&can_packet);
917         unregister_netdevice_notifier(&can_netdev_notifier);
918         sock_unregister(PF_CAN);
919 
920         /* remove created dev_rcv_lists from still registered CAN devices */
921         rcu_read_lock();
922         for_each_netdev_rcu(&init_net, dev) {
923                 if (dev->type == ARPHRD_CAN && dev->ml_priv) {
924 
925                         struct dev_rcv_lists *d = dev->ml_priv;
926 
927                         BUG_ON(d->entries);
928                         kfree(d);
929                         dev->ml_priv = NULL;
930                 }
931         }
932         rcu_read_unlock();
933 
934         rcu_barrier(); /* Wait for completion of call_rcu()'s */
935 
936         kmem_cache_destroy(rcv_cache);
937 }
938 
939 module_init(can_init);
940 module_exit(can_exit);
941 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp