From: Oliver Hartkopp bcm_sendmsg() copies the CAN frames of TX_SETUP, RX_SETUP and TX_SEND from user space while holding lock_sock(). A copy that faults or stalls, e.g. on a FUSE backed mapping, holds lock_sock() for its whole duration. bcm_notify() takes lock_sock() of every CAN_BCM socket in the namespace of a vanishing CAN device while holding RTNL, independent of the binding of the socket. So a stalled copy on any CAN_BCM socket can block RTNL on the unregistration or namespace change of a CAN device in this namespace, e.g. of a vcan device in an unprivileged user and network namespace. Copy the CAN frames that the opcode handler reads to kernel memory before lock_sock() and hand them to the handlers with a kvec based msghdr. bcm_tx_setup(), bcm_rx_setup() and bcm_tx_send() keep their checks and read the frames with memcpy_from_msg() as before. Up to sizeof(struct canfd_frame) bytes, i.e. a single CAN FD frame or up to four CAN CC frames, are copied to a buffer on the stack, more frames to a kvmalloc() buffer of up to MAX_NFRAMES + 1 CAN FD frames. As the frames are copied before lock_sock() now, a failing copy is reported before the error conditions that are checked under lock_sock(). This is in line with POSIX, which does not define an order in which multiple error conditions are detected and reported. The generic SOL_SOCKET options in sk_setsockopt() and sk_getsockopt(), e.g. SO_ATTACH_FILTER, still access user space under the socket lock. This is not specific to CAN_BCM and not addressed by this patch. Fixes: ffd980f976e7 ("[CAN]: Add broadcast manager (bcm) protocol") Cc: stable@vger.kernel.org Signed-off-by: Oliver Hartkopp Link: https://patch.msgid.link/20261117-can-bcmlock-memcg-v6-1-6826a6227d36@hartkopp.net Cc: Vincent Mailhol Cc: Marc Kleine-Budde Cc: Oleksij Rempel Cc: Zhu Ling Cc: linux-can@vger.kernel.org Signed-off-by: Marc Kleine-Budde --- net/can/bcm.c | 55 ++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 52 insertions(+), 3 deletions(-) diff --git a/net/can/bcm.c b/net/can/bcm.c index 7bd2aa39777a..3f4c8d828337 100644 --- a/net/can/bcm.c +++ b/net/can/bcm.c @@ -1643,6 +1643,11 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) struct bcm_sock *bo = bcm_sk(sk); int ifindex; struct bcm_msg_head msg_head; + struct msghdr fmsg = {}; /* CAN frames copied to kernel memory */ + struct kvec kv; + struct canfd_frame sframe; /* stack buffer for up to CANFD_MTU bytes */ + void *frames = &sframe; + size_t flen = 0; int cfsiz; int ret; /* read bytes or error codes as return value */ @@ -1663,6 +1668,47 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) if ((size - MHSIZ) % cfsiz) return -EINVAL; + /* Copy the CAN frames from user space before lock_sock(), so a + * stalled copy can not block bcm_notify() waiting for lock_sock() + * under RTNL. Only the frames the opcode handler reads are copied. + * The handlers keep their checks and read the frames from fmsg. + */ + switch (msg_head.opcode) { + case TX_SETUP: + if (msg_head.nframes >= 1 && msg_head.nframes <= MAX_NFRAMES) + flen = msg_head.nframes * cfsiz; + break; + + case RX_SETUP: + if (!(msg_head.flags & RX_FILTER_ID) && + msg_head.nframes <= MAX_NFRAMES + 1) + flen = msg_head.nframes * cfsiz; + break; + + case TX_SEND: + if (msg_head.nframes == 1 && size == cfsiz + MHSIZ) + flen = cfsiz; + break; + } + + /* a message with missing frames still fails in the handler */ + flen = min(flen, msg_data_left(msg)); + + if (flen > sizeof(sframe)) { + frames = kvmalloc(flen, GFP_KERNEL); + if (!frames) + return -ENOMEM; + } + + if (!copy_from_iter_full(frames, flen, &msg->msg_iter)) { + ret = -EFAULT; + goto out_free; + } + + kv.iov_base = frames; + kv.iov_len = flen; + iov_iter_kvec(&fmsg.msg_iter, ITER_SOURCE, &kv, 1, flen); + lock_sock(sk); /* Re-validate under the socket lock: a concurrent bcm_notify() @@ -1721,11 +1767,11 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) switch (msg_head.opcode) { case TX_SETUP: - ret = bcm_tx_setup(&msg_head, msg, ifindex, sk); + ret = bcm_tx_setup(&msg_head, &fmsg, ifindex, sk); break; case RX_SETUP: - ret = bcm_rx_setup(&msg_head, msg, ifindex, sk); + ret = bcm_rx_setup(&msg_head, &fmsg, ifindex, sk); break; case TX_DELETE: @@ -1759,7 +1805,7 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) if ((msg_head.nframes != 1) || (size != cfsiz + MHSIZ)) ret = -EINVAL; else - ret = bcm_tx_send(msg, ifindex, sk, cfsiz); + ret = bcm_tx_send(&fmsg, ifindex, sk, cfsiz); break; default: @@ -1769,6 +1815,9 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) out_release: release_sock(sk); +out_free: + if (frames != &sframe) + kvfree(frames); return ret; } base-commit: 5e9b2ad9b8384cd3c417cd5e2c3bc7eee4a72791 -- 2.53.0