can: bcm: collected fixes - final4 :-O
Subsystems (2)
Oliver Hartkopp
maintainerv9 cover can: bcm: collected fixes - final4 :-O
Hi Marc,
as there were different patches flying arround to fix CAN_BCM issues and AI assisted stuff pop's up again and again, I've created this collection to be applied.
Fixed the new issues in patch 4
- [Medium] bcm_update_stats() can be executed concurrently from different lock domains, contradicting the commit's claim of preventing races during counter reset.
- [Medium] TX operations incorrectly inherit the RX-specific statistics cap, causing premature zeroing of the TX frame counter.
Best regards,
Oliver
---
Changes in v9:
- patch 4: fixed two issues reported by sashiko-bot and mkl
https://lore.kernel.org/linux-can/[email protected]/
https://lore.kernel.org/linux-can/[email protected]/
- Link to v8: https://patch.msgid.link/[email protected]
Changes in v8:
- patch 9: fixed two issues reported by sashiko-bot:
https://lore.kernel.org/linux-can/[email protected]/
- Link to v7: https://patch.msgid.link/[email protected]
Changes in v7:
- patch 9: new: fix stale rx/tx ops after device removal reported by
sashiko-bot: https://lore.kernel.org/linux-can/[email protected]/
- patch 10: formerly patch 9 as new patch 8 & 9 belong together
- Link to v6: https://patch.msgid.link/[email protected]
Changes in v6:
- patch 1: added Tested-by: tags
- patch 3: changed commit message and comment regarding a wrong claim
about synchronous delivery from dev_queue_xmit() as remarked by
https://netdev-ai.bots.linux.dev/ai-review.html?id=6105ebab-87ef-43db-a085-7c190b9f119f
- patch 4: rebased patch 3 comment
- patch 9: new: fix data race on rx_stamp/rx_ifindex in bcm_rx_handler()
reported by sashiko-bot: https://lore.kernel.org/linux-can/[email protected]/
- Link to v5: https://patch.msgid.link/[email protected]
Changes in v5:
- patch 6: changed comment for bcm_op::bcm_tx_lock (mkl)
- patch 8: new: add missing device refcount for CAN filter removal
- Link to v4: https://patch.msgid.link/[email protected]
Changes in v4:
- incorporated more sashiko-bot concerns from v3
- patch 3: omit hrtimer_forward with zero interval
- patch 4: put bcm_update_stats() under bcm_rx_update_lock
- Link to v3: https://patch.msgid.link/[email protected]
Changes in v3:
- incorporated more sashiko-bot concerns from v2
- patch 3: make snapshot of currframe
- patch 6: add error patch for memcpy_from_msg()
- patch 7: new RTR-reply validation in bcm_rx_setup() from bcm_tx_setup()
- Link to v2: https://patch.msgid.link/[email protected]
Changes in v2:
- incorporated all sashiko-bot concerns from v1
- Link to v1: https://patch.msgid.link/[email protected]
---
Lee Jones (1):
can: bcm: defer rx_op deallocation to workqueue to fix thrtimer UAF
Oliver Hartkopp (9):
can: bcm: fix lockless bound/ifindex race and silent RX_SETUP failure
can: bcm: add locking when updating filter and timer values
can: bcm: fix CAN frame rx/tx statistics
can: bcm: add missing rcu list annotations and operations
can: bcm: extend bcm_tx_lock usage for data and timer updates
can: bcm: validate frame length in bcm_rx_setup() for RTR replies
can: bcm: add missing device refcount for CAN filter removal
can: bcm: fix stale rx/tx ops after device removal
can: bcm: fix data race on rx_stamp/rx_ifindex in bcm_rx_handler()
net/can/bcm.c | 536 +++++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 400 insertions(+), 136 deletions(-)
---
base-commit: 0e35b9b6ec0ffcc5e23cbdec09f5c622ad532b53
change-id: 20260612-bcm_fixes-84fb4aa93ac2
Best regards,
Signature · 1 line
Oliver Hartkopp <[email protected]>
Oliver Hartkopp
maintainerPATCH v9 1/10 can: bcm: defer rx_op deallocation to workqueue to fix thrtimer UAF
From: Lee Jones <[email protected]>
Commit f1b4e32aca08 ("can: bcm: use call_rcu() instead of costly synchronize_rcu()") replaced synchronize_rcu() in bcm_delete_rx_op() with call_rcu() and introduced the RX_NO_AUTOTIMER flag.
However, this flag check was omitted for thrtimer in the packet rx fast-path. During BCM RX operation teardown, a concurrent RCU reader (bcm_rx_handler) can race and re-arm thrtimer via bcm_rx_update_and_send() after call_rcu() has been scheduled. Once the RCU grace period elapses, bcm_op is freed. The subsequently firing thrtimer then dereferences the deallocated op, causing a UAF.
Adding flag checks to the rx fast-path (bcm_rx_update_and_send) does not fully close the TOCTOU race and introduces latency for every CAN frame. Conversely, calling hrtimer_cancel() directly inside the RCU callback (softirq context) is fatal as hrtimer_cancel() can sleep, triggering a "scheduling while atomic" panic.
Resolve this by deferring the timer cancellation and memory free to a dedicated unbound workqueue (bcm_wq). The RCU callback now queues a work item to bcm_wq, which safely cancels both timers and deallocates memory in sleepable process context. A dedicated workqueue is used to prevent system-wide WQ saturation and is cleanly flushed/destroyed on module unload to avoid rmmod page faults.
Since the deferred work can now outlive the calling context by an unbounded amount, also take a reference on op->sk when it is assigned and drop it only once the deferred work has cancelled both timers, so a socket can no longer be freed out from under a still-armed timer whose callback (bcm_send_to_user()) dereferences op->sk.
--- net/can/bcm.c | 37 ++++++++++++++++++++++++++++++++++--- 1 file changed, 34 insertions(+), 3 deletions(-)
net/can/bcm.c +34 -3
@@ -56,10 +56,11 @@#include <linux/can.h> #include <linux/can/core.h> #include <linux/can/skb.h> #include <linux/can/bcm.h> #include <linux/slab.h> +#include <linux/workqueue.h> #include <linux/spinlock.h> #include <net/can.h> #include <net/sock.h> #include <net/net_namespace.h>
@@ -90,10 +91,12 @@ MODULE_LICENSE("Dual BSD/GPL");MODULE_AUTHOR ("Oliver Hartkopp <[email protected]>" );MODULE_ALIAS ("can-proto-2" );#define BCM_MIN_NAMELEN CAN_REQUIRED_SIZE(struct sockaddr_can, can_ifindex) +static struct workqueue_struct *bcm_wq; +/* * easy access to the first 64 bit of can(fd)_frame payload. cp->data is * 64 bit aligned so the offset has to be multiples of 8 which is ensured * by the only callers in bcm_rx_cmp_to_index() bcm_rx_handler(). */
@@ -103,10 +106,11 @@ static inline u64 get_u64(const struct canfd_frame *cp, int offset) }struct bcm_op {struct list_head list;struct rcu_head rcu; +struct work_struct work;int ifindex;canid_t can_id;u32 flags;unsigned long frames_abs, frames_filtered;struct bcm_timeval ival1, ival2;
@@ -791,23 +795,40 @@ static struct bcm_op *bcm_find_op(struct list_head *ops, }return NULL ; } -static void bcm_free_op_rcu (struct rcu_head *rcu_head) +static void bcm_free_op_work (struct work_struct *work) { - struct bcm_op *op = container_of(rcu_head, struct bcm_op, rcu); + struct bcm_op *op = container_of(work, struct bcm_op, work); + +hrtimer_cancel (&op->timer); +hrtimer_cancel (&op->thrtimer);if ((op->frames) && (op->frames != &op->sframe))kfree (op->frames);if ((op->last_frames) && (op->last_frames != &op->last_sframe))kfree (op->last_frames); +/* the last possible access to op->timer/op->thrtimer has now +* happened above via hrtimer_cancel() - op->sk is no longer +* needed by any pending timer callback, so drop our reference +*/ +sock_put (op->sk); +kfree (op); } +static void bcm_free_op_rcu (struct rcu_head *rcu_head) +{ + struct bcm_op *op = container_of(rcu_head, struct bcm_op, rcu); + +INIT_WORK (&op->work, bcm_free_op_work); +queue_work (bcm_wq, &op->work); +} +static void bcm_remove_op (struct bcm_op *op) {hrtimer_cancel (&op->timer);hrtimer_cancel (&op->thrtimer);
@@ -1058,10 +1079,11 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,/* tx_ops never compare with previous received messages */ op->last_frames =NULL ;/* bcm_can_tx / bcm_tx_timeout_handler needs this */ op->sk = sk; +sock_hold (sk); op->ifindex = ifindex;/* initialize uninitialized (kzalloc) structure */ hrtimer_setup (&op->timer, bcm_tx_timeout_handler,CLOCK_MONOTONIC ,HRTIMER_MODE_REL_SOFT );
@@ -1219,10 +1241,11 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, } }/* bcm_can_tx / bcm_tx_timeout_handler needs this */ op->sk = sk; +sock_hold (sk); op->ifindex = ifindex;/* ifindex for timeout events w/o previous frame reception */ op->rx_ifindex = ifindex;
@@ -1837,15 +1860,19 @@ static struct notifier_block canbcm_notifier = {static int __init bcm_module_init (void ) {int err; + bcm_wq =alloc_workqueue ("can-bcm-wq" ,WQ_UNBOUND ,0 ); +if (!bcm_wq) +return -ENOMEM ; +pr_info ("can: broadcast manager protocol\n" ); err =register_pernet_subsys (&canbcm_pernet_ops);if (err) -return err; + goto register_pernet_failed; err =register_netdevice_notifier (&canbcm_notifier);if (err) goto register_notifier_failed;
@@ -1859,17 +1886,21 @@ static int __init bcm_module_init(void) register_proto_failed:unregister_netdevice_notifier (&canbcm_notifier); register_notifier_failed:unregister_pernet_subsys (&canbcm_pernet_ops); +register_pernet_failed: +destroy_workqueue (bcm_wq);return err; } static void __exit bcm_module_exit(void) {can_proto_unregister (&bcm_can_proto);unregister_netdevice_notifier (&canbcm_notifier);unregister_pernet_subsys (&canbcm_pernet_ops); +rcu_barrier (); +destroy_workqueue (bcm_wq); }module_init (bcm_module_init);module_exit (bcm_module_exit);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v9 01/10] can: bcm: defer rx_op deallocation to workqueue to fix thrtimer UAF
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [High] Module exit triggers a kmem_cache_destroy warning because the protocol slab cache is destroyed…
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [High] Module exit triggers a kmem_cache_destroy warning because the protocol slab cache is destroyed before the deferred workqueue frees the remaining sockets. --
--- Patch [1]: [PATCH v9 01/10] can: bcm: defer rx_op deallocation to workqueue to fix thrtimer UAF --- commit d847f243125a944d43b2a6970166b528eea27549
Author: Lee Jones <[email protected]>
can: bcm: defer rx_op deallocation to workqueue to fix thrtimer UAF
This commit resolves a use-after-free condition in the broadcast manager rx operation teardown. It moves the timer cancellation and memory deallocation to a dedicated unbound workqueue, and ensures the socket reference is held until the deferred work executes safely in process context.
Quoted 4 lines
net/can/bcm.c +0
-0
[ ... ]
net/can/bcm.c static void __exit bcm_module_exit(void) · line 1903
Quoted 7 lines
net/can/bcm.c +2
-0@@ -1869,6 +1898,8 @@ static void __exit bcm_module_exit(void)can_proto_unregister (&bcm_can_proto);unregister_netdevice_notifier (&canbcm_notifier);unregister_pernet_subsys (&canbcm_pernet_ops); +rcu_barrier (); +destroy_workqueue (bcm_wq); }
[Severity: High]
Will this sequence trigger a kmem_cache_destroy warning on module unload?
Since bcm_module_exit() calls can_proto_unregister() before destroy_workqueue(), the protocol slab cache is destroyed while deferred work items that release sockets back to the cache might still be pending in bcm_wq.
Should destroy_workqueue() be called before can_proto_unregister() to ensure all pending socket frees are completed prior to the protocol slab cache destruction?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
Oliver Hartkopp
maintainerPATCH v9 2/10 can: bcm: fix lockless bound/ifindex race and silent RX_SETUP failure
In reply to Oliver Hartkoppbcm_sendmsg() reads bo->ifindex and checks bo->bound before taking lock_sock(), while bcm_notify(), bcm_connect() and bcm_release() all mutate both fields under that same lock. Because the lockless reads and the locked writes are unordered with respect to each other, a racing bcm_notify() (device unregister) or bcm_connect() (concurrent bind on another thread sharing the socket) can make bcm_sendmsg() observe an inconsistent combination, e.g. a stale bound=1 together with the now-cleared ifindex=0, silently turning a socket bound to a specific CAN interface into one that also matches "any" interface.
Keep the lockless bo->bound check purely as a fast-path reject, and move the ifindex read (and a bo->bound re-check) into the locked section, where every writer already serializes. This removes the possibility of observing the two fields torn against each other, rather than trying to fix it with more READ_ONCE()/WRITE_ONCE() pairs on two independently updated fields. Annotate the now-purely-lockless bo->bound accesses consistently across all its write sites.
Also fix bcm_rx_setup() silently returning success when the target device disappears concurrently instead of reporting -ENODEV, so a broken RX op is no longer left registered as if it had succeeded.
--- net/can/bcm.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 51 insertions(+), 14 deletions(-)
net/can/bcm.c +51 -14
@@ -1321,10 +1321,15 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, bcm_rx_handler, op, "bcm", sk); op->rx_reg_dev = dev;dev_put (dev); + }else { +/* the requested device is gone - do not +* silently succeed without registering +*/ + err = -ENODEV ; } }else err = can_rx_register(sock_net(sk), NULL, op->can_id, REGMASK(op->can_id),
@@ -1394,16 +1399,17 @@ static int bcm_tx_send(struct msghdr *msg, int ifindex, struct sock *sk,*/ static int bcm_sendmsg (struct socket *sock,struct msghdr *msg,size_t size) {struct sock *sk = sock->sk;struct bcm_sock *bo =bcm_sk (sk); -int ifindex = bo->ifindex;/* default ifindex for this bcm_op */ +int ifindex;struct bcm_msg_head msg_head;int cfsiz;int ret;/* read bytes or error codes as return value */ -if (!bo->bound) +/* Lockless fast-path check for bound socket */ +if (!READ_ONCE (bo->bound))return -ENOTCONN ;/* check for valid message length from userspace */ if (size <MHSIZ )return -EINVAL ;
@@ -1415,43 +1421,65 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) cfsiz =CFSIZ (msg_head.flags);if ((size -MHSIZ ) % cfsiz)return -EINVAL ; +lock_sock (sk); + +/* Re-validate under the socket lock: a concurrent bcm_notify() +* may have unbound this socket (device removal) after the +* lockless fast-path check above. bo->ifindex is only ever +* mutated under lock_sock(), so reading it here - instead of +* before taking the lock - guarantees it can't be observed +* torn against bo->bound. +*/ +if (!bo->bound) { + ret = -ENOTCONN ; + goto out_release; + } + +/* default ifindex for this bcm_op */ + ifindex = bo->ifindex; +/* check for alternative ifindex for this bcm_op */ if (!ifindex && msg->msg_name) {/* no bound device as default => check msg_name */ DECLARE_SOCKADDR(struct sockaddr_can *, addr, msg->msg_name); -if (msg->msg_namelen <BCM_MIN_NAMELEN ) -return -EINVAL ; +if (msg->msg_namelen <BCM_MIN_NAMELEN ) { + ret = -EINVAL ; + goto out_release; + } -if (addr->can_family !=AF_CAN ) -return -EINVAL ; +if (addr->can_family !=AF_CAN ) { + ret = -EINVAL ; + goto out_release; + }/* ifindex from sendto() */ ifindex = addr->can_ifindex;if (ifindex) {struct net_device *dev; dev =dev_get_by_index (sock_net (sk), ifindex); -if (!dev) -return -ENODEV ; +if (!dev) { + ret = -ENODEV ; + goto out_release; + }if (dev->type !=ARPHRD_CAN ) {dev_put (dev); -return -ENODEV ; + ret = -ENODEV ; + goto out_release; }dev_put (dev); } } -lock_sock (sk); -switch (msg_head.opcode) {case TX_SETUP : ret =bcm_tx_setup (&msg_head, msg, ifindex, sk);break ;
@@ -1497,10 +1525,11 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)default : ret = -EINVAL ;break ; } +out_release:release_sock (sk);return ret; }
@@ -1533,11 +1562,16 @@ static void bcm_notify(struct bcm_sock *bo, unsigned long msg,if (sock_net (sk)->can.bcmproc_dir && bo->bcm_proc_read) {remove_proc_entry (bo->procname,sock_net (sk)->can.bcmproc_dir); bo->bcm_proc_read =NULL ; }#endif - bo->bound =0 ; +/* Paired with the lockless fast-path check in +* bcm_sendmsg(); bo->ifindex itself is only ever +* accessed under lock_sock() so it needs no +* annotation. +*/ +WRITE_ONCE (bo->bound,0 ); bo->ifindex =0 ; notify_enodev =1 ; }release_sock (sk);
@@ -1674,11 +1708,11 @@ static int bcm_release(struct socket *sock)list_for_each_entry_safe (op, next, &bo->rx_ops, list)bcm_remove_op (op);/* remove device reference */ if (bo->bound) { - bo->bound =0 ; +WRITE_ONCE (bo->bound,0 ); bo->ifindex =0 ; }sock_orphan (sk); sock->sk =NULL ;
@@ -1744,11 +1778,14 @@ static int bcm_connect(struct socket *sock, struct sockaddr_unsized *uaddr, int goto fail; } }#endif /* CONFIG_PROC_FS */ - bo->bound =1 ; +/* bo->ifindex above is fully assigned before this point; pairs +* with the lockless fast-path check in bcm_sendmsg() +*/ +WRITE_ONCE (bo->bound,1 ); fail:release_sock (sk);return ret;
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v9 02/10] can: bcm: fix lockless bound/ifindex race and silent RX_SETUP failure
Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
Pre-existing issues:
- [High] Unsafe lockless list traversal and missing memory barriers for tx_ops and rx_ops lists.
- [High] Unbounded allocation of bcm_op structures allows local users to exhaust kernel memory.
- [Medium] bcm_rx_setup() silently fails to resume frame delivery for an updated RX operation if the target network device was previously unregistered.
- [Medium] Data race on bo->ifindex and bo->bound during NETDEV_DOWN handling risks torn reads and spurious errors.
--
--- Patch [2]: [PATCH v9 02/10] can: bcm: fix lockless bound/ifindex race and silent RX_SETUP failure --- commit 48dc89358d05a6bfc0097f061749b853a77c5328
Author: Oliver Hartkopp <[email protected]>
Subject: can: bcm: fix lockless bound/ifindex race and silent RX_SETUP failure
This commit fixes a data race between lockless reads of bo->bound and bo->ifindex in bcm_sendmsg() and locked updates in bcm_notify() and other paths. It also addresses a silent failure in bcm_rx_setup() when the requested target device concurrently disappears.
net/can/bcm.c static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, · line 1331
Quoted 13 lines
net/can/bcm.c +5
-0@@ -1323,6 +1323,11 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, op->rx_reg_dev = dev;dev_put (dev); + }else { +/* the requested device is gone - do not +* silently succeed without registering +*/ + err = -ENODEV ; }
[Severity: High]
This is a pre-existing issue, but does the current iteration logic for bo->tx_ops and bo->rx_ops in bcm_proc_show() risk wild memory accesses or infinite loops?
bcm_proc_show() iterates over the operations holding only rcu_read_lock():
net/can/bcm.c:bcm_proc_show() {
...
list_for_each_entry_rcu(op, &bo->rx_ops, list) { ... }
...
list_for_each_entry(op, &bo->tx_ops, list) { ... }
}Meanwhile, bcm_rx_setup() and bcm_tx_setup() insert new elements without an RCU write memory barrier:
net/can/bcm.c:bcm_rx_setup() {
...
/* add this bcm_op to the list of the rx_ops */
list_add(&op->list, &bo->rx_ops);
}Could this allow a local user reading /proc/net/can-bcm to crash the system while operations are concurrently registered?
[Severity: High]
This isn't a bug introduced by this patch, but is it possible for local users to exhaust kernel memory by creating a large number of BCM operations?
In bcm_rx_setup() and bcm_tx_setup(), new operation structures and their associated frame arrays are allocated unboundedly:
net/can/bcm.c:bcm_rx_setup() {
...
op = kzalloc(OPSIZ, GFP_KERNEL);
...
op->frames = kmalloc_array(msg_head->nframes, op->cfsiz, GFP_KERNEL);
}Since these allocations do not appear to enforce any per-socket limit or charge the socket's memory quota (sk_rmem_alloc/sk_wmem_alloc), could an unprivileged user repeatedly call sendmsg() with unique can_ids to trigger an out-of-memory panic?
[Severity: Medium]
This is a pre-existing issue, but does bcm_rx_setup() silently fail to resume frame delivery for updated RX operations if the target interface was cycled?
When an interface is removed, bcm_notify() handles NETDEV_UNREGISTER by unregistering the filter and setting op->rx_reg_dev = NULL, but leaves the op in the active bo->rx_ops list:
net/can/bcm.c:bcm_rx_unreg() {
...
/* mark as removed subscription */
op->rx_reg_dev = NULL;
}If an RX_SETUP request subsequently attempts to update this existing filter, bcm_rx_setup() skips re-registration:
net/can/bcm.c:bcm_rx_setup() {
...
/* Only an update -> do not call can_rx_register() */
do_rx_register = 0;
}Should this logic check if the operation is currently unregistered before clearing do_rx_register?
[ ... ]
Quoted 4 lines
net/can/bcm.c +0
-0@@ -1535,7 +1564,12 @@ static void bcm_notify(struct bcm_sock *bo, unsigned long msg, bo->bcm_proc_read = NULL; }#endif
net/can/bcm.c static void bcm_notify(struct bcm_sock *bo, unsigned long msg, · line 1575
Quoted 10 lines
net/can/bcm.c +6
-1- bo->bound =0 ; +/* Paired with the lockless fast-path check in +* bcm_sendmsg(); bo->ifindex itself is only ever +* accessed under lock_sock() so it needs no +* annotation. +*/ +WRITE_ONCE (bo->bound,0 ); bo->ifindex =0 ; notify_enodev =1 ; }
[Severity: Medium]
This isn't a bug introduced by this patch, but does the handling of NETDEV_DOWN in bcm_notify() have a data race on bo->ifindex and bo->bound?
While the target patch adds WRITE_ONCE() for bo->bound during device removal, NETDEV_DOWN appears to read these fields locklessly:
net/can/bcm.c:bcm_notify() {
...
case NETDEV_DOWN:
if (bo->bound && bo->ifindex == dev->ifindex) {
}If a socket is connecting to a new device while an unrelated device goes down, could the lack of barriers allow bcm_notify() to observe a new bo->bound=1 but the old bo->ifindex, leading to a spurious ENETDOWN error?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
Oliver Hartkopp
maintainerPATCH v9 3/10 can: bcm: add locking when updating filter and timer values
In reply to Oliver HartkoppKCSAN detected a simultaneous access to timer values that can be overwritten in bcm_rx_setup() when updating timer and filter content while bcm_rx_handler(), bcm_rx_timeout_handler() or bcm_rx_thr_handler() run concurrently on incoming CAN traffic.
Protect the timer (ival1/ival2/kt_ival1/kt_ival2/kt_lastmsg) and filter (nframes/flags/frames/last_frames) updates in bcm_rx_setup() with a new per-op bcm_rx_update_lock, taken with the matching scope in the RX handlers. memcpy_from_msg() is staged into a temporary buffer before the lock is taken, since it can sleep and must not run under a spinlock.
hrtimer_cancel() is always called without bcm_rx_update_lock held, since bcm_rx_timeout_handler()/bcm_rx_thr_handler() take the same lock and a running callback would otherwise deadlock against the canceller.
Also close a related race: bcm_rx_setup() cleared the RTR flag in the stored reply frame's can_id as a separate, unprotected step after the frame content was already installed, so a concurrent bcm_rx_handler() could transmit a stale reply with CAN_RTR_FLAG still set. Fold that normalization into the initial frame preparation instead (on the staged buffer for updates, directly on op->frames pre-registration for new ops), so the installed frame is always atomically self-consistent.
bcm_rx_handler()'s RX_RTR_FRAME check now takes a lock-protected snapshot of op->flags before deciding whether to call bcm_can_tx(), but does not hold the lock across that call.
Also take a lock-protected snapshot of the currframe in bcm_can_tx() to avoid partly overwrites by content updates in bcm_tx_setup().
Omit calling hrtimer_forward() with zero interval in bcm_rx_thr_handler(). kt_ival2 may have been concurrently cleared by bcm_rx_setup() before it cancels this timer, so check kt_ival2 inside the bcm_rx_update_lock.
--- net/can/bcm.c | 136 ++++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 104 insertions(+), 32 deletions(-)
net/can/bcm.c +104 -32
@@ -127,10 +127,11 @@ struct bcm_op {struct canfd_frame sframe;struct canfd_frame last_sframe;struct sock *sk;struct net_device *rx_reg_dev;spinlock_t bcm_tx_lock;/* protect currframe/count in runtime updates */ +spinlock_t bcm_rx_update_lock;/* protect filter/timer data updates */ };struct bcm_sock {struct sock sk;int bound;
@@ -291,26 +292,30 @@ static int bcm_proc_show(struct seq_file *m, void *v)/* * bcm_can_tx - send the (next) CAN frame to the appropriate CAN interface * of the given bcm tx op */ -static void bcm_can_tx (struct bcm_op *op) +static void bcm_can_tx (struct bcm_op *op,struct canfd_frame *cf) {struct sk_buff *skb;struct can_skb_ext *csx;struct net_device *dev; -struct canfd_frame *cf; +struct canfd_frame cframe;int err;/* no target device? => exit */ if (!op->ifindex)return ; -/* read currframe under lock protection */ -spin_lock_bh (&op->bcm_tx_lock); - cf = op->frames + op->cfsiz * op->currframe; -spin_unlock_bh (&op->bcm_tx_lock); +if (!cf) { +/* read currframe under lock protection */ +spin_lock_bh (&op->bcm_tx_lock); +memcpy (&cframe, op->frames + op->cfsiz * op->currframe, + op->cfsiz); + cf = &cframe; +spin_unlock_bh (&op->bcm_tx_lock); + } dev =dev_get_by_index (sock_net (op->sk), op->ifindex);if (!dev) {/* RFC: should this bcm_op remove itself here? */ return ;
@@ -459,11 +464,11 @@ static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer) { struct bcm_op *op = container_of(hrtimer, struct bcm_op, timer);struct bcm_msg_head msg_head;if (op->kt_ival1 && (op->count >0 )) { -bcm_can_tx (op); +bcm_can_tx (op,NULL );if (!op->count && (op->flags &TX_COUNTEVT )) {/* create notification to user */ memset (&msg_head,0 ,sizeof (msg_head)); msg_head.opcode =TX_EXPIRED ;
@@ -476,11 +481,11 @@ static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer)bcm_send_to_user (op, &msg_head,NULL ,0 ); } }else if (op->kt_ival2) { -bcm_can_tx (op); +bcm_can_tx (op,NULL ); }return bcm_tx_set_expiry (op, &op->timer) ?HRTIMER_RESTART :HRTIMER_NORESTART ; }
@@ -620,10 +625,12 @@ static void bcm_rx_starttimer(struct bcm_op *op)static enum hrtimer_restart bcm_rx_timeout_handler (struct hrtimer *hrtimer) { struct bcm_op *op = container_of(hrtimer, struct bcm_op, timer);struct bcm_msg_head msg_head; +spin_lock_bh (&op->bcm_rx_update_lock); +/* if user wants to be informed, when cyclic CAN-Messages come back */ if ((op->flags &RX_ANNOUNCE_RESUME ) && op->last_frames) {/* clear received CAN frames to indicate 'nothing received' */ memset (op->last_frames,0 , op->nframes * op->cfsiz); }
@@ -636,10 +643,12 @@ static enum hrtimer_restart bcm_rx_timeout_handler(struct hrtimer *hrtimer) msg_head.ival1 = op->ival1; msg_head.ival2 = op->ival2; msg_head.can_id = op->can_id; msg_head.nframes =0 ; +spin_unlock_bh (&op->bcm_rx_update_lock); +bcm_send_to_user (op, &msg_head,NULL ,0 );return HRTIMER_NORESTART ; }
@@ -684,30 +693,43 @@ static int bcm_rx_thr_flush(struct bcm_op *op)* Check for throttled data and send it to the userspace */ static enum hrtimer_restart bcm_rx_thr_handler (struct hrtimer *hrtimer) { struct bcm_op *op = container_of(hrtimer, struct bcm_op, thrtimer); +enum hrtimer_restart ret; + +spin_lock_bh (&op->bcm_rx_update_lock); -if (bcm_rx_thr_flush (op)) { +/* kt_ival2 may have been concurrently cleared by bcm_rx_setup() +* before it cancels this timer - never forward with a zero +* interval in that case. +*/ +if (bcm_rx_thr_flush (op) && op->kt_ival2) {hrtimer_forward_now (hrtimer, op->kt_ival2); -return HRTIMER_RESTART ; + ret =HRTIMER_RESTART ; }else {/* rearm throttle handling */ op->kt_lastmsg =0 ; -return HRTIMER_NORESTART ; + ret =HRTIMER_NORESTART ; } + +spin_unlock_bh (&op->bcm_rx_update_lock); + +return ret; }/* * bcm_rx_handler - handle a CAN frame reception */ static void bcm_rx_handler (struct sk_buff *skb,void *data) {struct bcm_op *op = (struct bcm_op *)data;const struct canfd_frame *rxframe = (struct canfd_frame *)skb->data; +struct canfd_frame rtrframe;unsigned int i;unsigned char traffic_flags; +bool rtr_frame;if (op->can_id != rxframe->can_id)return ;/* make sure to handle the correct frame type (CAN / CAN FD) */
@@ -727,13 +749,22 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data)/* save originator for recvfrom() */ op->rx_ifindex = skb->dev->ifindex;/* update statistics */ op->frames_abs++; -if (op->flags &RX_RTR_FRAME ) { +/* snapshot the flag under lock: op->flags/op->frames may be updated +* concurrently by bcm_rx_setup(). +*/ +spin_lock_bh (&op->bcm_rx_update_lock); + rtr_frame = op->flags &RX_RTR_FRAME ; +if (rtr_frame) +memcpy (&rtrframe, op->frames, op->cfsiz); +spin_unlock_bh (&op->bcm_rx_update_lock); + +if (rtr_frame) {/* send reply for RTR-request (placed in op->frames[0]) */ -bcm_can_tx (op); +bcm_can_tx (op, &rtrframe);return ; }/* compute flags to distinguish between own/local/remote CAN traffic */ traffic_flags =0 ;
@@ -741,10 +772,12 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data) traffic_flags |=RX_LOCAL ;if (skb->sk == op->sk) traffic_flags |=RX_OWN ; } +spin_lock_bh (&op->bcm_rx_update_lock); +if (op->flags &RX_FILTER_ID ) {/* the easiest case */ bcm_rx_update_and_send (op, op->last_frames, rxframe, traffic_flags); goto rx_starttimer;
@@ -776,10 +809,12 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data) } } rx_starttimer:bcm_rx_starttimer (op); + +spin_unlock_bh (&op->bcm_rx_update_lock); }/* * helpers for bcm_op handling: find & delete bcm [rx|tx] op elements */
@@ -1114,11 +1149,11 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,/* spec: send CAN frame when starting timer */ op->flags |=TX_ANNOUNCE ; }if (op->flags &TX_ANNOUNCE ) -bcm_can_tx (op); +bcm_can_tx (op,NULL );if (op->flags &STARTTIMER )bcm_tx_start_timer (op);return msg_head->nframes * op->cfsiz +MHSIZ ;
@@ -1128,10 +1163,28 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,kfree (op->frames);kfree (op);return err; } +static void bcm_rx_setup_rtr_check (struct bcm_msg_head *msg_head, +struct bcm_op *op,void *new_frames) +{ +/* funny feature in RX(!)_SETUP only for RTR-mode: +* copy can_id into frame BUT without RTR-flag to +* prevent a full-load-loopback-test ... ;-] +* normalize this on the staged buffer, before it is +* ever installed into op->frames. +*/ +if (msg_head->flags &RX_RTR_FRAME ) { +struct canfd_frame *frame0 = new_frames; + +if ((msg_head->flags &TX_CP_CAN_ID ) || + frame0->can_id == op->can_id) + frame0->can_id = op->can_id & ~CAN_RTR_FLAG ; + } +} +/* * bcm_rx_setup - create or update a bcm rx op (for bcm_sendmsg) */ static int bcm_rx_setup (struct bcm_msg_head *msg_head,struct msghdr *msg,int ifindex,struct sock *sk)
@@ -1162,10 +1215,12 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,return -EINVAL ;/* check the given can_id */ op =bcm_find_op (&bo->rx_ops, msg_head, ifindex);if (op) { +void *new_frames =NULL ; +/* update existing BCM operation */ /* * Do we need more space for the CAN frames than currently * allocated? -> This is a _really_ unusual use-case and
@@ -1173,33 +1228,55 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,*/ if (msg_head->nframes > op->nframes)return -E2BIG ;if (msg_head->nframes) { -/* update CAN frames content */ - err =memcpy_from_msg (op->frames, msg, +/* get new CAN frames content before locking */ + new_frames =kmalloc (msg_head->nframes * op->cfsiz, +GFP_KERNEL ); +if (!new_frames) +return -ENOMEM ; + + err =memcpy_from_msg (new_frames, msg, msg_head->nframes * op->cfsiz); -if (err <0 ) +if (err <0 ) { +kfree (new_frames);return err; + } -/* clear last_frames to indicate 'nothing received' */ -memset (op->last_frames,0 , msg_head->nframes * op->cfsiz); +bcm_rx_setup_rtr_check (msg_head, op, new_frames); } +spin_lock_bh (&op->bcm_rx_update_lock); op->nframes = msg_head->nframes; op->flags = msg_head->flags; +if (msg_head->nframes) { +/* update CAN frames content */ +memcpy (op->frames, new_frames, + msg_head->nframes * op->cfsiz); + +/* clear last_frames to indicate 'nothing received' */ +memset (op->last_frames,0 , + msg_head->nframes * op->cfsiz); + } +spin_unlock_bh (&op->bcm_rx_update_lock); + +/* free temporary frames / kfree(NULL) is safe */ +kfree (new_frames); +/* Only an update -> do not call can_rx_register() */ do_rx_register =0 ; }else {/* insert new BCM operation for the given can_id */ op =kzalloc (OPSIZ ,GFP_KERNEL );if (!op)return -ENOMEM ;spin_lock_init (&op->bcm_tx_lock); +spin_lock_init (&op->bcm_rx_update_lock); op->can_id = msg_head->can_id; op->nframes = msg_head->nframes; op->cfsiz =CFSIZ (msg_head->flags); op->flags = msg_head->flags;
@@ -1237,10 +1314,12 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,if (op->last_frames != &op->last_sframe)kfree (op->last_frames);kfree (op);return err; } + +bcm_rx_setup_rtr_check (msg_head, op, op->frames); }/* bcm_can_tx / bcm_tx_timeout_handler needs this */ op->sk = sk;sock_hold (sk);
@@ -1264,45 +1343,38 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, }/* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */ /* check flags */ if (op->flags &RX_RTR_FRAME ) { -struct canfd_frame *frame0 = op->frames; -/* no timers in RTR-mode */ hrtimer_cancel (&op->thrtimer);hrtimer_cancel (&op->timer); - -/* -* funny feature in RX(!)_SETUP only for RTR-mode: -* copy can_id into frame BUT without RTR-flag to -* prevent a full-load-loopback-test ... ;-] -*/ -if ((op->flags &TX_CP_CAN_ID ) || - (frame0->can_id == op->can_id)) - frame0->can_id = op->can_id & ~CAN_RTR_FLAG ; - }else {if (op->flags &SETTIMER ) {/* set timer value */ +spin_lock_bh (&op->bcm_rx_update_lock); op->ival1 = msg_head->ival1; op->ival2 = msg_head->ival2; op->kt_ival1 =bcm_timeval_to_ktime (msg_head->ival1); op->kt_ival2 =bcm_timeval_to_ktime (msg_head->ival2); + op->kt_lastmsg =0 ; +spin_unlock_bh (&op->bcm_rx_update_lock);/* disable an active timer due to zero value? */ if (!op->kt_ival1)hrtimer_cancel (&op->timer);/* * In any case cancel the throttle timer, flush * potentially blocked msgs and reset throttle handling */ - op->kt_lastmsg =0 ;hrtimer_cancel (&op->thrtimer); + +spin_lock_bh (&op->bcm_rx_update_lock);bcm_rx_thr_flush (op); +spin_unlock_bh (&op->bcm_rx_update_lock); }if ((op->flags &STARTTIMER ) && op->kt_ival1)hrtimer_start (&op->timer, op->kt_ival1,HRTIMER_MODE_REL_SOFT );
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v9 03/10] can: bcm: add locking when updating filter and timer values
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [Medium] Lockless updates of RX metadata (rx_stamp, rx_ifindex, frames_abs) lead to torn reads, lost increments, and corrupted timestamps. --
--- Patch [3]: [PATCH v9 03/10] can: bcm: add locking when updating filter and timer values --- commit 10b4ca432b89b6bdfb7aab7948a13f81a6bc41ed
Author: Oliver Hartkopp <[email protected]>
can: bcm: add locking when updating filter and timer values
This commit introduces bcm_rx_update_lock to protect the filter and timer configurations of a bcm_op structure from concurrent accesses. It ensures that updates via bcm_rx_setup and usages in Rx and timeout handlers do not race.
Quoted 4 lines
net/can/bcm.c +0
-0
[ ... ]
net/can/bcm.c static void bcm_rx_handler(struct sk_buff *skb, void *data) · line 757
Quoted 9 lines
net/can/bcm.c +4
-1@@ -729,9 +751,18 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data)/* update statistics */ op->frames_abs++; -if (op->flags &RX_RTR_FRAME ) { +/* snapshot the flag under lock: op->flags/op->frames may be updated +* concurrently by bcm_rx_setup(). +*/ +spin_lock_bh (&op->bcm_rx_update_lock);
[Severity: Medium]
This is a pre-existing issue, but should the update to op->frames_abs be protected by the new bcm_rx_update_lock?
If a bcm_op is configured to listen on all interfaces (ifindex == 0) and receives frames concurrently on multiple CAN interfaces, bcm_rx_handler() can execute simultaneously on different CPUs.
Because op->frames_abs is updated outside the lock, concurrent writes can occur, potentially leading to lost statistical increments. Additionally, on 32-bit systems, concurrent writes to 64-bit metadata fields like op->rx_stamp could lead to torn reads when userspace retrieves them.
Could these metadata fields be moved inside the lock to prevent data races?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=3
Oliver Hartkopp
maintainerPATCH v9 4/10 can: bcm: fix CAN frame rx/tx statistics
In reply to Oliver HartkoppKCSAN detected a data race within the bcm_rx_handler() when two CAN frames have been simultaneously received and processed in a single rx op by two different CPUs.
Use atomic operations with (signed) long data types to access the statistics in the hot path to fix the KCSAN complaint.
Additionally simplify the update and check of statistics overflow by using the atomic operations in separate bcm_update_[rx|tx]_stats() functions. The rx variant runs under bcm_rx_update_lock to prevent races when resetting the two rx counters; the tx variant runs under bcm_tx_lock and only needs to guard its own counter's overflow.
As the rx path resets its values already at LONG_MAX / 100, there is no conflict between the two locking domains (bcm_rx_update_lock vs. bcm_tx_lock) even for ops that use both paths.
--- net/can/bcm.c | 56 +++++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 39 insertions(+), 17 deletions(-)
net/can/bcm.c +39 -17
@@ -110,11 +110,11 @@ struct bcm_op {struct rcu_head rcu;struct work_struct work;int ifindex;canid_t can_id;u32 flags; -unsigned long frames_abs, frames_filtered; +atomic_long_t frames_abs, frames_filtered;struct bcm_timeval ival1, ival2;struct hrtimer timer, thrtimer;ktime_t rx_stamp, kt_ival1, kt_ival2, kt_lastmsg;int rx_ifindex;int cfsiz;
@@ -227,14 +227,17 @@ static int bcm_proc_show(struct seq_file *m, void *v)rcu_read_lock ();list_for_each_entry_rcu (op, &bo->rx_ops, list) { -unsigned long reduction; +long reduction, frames_filtered, frames_abs; + + frames_filtered =atomic_long_read (&op->frames_filtered); + frames_abs =atomic_long_read (&op->frames_abs);/* print only active entries & prevent division by zero */ -if (!op->frames_abs) +if (!frames_abs)continue ;seq_printf (m,"rx_op: %03X %-5s " , op->can_id,bcm_proc_getifname (net, ifname, op->ifindex));
@@ -252,13 +255,13 @@ static int bcm_proc_show(struct seq_file *m, void *v)if (op->kt_ival2)seq_printf (m,"thr=%lld " , (long long )ktime_to_us (op->kt_ival2));seq_printf (m,"# recv %ld (%ld) => reduction: " , - op->frames_filtered, op->frames_abs); + frames_filtered, frames_abs); - reduction =100 - (op->frames_filtered *100 ) / op->frames_abs; + reduction =100 - (frames_filtered *100 ) / frames_abs;seq_printf (m,"%s%ld%%\n" , (reduction ==100 ) ?"near " :"" , reduction); }
@@ -278,20 +281,39 @@ static int bcm_proc_show(struct seq_file *m, void *v)if (op->kt_ival2)seq_printf (m,"t2=%lld " , (long long )ktime_to_us (op->kt_ival2)); - seq_printf(m, "# sent %ld\n", op->frames_abs); +seq_printf (m,"# sent %ld\n" , + atomic_long_read(&op->frames_abs)); }seq_putc (m,'\n' );rcu_read_unlock ();return 0 ; }#endif /* CONFIG_PROC_FS */ +static void bcm_update_rx_stats (struct bcm_op *op) +{ +/* prevent overflow of the reduction% calculation in bcm_proc_show() */ +if (atomic_long_inc_return (&op->frames_abs) >LONG_MAX /100 ) { +atomic_long_set (&op->frames_filtered,0 ); +atomic_long_set (&op->frames_abs,0 ); + } +} + +static void bcm_update_tx_stats (struct bcm_op *op) +{ +/* tx_op has no reduction% calculation - use the full range and +* just keep the displayed counter non-negative on overflow +*/ +if (atomic_long_inc_return (&op->frames_abs) ==LONG_MAX ) +atomic_long_set (&op->frames_abs,0 ); +} +/* * bcm_can_tx - send the (next) CAN frame to the appropriate CAN interface * of the given bcm tx op */ static void bcm_can_tx (struct bcm_op *op,struct canfd_frame *cf)
@@ -342,11 +364,11 @@ static void bcm_can_tx(struct bcm_op *op, struct canfd_frame *cf)/* update currframe and count under lock protection */ spin_lock_bh (&op->bcm_tx_lock);if (!err) - op->frames_abs++; +bcm_update_tx_stats (op); op->currframe++;/* reached last frame? */ if (op->currframe >= op->nframes)
@@ -495,16 +517,13 @@ static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer)*/ static void bcm_rx_changed (struct bcm_op *op,struct canfd_frame *data) {struct bcm_msg_head head; -/* update statistics */ - op->frames_filtered++; - -/* prevent statistics overflow */ -if (op->frames_filtered >ULONG_MAX /100 ) - op->frames_filtered = op->frames_abs =0 ; +/* update statistics (frames_filtered <= frames_abs) */ +if (atomic_long_read (&op->frames_abs)) +atomic_long_inc (&op->frames_filtered);/* this element is not throttled anymore */ data->flags &= ~RX_THR ;memset (&head,0 ,sizeof (head));
@@ -746,20 +765,23 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data)/* save rx timestamp */ op->rx_stamp = skb->tstamp;/* save originator for recvfrom() */ op->rx_ifindex = skb->dev->ifindex; -/* update statistics */ - op->frames_abs++; -/* snapshot the flag under lock: op->flags/op->frames may be updated -* concurrently by bcm_rx_setup(). +/* snapshot RTR content under lock: op->flags/op->frames may be +* updated concurrently by bcm_rx_setup(). */ spin_lock_bh (&op->bcm_rx_update_lock); + +/* update statistics with lock analogue to bcm_rx_changed() callers */ +bcm_update_rx_stats (op); + rtr_frame = op->flags &RX_RTR_FRAME ;if (rtr_frame)memcpy (&rtrframe, op->frames, op->cfsiz); +spin_unlock_bh (&op->bcm_rx_update_lock);if (rtr_frame) {/* send reply for RTR-request (placed in op->frames[0]) */ bcm_can_tx (op, &rtrframe);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v9 04/10] can: bcm: fix CAN frame rx/tx statistics
Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider:
New issues:
- [Medium] Lock dropping in bcm_rx_handler() allows frames_filtered to temporarily exceed frames_abs, breaking the invariant and causing negative reduction percentage calculations.
Pre-existing issues:
- [High] bcm_tx_setup modifies ktime_t timers, flags, and frames without holding bcm_tx_lock, allowing concurrent timers to read torn or corrupted data.
- [High] bcm_rx_handler races on op->rx_stamp and op->rx_ifindex updates outside bcm_rx_update_lock.
- [High] list_add() is used instead of list_add_rcu() when adding newly initialized bcm_op elements to the RCU-protected lists bo->tx_ops and bo->rx_ops. --
--- Patch [4]: [PATCH v9 04/10] can: bcm: fix CAN frame rx/tx statistics --- commit fe57f26f76b6c7f7c4b5702be973bf0265c694f1
Author: Oliver Hartkopp <[email protected]>
can: bcm: fix CAN frame rx/tx statistics
This commit fixes a KCSAN data race complaint in the broadcast manager receive handler when two CAN frames are processed simultaneously. It switches to atomic types for statistics and refactors overflow handling.
Quoted 4 lines
net/can/bcm.c +0
-0
[ ... ]
net/can/bcm.c static int bcm_proc_show(struct seq_file *m, void *v) · line 230
Quoted 3 lines
net/can/bcm.c +0
-0@@ -229,10 +229,13 @@ static int bcm_proc_show(struct seq_file *m, void *v)list_for_each_entry_rcu (op, &bo->rx_ops, list) {
[Severity: High]
This isn't a bug introduced by this patch, but is it safe for bcm_rx_setup() and bcm_tx_setup() to use list_add() when inserting new elements into these lists?
Since bcm_proc_show() iterates over bo->rx_ops and bo->tx_ops using list_for_each_entry_rcu(), using list_add() instead of list_add_rcu() during insertion lacks the necessary memory barriers. Could this allow concurrent RCU readers on weakly ordered architectures to observe uninitialized fields?
[ ... ]
net/can/bcm.c static void bcm_can_tx(struct bcm_op *op, struct canfd_frame *cf) · line 371
Quoted 8 lines
net/can/bcm.c +1
-1@@ -344,7 +366,7 @@ static void bcm_can_tx(struct bcm_op *op, struct canfd_frame *cf)spin_lock_bh (&op->bcm_tx_lock);if (!err) - op->frames_abs++; +bcm_update_tx_stats (op); op->currframe++;
[Severity: High]
This is a pre-existing issue, but does bcm_tx_setup() need to hold this same bcm_tx_lock when modifying op->frames, op->flags, and the ktime_t timers?
When a user calls bcm_sendmsg() to update an existing TX op, these values are modified without the lock. If a concurrent timer fires bcm_tx_timeout_handler() or transmission occurs here via bcm_can_tx(), could it result in torn reads of 64-bit ktime_t timers on 32-bit systems, or the transmission of partially updated CAN frames?
[ ... ]
net/can/bcm.c static void bcm_rx_handler(struct sk_buff *skb, void *data) · line 769
Quoted 4 lines
net/can/bcm.c +0
-0@@ -748,16 +767,19 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data) op->rx_stamp = skb->tstamp;/* save originator for recvfrom() */ op->rx_ifindex = skb->dev->ifindex;
[Severity: High]
This is a pre-existing issue, but can these unprotected assignments cause a metadata race?
If a socket is subscribed to all interfaces (ifindex == 0) and two frames are received simultaneously on different interfaces, couldn't different CPUs concurrently overwrite op->rx_stamp and op->rx_ifindex outside of bcm_rx_update_lock? This might result in corrupted stream metadata when the frames are eventually sent to userspace.
Quoted 8 lines
net/can/bcm.c +2
-4-/* update statistics */ - op->frames_abs++; -/* snapshot the flag under lock: op->flags/op->frames may be updated -* concurrently by bcm_rx_setup(). +/* snapshot RTR content under lock: op->flags/op->frames may be +* updated concurrently by bcm_rx_setup(). */
net/can/bcm.c static void bcm_rx_handler(struct sk_buff *skb, void *data) · line 783
Quoted 10 lines
net/can/bcm.c +5
-0spin_lock_bh (&op->bcm_rx_update_lock); + +/* update statistics with lock analogue to bcm_rx_changed() callers */ +bcm_update_rx_stats (op); + rtr_frame = op->flags &RX_RTR_FRAME ;if (rtr_frame)memcpy (&rtrframe, op->frames, op->cfsiz); +spin_unlock_bh (&op->bcm_rx_update_lock);
[Severity: Medium]
Can dropping the lock here allow frames_filtered to exceed frames_abs?
CPU 1 could increment frames_abs past the limit (LONG_MAX / 100) and reset both counters to 0 inside bcm_update_rx_stats(), then drop the lock.
CPU 2 could then process a packet, acquire the lock, increment frames_abs to 1, and drop the lock.
Both CPUs would then proceed to their second lock section where bcm_rx_changed() is called. Both would increment frames_filtered because frames_abs is non-zero, leaving frames_filtered at 2 while frames_abs is 1. Wouldn't this break the invariant and cause a negative reduction percentage to be displayed in procfs?
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=4
Oliver Hartkopp
maintainerPATCH v9 5/10 can: bcm: add missing rcu list annotations and operations
In reply to Oliver Hartkoppsashiko-bot remarked the missing use of list_add_rcu() in bcm_[rx|tx]_setup() to have a proper initialized bcm_op structure when bcm_proc_show() traverses the bcm_op's under rcu_read_lock().
To cover all initial settings of the bcm_op's the list_add_rcu() calls are moved to the end of the setup code.
While at it, also fix the mirroring removal side: bcm_release() called bcm_remove_op() - which frees the op via call_rcu() - on ops that were still linked in bo->tx_ops/bo->rx_ops, without list_del_rcu() first. Unlink each op with list_del_rcu() before handing it to bcm_remove_op(), matching the existing pattern in bcm_delete_tx_op()/bcm_delete_rx_op().
--- net/can/bcm.c | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-)
net/can/bcm.c +16 -9
@@ -263,11 +263,11 @@ static int bcm_proc_show(struct seq_file *m, void *v)seq_printf (m,"%s%ld%%\n" , (reduction ==100 ) ?"near " :"" , reduction); } -list_for_each_entry (op, &bo->tx_ops, list) { +list_for_each_entry_rcu (op, &bo->tx_ops, list) {seq_printf (m,"tx_op: %03X %s " , op->can_id,bcm_proc_getifname (net, ifname, op->ifindex));if (op->flags &CAN_FD_FRAME )
@@ -1006,10 +1006,11 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, int ifindex, struct sock *sk) { struct bcm_sock *bo = bcm_sk(sk);struct bcm_op *op;struct canfd_frame *cf; +bool add_op_to_list = false;unsigned int i;int err;/* we need a real device to send frames */ if (!ifindex)
@@ -1147,12 +1148,11 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,/* currently unused in tx_ops */ hrtimer_setup (&op->thrtimer, hrtimer_dummy_timeout,CLOCK_MONOTONIC ,HRTIMER_MODE_REL_SOFT ); -/* add this bcm_op to the list of the tx_ops */ -list_add (&op->list, &bo->tx_ops); + add_op_to_list = true; }/* if ((op = bcm_find_op(&bo->tx_ops, msg_head->can_id, ifindex))) */ if (op->flags &SETTIMER ) {/* set timer values */
@@ -1170,10 +1170,14 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,hrtimer_cancel (&op->timer);/* spec: send CAN frame when starting timer */ op->flags |=TX_ANNOUNCE ; } +/* add this bcm_op to the list of the tx_ops? */ +if (add_op_to_list) +list_add_rcu (&op->list, &bo->tx_ops); +if (op->flags &TX_ANNOUNCE )bcm_can_tx (op,NULL );if (op->flags &STARTTIMER )bcm_tx_start_timer (op);
@@ -1354,13 +1358,10 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,hrtimer_setup (&op->timer, bcm_rx_timeout_handler,CLOCK_MONOTONIC ,HRTIMER_MODE_REL_SOFT );hrtimer_setup (&op->thrtimer, bcm_rx_thr_handler,CLOCK_MONOTONIC ,HRTIMER_MODE_REL_SOFT ); -/* add this bcm_op to the list of the rx_ops */ -list_add (&op->list, &bo->rx_ops); -/* call can_rx_register() */ do_rx_register =1 ; }/* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */
@@ -1428,14 +1429,16 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, err =can_rx_register (sock_net (sk),NULL , op->can_id,REGMASK (op->can_id), bcm_rx_handler, op,"bcm" , sk);if (err) {/* this bcm rx op is broken -> remove it */ -list_del_rcu (&op->list);bcm_remove_op (op);return err; } + +/* add this bcm_op to the list of the rx_ops */ +list_add_rcu (&op->list, &bo->rx_ops); }return msg_head->nframes * op->cfsiz +MHSIZ ; }
@@ -1765,12 +1768,14 @@ static int bcm_release(struct socket *sock)/* remove procfs entry */ if (net->can.bcmproc_dir && bo->bcm_proc_read)remove_proc_entry (bo->procname, net->can.bcmproc_dir);#endif /* CONFIG_PROC_FS */ -list_for_each_entry_safe (op, next, &bo->tx_ops, list) +list_for_each_entry_safe (op, next, &bo->tx_ops, list) { +list_del_rcu (&op->list);bcm_remove_op (op); + }list_for_each_entry_safe (op, next, &bo->rx_ops, list) {/* * Don't care if we're bound or not (due to netdev problems) * can_rx_unregister() is always a save thing to do here.
@@ -1797,12 +1802,14 @@ static int bcm_release(struct socket *sock) }synchronize_rcu (); -list_for_each_entry_safe (op, next, &bo->rx_ops, list) +list_for_each_entry_safe (op, next, &bo->rx_ops, list) { +list_del_rcu (&op->list);bcm_remove_op (op); + }/* remove device reference */ if (bo->bound) {WRITE_ONCE (bo->bound,0 ); bo->ifindex =0 ;
Signature · 1 line
2.53.0
Oliver Hartkopp
maintainerPATCH v9 6/10 can: bcm: extend bcm_tx_lock usage for data and timer updates
In reply to Oliver HartkoppStage new CAN frame content for an existing tx op into a kmalloc()'d buffer and validate it there, mirroring the approach already used in bcm_rx_setup(). Only copy the validated data into op->frames while holding op->bcm_tx_lock, so bcm_can_tx() and bcm_tx_timeout_handler() can no longer observe a partially updated or unvalidated frame.
Add a missing error path for memcpy_from_msg() when copying CAN frame data from userspace.
Also move the kt_ival1/kt_ival2/ival1/ival2 updates in bcm_tx_setup() under op->bcm_tx_lock, and read kt_ival1/kt_ival2/count under the same lock in bcm_tx_set_expiry() and bcm_tx_timeout_handler(), closing the torn 64-bit ktime_t read on 32-bit platforms.
--- net/can/bcm.c | 81 +++++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 57 insertions(+), 24 deletions(-)
net/can/bcm.c +57 -24
@@ -126,11 +126,11 @@ struct bcm_op {void *last_frames;struct canfd_frame sframe;struct canfd_frame last_sframe;struct sock *sk;struct net_device *rx_reg_dev; -spinlock_t bcm_tx_lock;/* protect currframe/count in runtime updates */ +spinlock_t bcm_tx_lock;/* protect tx data and timer updates */ spinlock_t bcm_rx_update_lock;/* protect filter/timer data updates */ };struct bcm_sock {struct sock sk;
@@ -462,16 +462,22 @@ static void bcm_send_to_user(struct bcm_op *op, struct bcm_msg_head *head,static bool bcm_tx_set_expiry (struct bcm_op *op,struct hrtimer *hrt) {ktime_t ival; +spin_lock_bh (&op->bcm_tx_lock); +if (op->kt_ival1 && op->count) ival = op->kt_ival1; -else if (op->kt_ival2) +else if (op->kt_ival2) { ival = op->kt_ival2; -else + }else { +spin_unlock_bh (&op->bcm_tx_lock);return false; + } + +spin_unlock_bh (&op->bcm_tx_lock);hrtimer_set_expires (hrt,ktime_add (ktime_get (), ival));return true; }
@@ -484,12 +490,21 @@ static void bcm_tx_start_timer(struct bcm_op *op)/* bcm_tx_timeout_handler - performs cyclic CAN frame transmissions */ static enum hrtimer_restart bcm_tx_timeout_handler (struct hrtimer *hrtimer) { struct bcm_op *op = container_of(hrtimer, struct bcm_op, timer);struct bcm_msg_head msg_head; +bool tx_ival1, tx_ival2; -if (op->kt_ival1 && (op->count >0 )) { +/* snapshot kt_ival1/kt_ival2/count under lock to avoid torn +* ktime_t reads racing with concurrent bcm_tx_setup() updates +*/ +spin_lock_bh (&op->bcm_tx_lock); + tx_ival1 = op->kt_ival1 && (op->count >0 ); + tx_ival2 = !!op->kt_ival2; +spin_unlock_bh (&op->bcm_tx_lock); + +if (tx_ival1) {bcm_can_tx (op,NULL );if (!op->count && (op->flags &TX_COUNTEVT )) {/* create notification to user */ memset (&msg_head,0 ,sizeof (msg_head));
@@ -502,11 +517,11 @@ static enum hrtimer_restart bcm_tx_timeout_handler(struct hrtimer *hrtimer) msg_head.nframes =0 ;bcm_send_to_user (op, &msg_head,NULL ,0 ); } - }else if (op->kt_ival2) { + }else if (tx_ival2) {bcm_can_tx (op,NULL ); }return bcm_tx_set_expiry (op, &op->timer) ?HRTIMER_RESTART :HRTIMER_NORESTART ;
@@ -1025,64 +1040,80 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,return -EINVAL ;/* check the given can_id */ op =bcm_find_op (&bo->tx_ops, msg_head, ifindex);if (op) { +void *new_frames; +/* update existing BCM operation */ /* * Do we need more space for the CAN frames than currently * allocated? -> This is a _really_ unusual use-case and * therefore (complexity / locking) it is not supported. */ if (msg_head->nframes > op->nframes)return -E2BIG ; -/* update CAN frames content */ +/* get new CAN frames content into a staging buffer before +* locking: validate and normalize the frames there so that +* bcm_can_tx() / bcm_tx_timeout_handler() never observe a +* partially updated or unvalidated frame in op->frames +*/ + new_frames =kmalloc (msg_head->nframes * op->cfsiz,GFP_KERNEL ); +if (!new_frames) +return -ENOMEM ; +for (i =0 ; i < msg_head->nframes; i++) { - cf = op->frames + op->cfsiz * i; + cf = new_frames + op->cfsiz * i; err =memcpy_from_msg ((u8 *)cf, msg, op->cfsiz); +if (err <0 ) { +kfree (new_frames); +return err; + }if (op->flags &CAN_FD_FRAME ) {if (cf->len >64 ) err = -EINVAL ; }else {if (cf->len >8 ) err = -EINVAL ; } -if (err <0 ) +if (err <0 ) { +kfree (new_frames);return err; + }if (msg_head->flags &TX_CP_CAN_ID ) {/* copy can_id into frame */ cf->can_id = msg_head->can_id; } } + +spin_lock_bh (&op->bcm_tx_lock); + +/* update CAN frames content */ +memcpy (op->frames, new_frames, msg_head->nframes * op->cfsiz); + op->flags = msg_head->flags; -/* only lock for unlikely count/nframes/currframe changes */ if (op->nframes != msg_head->nframes || - op->flags &TX_RESET_MULTI_IDX || - op->flags &SETTIMER ) { - -spin_lock_bh (&op->bcm_tx_lock); + op->flags &TX_RESET_MULTI_IDX ) { +/* potentially update changed nframes */ + op->nframes = msg_head->nframes; +/* restart multiple frame transmission */ + op->currframe =0 ; + } -if (op->nframes != msg_head->nframes || - op->flags &TX_RESET_MULTI_IDX ) { -/* potentially update changed nframes */ - op->nframes = msg_head->nframes; -/* restart multiple frame transmission */ - op->currframe =0 ; - } +if (op->flags &SETTIMER ) + op->count = msg_head->count; -if (op->flags &SETTIMER ) - op->count = msg_head->count; +spin_unlock_bh (&op->bcm_tx_lock); -spin_unlock_bh (&op->bcm_tx_lock); - } +kfree (new_frames); }else {/* insert new BCM operation for the given can_id */ op =kzalloc (OPSIZ ,GFP_KERNEL );
@@ -1154,14 +1185,16 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, }/* if ((op = bcm_find_op(&bo->tx_ops, msg_head->can_id, ifindex))) */ if (op->flags &SETTIMER ) {/* set timer values */ +spin_lock_bh (&op->bcm_tx_lock); op->ival1 = msg_head->ival1; op->ival2 = msg_head->ival2; op->kt_ival1 =bcm_timeval_to_ktime (msg_head->ival1); op->kt_ival2 =bcm_timeval_to_ktime (msg_head->ival2); +spin_unlock_bh (&op->bcm_tx_lock);/* disable an active timer due to zero values? */ if (!op->kt_ival1 && !op->kt_ival2)hrtimer_cancel (&op->timer); }
Signature · 1 line
2.53.0
Oliver Hartkopp
maintainerPATCH v9 7/10 can: bcm: validate frame length in bcm_rx_setup() for RTR replies
In reply to Oliver Hartkoppbcm_tx_setup() validates cf->len against the CAN/CAN FD DLC limits before installing frames for TX_SETUP, but bcm_rx_setup() never did the same for the RTR-reply frame configured via RX_SETUP with RX_RTR_FRAME.
--- net/can/bcm.c | 59 +++++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 41 insertions(+), 18 deletions(-)
net/can/bcm.c +41 -18
@@ -1222,26 +1222,41 @@ static int bcm_tx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,kfree (op->frames);kfree (op);return err; } -static void bcm_rx_setup_rtr_check (struct bcm_msg_head *msg_head, -struct bcm_op *op,void *new_frames) +static int bcm_rx_setup_rtr_check (struct bcm_msg_head *msg_head, +struct bcm_op *op,void *new_frames) { +struct canfd_frame *frame0 = new_frames; + +if (!(msg_head->flags &RX_RTR_FRAME )) +return 0 ; + +/* this frame is sent out as-is by bcm_can_tx() whenever a matching +* remote request is received, so validate its length the same way +* bcm_tx_setup() validates TX_SETUP frames before installing it +*/ +if (msg_head->flags &CAN_FD_FRAME ) { +if (frame0->len >64 ) +return -EINVAL ; + }else { +if (frame0->len >8 ) +return -EINVAL ; + } +/* funny feature in RX(!)_SETUP only for RTR-mode: * copy can_id into frame BUT without RTR-flag to * prevent a full-load-loopback-test ... ;-] * normalize this on the staged buffer, before it is * ever installed into op->frames. */ -if (msg_head->flags &RX_RTR_FRAME ) { -struct canfd_frame *frame0 = new_frames; +if ((msg_head->flags &TX_CP_CAN_ID ) || + frame0->can_id == op->can_id) + frame0->can_id = op->can_id & ~CAN_RTR_FLAG ; -if ((msg_head->flags &TX_CP_CAN_ID ) || - frame0->can_id == op->can_id) - frame0->can_id = op->can_id & ~CAN_RTR_FLAG ; - } +return 0 ; }/* * bcm_rx_setup - create or update a bcm rx op (for bcm_sendmsg) */
@@ -1300,11 +1315,15 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,if (err <0 ) {kfree (new_frames);return err; } -bcm_rx_setup_rtr_check (msg_head, op, new_frames); + err =bcm_rx_setup_rtr_check (msg_head, op, new_frames); +if (err <0 ) { +kfree (new_frames); +return err; + } }spin_lock_bh (&op->bcm_rx_update_lock); op->nframes = msg_head->nframes; op->flags = msg_head->flags;
@@ -1365,20 +1384,16 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, }if (msg_head->nframes) { err =memcpy_from_msg (op->frames, msg, msg_head->nframes * op->cfsiz); -if (err <0 ) { -if (op->frames != &op->sframe) -kfree (op->frames); -if (op->last_frames != &op->last_sframe) -kfree (op->last_frames); -kfree (op); -return err; - } +if (err <0 ) + goto free_op; -bcm_rx_setup_rtr_check (msg_head, op, op->frames); + err =bcm_rx_setup_rtr_check (msg_head, op, op->frames); +if (err <0 ) + goto free_op; }/* bcm_can_tx / bcm_tx_timeout_handler needs this */ op->sk = sk;sock_hold (sk);
@@ -1471,10 +1486,18 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,/* add this bcm_op to the list of the rx_ops */ list_add_rcu (&op->list, &bo->rx_ops); }return msg_head->nframes * op->cfsiz +MHSIZ ; + +free_op: +if (op->frames != &op->sframe) +kfree (op->frames); +if (op->last_frames != &op->last_sframe) +kfree (op->last_frames); +kfree (op); +return err; }/* * bcm_tx_send - send a single CAN frame to the CAN interface (for bcm_sendmsg) */
Signature · 1 line
2.53.0
Oliver Hartkopp
maintainerPATCH v9 8/10 can: bcm: add missing device refcount for CAN filter removal
In reply to Oliver Hartkoppsashiko-bot remarked a problem with a concurrent device unregistration in isotp.c which also is present in the bcm.c code. A former fix for raw.c commit c275a176e4b6 ("can: raw: add missing refcount for memory leak fix") introduced a netdevice_tracker which solves the issue for bcm.c too.
bcm_release(), bcm_delete_rx_op() and bcm_notifier() relied on dev_get_by_index(ifindex) to re-find the device for an rx_op before unregistering its filter. If a concurrent NETDEV_UNREGISTER has already unlisted the device from the ifindex table, that lookup fails and can_rx_unregister() is silently skipped, leaving a stale CAN filter pointing at the soon-to-be-freed bcm_op/socket.
Hold a netdev_hold()/netdev_put() tracked reference on op->rx_reg_dev from the moment the rx filter is registered in bcm_rx_setup() until it is unregistered in bcm_rx_unreg(), and use that reference directly in bcm_release() and bcm_delete_rx_op() instead of re-looking the device up by ifindex.
--- net/can/bcm.c | 47 +++++++++++++++++++++++++++-------------------- 1 file changed, 27 insertions(+), 20 deletions(-)
net/can/bcm.c +27 -20
@@ -126,10 +126,11 @@ struct bcm_op {void *last_frames;struct canfd_frame sframe;struct canfd_frame last_sframe;struct sock *sk;struct net_device *rx_reg_dev; +netdevice_tracker rx_reg_dev_tracker;spinlock_t bcm_tx_lock;/* protect tx data and timer updates */ spinlock_t bcm_rx_update_lock;/* protect filter/timer data updates */ };struct bcm_sock {
@@ -913,10 +914,11 @@ static void bcm_rx_unreg(struct net_device *dev, struct bcm_op *op)can_rx_unregister (dev_net (dev), dev, op->can_id,REGMASK (op->can_id), bcm_rx_handler, op);/* mark as removed subscription */ op->rx_reg_dev =NULL ; +netdev_put (dev, &op->rx_reg_dev_tracker); }else printk (KERN_ERR "can-bcm: bcm_rx_unreg: registered device " "mismatch %p %p\n" , op->rx_reg_dev, dev); }
@@ -943,21 +945,18 @@ static int bcm_delete_rx_op(struct list_head *ops, struct bcm_msg_head *mh,if (op->ifindex) {/* * Only remove subscriptions that had not * been removed due to NETDEV_UNREGISTER * in bcm_notifier() +* +* op->rx_reg_dev is a tracked reference taken +* when the subscription was registered, so it +* stays valid here even if a concurrent +* NETDEV_UNREGISTER already unlisted the dev. */ -if (op->rx_reg_dev) { -struct net_device *dev; - - dev =dev_get_by_index (sock_net (op->sk), - op->ifindex); -if (dev) { -bcm_rx_unreg (dev, op); -dev_put (dev); - } - } +if (op->rx_reg_dev) +bcm_rx_unreg (op->rx_reg_dev, op); }else can_rx_unregister (sock_net (op->sk),NULL , op->can_id,REGMASK (op->can_id), bcm_rx_handler, op);
@@ -1462,11 +1461,21 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, op->can_id,REGMASK (op->can_id), bcm_rx_handler, op, "bcm", sk); - op->rx_reg_dev = dev; +/* keep a tracked reference so that a later +* unregister can safely reach the device even +* if a concurrent NETDEV_UNREGISTER has +* already unlisted it by ifindex +*/ +if (!err) { + op->rx_reg_dev = dev; +netdev_hold (dev, + &op->rx_reg_dev_tracker, +GFP_KERNEL ); + }dev_put (dev); }else {/* the requested device is gone - do not * silently succeed without registering */
@@ -1839,20 +1848,18 @@ static int bcm_release(struct socket *sock)if (op->ifindex) {/* * Only remove subscriptions that had not * been removed due to NETDEV_UNREGISTER * in bcm_notifier() +* +* op->rx_reg_dev is a tracked reference taken +* when the subscription was registered, so it +* stays valid here even if a concurrent +* NETDEV_UNREGISTER already unlisted the device. */ -if (op->rx_reg_dev) { -struct net_device *dev; - - dev =dev_get_by_index (net, op->ifindex); -if (dev) { -bcm_rx_unreg (dev, op); -dev_put (dev); - } - } +if (op->rx_reg_dev) +bcm_rx_unreg (op->rx_reg_dev, op); }else can_rx_unregister (net,NULL , op->can_id,REGMASK (op->can_id), bcm_rx_handler, op);
Signature · 1 line
2.53.0
[email protected]
AI reviewRe: [PATCH v9 08/10] can: bcm: add missing device refcount for CAN filter removal
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
Pre-existing issues:
- [High] An existing BCM RX filter silently fails to re-register if its bound device is unregistered and later replaced, or if the socket is bound to 'any' interface and the device is recreated. --
--- Patch [8]: [PATCH v9 08/10] can: bcm: add missing device refcount for CAN filter removal --- commit 1ad23d1877e2e80147338573cbaebed867d37fc0
Author: Oliver Hartkopp <[email protected]>
can: bcm: add missing device refcount for CAN filter removal
This commit fixes a missing device refcount issue in bcm.c when unregistering a CAN filter. It introduces a netdevice_tracker to hold a reference on op->rx_reg_dev from filter registration until unregistration, preventing lookups on a stale device index.
Quoted 4 lines
net/can/bcm.c +0
-0
[ ... ]
net/can/bcm.c static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, · line 1467
Quoted 5 lines
net/can/bcm.c +0
-1@@ -1464,7 +1463,17 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, bcm_rx_handler, op, "bcm", sk); - op->rx_reg_dev = dev;
[Severity: High]
This isn't a bug introduced by this patch, but is there a scenario where an existing BCM RX filter silently fails to re-register?
If a BCM socket is bound to interface 0, an RX_SETUP creates an operation for a specific interface and sets op->rx_reg_dev. If that interface is then unregistered, bcm_notify() unregisters the filter and clears op->rx_reg_dev but leaves the operation in bo->rx_ops.
When the device is recreated and another RX_SETUP is sent for the same id and ifindex, bcm_find_op() in bcm_rx_setup() finds the existing operation. Because it is found, do_rx_register remains 0. The setup then returns success but bypasses the can_rx_register() phase entirely.
Does this sequence result in the filter remaining inactive on the newly created device and silently dropping expected CAN frames?
Quoted 14 lines
net/can/bcm.c +11
-0+/* keep a tracked reference so that a later +* unregister can safely reach the device even +* if a concurrent NETDEV_UNREGISTER has +* already unlisted it by ifindex +*/ +if (!err) { + op->rx_reg_dev = dev; +netdev_hold (dev, + &op->rx_reg_dev_tracker, +GFP_KERNEL ); + }dev_put (dev); }else {/* the requested device is gone - do not
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=8
Oliver Hartkopp
maintainerPATCH v9 9/10 can: bcm: fix stale rx/tx ops after device removal
In reply to Oliver HartkoppRX: an RX_SETUP update(!) for an existing op skipped can_rx_register() unconditionally, even when a concurrent NETDEV_UNREGISTER had already torn down its registration (op->rx_reg_dev == NULL). This silently did not re-enable frame delivery for that updated filter. bcm_rx_setup() now re-registers in that case, while leaving rx_ops with ifindex = 0 (all CAN devices) which never carry a tracked rx_reg_dev registered as-is.
TX: bcm_notify() only handled bo->rx_ops on NETDEV_UNREGISTER, leaving tx_ops with an active cyclic transmission re-arming its hrtimer indefinitely to execute bcm_tx_timeout_handler(). Cancelling the hrtimer prevents the runaway timer and any injection into a later reused ifindex, since nothing else calls bcm_can_tx() for the op until an explicit TX_SETUP update re-arms it.
Unlike bcm_rx_unreg(), which clears the tracked rx_reg_dev for rx_ops, the ifindex is intentionally left unchanged for tx_ops. bcm_tx_setup() always rejects ifindex 0, so clearing it would strand the op: neither a later TX_SETUP (bcm_find_op()) nor TX_DELETE (bcm_delete_tx_op()) could ever find it again, since both require an exact ifindex match.
--- net/can/bcm.c | 47 ++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 38 insertions(+), 9 deletions(-)
net/can/bcm.c +38 -9
@@ -1263,10 +1263,11 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg, int ifindex, struct sock *sk) { struct bcm_sock *bo = bcm_sk(sk);struct bcm_op *op;int do_rx_register; +int new_op =0 ;int err =0 ;if ((msg_head->flags &RX_FILTER_ID ) || (!(msg_head->nframes))) {/* be robust against wrong usage ... */ msg_head->flags |=RX_FILTER_ID ;
@@ -1339,12 +1340,19 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,spin_unlock_bh (&op->bcm_rx_update_lock);/* free temporary frames / kfree(NULL) is safe */ kfree (new_frames); -/* Only an update -> do not call can_rx_register() */ - do_rx_register =0 ; +/* Don't register a new CAN filter for the rx_op update unless +* a concurrent NETDEV_UNREGISTER notifier already tore down +* the previous registration. In this case the receiver needs +* to be re-registered here so that this update doesn't +* silently stop delivering frames for the given ifindex. +* Ops with ifindex = 0 (all CAN interfaces) never carry a +* tracked rx_reg_dev and stay registered as-is. +*/ + do_rx_register = (ifindex && !op->rx_reg_dev) ?1 :0 ; }else {/* insert new BCM operation for the given can_id */ op =kzalloc (OPSIZ ,GFP_KERNEL );if (!op)
@@ -1407,10 +1415,11 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,hrtimer_setup (&op->thrtimer, bcm_rx_thr_handler,CLOCK_MONOTONIC ,HRTIMER_MODE_REL_SOFT );/* call can_rx_register() */ do_rx_register =1 ; + new_op =1 ; }/* if ((op = bcm_find_op(&bo->rx_ops, msg_head->can_id, ifindex))) */ /* check flags */
@@ -1448,11 +1457,14 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,if ((op->flags &STARTTIMER ) && op->kt_ival1)hrtimer_start (&op->timer, op->kt_ival1,HRTIMER_MODE_REL_SOFT ); } -/* now we can register for can_ids, if we added a new bcm_op */ +/* now we can register for can_ids, if we added a new bcm_op +* or need to re-register after a NETDEV_UNREGISTER tore down +* the previous registration of an existing op +*/ if (do_rx_register) {if (ifindex) {struct net_device *dev; dev =dev_get_by_index (sock_net (sk), ifindex);
@@ -1480,22 +1492,31 @@ static int bcm_rx_setup(struct bcm_msg_head *msg_head, struct msghdr *msg,* silently succeed without registering */ err = -ENODEV ; } - }else + }else { err =can_rx_register (sock_net (sk),NULL , op->can_id,REGMASK (op->can_id), bcm_rx_handler, op,"bcm" , sk); + } +if (err) { -/* this bcm rx op is broken -> remove it */ -bcm_remove_op (op); +/* newly created bcm rx op is broken -> remove it */ +if (new_op) +bcm_remove_op (op); + +/* an existing op just stays unregistered until the +* next successful RX_SETUP - it is already part of +* bo->rx_ops and must not be freed here +*/ return err; } -/* add this bcm_op to the list of the rx_ops */ -list_add_rcu (&op->list, &bo->rx_ops); +/* add a new bcm_op to the list of the rx_ops */ +if (new_op) +list_add_rcu (&op->list, &bo->rx_ops); }return msg_head->nframes * op->cfsiz +MHSIZ ; free_op:
@@ -1711,15 +1732,23 @@ static void bcm_notify(struct bcm_sock *bo, unsigned long msg,switch (msg) {case NETDEV_UNREGISTER :lock_sock (sk); -/* remove device specific receive entries */ +/* rx_ops: remove device specific receive entries */ list_for_each_entry (op, &bo->rx_ops, list)if (op->rx_reg_dev == dev)bcm_rx_unreg (dev, op); +/* tx_ops: stop device specific cyclic transmissions on the +* vanishing ifindex. Cancelling the timer is enough to stop +* cyclic bcm_can_tx() calls as there is no re-arming. +*/ +list_for_each_entry (op, &bo->tx_ops, list) +if (op->ifindex == dev->ifindex) +hrtimer_cancel (&op->timer); +/* remove device reference, if this is our bound device */ if (bo->bound && bo->ifindex == dev->ifindex) {#if IS_ENABLED (CONFIG_PROC_FS )if (sock_net (sk)->can.bcmproc_dir && bo->bcm_proc_read) {remove_proc_entry (bo->procname,sock_net (sk)->can.bcmproc_dir);
Signature · 1 line
2.53.0
Oliver Hartkopp
maintainerPATCH v9 10/10 can: bcm: fix data race on rx_stamp/rx_ifindex in bcm_rx_handler()
In reply to Oliver HartkoppFor an rx op subscribed on all interfaces (ifindex == 0), the same op is registered once in the shared per-netns wildcard filter list, so bcm_rx_handler() can run concurrently on different CPUs for frames arriving on different net devices.
op->rx_stamp and op->rx_ifindex were written before bcm_rx_update_lock was taken, allowing concurrent writers to race each other - including a torn store of the 64-bit rx_stamp on 32-bit platforms.
Beyond a torn store bcm_send_to_user() must report the timestamp/ifindex of the very same frame whose content it is delivering. So the assignment is placed in the same unbroken bcm_rx_update_lock section as the content comparison.
As a side effect, the RTR-request frame feature (which never reach bcm_send_to_user()) no longer updates rx_stamp/rx_ifindex, since only the notification path needs them.
--- net/can/bcm.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
net/can/bcm.c +8 -5
@@ -777,15 +777,10 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data) }/* disable timeout */ hrtimer_cancel (&op->timer); -/* save rx timestamp */ - op->rx_stamp = skb->tstamp; -/* save originator for recvfrom() */ - op->rx_ifindex = skb->dev->ifindex; -/* snapshot RTR content under lock: op->flags/op->frames may be * updated concurrently by bcm_rx_setup(). */ spin_lock_bh (&op->bcm_rx_update_lock);
@@ -812,10 +807,18 @@ static void bcm_rx_handler(struct sk_buff *skb, void *data) traffic_flags |=RX_OWN ; }spin_lock_bh (&op->bcm_rx_update_lock); +/* save rx timestamp and originator for recvfrom() under lock. +* For an op subscribed on all interfaces (ifindex == 0) +* bcm_rx_handler() can run concurrently on different CPUs so +* the CAN content and the meta data must be bundled correctly. +*/ + op->rx_stamp = skb->tstamp; + op->rx_ifindex = skb->dev->ifindex; +if (op->flags &RX_FILTER_ID ) {/* the easiest case */ bcm_rx_update_and_send (op, op->last_frames, rxframe, traffic_flags); goto rx_starttimer;
Signature · 1 line
2.53.0