Lines Matching +full:inverted +full:- +full:rx
1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 /* af_can.c - Protocol family CAN core module
5 * Copyright (c) 2002-2017 Volkswagen Group Electronic Research
61 #include <linux/can/can-ml.h>
91 skb_queue_purge(&sk->sk_receive_queue);
92 skb_queue_purge(&sk->sk_error_queue);
102 if (cp && !try_module_get(cp->prot->owner))
111 module_put(cp->prot->owner);
121 sock->state = SS_UNCONNECTED;
124 return -EINVAL;
132 err = request_module("can-proto-%d", protocol);
136 * return -EPROTONOSUPPORT
139 pr_err_ratelimited("can: request_module (can-proto-%d) failed.\n",
149 return -EPROTONOSUPPORT;
151 if (cp->type != sock->type) {
152 err = -EPROTOTYPE;
156 sock->ops = cp->ops;
158 sk = sk_alloc(net, PF_CAN, GFP_KERNEL, cp->prot, kern);
160 err = -ENOMEM;
165 sk->sk_destruct = can_sock_destruct;
167 if (sk->sk_prot->init)
168 err = sk->sk_prot->init(sk);
174 sock->sk = NULL;
176 sock_prot_inuse_add(net, sk->sk_prot, 1);
187 * can_send - transmit a CAN frame (optional with local loopback)
195 * -ENETDOWN when the selected interface is down
196 * -ENOBUFS on full driver queue (see net_xmit_errno())
197 * -ENOMEM when local loopback failed at calling skb_clone()
198 * -EPERM when trying to send on a non-CAN interface
199 * -EMSGSIZE CAN frame size is bigger than CAN interface MTU
200 * -EINVAL when the skb->data does not contain a valid CAN frame
205 struct can_pkg_stats *pkg_stats = dev_net(skb->dev)->can.pkg_stats;
206 int err = -EINVAL;
209 skb->protocol = htons(ETH_P_CANXL);
211 skb->protocol = htons(ETH_P_CAN);
213 struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
215 skb->protocol = htons(ETH_P_CANFD);
218 cfd->flags |= CANFD_FDF;
224 if (unlikely(skb->len > READ_ONCE(skb->dev->mtu))) {
225 err = -EMSGSIZE;
229 if (unlikely(skb->dev->type != ARPHRD_CAN)) {
230 err = -EPERM;
234 if (unlikely(!(skb->dev->flags & IFF_UP))) {
235 err = -ENETDOWN;
239 skb->ip_summed = CHECKSUM_UNNECESSARY;
249 skb->pkt_type = PACKET_LOOPBACK;
254 * Therefore we have to ensure that skb->sk remains the
255 * reference to the originating sock by restoring skb->sk
259 if (!(skb->dev->flags & IFF_ECHO)) {
266 return -ENOMEM;
269 can_skb_set_owner(newskb, skb->sk);
270 newskb->ip_summed = CHECKSUM_UNNECESSARY;
271 newskb->pkt_type = PACKET_BROADCAST;
275 skb->pkt_type = PACKET_HOST;
292 atomic_long_inc(&pkg_stats->tx_frames);
293 atomic_long_inc(&pkg_stats->tx_frames_delta);
303 /* af_can rx path */
310 return &can_ml->dev_rcv_lists;
312 return net->can.rx_alldev_list;
317 * effhash - hash function for 29 bit CAN identifier reduction
326 * Hash value from 0x000 - 0x3FF ( enforced by CAN_EFF_RCV_HASH_BITS mask )
336 return hash & ((1 << CAN_EFF_RCV_HASH_BITS) - 1);
340 * can_rcv_list_find - determine optimal filterlist inside device filter struct
357 * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
359 * frames there is a special filterlist and a special rx path filter handling.
375 return &dev_rcv_lists->rx[RX_ERR];
391 return &dev_rcv_lists->rx[RX_INV];
395 return &dev_rcv_lists->rx[RX_ALL];
397 /* extra filterlists for the subscription of a single non-RTR can_id */
402 return &dev_rcv_lists->rx_eff[effhash(*can_id)];
405 return &dev_rcv_lists->rx_sff[*can_id];
410 return &dev_rcv_lists->rx[RX_FIL];
414 * can_rx_register - subscribe CAN frames from a specific interface
430 * The filter can be inverted (CAN_INV_FILTER bit set in can_id) or it can
441 * -ENOMEM on missing cache mem to create subscription entry
442 * -ENODEV unknown device
451 struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
453 /* insert new receiver (dev,canid,mask) -> (func,data) */
455 if (dev && (dev->type != ARPHRD_CAN || !can_get_ml_priv(dev)))
456 return -ENODEV;
459 return -ENODEV;
463 return -ENOMEM;
465 spin_lock_bh(&net->can.rcvlists_lock);
470 rcv->can_id = can_id;
471 rcv->mask = mask;
472 rcv->matches = 0;
473 rcv->func = func;
474 rcv->data = data;
475 rcv->ident = ident;
476 rcv->sk = sk;
478 hlist_add_head_rcu(&rcv->list, rcv_list);
479 dev_rcv_lists->entries++;
481 rcv_lists_stats->rcv_entries++;
482 rcv_lists_stats->rcv_entries_max = max(rcv_lists_stats->rcv_entries_max,
483 rcv_lists_stats->rcv_entries);
484 spin_unlock_bh(&net->can.rcvlists_lock);
490 /* can_rx_delete_receiver - rcu callback for single receiver entry removal */
494 struct sock *sk = rcv->sk;
502 * can_rx_unregister - unsubscribe CAN frames from a specific interface
519 struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;
522 if (dev && dev->type != ARPHRD_CAN)
528 spin_lock_bh(&net->can.rcvlists_lock);
538 if (rcv->can_id == can_id && rcv->mask == mask &&
539 rcv->func == func && rcv->data == data)
555 hlist_del_rcu(&rcv->list);
556 dev_rcv_lists->entries--;
558 if (rcv_lists_stats->rcv_entries > 0)
559 rcv_lists_stats->rcv_entries--;
562 spin_unlock_bh(&net->can.rcvlists_lock);
566 if (rcv->sk)
567 sock_hold(rcv->sk);
568 call_rcu(&rcv->rcu, can_rx_delete_receiver);
575 rcv->func(skb, rcv->data);
576 rcv->matches++;
583 struct can_frame *cf = (struct can_frame *)skb->data;
584 canid_t can_id = cf->can_id;
586 if (dev_rcv_lists->entries == 0)
591 hlist_for_each_entry_rcu(rcv, &dev_rcv_lists->rx[RX_ERR], list) {
592 if (can_id & rcv->mask) {
601 hlist_for_each_entry_rcu(rcv, &dev_rcv_lists->rx[RX_ALL], list) {
607 hlist_for_each_entry_rcu(rcv, &dev_rcv_lists->rx[RX_FIL], list) {
608 if ((can_id & rcv->mask) == rcv->can_id) {
614 /* check for inverted can_id/mask entries */
615 hlist_for_each_entry_rcu(rcv, &dev_rcv_lists->rx[RX_INV], list) {
616 if ((can_id & rcv->mask) != rcv->can_id) {
622 /* check filterlists for single non-RTR can_ids */
627 hlist_for_each_entry_rcu(rcv, &dev_rcv_lists->rx_eff[effhash(can_id)], list) {
628 if (rcv->can_id == can_id) {
635 hlist_for_each_entry_rcu(rcv, &dev_rcv_lists->rx_sff[can_id], list) {
648 struct can_pkg_stats *pkg_stats = net->can.pkg_stats;
652 atomic_long_inc(&pkg_stats->rx_frames);
653 atomic_long_inc(&pkg_stats->rx_frames_delta);
655 /* create non-zero unique skb identifier together with *skb */
656 while (!(can_skb_prv(skb)->skbcnt))
657 can_skb_prv(skb)->skbcnt = atomic_inc_return(&skbcounter);
662 matches = can_rcv_filter(net->can.rx_alldev_list, skb);
674 atomic_long_inc(&pkg_stats->matches);
675 atomic_long_inc(&pkg_stats->matches_delta);
682 if (unlikely(dev->type != ARPHRD_CAN || !can_get_ml_priv(dev) || !can_is_can_skb(skb))) {
684 dev->type, skb->len);
697 if (unlikely(dev->type != ARPHRD_CAN || !can_get_ml_priv(dev) || !can_is_canfd_skb(skb))) {
699 dev->type, skb->len);
712 if (unlikely(dev->type != ARPHRD_CAN || !can_get_ml_priv(dev) || !can_is_canxl_skb(skb))) {
714 dev->type, skb->len);
727 * can_proto_register - register CAN transport protocol
732 * -EINVAL invalid (out of range) protocol number
733 * -EBUSY protocol already in use
734 * -ENOBUF if proto_register() fails
738 int proto = cp->protocol;
743 return -EINVAL;
746 err = proto_register(cp->prot, 0);
754 err = -EBUSY;
762 proto_unregister(cp->prot);
769 * can_proto_unregister - unregister CAN transport protocol
774 int proto = cp->protocol;
783 proto_unregister(cp->prot);
789 spin_lock_init(&net->can.rcvlists_lock);
790 net->can.rx_alldev_list =
791 kzalloc(sizeof(*net->can.rx_alldev_list), GFP_KERNEL);
792 if (!net->can.rx_alldev_list)
794 net->can.pkg_stats = kzalloc(sizeof(*net->can.pkg_stats), GFP_KERNEL);
795 if (!net->can.pkg_stats)
797 net->can.rcv_lists_stats = kzalloc(sizeof(*net->can.rcv_lists_stats), GFP_KERNEL);
798 if (!net->can.rcv_lists_stats)
804 timer_setup(&net->can.stattimer, can_stat_update,
806 mod_timer(&net->can.stattimer,
809 net->can.pkg_stats->jiffies_init = jiffies;
816 kfree(net->can.pkg_stats);
818 kfree(net->can.rx_alldev_list);
820 return -ENOMEM;
828 timer_delete_sync(&net->can.stattimer);
831 kfree(net->can.rx_alldev_list);
832 kfree(net->can.pkg_stats);
833 kfree(net->can.rcv_lists_stats);
881 return -ENOMEM;