6.18.64-rc1 review
Subsystems (3)
Greg Kroah-Hartman
maintainerPATCH 351/686 xfs: fix wrong compat fields in xfs_ioctl32_bstat_copyin()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Reid Downing <[email protected]>
[ Upstream commit b7eb276a39b14e685c2fe578f8ac22fc48ff9e6c ]
bs_blocks and bs_xflags were both read from bstat32->bs_size. Read each one from its own field instead.
--- fs/xfs/xfs_ioctl32.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/xfs/xfs_ioctl32.c +2 -2
@@ -123,8 +123,8 @@ xfs_ioctl32_bstat_copyin(xfs_ioctl32_bstime_copyin (&bstat->bs_atime, &bstat32->bs_atime) ||xfs_ioctl32_bstime_copyin (&bstat->bs_mtime, &bstat32->bs_mtime) ||xfs_ioctl32_bstime_copyin (&bstat->bs_ctime, &bstat32->bs_ctime) || -get_user (bstat->bs_blocks, &bstat32->bs_size) || -get_user (bstat->bs_xflags, &bstat32->bs_size) || +get_user (bstat->bs_blocks, &bstat32->bs_blocks) || +get_user (bstat->bs_xflags, &bstat32->bs_xflags) ||get_user (bstat->bs_extsize, &bstat32->bs_extsize) ||get_user (bstat->bs_extents, &bstat32->bs_extents) || get_user(bstat->bs_gen, &bstat32->bs_gen) ||
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 352/686 blk-mq: fix out-of-bounds read in blk_mq_free_rqs
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Krystian Kaniewski <[email protected]>
[ Upstream commit 894e4e6084924cfd590968d45fad20908e02ddae ]
A KASAN slab-out-of-bounds read can occur in blk_mq_free_rqs() when there is a mismatch between the number of hardware queues allocated for the IO scheduler (et->nr_hw_queues) and the number of hardware queues in the block tag set (set->nr_hw_queues).
This mismatch can happen if blk_mq_update_nr_hw_queues() fails halfway through (e.g., due to memory pressure during blk_mq_prealloc_tag_set_tags()). In this error path, the elevator is restored with a larger number of hardware queues than the block tag set actually has.
When the elevator is later freed, blk_mq_free_sched_tags() iterates up to the new et->nr_hw_queues and calls blk_mq_free_rqs(). In blk_mq_free_rqs(), it attempts to access set->tags[hctx_idx] to get the driver tags. Because set->nr_hw_queues was not updated due to the earlier failure, set->tags still has the old (smaller) size, leading to an out-of-bounds read.
BUG: KASAN: slab-out-of-bounds in blk_mq_free_rqs+0xde/0x680 Read of size 8 at addr ffff88818d67fc28 by task syz-executor117/5839 Call Trace: blk_mq_free_rqs+0xde/0x680 blk_mq_free_map_and_rqs+0x40/0xf0 blk_mq_free_sched_tags blk_mq_free_sched_res+0xeb/0x280 elevator_change_done+0x1d2/0x5c0 elevator_change+0x34f/0x480 elv_iosched_store+0x504/0x630 queue_attr_store+0x207/0x2b0
To fix this, explicitly check if hctx_idx < set->nr_hw_queues before accessing set->tags[hctx_idx]. If hctx_idx >= set->nr_hw_queues, the hardware queue doesn't exist in the tag set, meaning there are no driver tags to clear mappings from. In this case, safely set drv_tags to NULL. The subsequent call to blk_mq_clear_rq_mapping() already handles a NULL drv_tags pointer and will safely return.
--- block/blk-mq.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
block/blk-mq.c +3 -1
@@ -3495,8 +3495,10 @@ void blk_mq_free_rqs(struct blk_mq_tag_set *set, struct blk_mq_tags *tags,if (blk_mq_is_shared_tags (set->flags)) drv_tags = set->shared_tags; -else +else if (hctx_idx < set->nr_hw_queues) drv_tags = set->tags[hctx_idx]; +else + drv_tags =NULL ;if (tags->static_rqs && set->ops->exit_request) {int i;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 353/686 blk-iocost: account flush sequence latency only once
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Zhe Liu <[email protected]>
[ Upstream commit e9804489e27dd6e33aec5511fe3780ff3009f57f ]
A flush sequence with a DATA phase can complete its original request twice. Both completions invoke ioc_rqos_done(), causing the request to contribute two latency samples and adding the same queue wait time twice. This gives such requests disproportionate weight compared to ordinary writes, distorting the device-wide latency and queue wait feedback used to adjust iocost's virtual time rate.
Skip requests marked RQF_FLUSH_SEQ in ioc_rqos_done(). The flag is set when the request enters the flush machinery and is still set when the data phase completes; blk_flush_restore_request() clears it before the final completion, so accounting happens only once, after the whole sequence finishes. The remaining sample covers the request's lifetime through any postflush, and its queue wait time is accumulated only once.
--- block/blk-iocost.c | 3 +++ 1 file changed, 3 insertions(+)
block/blk-iocost.c +3 -0
@@ -2818,6 +2818,9 @@ static void ioc_rqos_done(struct rq_qos *rqos, struct request *rq)if (!ioc->enabled || !rq->alloc_time_ns || !rq->start_time_ns)return ; +if (unlikely (rq->rq_flags &RQF_FLUSH_SEQ )) +return ; +switch (req_op (rq)) {case REQ_OP_READ : pidx =QOS_RLAT ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 354/686 xfs: mark the inode preallocated for pNFS write layouts past EOF
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daejun Park <[email protected]>
[ Upstream commit 8b8e265991556d99b6d721697f148975a7c68767 ]
xfs_fs_map_blocks() marks the inode XFS_DIFLAG_PREALLOC only when it allocates blocks for a write layout. A write layout past EOF can also hand out allocated blocks, such as speculative preallocation. blockgc then frees them under the layout, and another file may get them.
Mark the inode whenever a write mapping ends past EOF.
--- fs/xfs/xfs_pnfs.c | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-)
fs/xfs/xfs_pnfs.c +25 -9
@@ -110,7 +110,15 @@ xfs_fs_map_update_inode( ip->i_diflags |=XFS_DIFLAG_PREALLOC ;xfs_trans_log_inode (tp, ip,XFS_ILOG_CORE ); -return xfs_trans_commit (tp); + error =xfs_trans_commit (tp); +if (error) +return error; + +/* +* Force the log so that the blocks handed out to the client are +* guaranteed to be present even after a server crash. +*/ +return xfs_log_force_inode (ip); }/*
@@ -135,6 +143,7 @@ xfs_fs_map_blocks(uint lock_flags;int error =0 ;u64 seq; +bool update_inode = false;if (xfs_is_shutdown (mp))return -EIO ;
@@ -203,20 +212,27 @@ xfs_fs_map_blocks( end_fsb - offset_fsb, 0, &imap, &seq);if (error) goto out_unlock; + update_inode = true; + }else { +xfs_iunlock (ip, lock_flags);/* -* Ensure the next transaction is committed synchronously so -* that the blocks allocated and handed out to the client are -* guaranteed to be present even after a server crash. +* Blocks past EOF that were allocated for buffered writes, such +* as speculative preallocation, can be freed by +* xfs_free_eofblocks() without breaking the layout unless the +* inode is marked as preallocated. Mark it before handing them +* out for writing, as for blocks allocated above. */ +if (write && !(ip->i_diflags &XFS_DIFLAG_PREALLOC ) && + imap.br_startoff + imap.br_blockcount > +XFS_B_TO_FSB (mp,XFS_ISIZE (ip))) + update_inode = true; + } + +if (update_inode) { error =xfs_fs_map_update_inode (ip); -if (!error) - error =xfs_log_force_inode (ip);if (error) goto out_unlock; - - }else { -xfs_iunlock (ip, lock_flags); }xfs_iunlock (ip,XFS_IOLOCK_EXCL );
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 355/686 xfs: add a flag to convert unwritten extents without allocating blocks
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daejun Park <[email protected]>
[ Upstream commit f3ca3498dfe624f9b604c934263538a3acd55af5 ]
xfs_bmapi_write() with XFS_BMAPI_CONVERT also allocates blocks for holes and delalloc extents in the range. Add XFS_BMAPI_CONVERT_ONLY for callers that may only convert already allocated blocks. It stops at a hole or delalloc extent, and returns -ENOSR if it stops before mapping anything.
Marked for stable because "xfs: refuse a pNFS LAYOUTCOMMIT of a range without blocks" needs it.
--- fs/xfs/libxfs/xfs_bmap.c | 14 ++++++++++++-- fs/xfs/libxfs/xfs_bmap.h | 10 +++++++++- 2 files changed, 21 insertions(+), 3 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +12 -2
@@ -4130,6 +4130,8 @@ xfs_bmapi_finish(* Returns a negative error code on failure, including -ENOSPC when it could not * allocate any blocks and -ENOSR when it did allocate blocks to convert a * delalloc range, but those blocks were before the passed in range. +* With XFS_BMAPI_CONVERT_ONLY, it stops at a hole or a delalloc extent instead +* of allocating blocks, and returns -ENOSR if it stops before mapping anything. */ int xfs_bmapi_write(
@@ -4189,6 +4191,8 @@ xfs_bmapi_write(*/ ASSERT ((flags & (XFS_BMAPI_PREALLOC |XFS_BMAPI_ZERO )) != (XFS_BMAPI_PREALLOC |XFS_BMAPI_ZERO )); +ASSERT (!(flags &XFS_BMAPI_CONVERT_ONLY ) || + (flags &XFS_BMAPI_CONVERT ));if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (ifp)) ||XFS_TEST_ERROR (mp,XFS_ERRTAG_BMAPIFORMAT )) {
@@ -4237,6 +4241,9 @@ xfs_bmapi_write(* that we found, if any. */ if (need_alloc || wasdelay) { +if (flags &XFS_BMAPI_CONVERT_ONLY ) +break ; + bma.eof = eof; bma.conv = !!(flags &XFS_BMAPI_CONVERT ); bma.wasdel = wasdelay;
@@ -4332,10 +4339,13 @@ xfs_bmapi_write(* * To avoid a successful return with *nmap set to 0, return the magic * -ENOSR error code for this particular case so that the caller can -* handle it. +* handle it. The same goes for XFS_BMAPI_CONVERT_ONLY stopping at a +* hole or a delalloc extent at the start of the range, in which case +* nothing has been changed. */ if (!n) { -ASSERT (bma.nallocs >= *nmap); +ASSERT ((flags &XFS_BMAPI_CONVERT_ONLY ) ? bma.nallocs ==0 : + bma.nallocs >= *nmap);return -ENOSR ; } *nmap = n;
fs/xfs/libxfs/xfs_bmap.h +9 -1
@@ -90,6 +90,13 @@ struct xfs_bmalloca {/* Try to align allocations to the extent size hint */ #define XFS_BMAPI_EXTSZALIGN (1u << 11) +/* +* Use with XFS_BMAPI_CONVERT to convert unwritten extents without allocating +* blocks. Stop at a hole or a delalloc extent: return the mappings found so +* far, or -ENOSR if there are none. +*/ +#define XFS_BMAPI_CONVERT_ONLY (1u << 12) +#define XFS_BMAPI_FLAGS \ { XFS_BMAPI_ENTIRE, "ENTIRE" }, \ { XFS_BMAPI_METADATA, "METADATA" }, \
@@ -102,7 +109,8 @@ struct xfs_bmalloca { { XFS_BMAPI_COWFORK, "COWFORK" }, \ { XFS_BMAPI_NODISCARD, "NODISCARD" }, \ { XFS_BMAPI_NORMAP, "NORMAP" },\ - { XFS_BMAPI_EXTSZALIGN, "EXTSZALIGN" } + { XFS_BMAPI_EXTSZALIGN, "EXTSZALIGN" }, \ + { XFS_BMAPI_CONVERT_ONLY, "CONVERT_ONLY" } static inline int xfs_bmapi_aflag(int w)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 356/686 xfs: clamp a pNFS LAYOUTCOMMIT extent before computing its end
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daejun Park <[email protected]>
[ Upstream commit d8c2bc88460f89e543ab3af622fc8f34c7011d71 ]
xfs_fs_commit_blocks() adds the client's length to the offset before it clamps the end to the file size. A large length wraps the sum and reaches xfs_iomap_write_unwritten() unclamped. With the previous two patches the LAYOUTCOMMIT then fails with -EIO and converts nothing.
Clamp the length first.
--- fs/xfs/xfs_pnfs.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
fs/xfs/xfs_pnfs.c +1 -3
@@ -311,9 +311,7 @@ xfs_fs_commit_blocks(if (start > size)continue ; - end = start + maps[i].length; -if (end > size) - end = size; + end = start +min_t (u64, maps[i].length, size - start); length = end - start;if (!length)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 357/686 xfs: cap the block count of xfs_iomap_write_direct() at one extent
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daejun Park <[email protected]>
[ Upstream commit 66d1ce09ebd72709f8d739630c39f440445173fd ]
xfs_iomap_write_direct() reserves blocks for the whole count in an unsigned int. For a pNFS layout the client chooses that count, and an RW LAYOUTGET for 16 TiB wraps the reservation and shuts XFS down.
xfs_bmapi_write() maps at most XFS_MAX_BMBT_EXTLEN blocks here, so cap the count at that. nfsd asks again for the rest. The other callers get the same mapping as before.
--- fs/xfs/xfs_iomap.c | 8 ++++++++ 1 file changed, 8 insertions(+)
fs/xfs/xfs_iomap.c +8 -0
@@ -282,6 +282,14 @@ xfs_iomap_write_direct(ASSERT (count_fsb >0 ); +/* +* xfs_bmapi_write() maps at most XFS_MAX_BMBT_EXTLEN blocks in one +* mapping, so don't reserve blocks for more. A pNFS layout range +* comes from a client, and its block count may not even fit the +* 32-bit reservation. The caller maps the rest with a later call. +*/ + count_fsb =min_t (xfs_filblks_t, count_fsb,XFS_MAX_BMBT_EXTLEN ); + resaligned =xfs_aligned_fsb_count (offset_fsb, count_fsb,xfs_get_extsz_hint (ip));if (unlikely (XFS_IS_REALTIME_INODE (ip))) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 358/686 xfs: clamp the pNFS layout range to the maximum file size
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daejun Park <[email protected]>
[ Upstream commit 29f3c1be4e554c9dbc66e13333034e0947477cb6 ]
xfs_fs_map_blocks() lets two bad layout ranges through. An offset of 2^63 or more is negative and passes "offset > limit". A length above the limit, such as NFS4_UINT64_MAX, wraps "offset > limit - length" and stays unclamped. With NFS4_UINT64_MAX, a read layout is built from an uninitialized mapping.
Reject a negative offset and one at the limit, and clamp the length. This needs "xfs: cap the block count of xfs_iomap_write_direct() at one extent".
--- fs/xfs/xfs_pnfs.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
fs/xfs/xfs_pnfs.c +2 -3
@@ -177,10 +177,9 @@ xfs_fs_map_blocks(if (!write) limit =max (limit,round_up (i_size_read (inode), inode->i_sb->s_blocksize)); -if (offset > limit) +if (offset <0 || offset >= limit) goto out_unlock; -if (offset > limit - length) - length = limit - offset; + length =min_t (u64, length, limit - offset); error =filemap_write_and_wait (inode->i_mapping);if (error)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 359/686 net: restore refcount ordering for lockless socket access
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hyunwoo Kim <[email protected]>
[ Upstream commit 5b5d8f351dd96f56a58bb516a80e2d4d742fe4e2 ]
Before commit fb041bb7c0a9 ("locking/refcount: Consolidate implementations of refcount_t"), default builds implemented refcount_inc_not_zero() using atomic_add_unless(), which provided full memory ordering on success. The commit removed that ordering on weakly ordered architectures, allowing accesses after a successful reference acquisition to be reordered before it.
Use refcount_inc_not_zero_acquire() in the IPv4 and IPv6 established lookups and in inet_twsk_purge(), where the socket is validated again after taking a reference.
bpf_sk_assign() can receive a socket pointer obtained through BTF without a reference. Use acquire ordering when it takes its own reference for a refcounted socket.
Use refcount_set_release() when setting refcounts in the SYN cookie, TCP Fast Open, request migration, and TIME_WAIT paths. Keep the existing TIME_WAIT smp_wmb(), which separately orders the refcount store before ehash publication.
--- net/core/filter.c | 2 +- net/ipv4/inet_connection_sock.c | 6 +++--- net/ipv4/inet_hashtables.c | 2 +- net/ipv4/inet_timewait_sock.c | 4 ++-- net/ipv4/syncookies.c | 2 +- net/ipv4/tcp_fastopen.c | 2 +- net/ipv6/inet6_hashtables.c | 2 +- 7 files changed, 10 insertions(+), 10 deletions(-)
net/core/filter.c +1 -1
@@ -7691,7 +7691,7 @@ BPF_CALL_3(bpf_sk_assign, struct sk_buff *, skb, struct sock *, sk, u64, flags)if (sk_unhashed (sk))return -EOPNOTSUPP ;if (sk_is_refcounted (sk) && -unlikely (!refcount_inc_not_zero (&sk->sk_refcnt))) +unlikely (!refcount_inc_not_zero_acquire (&sk->sk_refcnt)))return -ENOENT ;skb_orphan (skb);
net/ipv4/inet_connection_sock.c +3 -3
@@ -1083,8 +1083,8 @@ static void reqsk_timer_handler(struct timer_list *t)* hold another count to prevent use-after-free and * call reqsk_put() just before return. */ -refcount_set (&nreq->rsk_refcnt,2 +1 );timer_setup (&nreq->rsk_timer, reqsk_timer_handler,TIMER_PINNED ); +refcount_set_release (&nreq->rsk_refcnt,2 +1 );reqsk_queue_migrated (&inet_csk (nsk)->icsk_accept_queue, req); req = nreq;
@@ -1461,7 +1461,7 @@ struct sock *inet_csk_complete_hashdance(struct sock *sk, struct sock *child, goto child_put; } -refcount_set (&nreq->rsk_refcnt,1 ); +refcount_set_release (&nreq->rsk_refcnt,1 );if (inet_csk_reqsk_queue_add (sk, nreq, child)) {__NET_INC_STATS (sock_net (sk),LINUX_MIB_TCPMIGRATEREQSUCCESS );reqsk_migrate_reset (req);
@@ -1514,7 +1514,7 @@ void inet_csk_listen_stop(struct sock *sk)if (nsk) { nreq =inet_reqsk_clone (req, nsk);if (nreq) { -refcount_set (&nreq->rsk_refcnt,1 ); +refcount_set_release (&nreq->rsk_refcnt,1 );rcu_read_lock ();if (inet_csk_reqsk_queue_add (nsk, nreq, child)) {
net/ipv4/inet_hashtables.c +1 -1
@@ -547,7 +547,7 @@ struct sock *__inet_lookup_established(const struct net *net, if (sk->sk_hash != hash) continue; if (likely(inet_match(net, sk, acookie, ports, dif, sdif))) { - if (unlikely(!refcount_inc_not_zero(&sk->sk_refcnt))) + if (unlikely(!refcount_inc_not_zero_acquire(&sk->sk_refcnt))) goto out; if (unlikely(hlist_nulls_unhashed_lockless(&sk->sk_nulls_node) || !inet_match(net, sk, acookie, ports, dif,
net/ipv4/inet_timewait_sock.c +2 -2
@@ -161,7 +161,7 @@ void inet_twsk_hashdance_schedule(struct inet_timewait_sock *tw,* Also note that after this point, we lost our implicit reference * so we are not allowed to use tw anymore. */ -refcount_set (&tw->tw_refcnt,3 ); +refcount_set_release (&tw->tw_refcnt,3 );inet_twsk_schedule (tw, timeo);
@@ -339,7 +339,7 @@ void inet_twsk_purge(struct inet_hashinfo *hashinfo)if (check_net (sock_net (sk)))continue ; -if (unlikely (!refcount_inc_not_zero (&sk->sk_refcnt))) +if (unlikely (!refcount_inc_not_zero_acquire (&sk->sk_refcnt)))continue ;if (check_net (sock_net (sk))) {
net/ipv4/syncookies.c +1 -1
@@ -205,7 +205,7 @@ struct sock *tcp_get_cookie_sock(struct sock *sk, struct sk_buff *skb, child = icsk->icsk_af_ops->syn_recv_sock (sk, skb, req, dst,NULL , &own_req,NULL );if (child) { -refcount_set (&req->rsk_refcnt,1 ); +refcount_set_release (&req->rsk_refcnt,1 );sock_rps_save_rxhash (child, skb);if (rsk_drop_req (req)) {
net/ipv4/tcp_fastopen.c +1 -1
@@ -278,7 +278,7 @@ static struct sock *tcp_fastopen_create_child(struct sock *sk,tcp_reset_xmit_timer (child,ICSK_TIME_RETRANS , req->timeout, false); -refcount_set (&req->rsk_refcnt,2 ); +refcount_set_release (&req->rsk_refcnt,2 );sk_mark_napi_id_set (child, skb);
net/ipv6/inet6_hashtables.c +1 -1
@@ -70,7 +70,7 @@ struct sock *__inet6_lookup_established(const struct net *net,continue ;if (!inet6_match (net, sk, saddr, daddr, ports, dif, sdif))continue ; -if (unlikely (!refcount_inc_not_zero (&sk->sk_refcnt))) +if (unlikely (!refcount_inc_not_zero_acquire (&sk->sk_refcnt))) goto out; if (unlikely(hlist_nulls_unhashed_lockless(&sk->sk_nulls_node) ||
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 360/686 xfs: fix recovery of partial attr removals
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Christoph Hellwig <[email protected]>
[ Upstream commit 30bb61651d2da5a502cf504bcdad16c093c1bb08 ]
When running xfs/753 on parent pointer-enabled file systems with DEBUG enabled, log recovery will eventually crash after a few dozen iterations due to an ASSERT that XFS_ATTR_INCOMPLETE is not already set when xfs_attr3_leaf_setflag is called:
XFS: Assertion failed: (entry->flags & XFS_ATTR_INCOMPLETE) == 0, file: fs/xfs/libxfs/xfs_attr_leaf.c, line: 3045
This is because parent pointer use logged attributes, and the attribute intents do not track the work that has been done as the transaction rolls, and the recovery mechanism is to run the operation from scratch. Because of this various places check for XFS_DA_OP_RECOVERY skip work already done. But while recovery tolerates an attribute already fully removed, it currently trips the above assert for an attribute that already has the INCOMPLETE bit set, but still exists. Fix this by handling the case like all the others.
--- fs/xfs/libxfs/xfs_attr_leaf.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_attr_leaf.c +8 -1
@@ -2948,7 +2948,14 @@ xfs_attr3_leaf_setflag(#endif entry = &xfs_attr3_leaf_entryp (leaf)[args->index]; -ASSERT ((entry->flags &XFS_ATTR_INCOMPLETE ) ==0 ); +if (entry->flags &XFS_ATTR_INCOMPLETE ) { +if (!(args->op_flags &XFS_DA_OP_RECOVERY )) { +ASSERT (args->op_flags &XFS_DA_OP_RECOVERY ); +return -EFSCORRUPTED ; + } +return 0 ; + } + entry->flags |=XFS_ATTR_INCOMPLETE ;xfs_trans_log_buf (args->trans, bp,XFS_DA_LOGRANGE (leaf, entry,sizeof (*entry)));
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 361/686 nvmet: reject keep-alive timeouts that would overflow
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yingjie Wang <[email protected]>
[ Upstream commit 96ae13f40ce5930cd58c43128e385131476f2a66 ]
nvmet_set_feat_kato() and nvmet_alloc_ctrl() convert the 32-bit millisecond KATO from the host to seconds with DIV_ROUND_UP(kato, 1000). The addition in DIV_ROUND_UP() is done in 32 bits, so any KATO above 4294966296 ms wraps around and rounds to 0 seconds. A Set Features command with KATO 0xffffffff then succeeds but disables the keep-alive
timer: Get Features returns 0 and Keep Alive fails with Keep Alive Timeout Invalid. A Connect command with such a KATO creates a controller without a keep-alive timer.
The converted value has more consumers that can overflow. Get Features multiplies it by 1000, and the timer paths multiply it by HZ in 32 bits and arm a delay that must not exceed MAX_JIFFY_OFFSET.
Reject a KATO whose rounded value does not fit all of these. Return Keep Alive Timeout Invalid from both Set Features and Connect. Validate Set Features before stopping the current timer so a failed update leaves its timeout unchanged. Round in 64 bits. A KATO of 0 keeps its current meaning.
--- drivers/nvme/target/admin-cmd.c | 7 ++++++- drivers/nvme/target/core.c | 8 +++++++- drivers/nvme/target/nvmet.h | 8 ++++++++ 3 files changed, 21 insertions(+), 2 deletions(-)
drivers/nvme/target/admin-cmd.c +6 -1
@@ -1228,8 +1228,13 @@ u16 nvmet_set_feat_kato(struct nvmet_req *req) {u32 val32 =le32_to_cpu (req->cmd->common.cdw11); +if (val32 >NVMET_MAX_KATO *MSEC_PER_SEC ) { + req->error_loc = offsetof(struct nvme_common_command , cdw11); +return NVME_SC_KA_TIMEOUT_INVALID |NVME_STATUS_DNR ; + } +nvmet_stop_keep_alive_timer (req->sq->ctrl); - req->sq->ctrl->kato =DIV_ROUND_UP (val32,1000 ); + req->sq->ctrl->kato =DIV_ROUND_UP_ULL (val32,MSEC_PER_SEC );nvmet_start_keep_alive_timer (req->sq->ctrl);nvmet_set_result (req, req->sq->ctrl->kato);
drivers/nvme/target/core.c +7 -1
@@ -1588,6 +1588,12 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_alloc_ctrl_args *args)u8 dhchap_status;int ret; +if (kato >NVMET_MAX_KATO *MSEC_PER_SEC ) { + args->status =NVME_SC_KA_TIMEOUT_INVALID |NVME_STATUS_DNR ; + args->error_loc = offsetof(struct nvmf_connect_command , kato); +return NULL ; + } + args->status =NVME_SC_CONNECT_INVALID_PARAM |NVME_STATUS_DNR ; subsys =nvmet_find_get_subsys (args->port, args->subsysnqn);if (!subsys) {
@@ -1655,7 +1661,7 @@ struct nvmet_ctrl *nvmet_alloc_ctrl(struct nvmet_alloc_ctrl_args *args) kato =NVMET_DISC_KATO_MS ;/* keep-alive timeout in seconds */ - ctrl->kato =DIV_ROUND_UP (kato,1000 ); + ctrl->kato =DIV_ROUND_UP_ULL (kato,MSEC_PER_SEC ); ctrl->err_counter =0 ;spin_lock_init (&ctrl->error_lock);
drivers/nvme/target/nvmet.h +8 -0
@@ -7,6 +7,7 @@#define _NVMET_H#include <linux/dma-mapping.h> +#include <linux/jiffies.h> #include <linux/types.h> #include <linux/device.h> #include <linux/kref.h>
@@ -694,6 +695,13 @@ void nvmet_add_async_event(struct nvmet_ctrl *ctrl, u8 event_type,#define NVMET_KAS 10#define NVMET_DISC_KATO_MS 120000 +/* +* Largest keep-alive timeout in seconds that can be reported back in +* milliseconds and converted to jiffies without overflowing. +*/ +#define NVMET_MAX_KATO \ + min3(U32_MAX / MSEC_PER_SEC, U32_MAX / HZ, MAX_JIFFY_OFFSET / HZ) +int __init nvmet_init_configfs (void ); void __exit nvmet_exit_configfs(void);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 362/686 can: isotp: check the frame type, not just the length
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Kaixuan Li <[email protected]>
[ Upstream commit 933bf0fcb325e67b19c86c9c4da7f029878d5170 ]
isotp_rcv() separates Classic CAN from CAN FD by skb->len alone:
if (skb->len != so->ll.mtu) return; cf = (struct canfd_frame *)skb->data;
A CAN XL frame with cxl->len 4 is CAN_MTU bytes, so it passes, and is then read as a canfd_frame whose len comes out of canxl_frame.flags: at least 0x80.
Of the paths that follow, only the flow control one uses that length without bounding it first, so check_pad() walks to 255 over a 16-byte frame and the caller reports EBADMSG on an unrelated socket.
bcm_rx_handler(), j1939_can_recv(), can_can_gw_rcv() and raw_rcv() check the frame type here, and can_dropped_invalid_skb() switches on skb->protocol on the transmit side. isotp_rcv() is the gap.
--- net/can/isotp.c | 8 ++++++++ 1 file changed, 8 insertions(+)
net/can/isotp.c +8 -0
@@ -750,6 +750,14 @@ static void isotp_rcv(struct sk_buff *skb, void *data)if (skb->len != so->ll.mtu)return ; +/* check for correct CAN CC/FD frame content */ +if (so->ll.mtu ==CAN_MTU ) { +if (!can_is_can_skb (skb)) +return ; + }else if (!can_is_canfd_skb (skb)) { +return ; + } + cf = (struct canfd_frame *)skb->data;/* if enabled: check reception of my configured extended address */
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 363/686 can: dev: can_put_echo_skb(): free skb on invalid echo index
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Cunhao Lu <[email protected]>
[ Upstream commit b4ebcbbf66ba6c5816dfe229effb4641c46e4b4c ]
can_put_echo_skb() consumes the skb on all paths except when the echo index is out of bounds. This leaves ownership with the caller on -EINVAL, unlike the other error paths, and can leak the skb if the caller expects consistent semantics.
Free the skb before returning -EINVAL so that all return paths consume it.
---
FAQ:
Q: can_skb_init_valid() directly modifies skb->data without checking if
the SKB is cloned or shared. Is this violating SKB shared buffer rules and causing data corruption?
A: The finding about can_skb_init_valid() modifying skb->data on a
potentially shared buffer is not relevant for this (correct) patch.
The FDF-flag write in can_skb_init_valid() only matters for PF_PACKET
use: PF_CAN allocators already set CANFD_FDF. The write exists to normalize frames for PF_PACKET observers (tcpdump/Wireshark) so they can distinguish classic CAN from CAN FD at the netdev level, and to compensate for PF_PACKET senders that omit the bit. That normalization is functionally required.
The shared-buffer concern only becomes realistic through a specific
chain: a PF_PACKET sender injects a CANFD-sized frame, the CAN driver's loopback puts an echo skb back into can_rcv(), and cgw (without modfuncs) clones it for forwarding to another interface. Only on that second can_skb_init_valid() call is the skb cloned. By then the bit was already set on the exclusive skb during the initial xmit path, so the flags |= CANFD_FDF write is strictly idempotent for any parallel consumer of the shared buffer - no memory-safety or information-disclosure consequence. It's a formal violation of the skb sharing rules without an observable effect, so the current code can stay as-is.
--- drivers/net/can/dev/skb.c | 1 + 1 file changed, 1 insertion(+)
drivers/net/can/dev/skb.c +1 -0
@@ -52,6 +52,7 @@ int can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,if (idx >= priv->echo_skb_max) {netdev_err (dev,"%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n" , __func__, idx, priv->echo_skb_max); +dev_kfree_skb_any (skb);return -EINVAL ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 364/686 can: isotp: check the return values of can_rx_register() in isotp_bind()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Oliver Hartkopp <[email protected]>
[ Upstream commit 874f5f14cf626f72477071eff381c8485554250d ]
isotp_bind() ignores the return values of can_rx_register() for the RX and the echo receiver and binds the socket anyway. When a receiver can not be allocated, bind() succeeds without this receiver, so the socket does not receive frames or its transmissions time out. isotp_release() and isotp_notify() later try to remove the missing receiver, which triggers the "receive list entry not found" warning in can_rx_unregister().
As the device has been checked before and RTNL prevents a namespace change during bind(), only -ENOMEM can be returned here.
Check the return values and register the RX receiver as the last step. The echo receiver is registered first, as it only handles the socket's own echo frames and does nothing while no transmission is in progress. So a failed RX registration only needs to remove the echo receiver, and isotp_rcv() has never processed a frame for this socket.
Set so->ifindex before the registrations, so that a First Frame received before so->bound is set can be answered with a Flow Control frame and the RX timeout is started as usual. As the RX receiver is registered last, this can only happen for a bind() that succeeds. Reset so->ifindex when bind() fails.
Check IFF_UP only after the receivers have been registered, so that a bind() that fails on a down device does not report ENETDOWN. As bind() holds RTNL, the device state can not change in between.
--- net/can/isotp.c | 42 +++++++++++++++++++++++++++--------------- 1 file changed, 27 insertions(+), 15 deletions(-)
net/can/isotp.c +27 -15
@@ -1527,7 +1527,6 @@ static int isotp_bind(struct socket *sock, struct sockaddr *uaddr, int len)struct sock *sk = sock->sk;struct isotp_sock *so =isotp_sk (sk);struct net *net =sock_net (sk); -int ifindex;struct net_device *dev;canid_t tx_id = addr->can_addr.tp.tx_id;canid_t rx_id = addr->can_addr.tp.rx_id;
@@ -1604,26 +1603,36 @@ static int isotp_bind(struct socket *sock, struct sockaddr *uaddr, int len) err = -EINVAL ; goto out_put_dev; } -if (!(dev->flags &IFF_UP )) - notify_enetdown =1 ; - ifindex = dev->ifindex; - -if (isotp_register_rxid (so)) -can_rx_register (net, dev, rx_id,SINGLE_MASK (rx_id), - isotp_rcv, sk,"isotp" , sk); +/* switch to new settings */ + so->ifindex = dev->ifindex; + so->rxid = rx_id; + so->txid = tx_id;/* no consecutive frame echo skb in flight */ WRITE_ONCE (so->cfecho,0 ); -/* register for echo skb's */ -can_rx_register (net, dev, tx_id,SINGLE_MASK (tx_id), - isotp_rcv_echo, sk,"isotpe" , sk); +/* register for echo skb's first (no echo traffic at this point) */ + err =can_rx_register (net, dev, tx_id,SINGLE_MASK (tx_id), + isotp_rcv_echo, sk,"isotpe" , sk); +if (err) + goto out_put_dev; + +if (isotp_register_rxid (so)) { + err =can_rx_register (net, dev, rx_id,SINGLE_MASK (rx_id), + isotp_rcv, sk,"isotp" , sk); +if (err) { +/* unregister echo skb subscription */ +can_rx_unregister (net, dev, tx_id,SINGLE_MASK (tx_id), + isotp_rcv_echo, sk); + goto out_put_dev; + } + } + +/* report a down device only for a successful bind() */ +if (!(dev->flags &IFF_UP )) + notify_enetdown =1 ; -/* switch to new settings */ - so->ifindex = ifindex; - so->rxid = rx_id; - so->txid = tx_id; so->bound =1 ;/* bind() ok -> hold a reference for so->dev so that isotp_release()
@@ -1634,6 +1643,9 @@ static int isotp_bind(struct socket *sock, struct sockaddr *uaddr, int len)netdev_hold (so->dev, &so->dev_tracker,GFP_KERNEL ); out_put_dev: +if (err) + so->ifindex =0 ;/* reset on failed bind() */ +/* remove potential reference from dev_get_by_index() */ dev_put (dev); out:
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 365/686 can: proc: reset pkg_stats atomics individually
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Runyu Xiao <[email protected]>
[ Upstream commit 12297f855bbd943847cb8893a3614caef5a9c2a8 ]
Commit 80b5f90158d1 ("can: statistics: use atomic access in hot path") converted several members of struct can_pkg_stats to atomic_long_t and updated the hot TX/RX and procfs read paths to use atomic_long_*() helpers. However, can_init_stats() still clears the whole struct with memset().
can_init_stats() is reached from can_stat_update() in timer context and also from the procfs reset path. Those paths can run while the TX/RX hot paths are concurrently updating rx_frames, tx_frames, matches and their *_delta counters. Hitting the whole-struct memset() in that window performs plain writes to fields that otherwise follow an atomic_long_t access contract, which can lose or mix live statistics updates.
This issue was found by source-level API-misuse analysis looking for whole-object resets left behind after atomic_long_t conversions, then manually audited on Linux v6.18.21.
Replace the whole-struct memset() with a helper that resets the atomic_long_t counters via atomic_long_set() and clears the derived scalar statistics explicitly. This preserves the existing reset semantics for scalar fields while restoring atomic access discipline for the live counters.
Build-tested by compiling net/can/proc.o on x86_64 netdev/main. Runtime-tested with a QEMU + vcan setup on Linux v6.18.21 by driving concurrent traffic and reset_stats reads, which reproduced inconsistent exported statistics before the fix.
[Hartkopp] can_stat_update() also read the *_delta counters at the beginning and cleared them with atomic_long_set() at the end. Increments from the hot path in between were lost for both the current and the next interval. Use atomic_long_xchg() to fetch and clear the *_delta counters in one atomic step instead.
On x86_64 atomic_long_set() is a plain store like memset(), so the memset() is an actual problem only on architectures with lock-based atomics (e.g. parisc). The inconsistencies seen on x86_64 come from the *_delta handling and from the stale snapshots, which are fixed in "can:
proc: skip stats calculation after reset in can_stat_update()". As before, the counters are reset one at a time and the derived scalar statistics use plain stores.
--- net/can/proc.c | 39 +++++++++++++++++++++++++++++---------- 1 file changed, 29 insertions(+), 10 deletions(-)
net/can/proc.c +29 -10
@@ -76,16 +76,39 @@ static const char rx_list_name[][8] = {* af_can statistics stuff */ +static void can_reset_pkg_stats (struct can_pkg_stats *pkg_stats) +{ +atomic_long_set (&pkg_stats->rx_frames,0 ); +atomic_long_set (&pkg_stats->tx_frames,0 ); +atomic_long_set (&pkg_stats->matches,0 ); + + pkg_stats->total_rx_rate =0 ; + pkg_stats->total_tx_rate =0 ; + pkg_stats->total_rx_match_ratio =0 ; + + pkg_stats->current_rx_rate =0 ; + pkg_stats->current_tx_rate =0 ; + pkg_stats->current_rx_match_ratio =0 ; + + pkg_stats->max_rx_rate =0 ; + pkg_stats->max_tx_rate =0 ; + pkg_stats->max_rx_match_ratio =0 ; + +atomic_long_set (&pkg_stats->rx_frames_delta,0 ); +atomic_long_set (&pkg_stats->tx_frames_delta,0 ); +atomic_long_set (&pkg_stats->matches_delta,0 ); +} +static void can_init_stats (struct net *net) {struct can_pkg_stats *pkg_stats = net->can.pkg_stats;struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;/* -* This memset function is called from a timer context (when +* This stats reset is called from a timer context (when * can_stattimer is active which is the default) OR in a process * context (reading the proc_fs when can_stattimer is disabled). */ -memset (pkg_stats,0 ,sizeof (struct can_pkg_stats )); +can_reset_pkg_stats (pkg_stats); pkg_stats->jiffies_init = jiffies; rcv_lists_stats->stats_reset++;
@@ -121,9 +144,10 @@ void can_stat_update(struct timer_list *t)long rx_frames =atomic_long_read (&pkg_stats->rx_frames);long tx_frames =atomic_long_read (&pkg_stats->tx_frames);long matches =atomic_long_read (&pkg_stats->matches); -long rx_frames_delta =atomic_long_read (&pkg_stats->rx_frames_delta); -long tx_frames_delta =atomic_long_read (&pkg_stats->tx_frames_delta); -long matches_delta =atomic_long_read (&pkg_stats->matches_delta); +/* fetch and clear values for 'current rate' calculation */ +long rx_frames_delta =atomic_long_xchg (&pkg_stats->rx_frames_delta,0 ); +long tx_frames_delta =atomic_long_xchg (&pkg_stats->tx_frames_delta,0 ); +long matches_delta =atomic_long_xchg (&pkg_stats->matches_delta,0 );/* restart counting in timer context on user request */ if (user_reset)
@@ -172,11 +196,6 @@ void can_stat_update(struct timer_list *t)if (pkg_stats->max_rx_match_ratio < pkg_stats->current_rx_match_ratio) pkg_stats->max_rx_match_ratio = pkg_stats->current_rx_match_ratio; -/* clear values for 'current rate' calculation */ -atomic_long_set (&pkg_stats->tx_frames_delta,0 ); -atomic_long_set (&pkg_stats->rx_frames_delta,0 ); -atomic_long_set (&pkg_stats->matches_delta,0 ); -/* restart timer (one second) */ mod_timer (&net->can.stattimer,round_jiffies (jiffies +HZ )); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 366/686 can: proc: skip stats calculation after reset in can_stat_update()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Oliver Hartkopp <[email protected]>
[ Upstream commit 01b19ed9fa031a649f3dd103ebe6e0102602e542 ]
Commit 80b5f90158d1 ("can: statistics: use atomic access in hot path") introduced local snapshots of the statistics counters at the beginning of can_stat_update(). When can_init_stats() resets the statistics, these stale pre-reset snapshots are still used for the following total/current /max calculations and overwrite the freshly reset values. Additionally a jiffies tick between the snapshot and the reset could trigger a second can_init_stats() call.
Merge the reset conditions into a single check and skip the calculation for the current interval when the statistics have been reset.
--- net/can/proc.c | 30 ++++++++++++------------------ 1 file changed, 12 insertions(+), 18 deletions(-)
net/can/proc.c +12 -18
@@ -149,25 +149,18 @@ void can_stat_update(struct timer_list *t)long tx_frames_delta =atomic_long_xchg (&pkg_stats->tx_frames_delta,0 );long matches_delta =atomic_long_xchg (&pkg_stats->matches_delta,0 ); -/* restart counting in timer context on user request */ -if (user_reset) -can_init_stats (net); - -/* restart counting on jiffies overflow */ -if (j < pkg_stats->jiffies_init) -can_init_stats (net); - -/* prevent overflow in calc_rate() */ -if (rx_frames > (LONG_MAX /HZ )) -can_init_stats (net); - -/* prevent overflow in calc_rate() */ -if (tx_frames > (LONG_MAX /HZ )) -can_init_stats (net); - -/* matches overflow - very improbable */ -if (matches > (LONG_MAX /100 )) +/* +* Restart counting in timer context on user request, on jiffies +* overflow or to prevent overflows in calc_rate() and in the +* match ratio calculation. The local snapshots are stale after +* the reset, so skip the calculation for this interval. +*/ +if (user_reset || j < pkg_stats->jiffies_init || + rx_frames > (LONG_MAX /HZ ) || tx_frames > (LONG_MAX /HZ ) || + matches > (LONG_MAX /100 )) {can_init_stats (net); + goto out; + }/* calc total values */ if (rx_frames)
@@ -196,6 +189,7 @@ void can_stat_update(struct timer_list *t)if (pkg_stats->max_rx_match_ratio < pkg_stats->current_rx_match_ratio) pkg_stats->max_rx_match_ratio = pkg_stats->current_rx_match_ratio; +out:/* restart timer (one second) */ mod_timer (&net->can.stattimer,round_jiffies (jiffies +HZ )); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 367/686 can: dev: can_fill_info(): dont wake up controller if interface is down
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: ChunYuZhiQiang <[email protected]>
[ Upstream commit 75332c410c8190d61499001c5516af977ca426c3 ]
If the interface is down, the CAN controller might be powered down and its clocks gated. Don't call do_get_berr_counter() to read the bus error counters if the interface is down, and adjust can_get_size() to match.
This removes one trigger for a synchronous external abort seen on i.MX8QXP when "ip link show" is run on a flexcan interface that was never brought up. The underlying cause is platform-specific: on i.MX8QXP the CAN clocks are gated through the SCU LPCG and the subsystem shares the IMX_SC_R_CAN_0 power domain, and there is a window after pm_runtime_resume_and_get() returns where the clock has not reached the module yet. This patch avoids the netlink query path while the interface is down, but does not root-cause the LPCG window itself.
As a result, IFLA_CAN_BERR_COUNTER is no longer reported for down interfaces. Userspace must treat the attribute as optional.
The issue was triggered on an i.MX8QXP board by running "ip link show" without ever bringing the interface up:
Internal error: synchronous external abort: 0000000096000210
pc : flexcan_read_le+0x0/0x18
lr : flexcan_get_berr_counter+0x4c/0x8c
Call trace:
flexcan_read_le+0x0/0x18
flexcan_get_berr_counter+0x4c/0x8c
can_fill_info+0x1f8/0x434
rtnl_fill_ifinfo+0x8fc/0xbb4
rtnl_dump_ifinfo+0x364/0x448This is the same class of problem fixed for m_can in commit 91a55c72a821 ("can: m_can: m_can_get_berr_counter(): don't wake up controller if interface is down").
--- drivers/net/can/dev/netlink.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/net/can/dev/netlink.c +2 -2
@@ -586,7 +586,7 @@ static size_t can_get_size(const struct net_device *dev) size +=nla_total_size (sizeof (u32));/* IFLA_CAN_STATE */ size +=nla_total_size (sizeof (struct can_ctrlmode ));/* IFLA_CAN_CTRLMODE */ size +=nla_total_size (sizeof (u32));/* IFLA_CAN_RESTART_MS */ -if (priv->do_get_berr_counter)/* IFLA_CAN_BERR_COUNTER */ +if (priv->do_get_berr_counter &&netif_running (dev))/* IFLA_CAN_BERR_COUNTER */ size +=nla_total_size (sizeof (struct can_berr_counter ));if (priv->termination_const) { size +=nla_total_size (sizeof (priv->termination));/* IFLA_CAN_TERMINATION */
@@ -737,7 +737,7 @@ static int can_fill_info(struct sk_buff *skb, const struct net_device *dev)nla_put (skb,IFLA_CAN_CTRLMODE ,sizeof (cm), &cm) ||nla_put_u32 (skb,IFLA_CAN_RESTART_MS , priv->restart_ms) || - (priv->do_get_berr_counter && + (priv->do_get_berr_counter &&netif_running (dev) && !priv->do_get_berr_counter (dev, &bec) && nla_put(skb, IFLA_CAN_BERR_COUNTER, sizeof(bec), &bec)) ||
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 368/686 can: peak_usb: pcan_usb_fd_decode_buf(): accept short uCAN end-of-list records
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Liu Changjie <[email protected]>
[ Upstream commit 2d4c272e816a5b784f1fc7899256f8826df34edb ]
A PCAN-USB FD v2 running firmware 3.2.0 sends a 16-byte status record followed by a four-byte zero-size end marker.
Since commit 93fcab2c6968 ("can: peak_usb: validate uCAN receive record lengths") these transfers cause repeated receive-buffer dumps while the interface is up.
This has been observed on Linux 7.2.11-arch1-1 with matching kernel headers:
- Classic CAN, 500 kbit/s: 25 decoder errors in 5 s before the fix; none in 15 s after.
- CAN FD, 500 kbit/s nominal and 2 Mbit/s data: 26 decoder errors in 5 s before the fix; none in 60 s after.
- Three additional down/up cycles: no decoder errors.
pcan_usb_fd_decode_buf() requires a complete 12-byte struct pucan_msg before checking the size field, so it rejects the end marker with -EBADMSG.
Check that the size field is present before testing for an end marker. Require the full header for nonzero-size records and keep the remaining record and payload length checks.
This patch was created with LLM assistance.
---
Built and tested the original and patched peak_usb modules on Arch Linux 7.2.11-arch1-1 with matching kernel headers.
- Classic CAN, 500 kbit/s: 25 decoder errors in 5 s before the fix; none in 15 s after.
- CAN FD, 500 kbit/s nominal and 2 Mbit/s data: 26 decoder errors in 5 s before the fix; none in 60 s after.
- Three additional down/up cycles: no decoder errors.
USB captures during the patched tests contained 406 packets with short end markers. Neither receive-buffer dump recurred.
The CAN bus was disconnected; external TX/RX was not tested. One startup "can_change_state: oops, state did not change" message and an RX dropped count reaching 2 were observed during the patched tests. Their causes remain undetermined.
--- drivers/net/can/usb/peak_usb/pcan_usb_fd.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/net/can/usb/peak_usb/pcan_usb_fd.c +6 -1
@@ -755,7 +755,7 @@ static int pcan_usb_fd_decode_buf(struct peak_usb_device *dev, struct urb *urb)u16 rx_msg_type, rx_msg_size;size_t rx_msg_min_size; -if (msg_end - msg_ptr <sizeof (*rx_msg)) { +if (msg_end - msg_ptr <sizeof (rx_msg->size)) { err = -EBADMSG ;break ; }
@@ -766,6 +766,11 @@ static int pcan_usb_fd_decode_buf(struct peak_usb_device *dev, struct urb *urb)break ; } +if (msg_end - msg_ptr <sizeof (*rx_msg)) { + err = -EBADMSG ; +break ; + } + rx_msg_size =le16_to_cpu (rx_msg->size); rx_msg_type =le16_to_cpu (rx_msg->type);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 369/686 mm/khugepaged: always recheck the pmd in try_collapse_pte_mapped_thp()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Josef Bacik <[email protected]>
[ Upstream commit aa72cf34d90da7019591ab67533a8ece8b41da2d ]
try_collapse_pte_mapped_thp() drops the PTE lock after it has cleared the page table, and takes the PMD lock and the PTE lock to remove it.
In between, MADV_DONTNEED with CONFIG_PT_RECLAIM can reclaim the page table. The pmd_same() check is supposed to handle this, but it is only done with CONFIG_SPLIT_PTE_PTLOCKS.
Fix it by performing the check unconditionally.
Fix generated by an LLM and sent by Josef Bacik in private.
--- mm/khugepaged.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
mm/khugepaged.c +4 -5
@@ -1664,12 +1664,11 @@ int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr,/* step 4: remove empty page table */ if (!pml) { pml =pmd_lock (mm, pmd); -if (ptl != pml) { +if (ptl != pml)spin_lock_nested (ptl,SINGLE_DEPTH_NESTING ); -if (unlikely (!pmd_same (pgt_pmd,pmdp_get_lockless (pmd)))) { -flush_tlb_mm (mm); - goto unlock; - } +if (unlikely (!pmd_same (pgt_pmd,pmdp_get_lockless (pmd)))) { +flush_tlb_mm (mm); + goto unlock; } } pgt_pmd =pmdp_collapse_flush (vma, haddr, pmd);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 370/686 mm/khugepaged: fix PMD table lock leak in try_collapse_pte_mapped_thp()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Josef Bacik <[email protected]>
[ Upstream commit db38b902307e687219ec765ef51a6ef459746c87 ]
For a private mapping with userfaultfd, try_collapse_pte_mapped_thp() takes the PMD table lock before it maps the page table for the second time. If that (pte_offset_map_rw_nolock) fails, because the page table vanished in the meantime due to concurrent page table reclaim, it leaves through the abort label, where the PMD table lock is unlocked if it differs from PTE table lock.
In case the PMD table lock and the PTE table lock match, which is the case without CONFIG_SPLIT_PTE_PTLOCKS after pte_offset_map_rw_nolock() failed, we miss to unlock the PMD table.
To fix it, forget the PTE table lock when we unmap+unlock the PTE table.
Fix generated by an LLM and sent by Josef Bacik in private.
--- mm/khugepaged.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
mm/khugepaged.c +3 -2
@@ -1555,7 +1555,7 @@ int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr, result =SCAN_FAIL ; start_pte =pte_offset_map_lock (mm, pmd, haddr, &ptl); -if (!start_pte)/* mmap_lock + page lock should prevent this */ +if (!start_pte) goto drop_folio;/* step 1: check all mapped PTEs are to the right huge page */
@@ -1586,6 +1586,7 @@ int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr, }pte_unmap_unlock (start_pte, ptl); + ptl =NULL ;mmu_notifier_range_init (&range,MMU_NOTIFY_CLEAR ,0 , mm, haddr, haddr +HPAGE_PMD_SIZE );mmu_notifier_invalidate_range_start (&range);
@@ -1603,7 +1604,7 @@ int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr, pml =pmd_lock (mm, pmd); start_pte =pte_offset_map_rw_nolock (mm, pmd, haddr, &pgt_pmd, &ptl); -if (!start_pte)/* mmap_lock + page lock should prevent this */ +if (!start_pte) goto abort;if (!pml)spin_lock (ptl);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 371/686 mm/khugepaged: preserve dirty bits when collapsing PTE-mapped THPs
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit fe2817e3d5ea347214342c9a5cd8bcbff20c0574 ]
try_collapse_pte_mapped_thp() clears PTEs without transferring their dirty bits to the folio. A shmem read fault can map a clean folio writable, so a later store only dirties the PTE. Losing that dirty bit allows reclaim to discard modified data.
The assumption that regular files are read-only is also obsolete since commit 1b6444331bebb ("mm/khugepaged: enable clean pagecache folio collapse for writable files"). In any case, transferring PTE dirty bits to the folio when removing mappings (and while the folio is still mapped) is the right thing to do.
Use get_and_clear_ptes() to collect the dirty bits and mark the folio dirty before unmapping it. Update the comment.
This was reproduced with shmem using MADV_COLLAPSE followed by MADV_PAGEOUT.
Fix generated by an LLM and sent by Chris Mason in private.
--- mm/khugepaged.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
mm/khugepaged.c +3 -2
@@ -1646,9 +1646,10 @@ int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr,/* * Must clear entry, or a racing truncate may re-remove it. * TLB flush can be left until pmdp_collapse_flush() does it. -* PTE dirty? Shmem page is already dirty; file is read-only. */ -clear_ptes (mm, addr, pte, nr_batch_ptes); + ptent =get_and_clear_ptes (mm, addr, pte, nr_batch_ptes); +if (pte_dirty (ptent)) +folio_mark_dirty (folio);folio_remove_rmap_ptes (folio, page, nr_batch_ptes, vma); nr_mapped_ptes += nr_batch_ptes; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 372/686 mm/gup: recheck the PUD under PTL in follow_pud_mask()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Hildenbrand (Arm) <[email protected]>
[ Upstream commit 79cb51d538abc459f74e046d27797d36b133ce0e ]
follow_pud_mask() reads the PUD without a lock. If it is a leaf, it takes the lock and calls follow_huge_pud(), which reads the entry again, but only tests whether it is present.
A leaf can be zapped concurrently and a page fault can fill the empty entry with a page table.
This currently only applies when device-dax makes use of PUD entries, and the fault after e.g., MADV_DONTNEED would find THPs to be disabled.
That requires a sequence like
1) Fault in the PUD
2) Disable THP
3) Have GUP race against concurrent MADV_DONTNEED + refault
Which is rather unlikely to happen in practice, which is why we never received a report about such a problem.
Before commit 1b1676180246 ("mm/gup: handle huge pud for follow_pud_mask()"), we performed that check in follow_devmap_pud() by testing for pud_devmap().
Let's fix it by just structuring follow_pud_mask() similar to follow_pmd_mask(), minus protnone stuff that does not apply and minus FOLL_SPLIT_PMD handling. That makes it much easier to spot any such inconsistencies.
Perform the pud_bad() check early in follow_pmd_mask() and just forward the PUD value. We can drop the pud_present() check in follow_huge_pud(), just like we have in follow_huge_pmd().
Even though we are performing more changes than strictly necessary, the fix should be easy to backport.
--- mm/gup.c | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-)
mm/gup.c +18 -14
@@ -658,9 +658,6 @@ static struct page *follow_huge_pud(struct vm_area_struct *vma,assert_spin_locked (pud_lockptr (mm, pudp)); -if (!pud_present (pud)) -return NULL ; -if ((flags &FOLL_WRITE ) && !can_follow_write_pud (pud,pfn_to_page (pfn), vma, flags))return NULL ;
@@ -896,15 +893,17 @@ static struct page *follow_page_pte(struct vm_area_struct *vma, }static struct page *follow_pmd_mask (struct vm_area_struct *vma, -unsigned long address,pud_t *pudp, -unsigned int flags, -unsigned long *page_mask) +unsigned long address,pud_t *pudp,pud_t pud, +unsigned int flags,unsigned long *page_mask) {pmd_t *pmd, pmdval;spinlock_t *ptl;struct page *page;struct mm_struct *mm = vma->vm_mm; +if (unlikely (pud_bad (pud))) +return no_page_table (vma, flags, address); + pmd =pmd_offset (pudp, address); pmdval =pmdp_get_lockless (pmd);if (pmd_none (pmdval))
@@ -953,18 +952,23 @@ static struct page *follow_pud_mask(struct vm_area_struct *vma, pud =pudp_get (pudp);if (!pud_present (pud))return no_page_table (vma, flags, address); -if (pud_leaf (pud)) { - ptl =pud_lock (mm, pudp); - page =follow_huge_pud (vma, address, pudp, flags, page_mask); +if (!pud_leaf (pud)) +return follow_pmd_mask (vma, address, pudp, pud, flags, page_mask); + + ptl =pud_lock (mm, pudp); + pud = *pudp; +if (unlikely (!pud_present (pud))) {spin_unlock (ptl); -if (page) -return page;return no_page_table (vma, flags, address); } -if (unlikely (pud_bad (pud))) -return no_page_table (vma, flags, address); +if (unlikely (!pud_leaf (pud))) { +spin_unlock (ptl); +return follow_pmd_mask (vma, address, pudp, pud, flags, page_mask); + } -return follow_pmd_mask (vma, address, pudp, flags, page_mask); + page =follow_huge_pud (vma, address, pudp, flags, page_mask); +spin_unlock (ptl); +return page; } static struct page *follow_p4d_mask(struct vm_area_struct *vma,
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 373/686 mm/gup: fix clearing folios in memfd_pin_folios()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit c83ee2fa5a94edb2e04102b9dd4f1ee0eeb2b932 ]
memfd_pin_folios() pins folios obtained directly from the page cache without checking whether they are uptodate. However, shmem fallocate() can leave newly allocated folios uncleared and not uptodate. Callers such as udmabuf can then expose uninitialized memory to userspace.
Clear non-uptodate folios and mark them uptodate under the folio lock before returning them to the caller.
Fix generated by an LLM and sent by Chris Mason in private.
--- mm/gup.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
mm/gup.c +14 -0
@@ -3519,6 +3519,20 @@ long memfd_pin_folios(struct file *memfd, loff_t start, loff_t end, goto err; } +/* +* fallocate() can leave folios in the +* page cache that were never cleared. +*/ +if (!folio_test_uptodate (folio)) { +folio_lock (folio); +if (!folio_test_uptodate (folio)) { +folio_zero_range (folio,0 ,folio_size (folio)); +flush_dcache_folio (folio); +folio_mark_uptodate (folio); + } +folio_unlock (folio); + } +if (nr_folios ==0 ) *offset =offset_in_folio (folio, start);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 374/686 mm/gup: fix out-of-bounds write for nr_pages == 0 in GUP-fast
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 1dfe4b276c23189394afb42d114ee8a54cc3aff2 ]
With nr_pages == 0, GUP-fast still enters its page table walk and can write past the caller's page array. The old end <= start check caught empty ranges, but was replaced with an overflow check.
Users such as OrangeFS can pass a zero page count derived from a userspace-supplied length. So let's return zero for nr_pages == 0 before starting the walk, just like GUP-slow.
Fix generated by an LLM and sent by Chris Mason in private.
--- mm/gup.c | 3 +++ 1 file changed, 3 insertions(+)
mm/gup.c +3 -0
@@ -3207,6 +3207,9 @@ static int gup_fast_fallback(unsigned long start, unsigned long nr_pages, FOLL_PCI_P2PDMA | FOLL_HONOR_NUMA_FAULT)))return -EINVAL ; +if (unlikely (!nr_pages)) +return 0 ; +if (gup_flags &FOLL_PIN )mm_set_has_pinned_flag (current->mm);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 375/686 mm/gup: check for overflow when converting nr_pages to bytes in GUP-fast
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Hildenbrand (Arm) <[email protected]>
[ Upstream commit 21a3888d3d2f87b7f15ccea1f0befd57346fe899 ]
The overflow check in gup_fast_fallback() only covers the addition to start. The preceding nr_pages << PAGE_SHIFT can already have truncated the length on 32bit.
Users such as RapidIO's rio_dma_transfer() can derive such page counts from a 64-bit userspace length.
Let's just check_shl_overflow() to reject any such overflow with -EOVERFLOW early.
--- mm/gup.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
mm/gup.c +2 -2
@@ -3217,8 +3217,8 @@ static int gup_fast_fallback(unsigned long start, unsigned long nr_pages,might_lock_read (¤t->mm->mmap_lock); start =untagged_addr (start) &PAGE_MASK ; - len = nr_pages <<PAGE_SHIFT ; -if (check_add_overflow (start, len, &end)) +if (check_shl_overflow (nr_pages,PAGE_SHIFT , &len) || +check_add_overflow (start, len, &end))return -EOVERFLOW ;if (end >TASK_SIZE_MAX )return -EFAULT ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 376/686 mm/mmu_gather: fix flushing ranges with 4 GiB or larger
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Josef Bacik <[email protected]>
[ Upstream commit 64ae7959a1df8af8eec504e31df2ec9670424a4e ]
__tlb_adjust_range() takes the size of the range which has to be flushed as an unsigned int. Its callers, tlb_flush_{pte,pmd,pud,p4d}_range(), get and pass an unsigned long. Consequently, a range that is 4 GiB or larger gets truncated, possibly to 0.
On arm64 with hugetlb, a 64k kernel can have 16 GiB hugetlb folios mapped contiguously at the PMD level and flush them when unmapping, and a 16k kernel can flush 64 GiB PUDs through tlb_unshare_pmd_ptdesc(). So at least these two scenarios are affected.
Fix it by flushing the proper range instead of the truncated one by properly using "unsigned long" for range_size.
Fix generated by an LLM and sent by Josef Bacik in private.
--- include/asm-generic/tlb.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
include/asm-generic/tlb.h +1 -2
@@ -395,8 +395,7 @@ struct mmu_gather {void tlb_flush_mmu (struct mmu_gather *tlb);static inline void __tlb_adjust_range (struct mmu_gather *tlb, -unsigned long address, -unsigned int range_size) +unsigned long address,unsigned long range_size) { tlb->start =min (tlb->start, address); tlb->end =max (tlb->end, address + range_size);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 377/686 mm/mmu_notifier: finish non-blocking interval invalidation on error
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Josef Bacik <[email protected]>
[ Upstream commit 6d65925777ecae9d7a571a327e41c63f3940a0c7 ]
When an ordinary MMU notifier rejects a non-blocking invalidation, the interval invalidation started beforehand is left unfinished: the caller skips mmu_notifier_invalidate_range_end(). Subsequent interval notifier operations can then wait forever.
The only in-tree trigger is nouveau SVM, which uses both notifier types and rejects non-blocking invalidations. Reaping via the OOM reaper or process_mrelease() can therefore leave the GPU fault worker stuck, holding a reference that prevents the dying process's address space and memory from being freed.
End the interval invalidation when an ordinary notifier fails a non-blocking invalidation, like mn_itree_invalidate() already does when an interval notifier fails. Make that handling clearer in the documentation of mmu_notifier_invalidate_range_start_nonblock().
Fix generated by an LLM and sent by Josef Bacik in private.
--- include/linux/mmu_notifier.h | 3 ++- mm/mmu_notifier.c | 17 +++++++++++++---- 2 files changed, 15 insertions(+), 5 deletions(-)
include/linux/mmu_notifier.h +2 -1
@@ -444,7 +444,8 @@ mmu_notifier_invalidate_range_start(struct mmu_notifier_range *range)/* * This version of mmu_notifier_invalidate_range_start() avoids blocking, but it * can return an error if a notifier can't proceed without blocking, in which -* case you're not allowed to modify PTEs in the specified range. +* case you're not allowed to modify PTEs in the specified range or call +* mmu_notifier_invalidate_range_end(). * * This is mainly intended for OOM handling. */
mm/mmu_notifier.c +13 -4
@@ -522,16 +522,25 @@ int __mmu_notifier_invalidate_range_start(struct mmu_notifier_range *range) {struct mmu_notifier_subscriptions *subscriptions = range->mm->notifier_subscriptions; -int ret; +const bool has_itree = subscriptions->has_itree; +int ret =0 ; -if (subscriptions->has_itree) { +if (has_itree) { ret =mn_itree_invalidate (subscriptions, range);if (ret)return ret; }if (!hlist_empty (&subscriptions->list)) -return mn_hlist_invalidate_range_start (subscriptions, range); -return 0 ; + ret =mn_hlist_invalidate_range_start (subscriptions, range); + +/* +* On error, the non-blocking caller is not allowed to call +* invalidate_range_end(), as in mn_itree_invalidate(). +*/ +if (ret && has_itree && !mmu_notifier_range_blockable (range)) +mn_itree_inv_end (subscriptions); + +return ret; } static void
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 378/686 mm/mmu_notifier: set ->mm only after mmgrab()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 5ad9e4b0f1104f5dbfb41125c34bb30ea6dc7a94 ]
Radeon uses a non-NULL notifier->mm to decide whether to call mmu_interval_notifier_remove() when freeing a buffer object. __mmu_interval_notifier_insert() sets ->mm before validating the range, so a wrapping userptr range can leave ->mm set after insertion fails. Cleanup then tries to remove an unregistered notifier for which no mm reference was acquired.
Set ->mm only after mmgrab(), once insertion can no longer fail. While we could fix radeon's code instead, setting ->mm on success only makes the code more robust.
Fix generated by an LLM and sent by Chris Mason in private.
--- mm/mmu_notifier.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
mm/mmu_notifier.c +5 -2
@@ -901,7 +901,6 @@ static int __mmu_interval_notifier_insert( struct mmu_notifier_subscriptions *subscriptions, unsigned long start, unsigned long length, const struct mmu_interval_notifier_ops *ops) { - interval_sub->mm = mm; interval_sub->ops = ops;RB_CLEAR_NODE (&interval_sub->interval_tree.rb); interval_sub->interval_tree.start = start;
@@ -918,8 +917,12 @@ static int __mmu_interval_notifier_insert(if (WARN_ON (atomic_read (&mm->mm_users) <=0 ))return -EINVAL ; -/* pairs with mmdrop in mmu_interval_notifier_remove() */ +/* +* Pairs with mmdrop in mmu_interval_notifier_remove(). Drivers take a +* non-NULL ->mm for "registered", so set it only with the reference. +*/ mmgrab (mm); + interval_sub->mm = mm;/* * If some invalidate_range_start/end region is going on in parallel
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 379/686 mm/mremap: use pudp_huge_get_and_clear() when moving huge PUDs
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Hildenbrand (Arm) <[email protected]>
[ Upstream commit b4417d08034a7b4a3083e0e2d95429d4542524f2 ]
move_huge_pud() reads the old PUD and clears it in separate operations. Hardware accessed or dirty updates between those operations can be lost when the saved entry is installed at the new address.
The raw pud_clear() also bypasses page_table_check_pud_clear(), while set_pud_at() accounts for the destination mapping. This leaves the checker counts unbalanced for mappings tracked by page table checking.
To fix it, simply use pudp_huge_get_and_clear().
--- mm/mremap.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
mm/mremap.c +1 -2
@@ -496,8 +496,7 @@ static bool move_huge_pud(struct pagetable_move_control *pmc,spin_lock_nested (new_ptl,SINGLE_DEPTH_NESTING );/* Clear the pud */ - pud = *old_pud; -pud_clear (old_pud); + pud =pudp_huge_get_and_clear (mm, pmc->old_addr, old_pud);VM_BUG_ON (!pud_none (*new_pud));
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 380/686 mm/mremap: recheck PUDs under the page table lock
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Hildenbrand (Arm) <[email protected]>
[ Upstream commit 402882943dfa8bab5c2bcc66189f9fb2828f248e ]
Once get_old_pud() is fixed to accept PUD leaves, unmap_mapping_range() can clear a leaf between the lookup and the move. Holding mmap_lock in write mode does not prevent this.
If the zap happens before move_page_tables() tests the entry, an empty PUD can reach move_normal_pud(), where pud_populate() turns it into a present page table entry. If it happens after the test, move_huge_pud() can instead try to move an empty entry, triggering CONFIG_DEBUG_VM warnings on powerpc.
Recheck the source under the page table lock in both helpers. Treat an empty source in move_normal_pud() as a completed move, and use __pud_trans_huge_lock() in move_huge_pud().
In the future we should likely have the code lookup a PUD/PMD lockless once, instead of multiple times, because one of the problematic bits here is the:
pud_trans_huge(*old_pud)
--- mm/mremap.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
mm/mremap.c +8 -2
@@ -448,14 +448,18 @@ static bool move_normal_pud(struct pagetable_move_control *pmc,if (new_ptl != old_ptl)spin_lock_nested (new_ptl,SINGLE_DEPTH_NESTING ); -/* Clear the pud */ pud = *old_pud; +if (unlikely (pud_none (pud))) + goto out_unlock; + +/* Clear the pud */ pud_clear (old_pud);VM_BUG_ON (!pud_none (*new_pud));pud_populate (mm, new_pud,pud_pgtable (pud));flush_tlb_range (vma, pmc->old_addr, pmc->old_addr +PUD_SIZE ); +out_unlock:if (new_ptl != old_ptl)spin_unlock (new_ptl);spin_unlock (old_ptl);
@@ -490,7 +494,9 @@ static bool move_huge_pud(struct pagetable_move_control *pmc,* We don't have to worry about the ordering of src and dst * ptlocks because exclusive mmap_lock prevents deadlock. */ - old_ptl =pud_lock (mm, old_pud); + old_ptl =__pud_trans_huge_lock (old_pud, vma); +if (unlikely (!old_ptl)) +return false; new_ptl =pud_lockptr (mm, new_pud);if (new_ptl != old_ptl)spin_lock_nested (new_ptl,SINGLE_DEPTH_NESTING );
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 381/686 mm/mremap: fix moving PUD leaves
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Josef Bacik <[email protected]>
[ Upstream commit 440c8779757f09f290770b1d361dc1516a9d0b3e ]
pud_none_or_clear_bad() only really works on page tables. PUD leaves confuse the check and make us clear the page table entry and print a warning.
Since commit aed877c2b4257 ("device/dax: properly refcount device dax pages when mapping"), this also leaks device-DAX folio references, mapcounts and RSS accounting, resulting in "Bad rss-counter state" warnings on exit.
Allow PUD leaves in get_old_pud(). If a PUD leaf cannot be moved as a whole or the move fails, split it. This unmaps it with proper accounting instead of treating the leaf entry as a PMD table.
Keep using pud_trans_huge() for now, in the future this code should be cleaned up to just check for PUD leaves.
Fix generated by an LLM and sent by Josef Bacik in private.
--- mm/mremap.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-)
mm/mremap.c +4 -5
@@ -87,7 +87,7 @@ static pud_t *get_old_pud(struct mm_struct *mm, unsigned long addr)return NULL ; pud =pud_offset (p4d, addr); -if (pud_none_or_clear_bad (pud)) +if (!pud_trans_huge (*pud) &&pud_none_or_clear_bad (pud))return NULL ;return pud;
@@ -834,11 +834,10 @@ unsigned long move_page_tables(struct pagetable_move_control *pmc)if (!new_pud)break ;if (pud_trans_huge (*old_pud)) { -if (extent ==HPAGE_PUD_SIZE ) { -move_pgt_entry (pmc,HPAGE_PUD , old_pud, new_pud); -/* We ignore and continue on error? */ +if (extent ==HPAGE_PUD_SIZE && +move_pgt_entry (pmc,HPAGE_PUD , old_pud, new_pud))continue ; - } +split_huge_pud (pmc->old, old_pud, pmc->old_addr); }else if (IS_ENABLED (CONFIG_HAVE_MOVE_PUD ) && extent ==PUD_SIZE ) {if (move_pgt_entry (pmc,NORMAL_PUD , old_pud, new_pud))continue ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 382/686 mm/madvise: fix data loss from MADV_FREE on a KSM page
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Hildenbrand (Arm) <[email protected]>
[ Upstream commit 22d043c1da48d6c7274f9dd900714b6d58b7b9c6 ]
MADV_FREE can clear the dirty flag of a singly mapped KSM folio. The folio remains in the stable tree and can gain new mappings without being dirtied again. Once marked lazyfree, reclaim can discard data that those mappings still need.
KSM always marks a folio dirty when converting it to a KSM folio in try_to_merge_one_page(). Marking a folio lazyfree clears PG_swapbacked but leaves PG_dirty unchanged. Preserving PG_dirty makes reclaim restore PG_swapbacked instead of discarding the folio. This also protects folios that were already lazyfree when KSM converted them.
Skip KSM folios before clearing their dirty flag, checking under the folio lock to serialize with KSM conversion.
--- mm/madvise.c | 9 +++++++++ 1 file changed, 9 insertions(+)
mm/madvise.c +9 -0
@@ -755,6 +755,15 @@ static int madvise_free_pte_range(pmd_t *pmd, unsigned long addr,if (folio_test_swapcache (folio) ||folio_test_dirty (folio)) {if (!folio_trylock (folio))continue ; +/* +* KSM folios can gain new mappings at any time, so we must +* not clear their dirty flag. +*/ +if (folio_test_ksm (folio)) { +folio_unlock (folio); +continue ; + } +/* * If we have a large folio at this point, we know it is * fully mapped so if its mapcount is the same as its
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 383/686 mm/memory: reject remote COW faults on PFN mappings
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 8db6921cc07b74197a3866d62ed262b68aeadcf3 ]
When handling a COW fault without a normal source page (PFN mappings), __wp_page_copy_user() copies from the faulting user address. For remote faults, this accesses the wrong address space, resulting in wrong data getting copied.
For example, user_events updates an enable bit in the registering process's memory. If that memory needs to be faulted in, user_event_enabler_fault_fixup() calls fixup_user_fault() from a work item. Placing the enable bit in a private PFN mapping can trigger this remote COW path.
Reject these faults with VM_FAULT_SIGBUS when the target mm differs from current->mm: remote faults. Ordinary (non-PFN) mappings are not affected.
The user-address copy dates back to commit 6aab341e0a28 ("mm: re-architect the VM_UNPAGED logic"); likely, actual ways to get remote faults in there on COW PFN mappings appeared afterwards. But the fix is simple and straight forward.
Fix generated by an LLM and sent by Chris Mason in private.
--- mm/memory.c | 9 +++++++++ 1 file changed, 9 insertions(+)
mm/memory.c +9 -0
@@ -3387,6 +3387,13 @@ static inline int __wp_page_copy_user(struct page *dst, struct page *src,return 0 ; } +/* +* __copy_from_user_inatomic() only works as expected for local faults. +* Reject remote faults. +*/ +if (unlikely (mm != current->mm)) +return -EFAULT ; +/* * If the source page was a PFN mapping, we don't have * a "struct page" for it. We do a best-effort copy by
@@ -3712,6 +3719,8 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)folio_put (old_folio);delayacct_wpcopy_end (); +if (err == -EFAULT ) +return VM_FAULT_SIGBUS ;return err == -EHWPOISON ?VM_FAULT_HWPOISON :0 ; }kmsan_copy_page_meta (&new_folio->page, vmf->page);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 384/686 mm: fix unmap_mapping_range() beyond 4 GiB on 32-bit
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Josef Bacik <[email protected]>
[ Upstream commit 7a81bc23dade8082187be6d9cc36e4be4b7207e2 ]
Commit 9eab0421fa94 ("mm: fix unmap_mapping_range high bits shift bug") made holebegin and holelen unsigned before they are shifted, by casting them to pgoff_t. That is an unsigned long: on a 32-bit kernel the cast cuts off the upper half of the two loff_t values, so a hole which begins at 4 GiB or beyond is taken for one in the first 4 GiB of the file.
truncate_pagecache() passes the new size of the file and asks for private COWed pages to be unmapped as well. If a file of 6 GiB is truncated to 5 GiB, everything from 1 GiB on is unmapped, and what a process has written to a private mapping of the range between 1 GiB and 5 GiB is
lost: it reads the contents of the file again.
Where the range has an end, the wrong range is unmapped instead of the right one. The page cache copes with that, as it unmaps every folio that it removes. The callers which only have unmap_mapping_range() to get rid of user mappings do not, for example drm_vma_node_unmap(), whose fake offsets reach beyond 4 GiB on 32-bit, and revoke_iomem() with physical addresses of more than 32 bits.
Cast to u64 instead. Nothing changes for 64-bit kernels.
Fix generated by an LLM and sent by Josef Bacik in private.
--- mm/memory.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
mm/memory.c +2 -2
@@ -4277,8 +4277,8 @@ EXPORT_SYMBOL_GPL(unmap_mapping_pages);void unmap_mapping_range (struct address_space *mapping,loff_t const holebegin,loff_t const holelen,int even_cows) { -pgoff_t hba = (pgoff_t)(holebegin) >>PAGE_SHIFT ; -pgoff_t hlen = ((pgoff_t)(holelen) +PAGE_SIZE -1 ) >>PAGE_SHIFT ; +pgoff_t hba = (u64 )holebegin >>PAGE_SHIFT ; +pgoff_t hlen = ((u64 )holelen +PAGE_SIZE -1 ) >>PAGE_SHIFT ;/* Check for overflow. */ if (sizeof (holelen) >sizeof (hlen)) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 385/686 mm: fix unkillable fault loop on MAP_DROPPABLE memory
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 9f02ca8c15a74bc9e4e8e05ec089f63cb87cbf75 ]
handle_mm_fault() suppresses VM_FAULT_OOM for VM_DROPPABLE mappings.
For user-mode faults, pending signals are processed before retrying the access. Kernel-mode faults on user buffers instead return directly to the faulting instruction.
With persistent allocation failures (esp. memcg limits), a syscall, such as write(), can therefore loop while not dropping locks.
Only suppress VM_FAULT_OOM when FAULT_FLAG_USER is set, allowing kernel-mode faults and GUP to fail and signal allocation errors.
Fix generated by an LLM and sent by Chris Mason in private.
--- mm/memory.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
mm/memory.c +6 -2
@@ -6541,8 +6541,12 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address,lru_gen_exit_fault (); -/* If the mapping is droppable, then errors due to OOM aren't fatal. */ -if (is_droppable) +/* +* If the mapping is droppable, then errors due to OOM aren't fatal: the +* task returns to user mode, handles its signals and tries again. A +* fault from kernel mode has no such return, so it must see the error. +*/ +if (is_droppable && (flags &FAULT_FLAG_USER )) ret &= ~VM_FAULT_OOM ;if (flags &FAULT_FLAG_USER ) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 386/686 mm/ksm: reset the unstable trees of all nodes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Hildenbrand (Arm) <[email protected]>
[ Upstream commit 890e118e95bfc2aae4432ec2a95192d6f9193211 ]
Each full scan resets ksm_nr_node_ids unstable tree roots. Enabling merge_across_nodes resets this count to 1, even if per-node roots were previously allocated.
So when toggling "merge_across_nodes" 0 -> 1 -> 0, a scan that starts while the setting is 1 and continues after switching back to 0 can encounter stale unstable tree roots, resulting in UAF.
Only root is allowed to change "merge_across_nodes", and the documented sequence is: "merge_across_nodes setting can be changed only when there are no ksm shared pages in the system: set run 2 to unmerge pages first, then to 1 after changing merge_across_nodes, to remerge according to the new setting."
Let's fix it by tracking in ksm_nr_node_ids the actual number of allocated tree roots.
remove_all_stable_nodes() and ksm_check_stable_tree() will now scan more tree roots (skipping the empty ones), which is harmless.
--- mm/ksm.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
mm/ksm.c +3 -3
@@ -469,6 +469,7 @@ static void advisor_stop_scan(void)#ifdef CONFIG_NUMA /* Zeroed when merging across nodes is not allowed */ static unsigned int ksm_merge_across_nodes =1 ; +/* Number of allocated stable and unstable tree roots. */ static int ksm_nr_node_ids =1 ;#else #define ksm_merge_across_nodes 1U
@@ -3572,14 +3573,13 @@ static ssize_t merge_across_nodes_store(struct kobject *kobj,else { root_stable_tree = buf; root_unstable_tree = buf + nr_node_ids; + ksm_nr_node_ids = nr_node_ids;/* Stable tree is empty but not the unstable */ root_unstable_tree[0 ] = one_unstable_tree[0 ]; } } -if (!err) { +if (!err) ksm_merge_across_nodes = knob; - ksm_nr_node_ids = knob ?1 : nr_node_ids; - } }mutex_unlock (&ksm_thread_mutex);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 387/686 mm/vma: call ->may_split() before a partial merge
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 0193e83368022a308d19ee0293f55a4f5d548e40 ]
A driver can use the ->may_split() hook to forbid a VMA boundary at certain addresses.
A device-dax device is a character device that gives raw access to a range of memory through mmap(). device-dax refuses any address that is not a multiple of the device's alignment through vm_ops->may_split.
vma_merge_existing_range() can move boundaries, but does not call vm_ops->may_split.
If a range at the edge of a VMA gets the attributes of the adjacent VMA, the function moves only that range over to the neighbour: one VMA shrinks and the other grows. This is a partial merge, and vma_modify() tries it before any split.
Take a device-dax VMA that lies next to another VMA of the same file. The user calls mprotect() on the one page of the first VMA that touches the second VMA, and asks for the protection that the second VMA already has. The result is a partial merge. It puts the boundary inside a 1 GiB mapping, which is a single leaf entry at the PUD level.
As part of the merge, the kernel looks for a huge PMD to split at the new boundary. That code does not expect a PUD leaf:
vma_merge_existing_range()
commit_merge()
vma_adjust_trans_huge()
split_huge_pmd_address()
mm_find_pmd()
treats the PUD leaf as a pointer to a PMD table, so the "table" is the device memory that the leaf maps
__split_huge_pmd()
reads a PMD that the user wrote to the device memory folio_put() on the folio that this PMD names
Bad. While the code must at some point be taught to split PUD entries as well, the issue here is that we move VMA boundaries such that they are incompatible with the driver.
Fix this by calling ->may_split() on the address that a partial merge would move the boundary to, and by abandoning the merge if the driver refuses. vma_modify() then tries the split, which fails with -EINVAL.
Factor out existing split handling into check_split() and reuse it.
Fix generated by an LLM and sent by Chris Mason in private.
--- mm/vma.c | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-)
mm/vma.c +16 -5
@@ -485,6 +485,15 @@ void unmap_region(struct ma_state *mas, struct vm_area_struct *vma,tlb_finish_mmu (&tlb); } +static int check_split (struct vm_area_struct *vma,unsigned long addr) +{ +if (!vma->vm_ops) +return 0 ; +if (!vma->vm_ops->may_split) +return 0 ; +return vma->vm_ops->may_split (vma, addr); +} +/* * __split_vma() bypasses sysctl_max_map_count checking. We use this where it * has already been checked or doesn't make sense to fail.
@@ -501,11 +510,9 @@ __split_vma(struct vma_iterator *vmi, struct vm_area_struct *vma,WARN_ON (vma->vm_start >= addr);WARN_ON (vma->vm_end <= addr); -if (vma->vm_ops && vma->vm_ops->may_split) { - err = vma->vm_ops->may_split (vma, addr); -if (err) -return err; - } + err =check_split (vma, addr); +if (err) +return err; new =vm_area_dup (vma);if (!new)
@@ -875,6 +882,10 @@ static __must_check struct vm_area_struct *vma_merge_existing_range(if (vmg->__remove_middle && !can_merge_remove_vma (middle))return NULL ; +/* If middle isn't removed then it's resized, i.e. splits. */ +if (!vmg->__remove_middle &&check_split (middle, left_side ? end : start)) +return NULL ; +/* * If we merge both VMAs, then next is also deleted. This implies * merge_will_delete_vma also.
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 388/686 mm/memory-tiers: unregister empty tiers outside memory_tier_lock
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: David Hildenbrand (Arm) <[email protected]>
[ Upstream commit 500624f28eca441e35f978979ccfb373202fefd3 ]
When offlining a node's last memory empties its tier, clear_node_memory_tier() calls device_unregister() while holding memory_tier_lock. A concurrent sysfs read can hold a kernfs active reference and block in nodelist_show() on that mutex. device_unregister() then waits in kernfs_drain() for the read to finish and release its active reference, while the reader waits for the offlining task to release the mutex.
Return the node's former tier from clear_node_memory_tier(), making the helper more similar to set_node_memory_tier(), which also returns a memory_tier pointer. Let the caller unlink an empty tier under memory_tier_lock before rebuilding demotion targets, then unregister its device after dropping the lock.
--- mm/memory-tiers.c | 29 +++++++++++++---------------- 1 file changed, 13 insertions(+), 16 deletions(-)
mm/memory-tiers.c +13 -16
@@ -561,21 +561,14 @@ static struct memory_tier *set_node_memory_tier(int node)return memtier; } -static void destroy_memory_tier (struct memory_tier *memtier) +static struct memory_tier *clear_node_memory_tier (int node) { -list_del (&memtier->list); -device_unregister (&memtier->dev); -} - -static bool clear_node_memory_tier (int node) -{ -bool cleared = false;pg_data_t *pgdat;struct memory_tier *memtier; pgdat =NODE_DATA (node);if (!pgdat) -return false; +return NULL ;/* * Make sure that anybody looking at NODE_DATA who finds
@@ -593,14 +586,10 @@ static bool clear_node_memory_tier(int node)synchronize_rcu (); memtype = node_memory_types[node].memtype;node_clear (node, memtype->nodes); -if (nodes_empty (memtype->nodes)) { +if (nodes_empty (memtype->nodes))list_del_init (&memtype->tier_sibling); -if (list_empty (&memtier->memory_types)) -destroy_memory_tier (memtier); - } - cleared = true; } -return cleared; +return memtier; }static void release_memtype (struct kref *kref)
@@ -873,13 +862,21 @@ static int __meminit memtier_hotplug_callback(struct notifier_block *self, {struct memory_tier *memtier;struct node_notify *nn = _arg; +bool empty = false;switch (action) {case NODE_REMOVED_LAST_MEMORY :mutex_lock (&memory_tier_lock); -if (clear_node_memory_tier (nn->nid)) + memtier =clear_node_memory_tier (nn->nid); +if (memtier) { + empty =list_empty (&memtier->memory_types); +if (empty) +list_del (&memtier->list);establish_demotion_targets (); + }mutex_unlock (&memory_tier_lock); +if (empty) +device_unregister (&memtier->dev);break ;case NODE_ADDED_FIRST_MEMORY :mutex_lock (&memory_tier_lock);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 389/686 mm/huge_memory: set the mmu_gather page size in zap_huge_pud()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ritesh Harjani (IBM) <[email protected]>
[ Upstream commit 466d6844c8f19fba16b668b49861bdb8d7ded282 ]
Unmapping a device-dax mapping with 1G alignment on powerpc radix kernel built with CONFIG_DEBUG_VM triggers this warning on every munmap:
WARNING: mm/mmu_gather.c:176 at __tlb_remove_folio_pages_size+0x38/0x230
NIP [c00000000063d508] __tlb_remove_folio_pages_size+0x38/0x230
LR [c0000000006fb688] zap_huge_pud+0x1b8/0x2d0
Call Trace:
zap_huge_pud+0x170/0x2d0 (unreliable)
__zap_vma_range+0x1604/0x1e20
unmap_vmas+0xa0/0x1f0
unmap_region+0xb0/0x130
vms_complete_munmap_vmas+0x120/0x310
do_vmi_align_munmap+0x1ec/0x240
__vm_munmap+0x148/0x220
sys_munmap+0x28/0x40To trigger this - it is enough to mmap() /dev/dax0.0, touch the first byte so that the whole 1G is mapped by a single PUD and then munmap() it.
PowerPC needs MMU_GATHER_PAGE_SIZE in which mmu_gather needs to record the page size for which tlb flush is needed. zap_huge_pmd(), zap_pte_range(), change_huge_pud() etc all do this already. However, since commit:
dbe54153296d ("mm/huge_memory: add vmf_insert_folio_pud()")
a device-dax PUD maps a real folio and zap_huge_pud() now hands it to tlb_remove_page_size(tlb, page, HPAGE_PUD_SIZE). At that point tlb->page_size is still whatever the previous user left behind, which is 0 for the fresh gather set up by munmap() and so the check fires.
Fix this in the same way like how other similar paths do.
--- mm/huge_memory.c | 2 ++ 1 file changed, 2 insertions(+)
mm/huge_memory.c +2 -0
@@ -2822,6 +2822,8 @@ int zap_huge_pud(struct mmu_gather *tlb, struct vm_area_struct *vma,spinlock_t *ptl;pud_t orig_pud; +tlb_change_page_size (tlb,HPAGE_PUD_SIZE ); + ptl =__pud_trans_huge_lock (pud, vma);if (!ptl)return 0 ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 390/686 mm/gup: check folio->mapping under folio lock in memfd_pin_folios()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Samiullah Khawaja <[email protected]>
[ Upstream commit 71555ae8c7572fd99158013ca2e29187c5d2508d ]
memfd_pin_folios() pins folios from the page cache without taking the folio lock. khugepaged or MADV_COLLAPSE can therefore replace a folio after checking its refcount while memfd_pin_folios() still pins the old folio. The caller then receives a folio which is no longer part of the memfd.
For udmabuf and iommufd, this can cause data corruption: DMA accesses the detached folio rather than the live memfd contents. DMA reads can return stale data, while DMA writes update the detached copy and are lost from the live memfd. The detached folio remains pinned, so these accesses do not constitute a use-after-free or target another application's memory. For memfd live update, the stale contents can reappear in the memfd after handover.
Lock the folio and recheck folio->mapping before pinning it, like other page cache users do. If the folio was removed, retry the folio lookup from the index that was removed.
--- mm/gup.c | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-)
mm/gup.c +21 -8
@@ -3463,7 +3463,7 @@ long memfd_pin_folios(struct file *memfd, loff_t start, loff_t end, {unsigned int flags, nr_folios, nr_found;unsigned int i, pgshift =PAGE_SHIFT ; -pgoff_t start_idx, end_idx; +pgoff_t start_idx, end_idx, retry_idx;struct folio *folio =NULL ;struct folio_batch fbatch;struct hstate *h;
@@ -3504,6 +3504,7 @@ long memfd_pin_folios(struct file *memfd, loff_t start, loff_t end,* reason, we try to allocate them and add them to the * page cache. */ + retry_idx = start_idx; nr_found = filemap_get_folios_contig(memfd->f_mapping, &start_idx, end_idx,
@@ -3516,7 +3517,21 @@ long memfd_pin_folios(struct file *memfd, loff_t start, loff_t end,for (i =0 ; i < nr_found; i++) { folio = fbatch.folios[i]; +/* +* The folio might have been removed from the +* page cache (e.g., truncated or collapsed) +* after the lookup. Recheck under the folio +* lock. +*/ +folio_lock (folio); +if (unlikely (folio->mapping != memfd->f_mapping)) { +folio_unlock (folio); + start_idx = retry_idx; +break ; + } +if (try_grab_folio (folio,1 ,FOLL_PIN )) { +folio_unlock (folio);folio_batch_release (&fbatch); ret = -EINVAL ; goto err;
@@ -3527,14 +3542,12 @@ long memfd_pin_folios(struct file *memfd, loff_t start, loff_t end,* page cache that were never cleared. */ if (!folio_test_uptodate (folio)) { -folio_lock (folio); -if (!folio_test_uptodate (folio)) { -folio_zero_range (folio,0 ,folio_size (folio)); -flush_dcache_folio (folio); -folio_mark_uptodate (folio); - } -folio_unlock (folio); +folio_zero_range (folio,0 ,folio_size (folio)); +flush_dcache_folio (folio); +folio_mark_uptodate (folio); } + retry_idx =folio_next_index (folio); +folio_unlock (folio);if (nr_folios ==0 ) *offset =offset_in_folio (folio, start);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 391/686 ipv6: fix device binding after failed datagram connect
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Xia Yan <[email protected]>
[ Upstream commit bc53aab4881adc134f495092034e9e7c0791d84c ]
__ip6_datagram_connect() can change sk_bound_dev_if when connecting to an address that needs a scope ID. If ip6_datagram_dst_update() fails, the old peer address and port are restored, but the new device binding is left behind.
A UDP socket can then keep reporting its original peer while sends and attempts to reconnect to that peer fail with ENETUNREACH. Replies to the socket are also dropped by the device match. The same problem occurs when a scoped multicast destination picks up np->mcast_oif.
Save the original binding before processing the scope and restore it along with the peer information on failure. This completes the rollback in commit 2f987a76a977 ("net: ipv6: keep sk status consistent after datagram connect failure") and preserves the new binding on success.
Found while reviewing scope-ID handling in __ip6_datagram_connect().
Confirmed by exchanging UDP traffic over ::1, then attempting a link-local connect with a nonexistent scope ifindex or a down interface. After that connect fails, the original peer is still reported but communication and reconnecting to it fail.
Tested before and after the fix in UML for three rounds, covering explicit scopes, multicast interface fallback, initially unconnected sockets and existing bindings. With the fix, the old binding and peer are retained, and traffic and reconnection to the original peer work. Also built on x86_64 with W=1 using adjusted allmodconfig and allyesconfig configurations, with no new warnings.
--- net/ipv6/datagram.c | 4 ++++ 1 file changed, 4 insertions(+)
net/ipv6/datagram.c +4 -0
@@ -148,6 +148,7 @@ int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr,__be32 fl6_flowlabel =0 ;__be32 old_fl6_flowlabel;__be16 old_dport; +int old_bound_dev_if;int addr_type;int err;
@@ -218,6 +219,8 @@ int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, goto out; } + old_bound_dev_if = sk->sk_bound_dev_if; +if (__ipv6_addr_needs_scope_id (addr_type)) {if (addr_len >=sizeof (struct sockaddr_in6 ) && usin->sin6_scope_id) {
@@ -260,6 +263,7 @@ int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, sk->sk_v6_daddr = old_daddr; np->flow_label = old_fl6_flowlabel; inet->inet_dport = old_dport; +WRITE_ONCE (sk->sk_bound_dev_if, old_bound_dev_if); goto out; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 392/686 ovl: do not let chattr change the casefold flag
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 83b351c3ade542bbfa1073e8c2d919826628252a ]
chattr +F or -F on an overlay directory can make the directory, or the whole mount, unusable. Lookups of the directory, and lookups in it, then fail. From code inspection, the caller only needs to own the directory. The upper filesystem must support casefolding: ext4 or f2fs with the casefold feature, or tmpfs with the casefold option.
chattr +F and -F set and clear FS_CASEFOLD_FL, the casefold flag of a directory. The flag enables casefolding (case-insensitive name lookup) for the directory. All directories of an overlay must match the casefold state that was recorded at mount time, and ovl_lookup_single() enforces this:
- A lookup in a directory that does not match fails with -ESTALE.
- A lookup of the directory itself fails with -EREMOTE.
ovl_fileattr_set() copies the directory up, which creates it in the upper layer if it only existed in a lower layer. It then passes FS_CASEFOLD_FL on to the upper filesystem. The upper filesystem accepts the change if the upper directory is empty, regardless of what the merged directory contains. The merged directory is the one that the user sees, with the names from the upper and the lower directories.
After the change the upper directory no longer matches the mount. If the directory is the root of the overlay, the whole mount is affected.
The flag can also change without chattr +F or -F. chattr reads all flags of a directory, changes one and writes all of them back. For a directory that only exists in a lower layer, overlayfs reads the flags from the lower filesystem. xfs with the ascii-ci feature reports FS_CASEFOLD_FL on every inode, but never sets S_CASEFOLD, the inode flag that overlayfs compares with the mount. So its directories count as not casefolded. With a lower layer on such an xfs and an upper layer on ext4 with the casefold feature, chattr +A on a lower-only directory therefore sets FS_CASEFOLD_FL on the new, empty upper directory.
Reproduced as root on tmpfs and on ext4 with chattr +F or -F on an overlay directory whose upper directory was empty. Afterwards lookups below it failed with ESTALE, and lookups of the directory itself failed with EREMOTE. The chattr +A case was seen once, on a kernel with an earlier form of this patch that still passed the caller's flag on:
lookups of the directory failed with EREMOTE.
Fix this by returning -EOPNOTSUPP if FS_IOC_SETFLAGS, the only call that can change the flag, asks for a casefold flag on a directory that does not agree with the casefold state of the mount. This also refuses the chattr +A case above.
[amir: check the flag against the casefold state of the mount instead of
reading back the flags]
--- fs/overlayfs/inode.c | 8 ++++++++ 1 file changed, 8 insertions(+)
fs/overlayfs/inode.c +8 -0
@@ -657,6 +657,14 @@ int ovl_fileattr_set(struct mnt_idmap *idmap,unsigned int flags;int err; +/* +* Lookup refuses a directory that does not agree with the casefold +* state of the mount. Only FS_IOC_SETFLAGS can ask for a change. +*/ +if (S_ISDIR (inode->i_mode) && fa->flags_valid && + !!(fa->flags &FS_CASEFOLD_FL ) !=OVL_FS (inode->i_sb)->casefold) +return -EOPNOTSUPP ; + err =ovl_copy_up (dentry);if (!err) {ovl_path_real (dentry, &upperpath);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 393/686 net/sched: clamp skb->queue_mapping before indexing the tx queue
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jamal Hadi Salim <[email protected]>
[ Upstream commit f19f2b308beb158d0e6f6eb806ced636e4ebf6ce ]
This issue was caught by Sashiko (nipa). A producer-side path cap is already merged (ea4d4b5dddb5); this patch adds the matching consumer-side caps.
The issue:
The tx queue is picked and capped in netdev_core_pick_tx() before the __dev_xmit_skb() qdisc enqueue path. A tc BPF program running inside an egress qdisc (not clsact) can then change __sk_buff->queue_mapping; that store is never re-checked. bpf_convert_ctx_access() bounds it only by NO_QUEUE_MAPPING, not by the device's queue count.
Two consumers read the stale value:
- On dequeue, qdisc_restart() calls netdev_get_tx_queue(), which indexes dev->_tx[]. netdev_get_tx_queue() guards it with just a DEBUG_NET_WARN_ON_ONCE, so sch_direct_xmit() takes the out-of-bounds txq->_xmit_lock and writes txq->xmit_lock_owner past the end of the allocation on non-lltx devices such as ifb. Drivers that index their rings from skb_get_queue_mapping() (ex: ifb) go out of range the same way.
- On enqueue, taprio_enqueue() indexes q->qdiscs[] with the same value; the array is sized dev->num_tx_queues. A duplicating netem on a child qdisc clones the skb and re-enqueues the clone at the taprio root (qdisc_root_bh()) through a direct rootq->enqueue() call, so the value reaches taprio_enqueue() before any dequeue cap runs.
The Fix:
Cap the mapping at the consumers and write the capped value back, so the qdisc's _tx[] lookup, the taprio q->qdiscs[] lookup and any later driver read stay in range.
On the dequeue side the cap folds into the dequeue path instead of a separate walk over the returned list: dequeue_skb() caps the head, and each bulk helper caps the element it appends. For a qdisc that is not TCQ_F_ONETXQUEUE, netdev_cap_txqueue() logs a ratelimited notice and selects queue 0.
A TCQ_F_ONETXQUEUE qdisc is bound to a single tx queue: dequeue_skb() uses q->dev_queue for the frozen check, the BQL limit and the trace point, while qdisc_restart() transmits on the skb's queue. Capping an out-of-range mapping to queue 0 would therefore send a per-queue child's skb through a different queue than the one it was dequeued for. On mq, mqprio, taprio and htb offload children, a stopped queue 0 could then park the list in q->gso_skb, and the later wake would schedule queue 0's own child instead of this qdisc. Pin a TCQ_F_ONETXQUEUE mapping to the qdisc's own queue to keep the documented invariant.
The pin covers every mapping, not only an out-of-range one: an in-range mapping that a filter sets on one of those per-queue children is rewritten to the child's own queue, and this path does not call netdev_cap_txqueue(), so it logs no notice. On a single-queue device qdisc_create() sets TCQ_F_ONETXQUEUE, so the one-queue trigger described below also takes this branch and is corrected without a notice.
That also keeps a bulk list on one queue by construction: every element of a TCQ_F_ONETXQUEUE qdisc, including a follower changed by a filter, is pinned to q->dev_queue before it is appended. The fast bulk helper therefore needs no head comparison and no skb_bad_txq requeue; the slow helper, used only by non-ONETXQUEUE qdiscs, still compares and requeues a mismatched follower, where a wake on any queue reschedules q.
On the enqueue side taprio_enqueue() caps the mapping against real_num_tx_queues and writes it back before selecting q->qdiscs[queue], so a duplicating child cannot steer the clone out of the array.
Conditions to recreate the bug:
The dequeue path: load a SCHED_CLS or SCHED_ACT program that stores __sk_buff->queue_mapping (a tc BPF action is enough), attach it to a transmit qdisc (for example a matchall filter on a prio root), and send a packet. With a 1-queue device a store of 1 indexes one past dev->_tx[]. Under KASAN with panic_on_warn=1 the unfixed kernel faults with "BUG:
KASAN: slab-out-of-bounds in sch_direct_xmit". Loading the program needs
CAP_BPF/CAP_SYS_ADMIN, so the trigger is root.
The enqueue path: on a multi-queue device, install a software taprio root, graft a prio child with a duplicating netem on every class, and store an out-of-range queue_mapping from a matchall+bpf filter on the prio. The duplicate is re-enqueued at the taprio root and indexes q->qdiscs[] past dev->num_tx_queues; the unfixed kernel faults in taprio_enqueue_one(). Same CAP_BPF/CAP_SYS_ADMIN requirement.
--- net/sched/sch_generic.c | 41 ++++++++++++++++++++++++++++++++++++----- net/sched/sch_taprio.c | 5 +++++ 2 files changed, 41 insertions(+), 5 deletions(-)
net/sched/sch_generic.c +36 -5
@@ -71,9 +71,34 @@ static void qdisc_maybe_clear_missed(struct Qdisc *q,#define SKB_XOFF_MAGIC ((struct sk_buff *)1UL) +/* Re-cap a stale queue_mapping; an ONETXQUEUE qdisc pins q->dev_queue. */ +static u16 qdisc_cap_skb_tx_queue (struct Qdisc *q,struct sk_buff *skb) +{ +u16 queue =skb_get_queue_mapping (skb); +struct net_device *dev =qdisc_dev (q); +u16 capped; + +if (q->flags &TCQ_F_ONETXQUEUE ) + capped = q->dev_queue -netdev_get_tx_queue (dev,0 ); +else + capped =netdev_cap_txqueue (dev, queue); + +if (unlikely (capped != queue)) +skb_set_queue_mapping (skb, capped); + +return capped; +} + +static struct netdev_queue *skb_cap_tx_queue (struct Qdisc *q, +struct sk_buff *skb) +{ +return netdev_get_tx_queue (qdisc_dev (q), +qdisc_cap_skb_tx_queue (q, skb)); +} +static inline struct sk_buff *__skb_dequeue_bad_txq (struct Qdisc *q) { -const struct netdev_queue *txq = q->dev_queue; +const struct netdev_queue *txq;spinlock_t *lock =NULL ;struct sk_buff *skb;
@@ -85,7 +110,8 @@ static inline struct sk_buff *__skb_dequeue_bad_txq(struct Qdisc *q) skb =skb_peek (&q->skb_bad_txq);if (skb) {/* check the reason of requeuing without tx lock first */ - txq =skb_get_tx_queue (txq->dev, skb); +/* re-cap: real_num_tx_queues may have shrunk */ + txq =skb_cap_tx_queue (q, skb);if (!netif_xmit_frozen_or_stopped (txq)) { skb =__skb_dequeue (&q->skb_bad_txq);if (qdisc_is_percpu_stats (q)) {
@@ -199,6 +225,8 @@ static void try_bulk_dequeue_skb(struct Qdisc *q,if (!nskb)break ; +/* Every element of an ONETXQUEUE qdisc is pinned to q->dev_queue. */ +qdisc_cap_skb_tx_queue (q, nskb); bytelimit -= nskb->len;/* covers GSO len */ skb->next = nskb; skb = nskb;
@@ -216,7 +244,6 @@ static void try_bulk_dequeue_skb_slow(struct Qdisc *q,struct sk_buff *skb, int *packets) { - int mapping = skb_get_queue_mapping(skb); struct sk_buff *nskb;int cnt =0 ;
@@ -224,7 +251,9 @@ static void try_bulk_dequeue_skb_slow(struct Qdisc *q, nskb = q->dequeue (q);if (!nskb)break ; -if (unlikely (skb_get_queue_mapping (nskb) != mapping)) { +/* A tc BPF store may have changed the mapping; cap it. */ +if (unlikely (qdisc_cap_skb_tx_queue (q, nskb) != +skb_get_queue_mapping (skb))) {qdisc_enqueue_skb_bad_txq (q, nskb);break ; }
@@ -269,7 +298,7 @@ static struct sk_buff *dequeue_skb(struct Qdisc *q, bool *validate,if (xfrm_offload (skb)) *validate = true;/* check the reason of requeuing without tx lock first */ - txq =skb_get_tx_queue (txq->dev, skb); + txq =skb_cap_tx_queue (q, skb);if (!netif_xmit_frozen_or_stopped (txq)) { skb =__skb_dequeue (&q->gso_skb);if (qdisc_is_percpu_stats (q)) {
@@ -305,6 +334,8 @@ static struct sk_buff *dequeue_skb(struct Qdisc *q, bool *validate, skb = q->dequeue (q);if (skb) { bulk: +/* cap the head; the bulk helpers cap every appended element */ +qdisc_cap_skb_tx_queue (q, skb);if (qdisc_may_bulk (q))try_bulk_dequeue_skb (q, skb, txq, packets, budget);else
net/sched/sch_taprio.c +5 -0
@@ -631,6 +631,11 @@ static int taprio_enqueue(struct sk_buff *skb, struct Qdisc *sch,int queue; queue =skb_get_queue_mapping (skb); +if (unlikely (queue >=qdisc_dev (sch)->real_num_tx_queues)) { +/* A tc BPF program may have stored an out-of-range mapping. */ + queue =netdev_cap_txqueue (qdisc_dev (sch), queue); +skb_set_queue_mapping (skb, queue); + } child = q->qdiscs[queue];if (unlikely (child == &noop_qdisc))
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 394/686 vhost/vsock: size receive SKBs from declared payload
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daehyeon Ko <[email protected]>
[ Upstream commit d5e912448cd98b261eba8e35ab838f2dc69a79f5 ]
vhost_vsock_alloc_skb() sizes the skb from iov_length(), the total guest descriptor length. virtio_transport_inc_rx_pkt() instead adds hdr->len to rx_bytes and buf_used, and budgets each queued skb as SKB_TRUESIZE(0). The guest controls the descriptor length and hdr->len independently.
A guest can therefore provide a 64 KiB descriptor while declaring a zero payload. The descriptor-sized skb remains queued, rx_bytes and buf_used remain unchanged, and only the fixed queue-entry budget limits retention. This is not a lifetime leak: the skb is freed when dequeued or at socket teardown. Repeating this across connections can nevertheless exhaust host memory. On Linux v7.2, 455 such descriptors retained 30,255,680 bytes for a 262,144-byte receive buffer; a full-payload control retained 265,984 bytes.
Vhost previously read hdr->len and allocated pkt->buf from that value. The conversion from virtio_vsock_pkt to sk_buff instead allocated receive skbs from the descriptor length, introducing the allocation-accounting mismatch.
Copy the header into a stack object and validate hdr->len before allocating the skb. Size the allocation as sizeof(hdr) + payload_len so descriptor capacity no longer determines queued memory. Check payload_len against len - sizeof(hdr) to avoid addition overflow on 32-bit hosts.
--- drivers/vhost/vsock.c | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-)
drivers/vhost/vsock.c +16 -18
@@ -331,7 +331,7 @@ static struct sk_buff * vhost_vsock_alloc_skb(struct vhost_virtqueue *vq, unsigned int out, unsigned int in) { - struct virtio_vsock_hdr *hdr; + struct virtio_vsock_hdr hdr;struct iov_iter iov_iter;struct sk_buff *skb;size_t payload_len;
@@ -349,34 +349,32 @@ vhost_vsock_alloc_skb(struct vhost_virtqueue *vq, len > VIRTIO_VSOCK_MAX_PKT_BUF_SIZE + VIRTIO_VSOCK_SKB_HEADROOM)return NULL ; -/* len contains both payload and hdr */ - skb =virtio_vsock_alloc_skb (len,GFP_KERNEL ); -if (!skb) -return NULL ; -iov_iter_init (&iov_iter,ITER_SOURCE , vq->iov, out, len); - hdr =virtio_vsock_hdr (skb); - nbytes =copy_from_iter (hdr,sizeof (*hdr), &iov_iter); -if (nbytes !=sizeof (*hdr)) { + nbytes =copy_from_iter (&hdr,sizeof (hdr), &iov_iter); +if (nbytes !=sizeof (hdr)) {vq_err (vq,"Expected %zu bytes for pkt->hdr, got %zu bytes\n" , -sizeof (*hdr), nbytes); -kfree_skb (skb); +sizeof (hdr), nbytes);return NULL ; } - payload_len =le32_to_cpu (hdr->len); + payload_len =le32_to_cpu (hdr.len); + +/* The pkt is too big or the length in the header is invalid */ +if (payload_len > len -sizeof (hdr)) +return NULL ; + +/* Allocate only for the payload declared in the header. */ + skb =virtio_vsock_alloc_skb (payload_len +sizeof (hdr),GFP_KERNEL ); +if (!skb) +return NULL ; + +memcpy (virtio_vsock_hdr (skb), &hdr,sizeof (hdr));/* No payload */ if (!payload_len)return skb; -/* The pkt is too big or the length in the header is invalid */ -if (payload_len +sizeof (*hdr) > len) { -kfree_skb (skb); -return NULL ; - } -virtio_vsock_skb_put (skb, payload_len);if (skb_copy_datagram_from_iter (skb,0 , &iov_iter, payload_len)) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 395/686 mptcp: do not use Fast Open on MP_JOIN subflows
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yilin Zhang <[email protected]>
[ Upstream commit 6d2cf411aba2aa0bd641b49be5b1964ac5097a50 ]
tcp_fastopen_create_child() hands the SYN packet itself to subflow_syn_recv_sock(). For an MP_JOIN request this takes the fatal fallback: the cloned child is destroyed and handed back with drop_req flagged, but tcp_fastopen_create_child() does not check the flag and queues it, so accept() can expose the freed child.
MP_JOIN cannot use Fast Open: data on a subflow requires the completed HMAC exchange (RFC 8684, sec. 3.2). Refuse it (only the TFO path passes a SYN skb here) and let tcp_conn_request() fall back to the regular MP_JOIN handshake; also strip the Fast Open cookie from MP_JOIN SYN/ACKs.
--- net/mptcp/subflow.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
net/mptcp/subflow.c +11 -0
@@ -380,6 +380,10 @@ static void subflow_prep_synack(const struct sock *sk, struct request_sock *req,struct mptcp_subflow_context *subflow =mptcp_subflow_ctx (sk);struct inet_request_sock *ireq =inet_rsk (req); +/* MP_JOIN cannot use TFO, do not send a cookie in the SYN/ACK */ +if (foc &&mptcp_subflow_rsk (req)->mp_join) + foc->len =-1 ; +/* clear tstamp_ok, as needed depending on cookie */ if (foc && foc->len >-1 ) ireq->tstamp_ok =0 ;
@@ -889,6 +893,13 @@ static struct sock *subflow_syn_recv_sock(const struct sock *sk, fallback = true; }else if (subflow_req->mp_join) { +/* a SYN skb here comes from TFO, which MP_JOIN cannot use: just +* fall back to the regular path. +*/ +if ((TCP_SKB_CB (skb)->tcp_flags & (TCPHDR_SYN |TCPHDR_ACK )) == +TCPHDR_SYN ) +return NULL ; +mptcp_get_options (skb, &mp_opt);if (!(mp_opt.suboptions &OPTION_MPTCP_MPJ_ACK )) fallback = true;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 396/686 ublk: add missing DEL_DEV_ASYNC to unprivileged permission check
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Yitang Yang <[email protected]>
[ Upstream commit e6ac1da6a53c5f670bf09e60a2500d15be68d2fc ]
ublk_ctrl_uring_cmd_permission() is missing the UBLK_CMD_DEL_DEV_ASYNC case, causing the command to always return -EINVAL for unprivileged ublk devices. Fix it by adding the missing case.
--- drivers/block/ublk_drv.c | 1 + 1 file changed, 1 insertion(+)
drivers/block/ublk_drv.c +1 -0
@@ -3872,6 +3872,7 @@ static int ublk_ctrl_uring_cmd_permission(struct ublk_device *ub,case UBLK_CMD_STOP_DEV :case UBLK_CMD_ADD_DEV :case UBLK_CMD_DEL_DEV : +case UBLK_CMD_DEL_DEV_ASYNC :case UBLK_CMD_SET_PARAMS :case UBLK_CMD_START_USER_RECOVERY :case UBLK_CMD_END_USER_RECOVERY :
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 397/686 nvme-keyring: Add a missing key_put() call to nvme_tls_key_lookup()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jarkko Sakkinen <[email protected]>
[ Upstream commit 404a8f6caa63822c1d2a45adbf07fd9c0567a7ef ]
Call key_put() before returning -EKEYREVOKED, as the reference count gets incremented by key_lookup().
--- drivers/nvme/common/keyring.c | 1 + 1 file changed, 1 insertion(+)
drivers/nvme/common/keyring.c +1 -0
@@ -35,6 +35,7 @@ struct key *nvme_tls_key_lookup(key_serial_t key_id) }if (nvme_tls_psk_revoked (key)) {pr_err ("key id %08x revoked\n" , key_id); +key_put (key);return ERR_PTR (-EKEYREVOKED ); }return key;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 398/686 drm/amdgpu: Check cs flags.
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Bas Nieuwenhuizen <[email protected]>
[ Upstream commit f5ea64f9fcd921bc4e2307a262e19450b8a58524 ]
Had no validation before. libdrm_amdgpu memsets this, even for the raw/raw2 functions.
We have a lot of functions touching the ioctl struct, no strong opinion on where this is placed, but I thought early would be good.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c +3 -0
@@ -205,6 +205,9 @@ static int amdgpu_cs_pass1(struct amdgpu_cs_parser *p,int ret;int i; +if (cs->in.flags) +return -EINVAL ; + chunk_array =memdup_array_user (u64_to_user_ptr (cs->in.chunks), cs->in.num_chunks,sizeof (uint64_t ));
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 399/686 drm/amdgpu: parse CS IBs at the BO offset their VA mapping starts at
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jesse Zhang <[email protected]>
[ Upstream commit 63a59637517682a920f86da1a189a3e639dd4fb3 ]
For rings which parse or patch the IBs on the CPU, like JPEG and VCN, the CS looks the IB up through its VA mapping and maps the BO, but ignores the offset in the BO the mapping starts at. It then parses other data than the GPU executes. On navi31, an IB of JPEG NOPs in the second page of a BO, mapped with offset_in_bo 4096, is parsed from the zeros in the first page and rejected:
amdgpu 0000:03:00.0: Invalid packet [0x00000000]!
while the same IB submitted through a mapping of the whole BO works.
Add the mapping offset when locating the IB in the BO.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c +1 -1
@@ -1091,7 +1091,7 @@ static int amdgpu_cs_patch_ibs(struct amdgpu_cs_parser *p,if (r)return r; - kptr += va_start - (m->start *AMDGPU_GPU_PAGE_SIZE ); + kptr += va_start - (m->start *AMDGPU_GPU_PAGE_SIZE ) + m->offset;if (ring->funcs->parse_cs) {memcpy (ib->ptr, kptr, ib->length_dw *4 );
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 400/686 drm/amdgpu: keep the CS user fence BO in GTT
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jesse Zhang <[email protected]>
[ Upstream commit 7a56d929dc2304edaa6231e1eb5eb82b7e8b74a9 ]
The CS ioctl hands the GPU the GART address of the user fence BO, but since the BO keeps its own preferred and allowed domains, it no longer makes sure the BO is in GTT. A user fence in a VRAM BO, which only needs to be a page in size, gets its address from amdgpu_bo_gpu_offset(), which warns about non-contiguous VRAM. On navi31, a CS with a user fence in a 4K VRAM BO, or in one created with AMDGPU_GEM_CREATE_VM_ALWAYS_VALID:
WARNING: amdgpu_object.c:1531 at amdgpu_bo_gpu_offset+0x86/0xb0 [amdgpu], CPU#11: cs_gem_checks/18393 RIP: 0010:amdgpu_bo_gpu_offset+0x86/0xb0 [amdgpu] Call Trace: <TASK> amdgpu_cs_parser_bos.isra.0+0x4eb/0x850 [amdgpu] amdgpu_cs_ioctl+0x97e/0x2510 [amdgpu] drm_ioctl_kernel+0xac/0x110 [drm] drm_ioctl+0x2c6/0x5b0 [drm] __x64_sys_ioctl+0xa0/0xf0 do_syscall_64+0xa3/0x4d0 entry_SYSCALL_64_after_hwframe+0x76/0x7e
and BOs which can't be in GTT at all, like GWS or OA ones of a page in size, pass the checks as well.
Only take BOs which can't be anywhere else than in GTT as user fence, which the CS then validates there along with its other BOs. While at it, detect userptrs with amdgpu_ttm_tt_is_userptr(); amdgpu_ttm_tt_get_usermm() returns NULL once the task which created the userptr is gone.
v2: only take BOs which can only be in GTT instead of special casing the
user fence BO in the validation, use amdgpu_ttm_tt_is_userptr() (Christian)
--- drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c +6 -1
@@ -161,7 +161,12 @@ static int amdgpu_cs_p1_user_fence(struct amdgpu_cs_parser *p,if (size !=PAGE_SIZE || data->offset > (size -8 ))return -EINVAL ; -if (amdgpu_ttm_tt_get_usermm (p->uf_bo->tbo.ttm)) +if (amdgpu_ttm_tt_is_userptr (p->uf_bo->tbo.ttm)) +return -EINVAL ; + +/* The GPU writes the user fence through the GART */ +if (p->uf_bo->preferred_domains !=AMDGPU_GEM_DOMAIN_GTT && + p->uf_bo->allowed_domains !=AMDGPU_GEM_DOMAIN_GTT )return -EINVAL ; *offset = data->offset;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 401/686 drm/amdkfd: use the queues process info for the WPTR BO eviction fence
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jesse Zhang <[email protected]>
[ Upstream commit da2897ee8b811945fd40ecc4aaf03291c14ce61c ]
amdgpu_amdkfd_map_gtt_bo_to_gart() removes the eviction fence of bo->vm_bo->vm->process_info from the WPTR BO of a new queue. bo->vm_bo is the VM which opened the BO last, not necessarily the KFD process' VM, and a render node VM has no process info.
On navi31, an unprivileged process which exports its WPTR BO with AMDKFD_IOC_EXPORT_DMABUF and imports it on a second render node fd oopses in AMDKFD_IOC_CREATE_QUEUE:
BUG: kernel NULL pointer dereference, address: 0000000000000060 RIP: 0010:amdgpu_amdkfd_map_gtt_bo_to_gart+0x86/0x1a0 [amdgpu] init_user_queue.part.0+0x180/0x250 [amdgpu] pqm_create_queue+0x32d/0x730 [amdgpu] kfd_ioctl_create_queue+0x583/0x9f0 [amdgpu]
Pass the process info of the queue instead. With the fix, the queue is created and destroyed normally.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h | 3 ++- drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 8 +++++--- drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c | 3 ++- 3 files changed, 9 insertions(+), 5 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.h +2 -1
@@ -330,7 +330,8 @@ int amdgpu_amdkfd_gpuvm_map_gtt_bo_to_kernel(struct kgd_mem *mem, void **kptr, uint64_t *size);void amdgpu_amdkfd_gpuvm_unmap_gtt_bo_from_kernel (struct kgd_mem *mem); -int amdgpu_amdkfd_map_gtt_bo_to_gart (struct amdgpu_bo *bo,struct amdgpu_bo **bo_gart); +int amdgpu_amdkfd_map_gtt_bo_to_gart (struct amdgpu_bo *bo,struct amdgpu_bo **bo_gart, +struct amdkfd_process_info *process_info);int amdgpu_amdkfd_gpuvm_restore_process_bos (void *process_info,struct dma_fence __rcu **ef);
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +5 -3
@@ -2244,11 +2244,13 @@ int amdgpu_amdkfd_gpuvm_sync_memory(* amdgpu_amdkfd_map_gtt_bo_to_gart - Map BO to GART and increment reference count * @bo: Buffer object to be mapped * @bo_gart: Return bo reference +* @process_info: KFD process info of the queue the BO is for * * Before return, bo reference count is incremented. To release the reference and unpin/ * unmap the BO, call amdgpu_amdkfd_free_gtt_mem. */ -int amdgpu_amdkfd_map_gtt_bo_to_gart (struct amdgpu_bo *bo,struct amdgpu_bo **bo_gart) +int amdgpu_amdkfd_map_gtt_bo_to_gart (struct amdgpu_bo *bo,struct amdgpu_bo **bo_gart, +struct amdkfd_process_info *process_info) {int ret;
@@ -2270,8 +2272,8 @@ int amdgpu_amdkfd_map_gtt_bo_to_gart(struct amdgpu_bo *bo, struct amdgpu_bo **bo goto err_map_bo_gart_failed; } -amdgpu_amdkfd_remove_eviction_fence ( - bo, bo->vm_bo->vm->process_info->eviction_fence); +/* bo->vm_bo can be the VM of any file which opened the BO */ +amdgpu_amdkfd_remove_eviction_fence (bo, process_info->eviction_fence);amdgpu_bo_unreserve (bo);
drivers/gpu/drm/amd/amdkfd/kfd_process_queue_manager.c +2 -1
@@ -286,7 +286,8 @@ static int init_user_queue(struct process_queue_manager *pqm, } retval =amdgpu_amdkfd_map_gtt_bo_to_gart (q_properties->wptr_bo, - &(*q)->wptr_bo_gart); + &(*q)->wptr_bo_gart, + pqm->process->kgd_process_info);if (retval) {pr_err ("Failed to map wptr bo to GART\n" ); goto free_gang_ctx_bo;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 402/686 drm/amdgpu: check amdgpu_vm_ready() in dma-buf move notify
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Dariusz Marcinkiewicz <[email protected]>
[ Upstream commit 920ca822f527e45ce084b36f3c420b625eb7c62a ]
amdgpu_dma_buf_move_notify() touches the page tables without first calling amdgpu_vm_ready(). When a process is SIGKILLed, its VM entities are stopped. Teardown of an imported dma-buf then tries to clear PTEs by submitting to one of those stopped entities. That eventually hangs the task.
Commit aa5fc4362fac ("drm/amdgpu: fix task hang from failed job submission during process kill") added the stopped entity check in amdgpu_vm_ready() and used it in amdgpu_cs_vm_handling(). That did not cover a call in amdgpu_dma_buf_move_notify(), what was already mentioned in:
https://lists.freedesktop.org/archives/amd-gfx/2025-October/133076.html
Tested by SIGKILLing a GPU workload holding imported dma-bufs. Without the patch "Trying to push to a killed entity" errors are logged, then a task hangs. With the patch there are no hung tasks. This was tested on a 6.18 kernel.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c | 5 +++++ 1 file changed, 5 insertions(+)
drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c +5 -0
@@ -533,6 +533,11 @@ amdgpu_dma_buf_move_notify(struct dma_buf_attachment *attach)continue ; } +if (!amdgpu_vm_ready (vm)) { +dma_resv_unlock (resv); +continue ; + } +/* Reserve fences for two SDMA page table updates */ r =dma_resv_reserve_fences (resv,2 );if (!r)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 403/686 drm/amdgpu: finish GPU recovery callbacks before restarting schedulers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Prike Liang <[email protected]>
[ Upstream commit 733389cb31e2c55e355410759fdc68afe74a4582 ]
Run GPU post-reset callbacks, including KFD and display-audio resume, before restarting DRM scheduler workqueues. IP hardware initialization already happens inside ASIC recovery; this change orders the remaining callbacks before new scheduler submissions. Preserve the emergency-stop and guity job completition path's callbacks without starting schedulers,
--- drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -6
@@ -6667,8 +6667,10 @@ int amdgpu_device_gpu_recover(struct amdgpu_device *adev,amdgpu_device_halt_activities (adev, job, reset_context, &device_list, hive, need_emergency_restart); -if (need_emergency_restart) - goto skip_sched_resume; +if (need_emergency_restart) { +amdgpu_device_gpu_resume (adev, &device_list, need_emergency_restart); + goto reset_unlock; + }/* * Must check guilty signal here since after this point all old * HW fences are force signaled.
@@ -6678,18 +6680,17 @@ int amdgpu_device_gpu_recover(struct amdgpu_device *adev,if (job &&dma_fence_is_signaled (&job->hw_fence.base)) { job_signaled = true;dev_info (adev->dev,"Guilty job already signaled, skipping HW reset" ); - goto skip_hw_reset; + goto post_resume; } r =amdgpu_device_asic_reset (adev, &device_list, reset_context);if (r) goto reset_unlock; -skip_hw_reset: +post_resume: +amdgpu_device_gpu_resume (adev, &device_list, need_emergency_restart); r =amdgpu_device_sched_resume (&device_list, reset_context, job_signaled);if (r) goto reset_unlock; -skip_sched_resume: -amdgpu_device_gpu_resume (adev, &device_list, need_emergency_restart); reset_unlock:amdgpu_device_recovery_put_reset_lock (adev, &device_list); end_reset:
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 404/686 drm/amdgpu: clear RB_OVERFLOW bit when enabling interrupts for navi10_ih
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Milan Milicevic <[email protected]>
[ Upstream commit 146b96974b33b8cca52755ffed3cd24a82836013 ]
Port this change to navi10_ih.c:
commit afbf7955ff01 ("drm/amdgpu: clear RB_OVERFLOW bit when enabling interrupts")
Setting IH_RB_WPTR to 0 does not clear RB_OVERFLOW if RB_ENABLE is not set. Pulse WPTR_OVERFLOW_CLEAR after RB_ENABLE (and with WPTR_OVERFLOW_ENABLE) so overflow is cleared when interrupts are enabled.
--- drivers/gpu/drm/amd/amdgpu/navi10_ih.c | 28 ++++++++++++++++++++++++++ 1 file changed, 28 insertions(+)
drivers/gpu/drm/amd/amdgpu/navi10_ih.c +28 -0
@@ -161,6 +161,34 @@ static int navi10_ih_toggle_ring_interrupts(struct amdgpu_device *adev, tmp =RREG32 (ih_regs->ih_rb_cntl); tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,RB_ENABLE , (enable ?1 :0 )); tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,RB_GPU_TS_ENABLE ,1 ); + +if (enable) { +/* Unset the CLEAR_OVERFLOW bit to make sure the next step +* is switching the bit from 0 to 1 +*/ + tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,WPTR_OVERFLOW_CLEAR ,0 ); +if (amdgpu_sriov_vf (adev) &&amdgpu_sriov_reg_indirect_ih (adev)) { +if (psp_reg_program (&adev->psp, ih_regs->psp_reg_id, tmp)) +return -ETIMEDOUT ; + }else { +WREG32_NO_KIQ (ih_regs->ih_rb_cntl, tmp); + } + +/* Clear RB_OVERFLOW bit */ + tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,WPTR_OVERFLOW_CLEAR ,1 ); +if (amdgpu_sriov_vf (adev) &&amdgpu_sriov_reg_indirect_ih (adev)) { +if (psp_reg_program (&adev->psp, ih_regs->psp_reg_id, tmp)) +return -ETIMEDOUT ; + }else { +WREG32_NO_KIQ (ih_regs->ih_rb_cntl, tmp); + } + +/* Unset the CLEAR_OVERFLOW bit immediately so new overflows +* can be detected. +*/ + tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,WPTR_OVERFLOW_CLEAR ,0 ); + } +/* enable_intr field is only valid in ring0 */ if (ih == &adev->irq.ih) tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,ENABLE_INTR , (enable ?1 :0 ));
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 405/686 drm/amdgpu: publish IH enabled before PSP programs IH_RB_CNTL
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Milan Milicevic <[email protected]>
[ Upstream commit 9d550dd1a3b4b96da49f3560a84b5c2413a88cd3 ]
On SR-IOV, programming IH_RB_CNTL through PSP is slow enough for the first MSI to arrive before ih->enabled is set. amdgpu_ih_process() then drops the interrupt, rptr stays at 0, and RPTR_REARM never generates another edge, so every ring hits the fence fallback timer.
Set ih->enabled before psp_reg_program() on the indirect IH path for Navi10 and IH v6.0, and clear it if programming fails.
--- drivers/gpu/drm/amd/amdgpu/ih_v6_0.c | 13 ++++++++++++- drivers/gpu/drm/amd/amdgpu/navi10_ih.c | 13 ++++++++++++- 2 files changed, 24 insertions(+), 2 deletions(-)
drivers/gpu/drm/amd/amdgpu/ih_v6_0.c +12 -1
@@ -168,8 +168,19 @@ static int ih_v6_0_toggle_ring_interrupts(struct amdgpu_device *adev, tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,ENABLE_INTR , (enable ?1 :0 ));if (amdgpu_sriov_vf (adev) &&amdgpu_sriov_reg_indirect_ih (adev)) { -if (psp_reg_program (&adev->psp, ih_regs->psp_reg_id, tmp)) +/* +* PSP programming of IH_RB_CNTL is slow enough for MSI to +* arrive before this call returns. Publish ih->enabled first +* so amdgpu_ih_process() consumes that IV and rearms. +*/ +if (enable) { + ih->enabled = true; +smp_wmb (); + } +if (psp_reg_program (&adev->psp, ih_regs->psp_reg_id, tmp)) { + ih->enabled = false;return -ETIMEDOUT ; + } }else {WREG32 (ih_regs->ih_rb_cntl, tmp); }
drivers/gpu/drm/amd/amdgpu/navi10_ih.c +12 -1
@@ -194,8 +194,19 @@ static int navi10_ih_toggle_ring_interrupts(struct amdgpu_device *adev, tmp =REG_SET_FIELD (tmp,IH_RB_CNTL ,ENABLE_INTR , (enable ?1 :0 ));if (amdgpu_sriov_vf (adev) &&amdgpu_sriov_reg_indirect_ih (adev)) { -if (psp_reg_program (&adev->psp, ih_regs->psp_reg_id, tmp)) +/* +* PSP programming of IH_RB_CNTL is slow enough for MSI to +* arrive before this call returns. Publish ih->enabled first +* so amdgpu_ih_process() consumes that IV and rearms. +*/ +if (enable) { + ih->enabled = true; +smp_wmb (); + } +if (psp_reg_program (&adev->psp, ih_regs->psp_reg_id, tmp)) { + ih->enabled = false;return -ETIMEDOUT ; + } }else {WREG32 (ih_regs->ih_rb_cntl, tmp); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 406/686 drm/amd/display: Avoid closing unowned DDC pins
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Alex Hung <[email protected]>
[ Upstream commit e7ba638b8116cb5f1a5690f543052371215f1626 ]
[WHY]dal_ddc_open() cleans up pins it acquires on later failures. If the data-pin open fails, this attempt acquired nothing. If opening the clock pin or configuring fails, dal_ddc_open() closes the pins it opened. An extra dal_ddc_close() is unnecessary and unsafe:GPIO_RESULT_ALREADY_OPENED can mean AUX owns the existing handles, and closing them here would disrupt AUX.
[HOW]
Remove the extra dal_ddc_close() from the failed-open path.
--- .../drm/amd/display/dc/link/protocols/link_dp_capability.c | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-)
drivers/gpu/drm/amd/display/dc/link/protocols/link_dp_capability.c +1 -5
@@ -2483,12 +2483,8 @@ bool dp_is_sink_present(struct dc_link *link)* which indicates we need additional delay */ -if (dal_ddc_open (ddc,GPIO_MODE_INPUT , -GPIO_DDC_CONFIG_TYPE_MODE_I2C ) !=GPIO_RESULT_OK ) { -dal_ddc_close (ddc); - +if (dal_ddc_open (ddc,GPIO_MODE_INPUT ,GPIO_DDC_CONFIG_TYPE_MODE_I2C ) !=GPIO_RESULT_OK )return present; - }/* * Read GPIO: DP sink is present if both clock and data pins are zero
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 407/686 drm/amdgpu/gfx12: disallow GFXOFF while updating the SPM VMID
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jesse Zhang <[email protected]>
[ Upstream commit d1551515a3258b43cba60bd7f45bbdd1f4e9e60a ]
gfx_v12_0_update_spm_vmid() does a read-modify-write of RLC_SPM_MC_CNTL over MMIO without keeping GFX powered, unlike gfx11. When GFX is in GFXOFF at that point the update doesn't stick, and with the SPM VMID programmed on submission again, the job of a process with a reserved VMID can still run with the SPM writing through VMID 0.
On navi48, after a few other submissions and a VM fault on the same VM, a COPY_DATA of RLC_SPM_MC_CNTL from such a job reads 0 although the update was called for it:
$ amd_uapi_regression --run-subtest cs-secure-ib-compute,gem-mapping-info-high-va,gpuvm-fault-high-va,reserved-vmid-spm-vmid amdgpu 0000:03:00.0: [gfxhub] page fault (src_id:0 ring:40 vmid:7 pasid:185) amdgpu 0000:03:00.0: Faulty UTCL2 client ID: SDMA1 (0xe) RLC_SPM_MC_CNTL in the job: 0x00000000
With GFXOFF disallowed around the update it reads the reserved VMID 15.
--- drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/gpu/drm/amd/amdgpu/gfx_v12_0.c +2 -0
@@ -3976,6 +3976,7 @@ static void gfx_v12_0_update_spm_vmid(struct amdgpu_device *adev, {u32 reg, data; +amdgpu_gfx_off_ctrl (adev, false); reg =SOC15_REG_OFFSET (GC ,0 , regRLC_SPM_MC_CNTL);if (amdgpu_sriov_is_pp_one_vf (adev)) data =RREG32_NO_KIQ (reg);
@@ -3989,6 +3990,7 @@ static void gfx_v12_0_update_spm_vmid(struct amdgpu_device *adev,WREG32_SOC15_NO_KIQ (GC ,0 , regRLC_SPM_MC_CNTL, data); else WREG32_SOC15(GC, 0, regRLC_SPM_MC_CNTL, data); +amdgpu_gfx_off_ctrl (adev, true);if (ring && amdgpu_sriov_is_pp_one_vf(adev)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 408/686 drm/amd/display: Fix NULL deref in dcn401_update_clocks_update_dtb_dto
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Roman Demidov <[email protected]>
[ Upstream commit 7fac15d009cf236677a8cddf6bc0e8c85666ac3b ]
[Why]resource_get_otg_master_for_stream() can return NULL if no OTG master pipe is found for a given stream. The current code dereferences this pointer without a NULL check. This may lead to a possible NULL pointer dereference.
[How]
Add an explicit NULL check and skip the stream if the OTG master is not found. This is similar to dcn60_update_clocks_update_dtb_dto().
Found by Linux Verification Center (linuxtesting.org) with SVACE.
--- drivers/gpu/drm/amd/display/dc/clk_mgr/dcn401/dcn401_clk_mgr.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/gpu/drm/amd/display/dc/clk_mgr/dcn401/dcn401_clk_mgr.c +3 -0
@@ -535,6 +535,9 @@ static void dcn401_update_clocks_update_dtb_dto(struct clk_mgr_internal *clk_mgr otg_master =resource_get_otg_master_for_stream ( &context->res_ctx, context->streams[i]);ASSERT (otg_master); +if (!otg_master) +continue ; +ASSERT (otg_master->clock_source);ASSERT (otg_master->clock_source->funcs->program_pix_clk);ASSERT (otg_master->stream_res.pix_clk_params.controller_id >=CONTROLLER_ID_D0 );
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 409/686 drm/amd/display: Drop clock requirements on DCN32 when no displays are active
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Misha Nasledov <[email protected]>
[ Upstream commit bba4dc3306483335ddbe065c05b2d8359ec387a4 ]
amdgpu_dm builds the new dc_state as a copy of the old one. When the last stream is removed, dml1_validate() returns early on pipe_cnt == 0 and never reaches dcn32_calculate_dlg_params(), so bw.dcn.clk keeps the dramclk/dcfclk/fclk requirements of the display that was just turned off. dcn32_update_clocks() then keeps those hard minimums applied.
On an RX 7900 XTX this leaves UCLK at 456 MHz and DCFCLK at 637 MHz with the monitor off, and the board idles at 28.4 W. With this change they drop to 96 MHz and 145 MHz and board power falls to 15.3 W.
Reset the clock requirements in that case, as calculate_dlg_params() already does when no HUBP is active and as the DML2 path does for stream_count == 0.
--- .../display/dc/resource/dcn32/dcn32_resource.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
drivers/gpu/drm/amd/display/dc/resource/dcn32/dcn32_resource.c +14 -1
@@ -1777,8 +1777,21 @@ static bool dml1_validate(struct dc *dc, struct dc_state *context, enum dc_valid out =dcn32_internal_validate_bw (dc, context, pipes, &pipe_cnt, &vlevel, validate_mode);DC_FP_END (); -if (pipe_cnt ==0 ) +if (pipe_cnt ==0 ) { +/* The context is a copy of the previous state, so without this the +* clocks the last display needed stay applied with all displays off. +*/ + context->bw_ctx.bw.dcn.clk.socclk_khz =0 ; + context->bw_ctx.bw.dcn.clk.dppclk_khz =0 ; + context->bw_ctx.bw.dcn.clk.dcfclk_khz =0 ; + context->bw_ctx.bw.dcn.clk.dcfclk_deep_sleep_khz =0 ; + context->bw_ctx.bw.dcn.clk.dramclk_khz =0 ; + context->bw_ctx.bw.dcn.clk.fclk_khz =0 ; + context->bw_ctx.bw.dcn.clk.p_state_change_support = true; + context->bw_ctx.bw.dcn.clk.fclk_p_state_change_support = true; + context->bw_ctx.bw.dcn.clk.num_ways =0 ; goto validate_out; + }if (!out) goto validate_fail;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 410/686 drm/amd/display: Keep the nominal vtotal while VRR is inactive
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Matthew Schwartz <[email protected]>
[ Upstream commit f2853a06e4b923c77a8cba69d76d2222b198256b ]
Commit 33c995709121 ("drm/amd/display: Allow VRR params change if unsynced with the stream") derives the inactive vtotal from max_refresh_in_uhz and rounds it up. The round trip through integer rates can add a line even with VRR off. The ASUS ROG Xbox Ally X20's 120.0004 Hz mode exceeds its 120 Hz EDID maximum, so 1152 lines become 1153 and the CRTC vblank counter measures 119.89 Hz.
Take both limits from stream->timing.v_total, as mod_freesync_build_vrr_params() does, which keeps the resync to the stream's timing. Active VRR keeps the helper's rounding.
--- drivers/gpu/drm/amd/display/modules/freesync/freesync.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
drivers/gpu/drm/amd/display/modules/freesync/freesync.c +2 -4
@@ -1265,10 +1265,8 @@ void mod_freesync_handle_v_update(struct mod_freesync *mod_freesync,* If VRR is inactive, set vtotal min and max to nominal vtotal */ if (in_out_vrr->state ==VRR_STATE_INACTIVE ) { - in_out_vrr->adjust.v_total_min = -mod_freesync_calc_v_total_from_refresh (stream, - in_out_vrr->max_refresh_in_uhz); - in_out_vrr->adjust.v_total_max = in_out_vrr->adjust.v_total_min; + in_out_vrr->adjust.v_total_min = stream->timing.v_total; + in_out_vrr->adjust.v_total_max = stream->timing.v_total;return ; } }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 411/686 drm/amd/display: Dont select zero V_TOTAL_MIN/MAX on seamless boot
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Kylie C <[email protected]>
[ Upstream commit d13f36e4e055cce03761de590bc8dc6346b1d5c8 ]
Initialize V_TOTAL_MIN/MAX to V_TOTAL before enabling the selectors if they are still 0, as optc1_program_timing() does without seamless boot.
Tested on Renoir (DCN 2.1) eDP with amdgpu.seamless=1.
This removes the flash between the bios logo & plymouth on my laptop.
--- drivers/gpu/drm/amd/display/dc/optc/dcn20/dcn20_optc.c | 7 +++++++ 1 file changed, 7 insertions(+)
drivers/gpu/drm/amd/display/dc/optc/dcn20/dcn20_optc.c +7 -0
@@ -452,6 +452,13 @@ void optc2_lock_doublebuffer_disable(struct timing_generator *optc)void optc2_setup_manual_trigger (struct timing_generator *optc) {struct optc *optc1 =DCN10TG_FROM_TG (optc); +uint32_t v_total, v_total_max; + +REG_GET (OTG_V_TOTAL_MAX ,OTG_V_TOTAL_MAX , &v_total_max); +if (!v_total_max) { +REG_GET (OTG_V_TOTAL ,OTG_V_TOTAL , &v_total); + optc->funcs->set_vtotal_min_max (optc, v_total, v_total); + }/* Set the min/max selectors unconditionally so that * DMCUB fw may change OTG timings when necessary
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 412/686 drm/amdgpu: Fix duplicate dependency fence releases
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Erhan Bilgili <[email protected]>
[ Upstream commit ea47f84199241dd083d40a241beea665415d4f6c ]
drm_sched_job_add_dependency() consumes its fence reference on success and failure. Do not release the fence again if drm_sched_job_add_dependency() fails.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c | 4 +--- drivers/gpu/drm/amd/amdgpu/amdgpu_vm_sdma.c | 1 - 2 files changed, 1 insertion(+), 4 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_sync.c +1 -3
@@ -447,10 +447,8 @@ int amdgpu_sync_push_to_job(struct amdgpu_sync *sync, struct amdgpu_job *job)dma_fence_get (f); r =drm_sched_job_add_dependency (&job->base, f); -if (r) { -dma_fence_put (f); +if (r)return r; - } }return 0 ; }
drivers/gpu/drm/amd/amdgpu/amdgpu_vm_sdma.c +0 -1
@@ -234,7 +234,6 @@ static int amdgpu_vm_sdma_update(struct amdgpu_vm_update_params *p,dma_fence_get (fence); r =drm_sched_job_add_dependency (&p->job->base, fence);if (r) { -dma_fence_put (fence);dma_resv_iter_end (&cursor);return r; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 413/686 drm/amdgpu: Report MES ring wait timeouts.
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Erhan Bilgili <[email protected]>
[ Upstream commit 122e864861144150e905012b5fb52e63ad5de68d ]
Return -ETIMEDOUT when the fence wait before submission expires instead of reporting success without submitting the packet.
--- drivers/gpu/drm/amd/amdgpu/mes_v11_0.c | 4 +++- drivers/gpu/drm/amd/amdgpu/mes_v12_0.c | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-)
drivers/gpu/drm/amd/amdgpu/mes_v11_0.c +3 -1
@@ -207,8 +207,10 @@ static int mes_v11_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes, r =amdgpu_fence_wait_polling (ring, seq - ring->fence_drv.num_fences_mask, timeout); -if (r <1 ) +if (r <1 ) { + r = -ETIMEDOUT ; goto error_undo; + } api_status = (struct MES_API_STATUS *)((char *)pkt + api_status_off); api_status->api_completion_fence_addr = status_gpu_addr;
drivers/gpu/drm/amd/amdgpu/mes_v12_0.c +3 -1
@@ -192,8 +192,10 @@ static int mes_v12_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes, r =amdgpu_fence_wait_polling (ring, seq - ring->fence_drv.num_fences_mask, timeout); -if (r <1 ) +if (r <1 ) { + r = -ETIMEDOUT ; goto error_undo; + } api_status = (struct MES_API_STATUS *)((char *)pkt + api_status_off); api_status->api_completion_fence_addr = status_gpu_addr;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 414/686 drm/amdgpu: Clamp the ATIF backlight curve to its 99 points
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hugo Sales <[email protected]>
[ Upstream commit 7ba7655701c5cad5bfa043d464d1e24873e24aab ]
amdgpu_atif_query_backlight_caps() stores the firmware's number_of_points as data_points but copies only the 99 points that luminance_data[] holds. number_of_points is a u8, so a firmware table that claims more makes the custom curve code in amdgpu_dm index past the array, and dm_query_extended_brightness_caps() copy past the end of the data_points[] buffer it fills
Clamp the count to ATIF_QBTC_MAX_DATA_POINTS and warn, since a table that claims more is a firmware bug
--- drivers/gpu/drm/amd/amdgpu/amdgpu_acpi.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_acpi.c +5 -1
@@ -400,7 +400,11 @@ static int amdgpu_atif_query_backlight_caps(struct amdgpu_atif *atif) characteristics.max_input_signal; atif->backlight_caps.ac_level = characteristics.ac_level; atif->backlight_caps.dc_level = characteristics.dc_level; - atif->backlight_caps.data_points = characteristics.number_of_points; +if (characteristics.number_of_points >ATIF_QBTC_MAX_DATA_POINTS ) +pr_warn (FW_BUG "ATIF: backlight curve has %u points, using the first %u\n" , + characteristics.number_of_points,ATIF_QBTC_MAX_DATA_POINTS ); + atif->backlight_caps.data_points =min_t (u8, characteristics.number_of_points, +ATIF_QBTC_MAX_DATA_POINTS );memcpy (atif->backlight_caps.luminance_data, characteristics.data_points,sizeof (atif->backlight_caps.luminance_data));
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 415/686 drm/amdgpu: drop the dma-buf reference when a KFD import fails
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jesse Zhang <[email protected]>
[ Upstream commit fb900f8bfd8a16126affd186d21001e4c6533324 ]
import_obj_create() takes a reference on the dma-buf for the new kgd_mem, but the error path after validating the BO doesn't drop it. Since the validation reserves the BO interruptibly, an import failing with -ERESTARTSYS leaks the exported BO with its memory, and keeps the module in use.
Importing a 64 MiB VRAM BO in a loop while getting SIGUSR1 every 20 us and another thread changes the BO's mappings:
INFO: 171821 imports, VRAM used before 65 MiB, after 129 MiB
modprobe: FATAL: Module amdgpu is in use.
Drop the reference, and free the sync object and the mutex of the kgd_mem as well. With that VRAM usage returns to 65 MiB after the same test.
--- drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +3 -0
@@ -2450,6 +2450,9 @@ static int import_obj_create(struct amdgpu_device *adev, err_remove_mem:remove_kgd_mem_from_kfd_bo_list (*mem, avm->process_info); +amdgpu_sync_free (&(*mem)->sync); +mutex_destroy (&(*mem)->lock); +dma_buf_put (dma_buf);drm_vma_node_revoke (&obj->vma_node, drm_priv); err_free_mem:kfree (*mem);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 416/686 drm/amdgpu: Only enable HDMI audio if display supports it
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: renpanpan <[email protected]>
[ Upstream commit 0de95c96655c8a12df62e47871016f49e5cd8618 ]
The amdgpu legacy DCE audio path (dce_v6/v8/v10) unconditionally calls audio_enable(pin, true) at the end of afmt_setmode(), regardless of whether the connected display advertises audio support in its EDID.
This causes a phantom HDMI audio output to appear for displays that have no audio capability (no basic audio bit, no Audio Data Block in EDID), because the GPU sets the AUDIO_ENABLED register bit, which drives the HDA codec's ELDV pin sense, making the codec report the jack as audio-available.
The radeon, nouveau, and dw-hdmi drivers all gate audio enablement on display_info.has_audio. Apply the same check to amdgpu's DCE afmt_setmode functions.
--- drivers/gpu/drm/amd/amdgpu/dce_v10_0.c | 5 +++-- drivers/gpu/drm/amd/amdgpu/dce_v6_0.c | 5 +++-- drivers/gpu/drm/amd/amdgpu/dce_v8_0.c | 5 +++-- 3 files changed, 9 insertions(+), 6 deletions(-)
drivers/gpu/drm/amd/amdgpu/dce_v10_0.c +3 -2
@@ -1735,8 +1735,9 @@ static void dce_v10_0_afmt_setmode(struct drm_encoder *encoder,WREG32 (mmAFMT_RAMP_CONTROL2 + dig->afmt->offset,0x00000001 );WREG32 (mmAFMT_RAMP_CONTROL3 + dig->afmt->offset,0x00000001 ); -/* enable audio after to setting up hw */ -dce_v10_0_audio_enable (adev, dig->afmt->pin, true); +/* Only enable audio if the display supports it */ +if (connector->display_info.has_audio) +dce_v10_0_audio_enable (adev, dig->afmt->pin, true); }static void dce_v10_0_afmt_enable (struct drm_encoder *encoder,bool enable)
drivers/gpu/drm/amd/amdgpu/dce_v6_0.c +3 -2
@@ -1777,8 +1777,9 @@ static void dce_v6_0_afmt_setmode(struct drm_encoder *encoder,dce_v6_0_audio_dp_enable (encoder,1 ); } -/* enable audio after setting up hw */ -dce_v6_0_audio_enable (adev, dig->afmt->pin, true); +/* Only enable audio if the display supports it */ +if (connector->display_info.has_audio) +dce_v6_0_audio_enable (adev, dig->afmt->pin, true); }static void dce_v6_0_afmt_enable (struct drm_encoder *encoder,bool enable)
drivers/gpu/drm/amd/amdgpu/dce_v8_0.c +3 -2
@@ -1682,8 +1682,9 @@ static void dce_v8_0_afmt_setmode(struct drm_encoder *encoder,WREG32 (mmAFMT_RAMP_CONTROL2 + offset,0x00000001 );WREG32 (mmAFMT_RAMP_CONTROL3 + offset,0x00000001 ); -/* enable audio after setting up hw */ -dce_v8_0_audio_enable (adev, dig->afmt->pin, true); +/* Only enable audio if the display supports it */ +if (connector->display_info.has_audio) +dce_v8_0_audio_enable (adev, dig->afmt->pin, true); }static void dce_v8_0_afmt_enable (struct drm_encoder *encoder,bool enable)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 417/686 drm/amdgpu: dont drop the gang dependency fence twice
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jesse Zhang <[email protected]>
[ Upstream commit 6d1f901a83603a7d314e4a756b416b11d8dc7e35 ]
drm_sched_job_add_dependency() drops the fence reference when it fails, but amdgpu_cs_submit() drops it again, so the scheduled fence of a gang member loses a reference it still needs.
A GFX+COMPUTE gang waiting for another context, with the xarray node allocation for the leader's dependency failed through failslab:
WARNING: drivers/dma-buf/dma-fence.c:589 at dma_fence_release+0x34d/0x730, CPU#1: amd_uapi_regres/2993 drm_sched_job_cleanup+0x2c2/0x340 [gpu_sched] amdgpu_job_free+0xcb/0x3e0 [amdgpu] amdgpu_cs_parser_fini+0x435/0x710 [amdgpu] amdgpu_cs_ioctl+0xcd2/0x7a60 [amdgpu] Oops: general protection fault, probably for non-canonical address 0xdffffc0000000001: 0000 [#1] SMP KASAN NOPTI KASAN: null-ptr-deref in range [0x0000000000000008-0x000000000000000f] RIP: 0010:dma_fence_signal_timestamp_locked+0x1b8/0x610
--- drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c +1 -3
@@ -1333,10 +1333,8 @@ static int amdgpu_cs_submit(struct amdgpu_cs_parser *p, fence = &p->jobs[i]->base.s_fence->scheduled;dma_fence_get (fence); r =drm_sched_job_add_dependency (&leader->base, fence); -if (r) { -dma_fence_put (fence); +if (r)return r; - } }if (p->gang_size >1 ) {
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 418/686 nvmet: dont return memory contents beyond valid data when reading ANA log page
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ewan D. Milne <[email protected]>
[ Upstream commit 29b8758b4700357909f06705a0c48c7a60c556d5 ]
The host side does not know how much valid data will be returned by the target so it will typically provide a buffer larger than the amount of valid data in the ANA log page. The memory allocation used by the target does not guarantee that prior kernel memory contents will not be returned past the end of the valid page data. Fix this to ensure that the SGL is zeroed before copying the data.
--- drivers/nvme/target/admin-cmd.c | 9 +++++++++ 1 file changed, 9 insertions(+)
drivers/nvme/target/admin-cmd.c +9 -0
@@ -543,6 +543,15 @@ static void nvmet_execute_get_log_page_ana(struct nvmet_req *req)u16 ngrps =0 ;u16 status; +/* +* The header and one descriptor per enabled group are the only bytes +* written below; zero the whole transfer first so the unwritten tail +* does not leak stale kernel memory to the host. +*/ + status =nvmet_zero_sgl (req,0 , req->transfer_len); +if (status) + goto out; + status =NVME_SC_INTERNAL ; desc =kmalloc (struct_size (desc, nsids,NVMET_MAX_NAMESPACES ),GFP_KERNEL );
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 419/686 arm64: suspend: Save and restore TPIDR2_EL0 across CPU suspend
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Wei Wang <[email protected]>
[ Upstream commit beeec04046227eba42b7cc5ab32498aa43da9632 ]
TPIDR2_EL0 is a live EL0 register on systems with SME, but cpu_do_suspend()/cpu_do_resume() don't preserve it. Its value is UNKNOWN after a warm reset, so the task that initiates suspend can return to userspace with a corrupted TPIDR2_EL0.
Save and restore it alongside TPIDR_EL0 and TPIDRRO_EL0. The new slot fits in existing padding, so sizeof(struct cpu_suspend_ctx) is unchanged.
--- arch/arm64/include/asm/suspend.h | 2 +- arch/arm64/mm/proc.S | 8 ++++++++ 2 files changed, 9 insertions(+), 1 deletion(-)
arch/arm64/include/asm/suspend.h +1 -1
@@ -2,7 +2,7 @@#ifndef __ASM_SUSPEND_H#define __ASM_SUSPEND_H -#define NR_CTX_REGS 14 +#define NR_CTX_REGS 15#define NR_CALLEE_SAVED_REGS 12/*
arch/arm64/mm/proc.S +8 -0
@@ -103,6 +103,10 @@ SYM_FUNC_START(cpu_do_suspend) alternative_if ARM64_HAS_TCR2 mrs x2, REG_TCR2_EL1 str x2, [x0, #104] +alternative_else_nop_endif +alternative_if ARM64_SME + mrs_s x2, SYS_TPIDR2_EL0 + str x2, [x0, #112] alternative_else_nop_endif ret SYM_FUNC_END(cpu_do_suspend)
@@ -142,6 +146,10 @@ alternative_if ARM64_HAS_TCR2 ldr x2, [x0, #104] msr REG_TCR2_EL1, x2 alternative_else_nop_endif +alternative_if ARM64_SME + ldr x2, [x0, #112] + msr_s SYS_TPIDR2_EL0, x2 +alternative_else_nop_endif msr sctlr_el1, x12 set_this_cpu_offset x13
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 420/686 arm64: mm: validate /dev/mem mmap ranges without overflow
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Zhao Gongyi <[email protected]>
[ Upstream commit b0958b1397fb5ffdb995c0ccc74349841929c08d ]
An arm64 syzkaller reproducer creates a FUSE character device with major:minor 1:1, so opening it uses the /dev/mem file operations. It maps one page from offset 0xfffffffffffff000 at user address zero. The next openat() with a NULL pathname triggers a synchronous external abort (SEA, ESR 0x96000010) in strncpy_from_user() via do_getname(), panicking the kernel.
valid_mmap_phys_addr_range() checks the exclusive end by adding the mapping size to the starting address. For this offset, the sum wraps to zero and passes the PHYS_MASK test, allowing an out-of-range PFN to reach remap_pfn_range(). The inclusive-end overflow check in mmap_mem_prepare() does not catch it because the end is ULONG_MAX.
Reject starting PFNs outside PHYS_MASK and compare the inclusive length against the remaining physical range without overflowing. This also allows mappings that end exactly at PHYS_MASK, which the old check incorrectly rejects.
--- arch/arm64/mm/mmap.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
arch/arm64/mm/mmap.c +3 -1
@@ -61,7 +61,9 @@ int valid_phys_addr_range(phys_addr_t addr, size_t size)*/ int valid_mmap_phys_addr_range (unsigned long pfn,size_t size) { -return !(((pfn <<PAGE_SHIFT ) + size) & ~PHYS_MASK ); +const phys_addr_t limit =PHYS_MASK +1 ; + +return size <= limit && pfn <= (limit - size) >>PAGE_SHIFT ; }static int __init adjust_protection_map (void )
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 421/686 nvme-pci: add NVME_QUIRK_DMAPOOL_ALIGN_512 for KIOXIA XG10d
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
[ Upstream commit c64d9b2c1f4fd1d8fa52dab37b48428a99c4d58d ]
The KIOXIA XG10d reads past the end of a PRP list that completely fills a 256 byte small pool block. When that block is the last one in its dmapool page, the read lands on the next page, which usually isn't mapped. The IOMMU faults it and the controller craps itself:
arm-smmu-v3 arm-smmu-v3.0.auto: event: F_TRANSLATION client: 0001:09:00.0 sid: 0x20900 ssid: 0x0 iova: 0xff7fe000 ipa: 0x0 nvme nvme0: controller is down; will reset: CSTS=0xffffffff, PCI_STATUS=0xffff
Filling the block requires a slightly larger write, and those became common with commit 2e8e30b3cf9f ("Revert "nvme-pci: clamp max_hw_sectors based on DMA optimized limitation"").
Do what we do for other disks and use 512 byte aligned small pool blocks for this controller.
--- drivers/nvme/host/pci.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/nvme/host/pci.c +2 -0
@@ -3939,6 +3939,8 @@ static const struct pci_device_id nvme_id_table[] = { .driver_data = NVME_QUIRK_BOGUS_NID, }, { PCI_DEVICE(0x1344, 0x6004), /* Micron 4100AT */ .driver_data = NVME_QUIRK_DMAPOOL_ALIGN_512, }, + { PCI_DEVICE(0x1e0f, 0x0032), /* KIOXIA XG10d */ + .driver_data = NVME_QUIRK_DMAPOOL_ALIGN_512, }, { PCI_DEVICE(0x1c5c, 0x1504), /* SK Hynix PC400 */ .driver_data = NVME_QUIRK_DISABLE_WRITE_ZEROES, }, { PCI_DEVICE(0x1c5c, 0x174a), /* SK Hynix P31 SSD */
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 422/686 ovl: look up the index by the decoded origin
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 520ef67f47f69255695859b0008281a384d0bc20 ]
A file opened by file handle on an overlay with nfs_export=on can show the stale lower data of a file that was copied up to the upper layer. While the file opened this way stays in the inode cache, a lookup of the copied up file by path fails with ESTALE for all users. The open can also succeed for a file that was removed, where it has to fail with ESTALE. This happens with a handle that has one byte changed. The handle comes from an NFS client, or from a process that calls open_by_handle_at() with CAP_DAC_READ_SEARCH in the initial user namespace.
When a file in a lower layer is about to be modified, overlayfs first copies it to the upper layer (copy up). With nfs_export=on, each copy up also creates an entry in the index directory, a directory that overlayfs keeps for itself on the upper filesystem.
The handle of an overlay file that comes from a lower layer wraps the handle of its lower inode. Overlayfs calls this lower inode the origin. The overlay handle stays valid after a copy up.
To decode such a handle, ovl_lower_fh_to_d() first decodes the wrapped handle to the origin. If no overlay inode is cached for the origin, it looks in the index directory:
- An index entry there leads to the upper file.
- A whiteout, the marker that overlayfs uses for a removed file, means that the overlay file was removed.
The name of an index entry is the handle that copy up encoded for the origin, as a hex string.
ovl_lower_fh_to_d() builds the name for this lookup from the bytes that the caller passed in. But handles with different bytes can decode to the same inode:
- Overlayfs ignores some flag bits of the handle.
- A lower filesystem can accept a different fid type, extra bytes, or generation 0 for any generation.
Such a handle decodes to the origin but misses the index entry or the whiteout. So the decode returns an overlay inode that has only the lower file.
While that inode is cached, a path lookup of a copied up file fails with ESTALE, since the upper file that the lookup finds does not match the cached inode, which has none.
Reproduced on tmpfs and on ext4 with open_by_handle_at(), after a copy up and a mount cycle. A handle in which one flag bit, the fid type, the length or the generation was changed read the old lower data, and path lookups returned ESTALE.
Fix this by re-encoding the decoded origin and building the index name from that handle.
--- Documentation/filesystems/overlayfs.rst | 3 ++- fs/overlayfs/export.c | 4 ++-- fs/overlayfs/namei.c | 13 ++++++++++--- fs/overlayfs/overlayfs.h | 2 +- 4 files changed, 15 insertions(+), 7 deletions(-)
Documentation/filesystems/overlayfs.rst +2 -1
@@ -716,7 +716,8 @@ When decoding an overlay file handle, the following steps are followed: 1. Find underlying layer by UUID and path type information. 2. Decode the underlying filesystem file handle to underlying dentry. - 3. For a lower file handle, lookup the handle in index directory by name. + 3. For a lower file handle, encode the decoded underlying inode again and + lookup that handle in index directory by name. 4. If a whiteout is found in index, return ESTALE. This represents an overlay object that was deleted after its file handle was encoded. 5. For a non-directory, instantiate a disconnected overlay dentry from the
fs/overlayfs/export.c +2 -2
@@ -718,9 +718,9 @@ static struct dentry *ovl_lower_fh_to_d(struct super_block *sb, } } -/* Then lookup indexed upper/whiteout by origin fh */ +/* Then lookup indexed upper/whiteout by origin */ if (ovl_indexdir (sb)) { - index =ovl_get_index_fh (ofs, fh); + index =ovl_get_index_origin (ofs, origin.dentry); err =PTR_ERR (index);if (IS_ERR (index)) { index =NULL ;
fs/overlayfs/namei.c +10 -3
@@ -775,14 +775,21 @@ int ovl_get_index_name(struct ovl_fs *ofs, struct dentry *origin,return err; } -/* Lookup index by file handle for NFS export */ -struct dentry *ovl_get_index_fh (struct ovl_fs *ofs,struct ovl_fh *fh) +/* +* Lookup index by decoded origin for NFS export. +* +* The name of an index is the hex of the file handle that copy up encoded. +* The bytes of the handle to decode cannot be used as the name, because a +* lower fs may decode many handles to the same inode. For example, it may +* ignore the fid type, extra fid bytes or a zero generation. +*/ +struct dentry *ovl_get_index_origin (struct ovl_fs *ofs,struct dentry *origin) {struct dentry *index;struct qstr name;int err; - err =ovl_get_index_name_fh (fh, &name); + err =ovl_get_index_name (ofs, origin, &name);if (err)return ERR_PTR (err);
fs/overlayfs/overlayfs.h +1 -1
@@ -736,7 +736,7 @@ int ovl_verify_index(struct ovl_fs *ofs, struct dentry *index);int ovl_get_index_name_fh (const struct ovl_fh *fh,struct qstr *name);int ovl_get_index_name (struct ovl_fs *ofs,struct dentry *origin,struct qstr *name); -struct dentry *ovl_get_index_fh (struct ovl_fs *ofs,struct ovl_fh *fh); +struct dentry *ovl_get_index_origin (struct ovl_fs *ofs,struct dentry *origin);struct dentry *ovl_lookup_index (struct ovl_fs *ofs,struct dentry *upper,struct dentry *origin,bool verify); int ovl_path_next(int idx, struct dentry *dentry, struct path *path,
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 423/686 l2tp: only return sessions of the given tunnel in l2tp_session_get()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hengyu Liang <[email protected]>
[ Upstream commit a75facf4bb3e866103ddca4f47a6f3ca4b090d8b ]
Commit 5f77c18ea556 ("l2tp: use IDR for all session lookups") made pppol2tp_connect() and the netlink session commands find sessions with l2tp_session_get(), passing the socket of the tunnel they name.
L2TPv3 session IDs are unique per network namespace, except that sessions carried over UDP are only unique per UDP socket, the socket of their tunnel. However, l2tp_v3_session_get() only checks the socket when another session has the same session ID. Otherwise it returns the session, whichever tunnel it belongs to. As of now, a session command that names the wrong tunnel acts on a session of another tunnel, and a PPPoL2TP socket for a second L2TPv3 tunnel fails with EEXIST, because it finds session 0 of the first tunnel.
The issue can be reproduced with:
ip l2tp add tunnel tunnel_id 3 peer_tunnel_id 3 encap udp \
local 127.0.0.1 remote 127.0.0.1 udp_sport 5003 udp_dport 6003
ip l2tp add tunnel tunnel_id 4 peer_tunnel_id 4 encap udp \
local 127.0.0.1 remote 127.0.0.1 udp_sport 5004 udp_dport 6004
ip l2tp add session tunnel_id 3 session_id 7 peer_session_id 7
ip l2tp del session tunnel_id 4 session_id 7
ip l2tp show sessionBefore that commit, the delete fails with "No such device", and session 7 of tunnel 3 is still listed. After that commit, the delete succeeds, and session 7 of tunnel 3 is gone.
This patch will make l2tp_session_get() return NULL when the L2TPv3 session it finds does not belong to the given socket. The receive path calls l2tp_v3_session_get() directly and is not changed.
--- net/l2tp/l2tp_core.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-)
net/l2tp/l2tp_core.c +11 -2
@@ -315,10 +315,19 @@ EXPORT_SYMBOL_GPL(l2tp_v2_session_get);struct l2tp_session *l2tp_session_get (const struct net *net,struct sock *sk,int pver,u32 tunnel_id,u32 session_id) { +struct l2tp_session *session; +if (pver ==L2TP_HDR_VER_2 )return l2tp_v2_session_get (net, tunnel_id, session_id); -else -return l2tp_v3_session_get (net, sk, session_id); + +/* l2tp_v3_session_get() doesn't check sk if the ID hasn't collided */ + session =l2tp_v3_session_get (net, sk, session_id); +if (session && session->tunnel->sock != sk) { +l2tp_session_put (session); +return NULL ; + } + +return session; }EXPORT_SYMBOL_GPL (l2tp_session_get);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 424/686 drm/nouveau/nvkm: clear use.enabled when subdev init fails
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Rosen Penev <[email protected]>
[ Upstream commit a1f7f37417bacf2eaf80a8ce6b598b1fa56f8906 ]
On Kepler boards without the video decode falcon firmware installed (msvld/mspdec/msppp), every other VA-API decode attempt binds to an engine with no ucode loaded. The submitted work never completes, which leads to a context switch timeout, a channel recovery that cannot reset the engine, and eviction waits on fences that never signal. The process ends up stuck in D state, or killed by SIGBUS when it touches a buffer evicted after the wait times out:
msvld: unable to load firmware data
msvld: init failed, -19
fifo: SCHED_ERROR 0a [CTXSW_TIMEOUT]
vo[5444]: channel 14 killed!
WARNING: drivers/gpu/drm/nouveau/nvkm/engine/fifo/runl.c:117 at nvkm_runl_rc+0x2a4/0x3b0 [nouveau] [TTM] Buffer eviction failed WARNING: drivers/gpu/drm/nouveau/nouveau_bo.c:1092 at nouveau_bo_move_ntfy.part.0+0x9b/0x100 [nouveau]
Tracing nvkm_subdev_ref() and nvkm_subdev_init_() shows the pattern:
a reference taken with enabled=0 runs nvkm_falcon_init(), which returns -ENODEV; the next reference sees enabled=1 and succeeds without running it.
Clear use.enabled when init() fails, so that every later reference retries init and fails cleanly. The other readers of use.enabled are fini() handlers that use it to skip teardown, which they now also do after a failed init().
On a GK107 (Quadro K1100M) without video firmware, playing H.264 with mpv --hwdec=auto: without this patch the GPU channel is killed within a minute and mpv hangs; with it, VA-API decoder creation fails, mpv falls back to software decoding, and no faults are logged.
--- drivers/gpu/drm/nouveau/nvkm/core/subdev.c | 1 + 1 file changed, 1 insertion(+)
drivers/gpu/drm/nouveau/nvkm/core/subdev.c +1 -0
@@ -157,6 +157,7 @@ nvkm_subdev_init_(struct nvkm_subdev *subdev) ret = subdev->func->init (subdev);if (ret) {nvkm_error (subdev,"init failed, %d\n" , ret); + subdev->use.enabled = false;return ret; } }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 425/686 drm/dp: keep MOT set between messages when no_zero_sized is set
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Finn Zeruhn <[email protected]>
[ Upstream commit 06bb2e5c71e9983519929a8482bea89da6d80ad8 ]
When aux->no_zero_sized is set, drm_dp_i2c_xfer() cannot use a bare address packet to close the transaction, so it clears MOT on the last data packet instead. The check only looks at the position within the current i2c_msg, so MOT is cleared at the end of every message and each one is terminated by an I2C stop.
This breaks E-DDC reads of EDID blocks 2 and up. Those are read as three
messages: a write of the segment pointer to 0x30, a write of the offset to 0x50, and the read. The stop after the first message resets the segment pointer, so the read returns segment 0 again.
On a Pimax Dream Air (three EDID blocks, native timings in a DisplayID extension in block 2) connected to an RTX 5070 Ti with nouveau, block 2 reads back as a copy of block 0. The checksum is valid, so nothing is reported, and the connector only offers fallback modes.
Clear MOT only on the last packet of the last message, as the commit that added the option describes. With this, block 2 reads correctly and the native 7104x3840 modes are listed for the Dream Air.
The same problem was pointed out by the Sashiko review of the patch that sets no_zero_sized for all DisplayPort connectors in nouveau.
--- drivers/gpu/drm/display/drm_dp_helper.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/display/drm_dp_helper.c +2 -1
@@ -2183,7 +2183,8 @@ static int drm_dp_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs, msg.buffer = msgs[i].buf + j; msg.size =min (transfer_size, msgs[i].len - j); -if (j + msg.size == msgs[i].len && aux->no_zero_sized) +if (aux->no_zero_sized && i == num -1 && + j + msg.size == msgs[i].len) msg.request &= ~DP_AUX_I2C_MOT ; err =drm_dp_i2c_drain_msg (aux, &msg);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 426/686 drm/nouveau/devinit/gf100-: try to avoid double-running vbios scripts
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ilia Mirkin <[email protected]>
[ Upstream commit 2139cb633d48ebbbaec88d2e5a8ebe8e774df4fb ]
Turns out some VBIOSes don't actually set the bit in question in 2240c. Use the nv50-style detection to try avoiding running the vbios twice.
--- .../drm/nouveau/nvkm/subdev/devinit/gf100.c | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+)
drivers/gpu/drm/nouveau/nvkm/subdev/devinit/gf100.c +20 -0
@@ -27,6 +27,7 @@#include <subdev/bios/init.h> #include <subdev/bios/pll.h> #include <subdev/clk/pll.h> +#include <subdev/vga.h> int gf100_devinit_pll_set (struct nvkm_devinit *init,u32 type,u32 freq)
@@ -99,6 +100,25 @@ gf100_devinit_preinit(struct nvkm_devinit *base)* can use it as a reliable way to know whether we should run devinit. */ base->post = ((nvkm_rd32 (device,0x2240c ) &BIT (1 )) ==0 ); + +/* +* However some VBIOS init sequences miss this bit. So fall back to +* the nv50 method of checking if the bit is not set. Running the +* VBIOS multiple times may have detrimental effects. +*/ +if (base->post) { +u64 disable =nvkm_devinit_disable (base); +/* magic to detect whether or not x86 vbios code has +* executed the devinit scripts to initialise the +* board. only works if there's a display engine. +*/ +if (!(disable & (1ULL <<NVKM_ENGINE_DISP ))) { +if (nvkm_rdvgac (device,0 ,0x00 ) || +nvkm_rdvgac (device,0 ,0x1a )) { + base->post = false; + } + } + } } static const struct nvkm_devinit_func
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 427/686 ALSA: ump: Fix dropped data bytes at UMP System message conversion
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: HyeongJun An <[email protected]>
[ Upstream commit ac1cac4c1f1b143650f7261ae78f64a3e22fa4d6 ]
The cvt_ump_system_to_legacy() function switches on ump_message_status_code(), which returns only the upper 4 bits of the status. The case labels are the full 0xf1, 0xf2 and 0xf3 values, so they never match. MIDI Time Code, Song Position and Song Select are converted to the status byte alone, and their data bytes are lost.
Switch on the full status byte in buf[0] instead.
Both callers of snd_ump_convert_from_ump() pass the result on as is: the legacy rawmidi input of a UMP endpoint, and the MIDI 1.0 path of the f_midi2 USB gadget.
--- sound/core/ump_convert.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
sound/core/ump_convert.c +1 -1
@@ -69,7 +69,7 @@ static u32 upscale_14_to_32bit(u16 src)static int cvt_ump_system_to_legacy (u32 data,unsigned char *buf) { buf[0 ] =ump_message_status_channel (data); -switch (ump_message_status_code (data)) { +switch (buf[0 ]) {case UMP_SYSTEM_STATUS_MIDI_TIME_CODE :case UMP_SYSTEM_STATUS_SONG_SELECT : buf[1 ] = (data >>8 ) &0x7f ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 428/686 ALSA: hda/realtek: Enable bass speakers on Alienware m17 R3
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Simpson <[email protected]>
[ Upstream commit eb296114d5ba4d335a640dbbbbc9618fded0ffe7 ]
The Alienware m17 R3 (ALC289, PCI SSID 1028:09d1) has a second speaker pair, the bass speakers, on pin 0x17, which the BIOS leaves unconnected (0x411111f0). No PCI SSID quirk matches the machine, so it gets ALC269_FIXUP_DELL4_MIC_NO_PRESENCE from the fallback pin quirk table, and only the speakers on pin 0x14 play.
Use ALC289_FIXUP_DUAL_SPK, as on the Alienware x16 R2 and Dell XPS 15 9510/9520: it sets pin 0x17 up as a speaker on DAC 0x02, so one volume control covers both pairs, and chains to ALC269_FIXUP_DELL4_MIC_NO_PRESENCE, so the headset mic setup is unchanged.
Tested on an Alienware m17 R3 (BIOS 1.38.0), Linux 7.3 with this change
applied: the bass speakers play, and volume and mute cover both pairs, also after suspend and resume. Headphones and a headset mic were not tested.
I used Claude Code (Claude Opus 5.5) to find the unused pin, pick the existing fixup and write this patch and changelog; I did the listening tests myself.
--- sound/hda/codecs/realtek/alc269.c | 1 + 1 file changed, 1 insertion(+)
sound/hda/codecs/realtek/alc269.c +1 -0
@@ -6710,6 +6710,7 @@ static const struct hda_quirk alc269_fixup_tbl[] = {SND_PCI_QUIRK (0x1028 ,0x097e ,"Dell Precision" ,ALC289_FIXUP_DUAL_SPK ),SND_PCI_QUIRK (0x1028 ,0x098d ,"Dell Precision" ,ALC233_FIXUP_ASUS_MIC_NO_PRESENCE ),SND_PCI_QUIRK (0x1028 ,0x09bf ,"Dell Precision" ,ALC233_FIXUP_ASUS_MIC_NO_PRESENCE ), +SND_PCI_QUIRK (0x1028 ,0x09d1 ,"Alienware m17 R3" ,ALC289_FIXUP_DUAL_SPK ),SND_PCI_QUIRK (0x1028 ,0x0a2e ,"Dell" ,ALC236_FIXUP_DELL_AIO_HEADSET_MIC ),SND_PCI_QUIRK (0x1028 ,0x0a30 ,"Dell" ,ALC236_FIXUP_DELL_AIO_HEADSET_MIC ), SND_PCI_QUIRK(0x1028, 0x0a38, "Dell Latitude 7520", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE_QUIET),
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 429/686 ALSA: cs46xx: Handle SCB creation failures before dereferencing
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Alex Kazinsky <[email protected]>
[ Upstream commit 023d3e1176202339cd94a3d732e3aec74e36ba22 ]
With CONFIG_PM_SLEEP enabled, cs46xx_dsp_create_scb() can return NULL if kmemdup() fails to allocate the SCB data saved for resume. cs46xx_dsp_scb_and_task_init() and _dsp_create_generic_scb() dereference the returned pointer without checking it, causing a NULL pointer dereference on allocation failure.
Check both return values before accessing the SCB descriptors. Return -ENOMEM when creating the null SCB fails and propagate NULL from _dsp_create_generic_scb().
Found by Linux Verification Center (linuxtesting.org) with SVACE static analysis tool.
--- sound/pci/cs46xx/dsp_spos.c | 2 ++ sound/pci/cs46xx/dsp_spos_scb_lib.c | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-)
sound/pci/cs46xx/dsp_spos.c +2 -0
@@ -1106,6 +1106,8 @@ int cs46xx_dsp_scb_and_task_init (struct snd_cs46xx *chip) null_scb.entry_point = null_algorithm->address; ins->the_null_scb =cs46xx_dsp_create_scb (chip,"nullSCB" , (u32 *)&null_scb,NULL_SCB_ADDR ); +if (!ins->the_null_scb) +return -ENOMEM ; ins->the_null_scb->task_entry = null_algorithm; ins->the_null_scb->sub_list_ptr = ins->the_null_scb; ins->the_null_scb->next_scb_ptr = ins->the_null_scb;
sound/pci/cs46xx/dsp_spos_scb_lib.c +2 -1
@@ -274,7 +274,8 @@ _dsp_create_generic_scb (struct snd_cs46xx *chip, char * name, u32 * scb_data, udev_dbg (chip->card->dev,"dsp_spos: creating SCB <%s>\n" , name); scb =cs46xx_dsp_create_scb (chip,name,scb_data,dest); - +if (!scb) +return NULL ; scb->sub_list_ptr = ins->the_null_scb; scb->next_scb_ptr = ins->the_null_scb;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 430/686 ALSA: bcd2000: Fix use-after-free of MIDI URBs on file close
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: YuanZhe Liu <[email protected]>
[ Upstream commit f6c7bb1f0799591a62be75b9bcf84245b4f208b7 ]
bcd2000_disconnect() calls snd_card_disconnect(), which only prevents new opens, and then frees the MIDI URBs. A rawmidi file that was already open can still be closed afterwards, and its close callback, bcd2000_midi_output_close(), calls usb_kill_urb() on midi_out_urb.
The URB pointers are cleared on disconnect and their accesses are serialized with midi_lock, but bcd2000_midi_output_close() reads midi_out_urb without that lock. The check can therefore pass just before the pointer is cleared, and usb_kill_urb() then runs on the URB that has already been freed:
BUG: KASAN: slab-use-after-free in usb_kill_urb+0x74/0x80 Read of size 8 at addr ffff8880078e7d40 usb_kill_urb bcd2000_midi_output_close close_substream rawmidi_release_priv snd_rawmidi_release
Allocated by: usb_alloc_urb <- bcd2000_init_midi <- bcd2000_probe
Freed by: usb_free_urb <- bcd2000_midi_free
<- bcd2000_disconnect
Take the lock in bcd2000_midi_output_close() and reference the URB with usb_get_urb() before releasing it. The URB then stays valid until usb_put_urb() after usb_kill_urb() has returned, even if a disconnect frees it in the meantime. usb_kill_urb() itself cannot run under midi_lock, as the completion handler takes the same lock.
--- sound/usb/bcd2000/bcd2000.c | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-)
sound/usb/bcd2000/bcd2000.c +17 -3
@@ -183,10 +183,24 @@ static int bcd2000_midi_output_open(struct snd_rawmidi_substream *substream)static int bcd2000_midi_output_close (struct snd_rawmidi_substream *substream) {struct bcd2000 *bcd2k = substream->rmidi->private_data; +struct urb *urb =NULL ; -if (bcd2k->midi_out_active && bcd2k->midi_out_urb) { -usb_kill_urb (bcd2k->midi_out_urb); - bcd2k->midi_out_active =0 ; +/* +* Reference the URB under the lock so that it stays valid until +* usb_kill_urb() returns, even if a disconnect frees it in the +* meantime. usb_kill_urb() cannot run under the lock, as the +* completion handler takes the same lock. +*/ + scoped_guard(spinlock_irqsave, &bcd2k->midi_lock) { +if (bcd2k->midi_out_active && bcd2k->midi_out_urb) { + urb =usb_get_urb (bcd2k->midi_out_urb); + bcd2k->midi_out_active =0 ; + } + } + +if (urb) { +usb_kill_urb (urb); +usb_put_urb (urb); }return 0 ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 431/686 ALSA: usx2y: Refuse a retried DSP load after a failure
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: YuanZhe Liu <[email protected]>
[ Upstream commit 1f8101b6adc87a3ddbd51fcb6609251591758026 ]
snd_usx2y_hwdep_dsp_load() sets up the asynchronous sequence URBs and the interrupt URB when the FPGA firmware image with index 1 is loaded, and then creates the ALSA devices. If usx2y_in04_init() or usx2y_create_alsa_devices() fails, the URBs that were already set up are left in place.
The core keeps the index unloaded when the callback fails, so user space may issue the same request again. The second attempt then enters usx2y_async_seq04_init() or usx2y_in04_init() with the URBs still allocated and trips WARN_ON(usx2y->as04.buffer) or WARN_ON(usx2y->in04_urb).
The URBs cannot be released at this point: the card may already have registered PCM devices that user space can still open, and the disconnect handler accesses the URBs without holding the DSP lock. Mark the chip as hung instead, so that a retried request is refused with -ENODEV and the assertions keep their meaning. The URBs are released by snd_usx2y_card_private_free() when the card is freed.
A failing usx2y_async_seq04_init() still releases its own URBs, so that path remains retryable.
--- sound/usb/usx2y/usX2Yhwdep.c | 5 +++++ 1 file changed, 5 insertions(+)
sound/usb/usx2y/usX2Yhwdep.c +5 -0
@@ -179,6 +179,9 @@ static int snd_usx2y_hwdep_dsp_load(struct snd_hwdep *hw,int lret, err;char *buf; +if (priv->chip_status &USX2Y_STAT_CHIP_HUP ) +return -ENODEV ; + buf =memdup_user (dsp->image, dsp->length);if (IS_ERR (buf))return PTR_ERR (buf);
@@ -201,11 +204,13 @@ static int snd_usx2y_hwdep_dsp_load(struct snd_hwdep *hw, err =usx2y_in04_init (priv);if (err) {dev_err (&dev->dev,"usx2y_in04_init error\n" ); + priv->chip_status |=USX2Y_STAT_CHIP_HUP ;return err; } err =usx2y_create_alsa_devices (hw->card);if (err) {dev_err (&dev->dev,"usx2y_create_alsa_devices error %i\n" , err); + priv->chip_status |=USX2Y_STAT_CHIP_HUP ;return err; } priv->chip_status |=USX2Y_STAT_CHIP_INIT ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 432/686 ALSA: hda/tas2781: Only accept CRC-less V1 data if all entries are valid
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Mohamed Yassine Jebabli <[email protected]>
[ Upstream commit 8dbab764f1e0a92c3fac0ce070ce30c0c33c2692 ]
Commit 408249089c48 ("ALSA: hda/tas2781: Accept V1 calibration data without CRC") only checked the first device entry. On machines where the BIOS populates fewer entries than p->ndev, the remaining all-zero entries are applied and tas2781_cali_preproc() divides by zero on playback open.
Accept CRC-less V1 data only if every expected entry is non-zero and self-consistent (R0 * 1/R0 close to 1.0), otherwise reject it as before.
--- sound/hda/codecs/side-codecs/tas2781_hda.c | 27 +++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-)
sound/hda/codecs/side-codecs/tas2781_hda.c +26 -1
@@ -50,6 +50,31 @@ static void cali_cnv(unsigned char *data, unsigned int base, int offset) (u32 *)®_data, TASDEV_CALIB_N); } +/* +* V1 data without CRC is only trusted if every expected device has a +* populated, self-consistent entry: R0 (Q27) * 1/R0 (Q31) must be +* close to 1.0 in Q58. +*/ +static bool tas2781_v1_nocrc_valid (const unsigned int *v,int ndev) +{ +const u64 one =1ULL <<58 ; +int i; + +if (ndev <=0 || ndev >4 ) +return false; + +for (i =0 ; i < ndev; i++) { +const unsigned int *e = &v[i *5 ]; +u64 prod = (u64 )e[0 ] * e[1 ]; + +if (!e[0 ] || !e[1 ] || + prod < one - one /10 || prod > one + one /10 ) +return false; + } + +return true; +} +static void tas2781_apply_calib (struct tasdevice_priv *p) {struct calidata *cali_data = &p->cali_data;
@@ -145,7 +170,7 @@ static void tas2781_apply_calib(struct tasdevice_priv *p)* but leave TimeStamp and CRC zeroed. */ if (!tmp_val[20 ] && !tmp_val[21 ] && - tmp_val[0 ] && tmp_val[1 ]) { +tas2781_v1_nocrc_valid (tmp_val, p->ndev)) {dev_warn (p->dev,"%s: V1 data without CRC, accepting\n" , __func__);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 433/686 ALSA: line6: Reject capture buffers smaller than two packets
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sinan Turunc <[email protected]>
[ Upstream commit db51425c9eb038a8e40e09b837afde015ae9e3ec ]
line6_capture_copy() splits the copy into the ALSA ring buffer once at the buffer end and wraps pos_done once, which is only correct when one packet holds at most buffer_size frames. The packet size comes from the device's endpoint, and the per-device hw structs allow 64-byte periods with periods_min 1, so a packet can be larger than the whole buffer. audio_in_callback() logs an oversized packet and then copies it anyway.
The packet size is known at probe time, so constrain SNDRV_PCM_HW_PARAM_BUFFER_BYTES in snd_line6_capture_open() to at least twice the larger of the two endpoints' packet sizes. Two rather than one, because pos_done advances by the packet and wraps once, so a buffer of exactly one packet leaves the position unchanged after every packet. hw_params then rejects a buffer that cannot hold two packets, and the single wrap is valid for every configuration that gets through. Keep a guard in line6_capture_copy() that drops an oversized packet with a ratelimited error, for the case that should no longer be reachable.
Reproduced on 7.3-rc7 with a USB/IP device presenting the GuitarPort interface layout and 1024-byte packets into a 128-byte buffer: ALSA logged "invalid position: pos = 224, buffer size = 32" and the driver logged "driver bug: len" on every following packet. With this patch a 1024-byte buffer is refused at hw_params, and a 2048-byte buffer streams for 30 s with no report and with the position moving inside the buffer.
--- sound/usb/line6/capture.c | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
sound/usb/line6/capture.c +29 -0
@@ -94,6 +94,18 @@ void line6_capture_copy(struct snd_line6_pcm *line6pcm, char *fbuf, int fsize)if (runtime ==NULL )return ; +/* +* snd_line6_capture_open() constrains the buffer to hold at least +* two packets, so this cannot happen for a conforming device. Drop +* the packet rather than overrun the single wrap below. +*/ +if (unlikely (frames > runtime->buffer_size)) { +dev_err_ratelimited (line6pcm->line6->ifcdev, +"packet of %d frames exceeds %lu-frame buffer, dropping\n" , + frames, runtime->buffer_size); +return ; + } +if (line6pcm->in.pos_done + frames > runtime->buffer_size) {/* The transferred area goes over buffer boundary,
@@ -231,6 +243,23 @@ static int snd_line6_capture_open(struct snd_pcm_substream *substream)if (err <0 )return err; +/* +* line6_capture_copy() wraps the ring buffer once per packet and +* advances pos_done by the packet, which only works when the buffer +* holds more than one packet: with exactly one, pos_done gains a +* buffer and loses it again on every packet. The packet size comes +* from the device, so bound the buffer by two packets here. The +* impulse-response path copies a playback URB into this ring, so +* take the larger of the two endpoints. +*/ + err =snd_pcm_hw_constraint_minmax (runtime, +SNDRV_PCM_HW_PARAM_BUFFER_BYTES , +2 *max (line6pcm->max_packet_size_in, + line6pcm->max_packet_size_out), +UINT_MAX ); +if (err <0 ) +return err; +line6_pcm_acquire (line6pcm,LINE6_STREAM_CAPTURE_HELPER , false); runtime->hw = line6pcm->properties->capture_hw;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 434/686 ALSA: caiaq: free the EP4 URB when input setup fails
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Wentao Liang <[email protected]>
[ Upstream commit d21746bafdb8e1a5fc9bdcb86f603d827a500a62 ]
The three controllers that use the EP4 input URB allocate it before checking the endpoint type and before registering the input device. On failure they jump to exit_free_idev, which clears cdev->input_dev but leaves cdev->ep4_in_urb set. The card teardown then calls snd_usb_caiaq_input_free(), which returns early because input_dev is NULL, so the URB is never freed.
Release the URB before dropping the input device on the error path.
--- sound/usb/caiaq/input.c | 2 ++ 1 file changed, 2 insertions(+)
sound/usb/caiaq/input.c +2 -0
@@ -830,6 +830,8 @@ int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *cdev)return 0 ; exit_free_idev: +usb_free_urb (cdev->ep4_in_urb); + cdev->ep4_in_urb =NULL ;input_free_device (input); cdev->input_dev =NULL ;return ret;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 435/686 ALSA: usx2y: Require a buffer of two URBs
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sinan Turunc <[email protected]>
[ Upstream commit 4cbb826b3b36df6c275454287ba1df4564a5370b ]
usx2y_urb_capt_retire() wraps the ring buffer once per packet and usx2y_urb_play_prepare() once per URB of nr_of_packs() packets of up to 50 frames. Both assume that the data fits in the buffer, and the hw constraints only require about two 1 ms periods, so a packet larger than the buffer on capture, or a URB larger than the buffer on playback, violates that assumption.
Constrain SNDRV_PCM_HW_PARAM_BUFFER_SIZE in snd_usx2y_pcm_open() to at least two URBs, 2 * nr_of_packs() * 50 frames, for both directions. The bound is in frames and derived from the driver's own packet limit, so it does not read the endpoint, whose altsetting is only selected in prepare. Two URBs rather than one, because the position advances by a URB on playback and only moves when a URB is less than the whole buffer. Keep a guard in usx2y_urb_capt_retire() that drops a packet larger than the buffer, for the case the constraint makes unreachable.
With nrpacks above about 163 (S16_LE) or 109 (S24_3LE) the bound exceeds the 64 KiB buffer the substream preallocates (twice that with the preallocation raised to its 128 KiB maximum), so hw_params fails for those module settings. That is intended: the driver cannot be safe with a URB larger than half the largest buffer.
Reproduced on 7.3-rc7 with a USB/IP device presenting the US-122 interface layout and 1024-byte packets into a 512-byte capture buffer:
BUG: KASAN: out-of-bounds in i_usx2y_urb_complete+0x1285/0x1ac0 Read of size 18446744073709551104 at addr ffff88800e448800 by task vhci_rx/83
Tested on 7.3-rc7 with the same device, S16_LE at 44100 Hz, nrpacks 4, so the bound is 400 frames. A 128-frame capture buffer and a 200-frame playback buffer are refused at hw_params with EINVAL. A 400-frame buffer streams for 30 s in each direction with the position advancing inside the buffer and no KASAN report; the capture guard did not fire. The same 400-frame capture buffer with S24_3LE, which selects altsetting 2 in prepare, streams for 30 s with the same result.
--- sound/usb/usx2y/usbusx2yaudio.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
sound/usb/usx2y/usbusx2yaudio.c +24 -0
@@ -51,6 +51,18 @@ static int usx2y_urb_capt_retire(struct snd_usx2y_substream *subs)dev_dbg (&usx2y->dev->dev,"%s: 0 == len ERROR!\n" , __func__);continue ; } +/* +* snd_usx2y_pcm_open() constrains the buffer to hold at least +* two URBs, so this cannot happen for a device that keeps its +* packets at 50 frames. Drop the packet rather than exceed the +* single wrap below. +*/ +if (unlikely (len > runtime->buffer_size)) { +dev_err_ratelimited (&usx2y->dev->dev, +"%s: packet of %i frames exceeds %lu-frame buffer, dropping\n" , + __func__, len, runtime->buffer_size); +continue ; + }/* copy a data chunk */ if ((hwptr_done + len) > runtime->buffer_size) {
@@ -890,6 +902,18 @@ static int snd_usx2y_pcm_open(struct snd_pcm_substream *substream) runtime->private_data = subs; subs->pcm_substream = substream;snd_pcm_hw_constraint_minmax (runtime,SNDRV_PCM_HW_PARAM_PERIOD_TIME ,1000 ,200000 ); +/* +* Capture wraps the ring buffer once per packet and playback once +* per URB of nr_of_packs() packets of at most 50 frames (see +* usx2y_urb_play_prepare()). Playback needs the buffer to hold more +* than one URB and capture more than one packet; use the URB bound +* for both, and two URBs rather than one, because the position only +* advances when a URB is less than the whole buffer. The bound is in +* frames and does not depend on the altsetting, which is selected +* in prepare. +*/ +snd_pcm_hw_constraint_minmax (runtime,SNDRV_PCM_HW_PARAM_BUFFER_SIZE , +2 *nr_of_packs () *50 ,UINT_MAX );return 0 ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 436/686 ALSA: usx2y: Guard the playback copy
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sinan Turunc <[email protected]>
[ Upstream commit e2c6de52ffacb2c0f4076884ee3fdb744735a4cb ]
usx2y_urb_play_prepare() sums the packet lengths of a whole URB, copies that many frames with a single wrap, and sizes each playback packet from the capture packet's actual_length. Three things are unchecked: that the URB fits in the ring buffer, that a packet fits in the playback endpoint's maxpacksize, from which tmpbuf is allocated, and that actual_length is a whole number of frames. The ISO descriptors take the raw actual_length while transfer_buffer_length and the copies take count * stride, so a packet that is not a multiple of the stride makes the descriptors add up to more than the buffer, by up to stride - 1 bytes per packet.
Return -EPIPE, as the existing packet-size check does, when the URB is larger than the buffer or a packet is larger than maxpacksize, and size each descriptor from whole frames, so the descriptors add up to transfer_buffer_length and each stays within maxpacksize. The buffer case is prevented by the previous patch and this is the guard for it; the other two depend only on the device.
The first case is reachable on the unpatched driver with ordinary
packets: on 7.3-rc7, a USB/IP device presenting the US-122 interface layout and sending 48-frame packets, with a 100-frame playback buffer (two 50-frame periods, inside the stock constraints), KASAN reports:
BUG: KASAN: out-of-bounds in i_usx2y_urb_complete+0x79b/0x1ac0 Read of size 18446744073709551280 at addr ffff88800e6b02e0 by task vhci_rx/80
With both patches, the same device and a 200-frame playback buffer is refused at hw_params with EINVAL, and a 400-frame buffer plays for 30 s with the position advancing inside the buffer, no KASAN report and neither guard message. The maxpacksize check is not exercised: the emulated device reports the same wMaxPacketSize on both endpoints.
The descriptor case is visible with capture packets of 195 bytes at stride 4 (48 frames and 3 bytes): without this change the four descriptors add up to 780 bytes for 768 bytes of data, and USB/IP's completion check refuses the URB ("total length of iso packets 780 not equal to actual length of buffer 768", -EPROTO), after which the driver stops the streams. With this patch every descriptor is 192 bytes, the descriptors add up to the data in every URB for 30 s, the position advances inside the buffer and KASAN reports nothing. The 48-frame playback run above is unchanged.
--- sound/usb/usx2y/usbusx2yaudio.c | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-)
sound/usb/usx2y/usbusx2yaudio.c +18 -1
@@ -118,14 +118,31 @@ static int usx2y_urb_play_prepare(struct snd_usx2y_substream *subs, __func__, counts);return -EPIPE ; } +if (counts * usx2y->stride > subs->maxpacksize) { +dev_err_ratelimited (&usx2y->dev->dev, +"%s: packet of %i bytes exceeds maxpacksize %u\n" , + __func__, counts * usx2y->stride, + subs->maxpacksize); +return -EPIPE ; + }/* set up descriptor */ urb->iso_frame_desc[pack].offset = pack ? urb->iso_frame_desc[pack -1 ].offset + urb->iso_frame_desc[pack -1 ].length :0 ; - urb->iso_frame_desc[pack].length = cap_urb->iso_frame_desc[pack].actual_length; + urb->iso_frame_desc[pack].length = counts * usx2y->stride; }if (atomic_read (&subs->state) >=STATE_PRERUNNING ) { +/* +* The copy below wraps once, which needs count <= buffer_size. +* snd_usx2y_pcm_open() guarantees it; guard anyway. +*/ +if (unlikely (count > runtime->buffer_size)) { +dev_err_ratelimited (&usx2y->dev->dev, +"%s: URB of %i frames exceeds %lu-frame buffer, stopping\n" , + __func__, count, runtime->buffer_size); +return -EPIPE ; + }if (subs->hwptr + count > runtime->buffer_size) {/* err, the transferred area goes over buffer boundary. * copy the data to the temp buffer.
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 437/686 ext2: preserve IOMAP_F_DIRTY for extending direct writes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hungyu Lin <[email protected]>
[ Upstream commit 4f91b042af212ca0b610e43f9a975ddc7f0d0923 ]
ext2_iomap_begin() sets IOMAP_F_DIRTY for writes that may extend i_size, but clears the flag after ext2_get_blocks(). When the write uses an existing mapped block, iomap can then use FUA and skip generic_write_sync(), even though ext2_dio_write_end_io() updates the inode size. An O_DSYNC write can therefore return without persisting the new size.
For example, on a FUA-capable device, a 512-byte O_DIRECT|O_DSYNC write at offset 512 into a fsynced one-byte file returns successfully and extends the in-memory size to 1024, while an immediate read of the on-disk inode still shows size 1. An explicit fsync persists the new size.
Move setting of IOMAP_F_DIRTY after the initialization.
--- fs/ext2/inode.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-)
fs/ext2/inode.c +6 -7
@@ -824,6 +824,12 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length, (first_block << blkbits) < i_size_read(inode)) create =0 ; + ret =ext2_get_blocks (inode, first_block, max_blocks, + &bno, &new, &boundary, create); +if (ret <0 ) +return ret; + + iomap->flags =0 ;/* * Writes that span EOF might trigger an IO size update on completion, * so consider them to be dirty for the purposes of O_DSYNC even if
@@ -831,13 +837,6 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,*/ if ((flags &IOMAP_WRITE ) && offset + length >i_size_read (inode)) iomap->flags |=IOMAP_F_DIRTY ; - - ret =ext2_get_blocks (inode, first_block, max_blocks, - &bno, &new, &boundary, create); -if (ret <0 ) -return ret; - - iomap->flags =0 ; iomap->offset = (u64 )first_block << blkbits;if (flags &IOMAP_DAX ) iomap->dax_dev = sbi->s_daxdev;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 438/686 net/smc: dont spin in smc_rx_recvmsg() while a pipe holds spliced data
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Bryam Vargas <[email protected]>
[ Upstream commit 8288ba942cfd20621c05e16978b7c3da91513ae1 ]
While bytes spliced off the RMB are still in a pipe, recvmsg() waits for the pipe to release them before it copies the data behind them. The path to that wait skips the timeout and signal checks, and smc_rx_wait() returns at once on RCV_SHUTDOWN. With a signal pending, after SHUT_RD, or once the peer closes or shuts down writing, recvmsg() spins on a CPU until the pipe is drained, and SIGKILL cannot stop it. MSG_DONTWAIT and an expired SO_RCVTIMEO wait there too instead of returning -EAGAIN.
Check the timeout and signals before that wait, and end it when the pipe releases the data or the connection is killed, not on RCV_SHUTDOWN. A zero-length read returns 0 without waiting for the pipe; a non-blocking one returns -EAGAIN while poll() still reports the socket readable (splice() can still take those bytes). The wait sets SOCKWQ_ASYNC_WAITDATA like smc_rx_wait(), so a byte arriving behind the pipe raises no SIGIO on a reader already asleep for it, and a full barrier orders its wait queue entry before its read of splice_pending, so no wake is lost.
--- net/smc/smc_rx.c | 39 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 38 insertions(+), 1 deletion(-)
net/smc/smc_rx.c +38 -1
@@ -286,6 +286,27 @@ int smc_rx_wait(struct smc_sock *smc, long *timeo, size_t peeked,return rc; } +/* Wait for the pipe to release the spliced data. Unlike smc_rx_wait() +* it does not end on shutdown or sk_err, the data is already in the +* RMB; smc_conn_kill() wakes it and the caller checks conn->killed. +*/ +static void smc_rx_wait_splice (struct smc_sock *smc,long *timeo) +{ +DEFINE_WAIT_FUNC (wait, woken_wake_function); +struct smc_connection *conn = &smc->conn; +struct sock *sk = &smc->sk; + +sk_set_bit (SOCKWQ_ASYNC_WAITDATA , sk); +add_wait_queue (sk_sleep (sk), &wait); +/* pairs with the smp_mb() in wq_has_sleeper(): the release drops +* splice_pending, then looks for a sleeper +*/ +smp_mb (); +sk_wait_event (sk, timeo, !atomic_read (&conn->splice_pending), &wait); +remove_wait_queue (sk_sleep (sk), &wait); +sk_clear_bit (SOCKWQ_ASYNC_WAITDATA , sk); +} +static int smc_rx_recv_urg (struct smc_sock *smc,struct msghdr *msg,int len,int flags) {
@@ -443,7 +464,23 @@ int smc_rx_recvmsg(struct smc_sock *smc, struct msghdr *msg,/* could be just 1 byte, even after waiting on data above */ readable =smc_rx_data_available (conn, peeked_bytes); splbytes =atomic_read (&conn->splice_pending); -if (!readable || (msg && splbytes)) { +if (msg && splbytes) { +/* a pipe holds bytes ahead of these; the copy path +* skips the timeout and signal checks +*/ +if (!read_remaining) +break ; +if (!timeo ||signal_pending (current)) { +if (!read_done) + read_done = timeo ? +sock_intr_errno (timeo) : + -EAGAIN ; +break ; + } +smc_rx_wait_splice (smc, &timeo); +continue ; + } +if (!readable) {if (splbytes) func = smc_rx_data_available_and_no_splice_pend;else
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 439/686 net: count last skb of each sk_backlog pass in __release_sock()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ray Zhang <[email protected]>
[ Upstream commit c4e4056b21355356f6a95bcdf03a850edd9f49e7 ]
Running 500 concurrent TCPv6 streams (neper "tcp_stream -6 -T 1 -F 500") on a 2-core Cortex-A53 (CONFIG_PREEMPT_NONE=y, HZ=1000, LATENCY_WARN) triggers resched_latency_warn() in __release_sock():
[ 3655.311821] sched: CPU 0 need_resched set for > 100006892 ns (100 ticks) without schedule [ 3655.311889] Call trace: ... [ 3655.311944] resched_latency_warn+0x7c/0x88 [ 3655.311958] sched_tick+0x1c0/0x418 ... [ 3655.312578] net_rx_action+0x238/0x438 ... [ 3655.312641] do_softirq+0x4c/0x90 [ 3655.312651] __local_bh_enable_ip+0x84/0x90 [ 3655.312663] local_bh_enable+0x1c/0x28 [ 3655.312674] __dev_queue_xmit+0x4a8/0xb00 ... [ 3655.312782] tcp_v6_do_rcv+0x240/0x5f8 [ 3655.312793] __release_sock+0x9c/0x188 [ 3655.312806] release_sock+0x150/0x168 [ 3655.312817] tcp_sendmsg+0x4c/0x70
__release_sock() can loop past 100 ms without calling cond_resched():
- Each outer-loop pass drains sk_backlog, but "if (!skb) break;" runs before "++nb", so a pass of B skbs only adds B - 1 to nb (0 for 1 skb).
- With 500 TCPv6 streams and NAPI sharing two Cortex-A53 cores, runnable tasks keep TIF_NEED_RESCHED set on CPU 0.
- During spin_unlock_bh() and TX softirqs (__dev_queue_xmit() -> local_bh_enable()), tcp_add_backlog() coalesces arriving pure ACKs into a single tail skb.
- Repeated 1-skb passes never advance nb or call cond_resched(), triggering resched_latency_warn() after 100 ticks.
Restore the do-while loop and drop "if (!skb) break;" so every skb increments nb across passes and calls cond_resched() every 16 skbs.
Reproduced the issue and verified the fix on two 2-core Cortex-A53 hosts (CONFIG_PREEMPT_NONE=y, HZ=1000, LATENCY_WARN, latency_warn_once=0) with a userspace reproducer over /dev/net/tun:
- CPU 0 runs a TCPv6 sender and a second runnable task while CPU 1 writes pure ACKs to /dev/net/tun (~30k TCPBacklogCoalesce/run), sustaining 1-skb sk_backlog refills in __release_sock() for ~400 ms (ftrace).
- Before: CPU 0 stayed unscheduled in __release_sock(), hitting resched_latency_warn() 293 and 275 times on the two hosts (> 100.9 ms).
- After: cond_resched() yielded CPU 0 inside __release_sock(), with 0 resched_latency_warn() hits on both hosts.
- Also observed no regression with the workload from
commit 16c610162d1f ("net: call cond_resched() less often in __release_sock()"), "super_netperf 4 -H srv -T,10 -l 3000 &".
--- net/core/sock.c | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-)
net/core/sock.c +2 -4
@@ -3185,7 +3185,7 @@ void __release_sock(struct sock *sk)spin_unlock_bh (&sk->sk_lock.slock); -while (1 ) { + do { next = skb->next; prefetch(next); DEBUG_NET_WARN_ON_ONCE(skb_dst_is_noref(skb));
@@ -3193,12 +3193,10 @@ void __release_sock(struct sock *sk)sk_backlog_rcv (sk, skb); skb = next; -if (!skb) -break ;if (!(++nb &15 ))cond_resched (); - } + }while (skb);spin_lock_bh (&sk->sk_lock.slock); }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 440/686 net: ethernet: ti: am65-cpsw-nuss: Enable timestamping of unicast PTP packets
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: James Clark <[email protected]>
[ Upstream commit 6887a8f98244ba4c0fbe2d2461b9b8f8a300e326 ]
On a BeagleY-AI (J722S), ptp4l as a unicast master (unicast_listen) logs "received DELAY_REQ without timestamp" for each unicast Delay_Req, and its port goes to FAULTY after "timed out while polling for tx timestamp" for the first unicast Sync.
am65_cpsw_nuss_hwtstamp_set() does not set the TS_UNI_EN bit (bit 24) of the port's TS_CTL_LTYPE2 register. According to the TRM (J722S TRM SPRUJB3D, 12.2.1.4.7.13.5.1 Ethernet Port Receive Event and 12.2.1.4.7.13.5.2 Ethernet Port Transmit Event), this bit must be set for the port to timestamp PTP event messages over UDP sent to a unicast address; without it, only messages sent to the PTP multicast addresses selected by the TS_107 and TS_129 to TS_132 bits are timestamped. TI's netcp_ethss driver for the Keystone 2 Ethernet switch, which has the same timestamping registers, always sets TS_UNI_EN.
Set TS_UNI_EN along with the other bits. With this change, ptp4l in the same setup gets timestamps for the unicast Delay_Req and Sync messages.
--- drivers/net/ethernet/ti/am65-cpsw-nuss.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/net/ethernet/ti/am65-cpsw-nuss.c +3 -1
@@ -128,6 +128,7 @@#define AM65_CPSW_PN_TS_CTL_LTYPE2_TS_319 BIT(21)#define AM65_CPSW_PN_TS_CTL_LTYPE2_TS_320 BIT(22)#define AM65_CPSW_PN_TS_CTL_LTYPE2_TS_TTL_NONZERO BIT(23) +#define AM65_CPSW_PN_TS_CTL_LTYPE2_TS_UNI_EN BIT(24)/* The PTP event messages - Sync, Delay_Req, Pdelay_Req, and Pdelay_Resp. */ #define AM65_CPSW_TS_EVENT_MSG_TYPE_BITS (BIT(0) | BIT(1) | BIT(2) | BIT(3))
@@ -1859,7 +1860,8 @@ static int am65_cpsw_nuss_hwtstamp_set(struct net_device *ndev,AM65_CPSW_PN_TS_CTL_LTYPE2_TS_132 |AM65_CPSW_PN_TS_CTL_LTYPE2_TS_319 |AM65_CPSW_PN_TS_CTL_LTYPE2_TS_320 | -AM65_CPSW_PN_TS_CTL_LTYPE2_TS_TTL_NONZERO ; +AM65_CPSW_PN_TS_CTL_LTYPE2_TS_TTL_NONZERO | +AM65_CPSW_PN_TS_CTL_LTYPE2_TS_UNI_EN ; ts_ctrl =AM65_CPSW_TS_EVENT_MSG_TYPE_BITS <<AM65_CPSW_PN_TS_CTL_MSG_TYPE_EN_SHIFT ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 441/686 drm/etnaviv: Flush the tile status cache through both the PE and BLT
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Christian Gmeiner <[email protected]>
[ Upstream commit c1a757f8df1363032623fa9b1baaba0dcf34de6d ]
Since commit f232d9ec029c ("drm/etnaviv: fix TS cache flushing on GPUs with BLT engine"), jobs on GPUs with a BLT engine use a BLT command to flush the tile status cache instead of TS_FLUSH_CACHE, which is broken on most of these GPUs.
GC7000 r6008/r6009 and GC8200 r6401 are the other way around:TS_FLUSH_CACHE works, but the BLT command does not flush the cache. The vendor driver handles these GPUs using TS_FLUSH_CACHE, but the etnaviv kernel driver has no way to identify them.
As a result, dirty tile status cache lines survive the end of a job. They are written back by the next cache flush, using the page table of the job issuing it. If that job belongs to another process, the write goes to the wrong address space.
On GC7000 r6009 this causes MMU faults and GPU recoveries blamed on an innocent process. I see around 1100 per run of a multisample depth/stencil test running alongside two other GPU clients.
Emit both flushes at the end of every job on GPUs with a BLT engine. Whichever does not work on a given GPU is a no-op. Since dirty lines are only written back once, this costs one additional state load per job.
--- drivers/gpu/drm/etnaviv/etnaviv_buffer.c | 40 +++++++++++------------- 1 file changed, 18 insertions(+), 22 deletions(-)
drivers/gpu/drm/etnaviv/etnaviv_buffer.c +18 -22
@@ -230,6 +230,17 @@ u16 etnaviv_buffer_config_pta(struct etnaviv_gpu *gpu, unsigned short id)return buffer->user_size /8 ; } +static void etnaviv_cmd_flush_ts (struct etnaviv_cmdbuf *buffer,bool has_blt) +{ +CMD_LOAD_STATE (buffer,VIVS_TS_FLUSH_CACHE ,VIVS_TS_FLUSH_CACHE_FLUSH ); + +if (has_blt) { +CMD_LOAD_STATE (buffer,VIVS_BLT_ENABLE ,0x1 ); +CMD_LOAD_STATE (buffer,VIVS_BLT_SET_COMMAND ,0x1 ); +CMD_LOAD_STATE (buffer,VIVS_BLT_ENABLE ,0x0 ); + } +} +void etnaviv_buffer_end (struct etnaviv_gpu *gpu) {struct etnaviv_cmdbuf *buffer = &gpu->buffer;
@@ -253,7 +264,7 @@ void etnaviv_buffer_end(struct etnaviv_gpu *gpu)unsigned int dwords =7 ;if (has_blt) - dwords +=10 ; + dwords +=11 ; link_target =etnaviv_buffer_reserve (gpu, buffer, dwords);
@@ -266,16 +277,8 @@ void etnaviv_buffer_end(struct etnaviv_gpu *gpu)CMD_LOAD_STATE (buffer,VIVS_BLT_ENABLE ,0x0 ); }CMD_LOAD_STATE (buffer,VIVS_GL_FLUSH_CACHE , flush); -if (gpu->exec_state ==ETNA_PIPE_3D ) { -if (has_blt) { -CMD_LOAD_STATE (buffer,VIVS_BLT_ENABLE ,0x1 ); -CMD_LOAD_STATE (buffer,VIVS_BLT_SET_COMMAND ,0x1 ); -CMD_LOAD_STATE (buffer,VIVS_BLT_ENABLE ,0x0 ); - }else { -CMD_LOAD_STATE (buffer,VIVS_TS_FLUSH_CACHE , -VIVS_TS_FLUSH_CACHE_FLUSH ); - } - } +if (gpu->exec_state ==ETNA_PIPE_3D ) +etnaviv_cmd_flush_ts (buffer, has_blt);CMD_SEM (buffer,SYNC_RECIPIENT_FE ,SYNC_RECIPIENT_PE );CMD_STALL (buffer,SYNC_RECIPIENT_FE ,SYNC_RECIPIENT_PE );if (has_blt) {
@@ -462,12 +465,12 @@ void etnaviv_buffer_queue(struct etnaviv_gpu *gpu, u32 exec_state, return_dwords =7 ;/* -* When the BLT engine is present we need 6 more dwords in the return +* When the BLT engine is present we need 7 more dwords in the return * target: 3 enable/flush/disable + 4 enable/semaphore stall/disable, -* but we don't need the normal TS flush state. +* on top of the normal TS flush state. */ if (has_blt) - return_dwords +=6 ; + return_dwords +=7 ; return_target =etnaviv_buffer_reserve (gpu, buffer, return_dwords);CMD_LINK (cmdbuf, return_dwords, return_target);
@@ -484,14 +487,7 @@ void etnaviv_buffer_queue(struct etnaviv_gpu *gpu, u32 exec_state,VIVS_GL_FLUSH_CACHE_DEPTH |VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_SHADER_L1); -if (has_blt) { -CMD_LOAD_STATE (buffer,VIVS_BLT_ENABLE ,0x1 ); -CMD_LOAD_STATE (buffer,VIVS_BLT_SET_COMMAND ,0x1 ); -CMD_LOAD_STATE (buffer,VIVS_BLT_ENABLE ,0x0 ); - }else { -CMD_LOAD_STATE (buffer,VIVS_TS_FLUSH_CACHE , -VIVS_TS_FLUSH_CACHE_FLUSH ); - } +etnaviv_cmd_flush_ts (buffer, has_blt); }CMD_SEM (buffer,SYNC_RECIPIENT_FE ,SYNC_RECIPIENT_PE );CMD_STALL (buffer,SYNC_RECIPIENT_FE ,SYNC_RECIPIENT_PE );
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 442/686 mptcp: pm: kernel: use RCU to free endpoint listeners
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Kyle Zeng <[email protected]>
[ Upstream commit 49b09ae0bf57b4230187d4cdd0a370558e44a6e8 ]
mptcp_pm_nl_create_listen_socket() starts the TCP listener directly instead of going through mptcp_listen(). It consequently misses setting SOCK_RCU_FREE on the parent MPTCP socket.
tcp_child_process() can invoke the listener's subflow_data_ready() callback without holding the MPTCP parent lock or a reference to the parent. An authenticated MP_JOIN racing with endpoint teardown can therefore access the parent after its last reference has been dropped. The ADD_ADDR error path can also close an already published listener.
Set SOCK_RCU_FREE before __inet_listen_sk() publishes the TCP listener, matching mptcp_listen(). This protects the parent on every subsequent close path, including a failed endpoint addition.
--- net/mptcp/pm_kernel.c | 1 + 1 file changed, 1 insertion(+)
net/mptcp/pm_kernel.c +1 -0
@@ -881,6 +881,7 @@ static int mptcp_pm_nl_create_listen_socket(struct sock *sk,* old status is known (TCP_CLOSE). */ inet_sk_state_store (newsk,TCP_LISTEN ); +sock_set_flag (newsk,SOCK_RCU_FREE );lock_sock (ssk);WRITE_ONCE (mptcp_subflow_ctx (ssk)->pm_listener, true); err =__inet_listen_sk (ssk, backlog);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 443/686 udf: dont let the extent type hide an exhausted free-space table extent
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Matthias Goergens <[email protected]>
[ Upstream commit da582d84fcf5f2f0c1d7760e1a899ca7cedb80fc ]
udf_table_new_block() takes the first block of the free-space table extent closest to the goal. It keeps that extent's type and length together in goal_elen, subtracts one block, and deletes the extent only if goal_elen then reaches zero. UDF 2.60 section 2.3.7.1 requires the free-space extents of an Unallocated Space Entry to be of type 1 (allocated but not recorded), and mkudffs writes them that way. For such an extent the type bits keep goal_elen non-zero, so taking its last block leaves a type-1 extent of length zero behind, starting at the block after the extent, which is in use.
The next allocation that picks this empty extent returns that in-use block. Subtracting a block from 0x40000000 then borrows from the type bits, and the extent becomes type 0 with a length of 2^30 - blocksize:
about a gigabyte of "free" space overlapping live metadata, the other table extents and whatever lies behind the partition. From then on blocks are handed out twice, or past the end of the partition.
Extents that udf_table_free_blocks() adds are type 0, where the check works, so only tables written by mkudffs or by another implementation are affected. Nothing more than filling such a filesystem is needed:
on a fresh 1 MiB "mkudffs --space=unalloctable" image, creating empty files until the partition is full writes file entries over the reserve volume descriptor sequence and the backup anchor, and df then reports a negative amount of used space.
On syzbot's images the same double allocation is what the two reports below trip over. In the first, ftruncate() extends a new file with enough hole extents to need a chain of allocation extent descriptors; one AED is placed on another inode's file entry, and a later one is placed on the block of the AED currently being filled, which udf_setup_indirect_aext() zeroes, so __udf_add_aext() finds lengthAllocDescs out of step with its cursor. In the second, an AED is placed past the end of the device, sb_getblk() fails, and the error path of udf_do_extend_file() calls udf_truncate_extents() on an extent list that no longer covers i_size.
Keep the type separately from the length, as udf_table_prealloc_blocks() already does.
--- fs/udf/balloc.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
fs/udf/balloc.c +5 -3
@@ -572,7 +572,7 @@ static udf_pblk_t udf_table_new_block(struct super_block *sb,uint32_t elen, goal_elen =0 ;struct kernel_lb_addr eloc, goal_eloc;struct extent_position epos, goal_epos; -int8_t etype; +int8_t etype, goal_etype =0 ;struct udf_inode_info *iinfo =UDF_I (table);int ret =0 ;
@@ -623,7 +623,8 @@ static udf_pblk_t udf_table_new_block(struct super_block *sb, goal_epos.block = epos.block; goal_epos.offset = epos.offset - adsize; goal_eloc = eloc; - goal_elen = (etype <<30 ) | elen; + goal_elen = elen; + goal_etype = etype; } }
@@ -647,7 +648,8 @@ static udf_pblk_t udf_table_new_block(struct super_block *sb, goal_elen -= sb->s_blocksize;if (goal_elen) -udf_write_aext (table, &goal_epos, &goal_eloc, goal_elen,1 ); +udf_write_aext (table, &goal_epos, &goal_eloc, + (goal_etype <<30 ) | goal_elen,1 );else udf_delete_aext (table, goal_epos, &freed);brelse (goal_epos.bh);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 444/686 udf: check the unallocated space table when it is loaded
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Matthias Goergens <[email protected]>
[ Upstream commit e614c3e35a6699ed691b4d17e1ec4230e34aa3eb ]
udf_table_new_block() hands out the first block of the extent closest to its goal and trusts that the extent covers at least one whole block inside the partition. Nothing checks that. A zero-length extent makes it return the block the extent points at, which need not be free, and the subtraction of one block then underflows the length into the type bits, turning the entry into a bogus continuation. An extent running past the end of the partition makes it return blocks behind the partition.
Such tables are not only found on crafted images: until the previous commit, udf_table_new_block() itself left zero-length extents behind in tables written by mkudffs, and then converted them into extents running past the partition.
Check every extent once when the table is loaded, and refuse read-write access if one is empty, is not a whole number of blocks, or does not lie inside the partition, in the same way as for other allocation information the kernel cannot use. Check first that the table is an Unallocated Space Entry at all: the walk starts at the offset of the allocation descriptors in one, and for a file entry that offset lies before the inode's in-memory copy of the descriptors. Treat a chain of allocation extent descriptors that leads back to itself the same way: the walk would otherwise return the same extents forever, and the mount would never finish. Let a fatal signal interrupt the walk and fail the mount.
Refusing read-write access to an empty extent is deliberate. It shows that an old kernel took the last block but left the entry behind. If consumed again, the entry returns an in-use block and turns into a huge bogus extent. Refusing the table before that
happens avoids this second allocation; the filesystem can still be mounted read-only. The check cannot detect every overlap that may already exist in a damaged table.
This patch should be backported together with the previous one: that patch stops creating new empty extents, and this one rejects existing ones before they are consumed again.
--- fs/udf/super.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-)
fs/udf/super.c +79 -1
@@ -1105,6 +1105,73 @@ static int check_partition_desc(struct super_block *sb,return 0 ; } +/* +* Check the Unallocated Space Table once when it is loaded: the allocator +* hands out blocks from the start of each extent and trusts that every +* extent covers at least one whole block inside the partition. +*/ +static int udf_check_unalloc_table (struct super_block *sb, +struct inode *table,u32 partition_len) +{ +struct extent_position epos = { + .block =UDF_I (table)->i_location, + .offset =sizeof (struct unallocSpaceEntry ), + }; +struct kernel_lb_addr eloc; +uint32_t elen, blocks; +struct kernel_lb_addr seen_block = {}; +uint32_t seen_offset =0 ; +u64 steps =0 , period =1 ; +int8_t etype; +int ret; + +/* The walk below assumes the layout of an Unallocated Space Entry */ +if (!UDF_I (table)->i_use) { +udf_err (sb,"unallocated space table is not an unallocated space entry\n" ); +return -EFSCORRUPTED ; + } + +while ((ret =udf_next_aext (table, &epos, &eloc, &elen, &etype,1 )) >0 ) { + blocks = elen >> sb->s_blocksize_bits; +if (!blocks || (elen & (sb->s_blocksize -1 )) || + eloc.logicalBlockNum >= partition_len || + blocks > partition_len - eloc.logicalBlockNum) { +udf_err (sb,"invalid unallocated space table extent (block %u, length %u)\n" , + eloc.logicalBlockNum, elen); + ret = -EFSCORRUPTED ; +break ; + } +/* +* A chain of allocation extents can lead back to itself, and +* then the walk returns the same extents forever. Remember a +* position at doubling intervals; a walk that comes back to it +* is in a loop. +*/ +if (epos.block.logicalBlockNum == seen_block.logicalBlockNum && + epos.block.partitionReferenceNum == + seen_block.partitionReferenceNum && + epos.offset == seen_offset) { +udf_err (sb,"unallocated space table loops back on itself\n" ); + ret = -EFSCORRUPTED ; +break ; + } +if (++steps == period) { + seen_block = epos.block; + seen_offset = epos.offset; + steps =0 ; + period <<=1 ; + } +if (fatal_signal_pending (current)) { +udf_err (sb,"interrupted while checking the unallocated space table\n" ); + ret = -EINTR ; +break ; + } +cond_resched (); + } +brelse (epos.bh); +return ret; +} +static int udf_fill_partdesc_info (struct super_block *sb,struct partitionDesc *p,int p_index) {
@@ -1165,6 +1232,16 @@ static int udf_fill_partdesc_info(struct super_block *sb, p_index);return PTR_ERR (inode); } + err =udf_check_unalloc_table (sb, inode, map->s_partition_len); +if (err) { +iput (inode); +if (err == -EINTR ) +return err; +if (!sb_rdonly (sb)) +return -EACCES ; +UDF_SET_FLAG (sb,UDF_FLAG_RW_INCOMPAT ); +return 0 ; + } map->s_uspace.s_table = inode; map->s_partition_flags |=UDF_PART_FLAG_UNALLOC_TABLE ; udf_debug("unallocSpaceTable (part %d) @ %lu\n",
@@ -2228,8 +2305,9 @@ static int udf_fill_super(struct super_block *sb, struct fs_context *fc)/* * EACCES is special - we want to propagate to * upper layers that we cannot handle RW mount. +* EINTR means that a fatal signal is pending. */ -if (ret == -EACCES ) +if (ret == -EACCES || ret == -EINTR )break ; }else break ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 445/686 udf: fix preallocation discarding before an empty allocation extent
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Matthias Goergens <[email protected]>
[ Upstream commit 0c52750caaaccee8b0e929450fe6538ec4985722 ]
udf_discard_prealloc() finds the last extent of a file by peeking at the next one with udf_next_aext() and stopping when that returns 0. The peek reads into eloc and elen, and the code then uses them as the last extent. But when udf_next_aext() returns 0 they hold no defined
value: if the extent list ends in a continuation descriptor that leads to an empty allocation extent, they describe that continuation, i.e. the block of the empty allocation extent, one block long.
The kernel creates such lists itself: when udf_delete_aext() removes the only descriptor of the last allocation extent in a list, it leaves that allocation extent empty and the continuation to it in place.
If the last extent is a preallocation, udf_discard_prealloc() deletes it with udf_delete_aext(), which finds the following allocation extent empty, so it also removes the continuation and frees that allocation extent's block. udf_discard_prealloc() then frees eloc and elen: that block a second time, instead of the preallocated blocks. On a space bitmap the preallocated blocks leak and the free block count drifts. On an unallocated space table the second free adds a second free extent for the same block, which is later handed out twice: fsx as run by generic/091 and generic/263 ends up with two parts of its test file in one block and reads back bad data.
Peek into separate variables, so that eloc and elen keep the last extent that udf_next_aext() returned with 1.
--- fs/udf/truncate.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
fs/udf/truncate.c +4 -3
@@ -124,8 +124,8 @@ void udf_discard_prealloc(struct inode *inode) {struct extent_position epos = {};struct extent_position prev_epos = {}; -struct kernel_lb_addr eloc; -uint32_t elen; +struct kernel_lb_addr eloc, tmpeloc; +uint32_t elen, tmpelen;uint64_t lbcount =0 ;int8_t etype =-1 ;struct udf_inode_info *iinfo =UDF_I (inode);
@@ -141,7 +141,8 @@ void udf_discard_prealloc(struct inode *inode)/* Find the last extent in the file */ while (1 ) { - ret =udf_next_aext (inode, &epos, &eloc, &elen, &tmpetype,0 ); + ret =udf_next_aext (inode, &epos, &tmpeloc, &tmpelen, + &tmpetype,0 );if (ret <0 ) goto out;if (ret ==0 )
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 446/686 udf: dont use eloc after the end of the unallocated space table
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Matthias Goergens <[email protected]>
[ Upstream commit 94401199df90e1c2a50c6e4b73618ac5a4ba83ba ]
When udf_next_aext() returns 0, its eloc, elen and etype outputs hold no defined value. Two walks of the unallocated space table still use eloc after the walk has reached the end of the table.
udf_table_prealloc_blocks() looks for a free extent starting at first_block and decides whether it found one by comparing eloc with first_block after the walk. If the table's list ends in a continuation descriptor that leads to an empty allocation extent, eloc is then the block of that allocation extent, which is in use, and if that is first_block, the block is handed out as preallocation. Once udf_discard_prealloc() no longer frees the wrong block, this is what still makes fsx in generic/091 and generic/263 read back bad data on a table, in about one run in four. Only take the extent if the walk stopped at it.
When udf_table_free_blocks() cannot merge the freed blocks into an existing extent, it appends a new one and sets only its block number, so the partition reference comes from whatever eloc held after the walk, and with long allocation descriptors it is written to disk. For a table without extents, eloc was never set. Take the partition reference from the freed blocks instead. Short allocation descriptors do not store the partition reference, which is why this half remains a latent long-descriptor fix rather than a reproduced failure.
--- fs/udf/balloc.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/udf/balloc.c +2 -1
@@ -457,6 +457,7 @@ static void udf_table_free_blocks(struct super_block *sb,int adsize; + eloc.partitionReferenceNum = bloc->partitionReferenceNum; eloc.logicalBlockNum = start; elen =EXT_RECORDED_ALLOCATED | (count << sb->s_blocksize_bits);
@@ -532,7 +533,7 @@ static int udf_table_prealloc_blocks(struct super_block *sb, eloc.logicalBlockNum, elen, first_block); } -if (first_block == eloc.logicalBlockNum) { +if (ret >0 && first_block == eloc.logicalBlockNum) { epos.offset -= adsize; alloc_count = (elen >> sb->s_blocksize_bits);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 447/686 MIPS: mm: Fix the cache error vector jump for XKPHYS kernels
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Imre Kaloz <[email protected]>
[ Upstream commit 30b76362f80d39d80f1197c88b284d9fa7952356 ]
except_vec2_generic jumps to cache_parity_error with a j, which cannot leave the vector's 256MB region. An XKPHYS kernel such as IP30's, linked at 512MB, is outside it, so the j targets an unbacked address and its speculative fetch raises bus errors on unrelated fetches. Jump to the handler's uncached XKPHYS address instead.
--- arch/mips/mm/cex-gen.S | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
arch/mips/mm/cex-gen.S +16 -0
@@ -8,6 +8,7 @@ * * Cache error handler */ +#include <asm/addrspace.h> #include <asm/asm.h> #include <asm/regdef.h> #include <asm/mipsregs.h>
@@ -37,6 +38,21 @@ nop nop +#if defined(CONFIG_64BIT) && VMLINUX_LOAD_ADDRESS >= XKPHYS && \ + VMLINUX_LOAD_ADDRESS < XKSEG + /* + * An XKPHYS kernel may lie outside the 256MB region a j from the + * vector reaches, so jump to the handler's uncached XKPHYS address. + */ + PTR_LA k0, cache_parity_error + PTR_LI k1, TO_PHYS_MASK + and k0, k0, k1 + PTR_LI k1, UNCAC_BASE + or k0, k0, k1 + jr k0 + nop +#else j cache_parity_error nop +#endif END(except_vec2_generic)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 448/686 MIPS: sgi-ip32: Mask MACE PCI interrupts in CRIME only
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Imre Kaloz <[email protected]>
[ Upstream commit 4e65c502b8975e7c3c3d84aba59cd04af1dd6b8a ]
Masking PCI interrupts in the MACE PCI control register overwrites the error and arbitration enables set at init, and a read-modify-write can hang CRIME 1.1 machines under DMA load. Enable the slot interrupts once and mask them in CRIME.
--- arch/mips/pci/pci-ip32.c | 7 ++++-- arch/mips/sgi-ip32/ip32-irq.c | 45 +++-------------------------------- 2 files changed, 8 insertions(+), 44 deletions(-)
arch/mips/pci/pci-ip32.c +5 -2
@@ -125,10 +125,13 @@ static int __init mace_init(void) {PCIBIOS_MIN_IO =0x1000 ; -/* Clear any outstanding errors and enable interrupts */ +/* +* Clear any outstanding errors and enable interrupts. PCI interrupts +* are masked in CRIME, so the per-slot enables stay on. +*/ mace->pci.error_addr =0 ; mace->pci.error =0 ; - mace->pci.control =0xff008500 ; + mace->pci.control =0xff0085ff ;printk ("MACE PCI rev %d\n" , mace->pci.rev);
arch/mips/sgi-ip32/ip32-irq.c +3 -42
69 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 449/686 MIPS: sgi-ip32: Leave MACE PCI control alone in config accesses
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Imre Kaloz <[email protected]>
[ Upstream commit a55a7df2cf788234850d9053ecc25a5470175929 ]
mace_pci_read_config() clears the master abort interrupt enable in the MACE PCI control register around each config read. A register read followed by two register writes can hang CRIME 1.1 under DMA load.
Ack master aborts in the error register instead, and follow every write with a read so back-to-back accesses cannot form that sequence.
--- arch/mips/pci/ops-mace.c | 26 +++++++++++++++++++------- arch/mips/pci/pci-ip32.c | 2 ++ 2 files changed, 21 insertions(+), 7 deletions(-)
arch/mips/pci/ops-mace.c +19 -7
@@ -35,15 +35,27 @@ static inline int mkaddr(struct pci_bus *bus, unsigned int devfn, (reg &0xfc ); } +/* +* On CRIME 1.1, a MACE PCI register read followed by two register writes +* can hang the machine under DMA load, so every register write in this +* file is followed by a read. Config cycles to empty slots end in a +* master abort; ack it with interrupts still off so the bridge error +* interrupt does not report it. +*/ +static void mace_pci_ack_abort (void ) +{ +u32 error = mace->pci.error; + +if (error &MACEPCI_ERROR_MASTER_ABORT ) { + mace->pci.error = error & ~MACEPCI_ERROR_MASTER_ABORT ; + mace->pci.error; + } +}static int mace_pci_read_config (struct pci_bus *bus,unsigned int devfn,int reg,int size,u32 *val) { -u32 control = mace->pci.control; - -/* disable master aborts interrupts during config read */ - mace->pci.control = control & ~MACEPCI_CONTROL_MAR_INT ; mace->pci.config_addr =mkaddr (bus, devfn, reg);switch (size) {case 1 :
@@ -56,9 +68,7 @@ mace_pci_read_config(struct pci_bus *bus, unsigned int devfn, *val = mace->pci.config_data.l;break ; } -/* ack possible master abort */ - mace->pci.error &= ~MACEPCI_ERROR_MASTER_ABORT ; - mace->pci.control = control; +mace_pci_ack_abort ();/* * someone forgot to set the ultra bit for the onboard * scsi chips; we fake it here
@@ -77,6 +87,7 @@ mace_pci_write_config(struct pci_bus *bus, unsigned int devfn, int reg, int size, u32 val) { mace->pci.config_addr = mkaddr(bus, devfn, reg); + mace->pci.error;switch (size) {case 1 : mace->pci.config_data.b[(reg &3 ) ^3 ] = val;
@@ -88,6 +99,7 @@ mace_pci_write_config(struct pci_bus *bus, unsigned int devfn, mace->pci.config_data.l = val;break ; } +mace_pci_ack_abort ();DPRINTK ("write%d: reg=%08x,val=%02x\n" , size *8 , reg, val);
arch/mips/pci/pci-ip32.c +2 -0
@@ -77,6 +77,8 @@ static irqreturn_t macepci_error(int irq, void *dev) } mace->pci.error = flags; +/* follow the write with a read, see mace_pci_ack_abort() */ + mace->pci.error;return IRQ_HANDLED ; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 450/686 srcu: Add list_splice_init_srcu()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Qiliang Yuan <[email protected]>
[ Upstream commit d06917d0ba226206dbd606330d73a8eb1e3029c1 ]
list_splice_init_rcu() makes a list look empty to new readers, waits for the current ones with the given sync function, and only then links the entries into the new list. The sync function takes no argument, so it can wait for RCU readers but not for the readers of an srcu_struct.
Passing synchronize_rcu() for a list read under SRCU still builds, but leaves SRCU readers on the entries while the last one's next pointer is moved onto the new list head. nvme_remove_namespaces() does this today.
Add list_splice_init_srcu(), which waits for the readers of the given srcu_struct instead.
--- include/linux/srcu.h | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+)
include/linux/srcu.h +36 -0
@@ -18,6 +18,7 @@#include <linux/mutex.h> #include <linux/rcupdate.h> +#include <linux/rculist.h> #include <linux/workqueue.h> #include <linux/rcu_segcblist.h>
@@ -68,6 +69,41 @@ void call_srcu(struct srcu_struct *ssp, struct rcu_head *head,void cleanup_srcu_struct (struct srcu_struct *ssp);void synchronize_srcu (struct srcu_struct *ssp); +/** +* list_splice_init_srcu - splice an SRCU-protected list into an existing list +* @list: the SRCU-protected list to splice +* @head: the place in the existing list to splice the first list into +* @ssp: the srcu_struct that readers of @list use +* +* Like list_splice_init_rcu(), but wait for the SRCU readers of @list +* instead of RCU ones, so that none of them can follow a next pointer +* onto @head. +* +* Note that this function blocks, and that the caller must prevent any +* other updates to @list. +*/ +static inline void list_splice_init_srcu (struct list_head *list, +struct list_head *head, +struct srcu_struct *ssp) +{ +struct list_head *first = list->next; +struct list_head *last = list->prev; +struct list_head *next = head->next; + +if (list_empty (list)) +return ; + +INIT_LIST_HEAD_RCU (list); +synchronize_srcu (ssp); +ASSERT_EXCLUSIVE_ACCESS (*first); +ASSERT_EXCLUSIVE_ACCESS (*last); + + last->next = next; +rcu_assign_pointer (list_next_rcu (head), first); + first->prev = head; + next->prev = last; +} +#define SRCU_GET_STATE_COMPLETED 0x1/**
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 451/686 nvme: wait for SRCU readers before splicing the namespace list
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Qiliang Yuan <[email protected]>
[ Upstream commit 8a0449832b50cd4f99f2d2952cfc1476e5f26d0f ]
Readers walk ctrl->namespaces under ctrl->srcu, and some of them sleep there, e.g. nvme_wait_freeze() waiting for I/O to drain.
nvme_remove_namespaces() moves the list onto its on-stack ns_list with list_splice_init_rcu(), which only waits for RCU readers before relinking the entries. A reader still on the last namespace then follows its next pointer to ns_list instead of ctrl->namespaces and treats the stack as a namespace. Deleting a controller while a Format NVM passthrough waits for a delayed read on the last namespace gives:
BUG: KASAN: stack-out-of-bounds in nvme_wait_freeze+0x102/0x120 Read of size 8 at addr ff110001d2f3fc38 by task nvme/4413 Call Trace: nvme_wait_freeze nvme_passthru_start nvme_submit_user_cmd nvme_user_cmd nvme_dev_ioctl BUG: unable to handle page fault for address: ffffffff8af04850
Use list_splice_init_srcu() instead, which waits for the SRCU readers. This also takes the RCU grace period out of every controller deletion. Deleting 64 tcp controllers with one namespace each, median of 3 runs on each of two boots per kernel:
before after nvme disconnect-all (ms) 3491 / 3509 2996 / 3165 nvme_remove_namespaces() avg (ms) 39.0 / 40.5 31.9 / 34.7
--- drivers/nvme/host/core.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
drivers/nvme/host/core.c +1 -2
@@ -4628,9 +4628,8 @@ void nvme_remove_namespaces(struct nvme_ctrl *ctrl)nvme_change_ctrl_state (ctrl,NVME_CTRL_DELETING_NOIO );mutex_lock (&ctrl->namespaces_lock); -list_splice_init_rcu (&ctrl->namespaces, &ns_list, synchronize_rcu); +list_splice_init_srcu (&ctrl->namespaces, &ns_list, &ctrl->srcu);mutex_unlock (&ctrl->namespaces_lock); -synchronize_srcu (&ctrl->srcu);list_for_each_entry_safe (ns, next, &ns_list, list)nvme_ns_remove (ns);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 452/686 nvmet: bound the traddr and trsvcid configfs writes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Shao Mingyin <[email protected]>
[ Upstream commit cf399d4abbeddc317f8160a79fefb4016c469862 ]
nvmet_addr_traddr_store() and nvmet_addr_trsvcid_store() reject a write only when count is larger than NVMF_TRADDR_SIZE (256) respectively NVMF_TRSVCID_SIZE (32). A write of exactly that many characters is accepted, and the following
sscanf(page, "%s\n", port->disc_addr.traddr)
has no field width. configfs terminates the buffer at page[count], so the scan writes 256 characters plus the trailing NUL, i.e. 257 bytes, into traddr[256]. The extra byte lands in the following tsas field of the discovery log entry, silently clearing the first TSAS byte (the RDMA queue type, or the TLS section type for TCP). trsvcid has the same off-by-one with a 32-byte write; there the extra byte lands in the reserved bytes that follow trsvcid.
Limit the scans to one byte less than the destination arrays. The count checks can stay as they are so that a normal newline-terminated write is still accepted.
--- drivers/nvme/target/configfs.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/nvme/target/configfs.c +2 -2
@@ -150,7 +150,7 @@ static ssize_t nvmet_addr_traddr_store(struct config_item *item,if (nvmet_is_port_enabled (port, __func__))return -EACCES ; -if (sscanf (page,"%s\n" , port->disc_addr.traddr) !=1 ) +if (sscanf (page,"%255s" , port->disc_addr.traddr) !=1 )return -EINVAL ;return count; }
@@ -242,7 +242,7 @@ static ssize_t nvmet_addr_trsvcid_store(struct config_item *item,if (nvmet_is_port_enabled (port, __func__))return -EACCES ; -if (sscanf (page,"%s\n" , port->disc_addr.trsvcid) !=1 ) +if (sscanf (page,"%31s" , port->disc_addr.trsvcid) !=1 )return -EINVAL ;return count; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 453/686 perf/core: Dont send SIGTRAP after exec removed the event
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Danish Khateeb <[email protected]>
[ Upstream commit 6f083fbccd5f06889bc08e1182bd02c0383b9121 ]
A sigtrap event must also set remove_on_exec, so that its SIGTRAP never reaches a program after exec. But the signal is sent from task work, which only runs on the way back to user space. If the event overflows shortly before execve(), the task work can still be pending when the task enters execve(), and then runs when execve() returns. By then perf_event_exec() has removed the event and the new program has default signal handlers, so the SIGTRAP kills it.
The exec_stress test in the remove_on_exec selftest catches this and fails about half the time in a VM. A process that opens a sigtrap event on itself and then calls execve() is killed by SIGTRAP in 15% to 50% of runs, both on an AMD machine running v7.2 and in a VM, with or without close-on-exec on the event fd.
Commit ffb684f2aa14 ("perf: Fix race between perf_event_exit_task() and perf_pending_task()") made perf_sigtrap() return once perf_event_exit_task() has set ctx->task to TASK_TOMBSTONE. Exec only calls perf_event_exit_task() when the new program is not dumpable, such as a setuid one. An ordinary exec keeps the context and only removes the remove_on_exec events, so the SIGTRAP is still sent.
perf_event_exit_event() sets PERF_EVENT_STATE_EXIT when exec removes the event. If the event fd is close-on-exec and was the last reference to the file, exec also queues the file release as task work. Task work runs newest first, so perf_release() runs before the SIGTRAP work and moves the event on to PERF_EVENT_STATE_DEAD. So don't send the signal when the event state is PERF_EVENT_STATE_EXIT or lower, which means the event has been removed. That also covers PERF_EVENT_STATE_REVOKED, where the PMU is gone.
--- kernel/events/core.c | 9 +++++++++ 1 file changed, 9 insertions(+)
kernel/events/core.c +9 -0
@@ -7324,6 +7324,15 @@ static void perf_sigtrap(struct perf_event *event)if (event->ctx->task ==TASK_TOMBSTONE )return ; +/* +* The event was removed after this signal was queued, e.g. by exec() +* (remove_on_exec), which may also have closed its fd (close-on-exec). +* The new program has default signal handlers, so a SIGTRAP would +* kill it. +*/ +if (READ_ONCE (event->state) <=PERF_EVENT_STATE_EXIT ) +return ; +/* * We'd expect this to only occur if the irq_work is delayed and either * ctx->task or current has changed in the meantime. This can be the
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 454/686 x86/nmi: Ignore negative NMI handler durations
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Breno Leitao <[email protected]>
[ Upstream commit ade63af6cfb7b3ca19ced28730fd6461e8d1d410 ]
I am seeing NMI handlers in the Meta fleet reported as running for about 584 years. Over 30 days, 11 AMD and Intel machines logged 637 such lines, for example:
AMD EPYC 9D25 (family 0x1a, model 0x11, stepping 0x0):
[ 1650.616627] INFO: NMI handler (nmi_cpu_backtrace_handler.llvm.9643156322683129580) took too long to run: 18446744073709.551 msecs
Intel Xeon Platinum 8321HC (family 0x6, model 0x55, stepping 0xb):
[360448.230129] INFO: NMI handler (perf_event_nmi_handler) took too long to run: 18446744071018.936 msecs
Intel Xeon D-2191A (family 0x6, model 0x55, stepping 0x4):
[81787.188959] INFO: NMI handler (ghes_notify_nmi) took too long to run: 18446744073709.545 msecs
nmi_handle() times each handler with two sched_clock() reads. When the second read is lower than the first, the u64 subtraction wraps, and nmi_check_duration() treats the result as a duration. In the three examples, the clock went back by less than 1 us, by 2.7 s and by about 6 us.
The wrapped value is also stored in action->max_duration. Every later real duration is smaller, so the handler is never reported again until the next boot.
Whatever makes the clock read lower, a negative difference is not a duration, so return before it is stored or reported. A clock that steps forward is not covered, since that cannot be told from a real stall.
A backwards clock is still worth knowing about, so print the size of the step once per boot. This uses pr_warn_once() rather than WARN, as a stack trace says nothing about the clock and panic_on_warn machines should not go down for it.
--- arch/x86/kernel/nmi.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/x86/kernel/nmi.c +8 -0
@@ -114,6 +114,14 @@ static void nmi_check_duration(struct nmiaction *action, u64 duration) {int remainder_ns, decimal_msecs; +/* sched_clock() went backwards? */ +if ((s64 )duration <0 ) { +pr_warn_once ("NMI handler (%ps): sched_clock() went backwards by %lld ns on CPU%d\n" , + action->handler, -(s64 )duration, +smp_processor_id ()); +return ; + } +if (duration < nmi_longest_ns || duration < action->max_duration)return ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 455/686 iommu/amd: Skip non-IVMD entries when parsing IVRS memory definitions
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Akshay Jindal <[email protected]>
[ Upstream commit e62df37e0eff4d670e78bbd415be2c1675883c15 ]
init_memory_definitions() walks every top-level subtable including the IVHD blocks (type 0x10/0x11/0x40) in the IVRS ACPI table. It interprets each one as a 'struct ivmd_header', solely on m->flags, without first checking that the subtable's type actually is one of the IVMD types (ACPI_IVMD_TYPE, ACPI_IVMD_TYPE_ALL, ACPI_IVMD_TYPE_RANGE).
if (m->flags & (IVMD_FLAG_UNITY_MAP | IVMD_FLAG_EXCL_RANGE))
init_unity_map_range(m, table);IVMD_FLAG_UNITY_MAP (0x01) occupies the same bit position as the IVHD flags field's HtTunEn bit. Unlike real hardware, QEMU's AMD IOMMU emulation sets HtTunEn unconditionally (flags=0xD1 for type 0x10, 0x11 for type 0x11), so every QEMU-emitted IVHD block is misidentified as a unity-map/exclusion-range IVMD entry, which subsequently results in the creation of a bogus pci segment. Eg:
AMD-Vi: PCI segment : 0x4000, last bdf : 0x0000
Fix by checking the subtable's type before treating it as IVMD.
--- drivers/iommu/amd/init.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
drivers/iommu/amd/init.c +12 -2
@@ -2721,6 +2721,15 @@ static int __init init_unity_map_range(struct ivmd_header *m,return 0 ; } +static bool ivrs_block_type_ivmd (u8 type) +{ +if (type ==ACPI_IVMD_TYPE || + type ==ACPI_IVMD_TYPE_ALL || + type ==ACPI_IVMD_TYPE_RANGE ) +return true; +return false; +} +/* iterates over all memory definitions we find in the ACPI table */ static int __init init_memory_definitions (struct acpi_table_header *table) {
@@ -2732,10 +2741,11 @@ static int __init init_memory_definitions(struct acpi_table_header *table)while (p < end) { m = (struct ivmd_header *)p; + p += m->length; +if (!ivrs_block_type_ivmd (m->type)) +continue ;if (m->flags & (IVMD_FLAG_UNITY_MAP |IVMD_FLAG_EXCL_RANGE ))init_unity_map_range (m, table); - - p += m->length; }return 0 ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 456/686 arm64: kexec_file: Fix elf_headers memory leak in retry loop
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Jinjie Ruan <[email protected]>
[ Upstream commit ac302aea3d824ccc99f29b8e499c365cb9a684a9 ]
A retry allocates new elf headers and overwrites image->elf_headers, leaking the previous buffer.
Free it before assigning.
--- arch/arm64/kernel/machine_kexec_file.c | 2 ++ 1 file changed, 2 insertions(+)
arch/arm64/kernel/machine_kexec_file.c +2 -0
@@ -128,6 +128,8 @@ int load_other_segments(struct kimage *image,vfree (headers); goto out_err; } + +vfree (image->elf_headers); image->elf_headers = headers; image->elf_load_addr = kbuf.mem; image->elf_headers_sz = headers_sz;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 457/686 x86/boot: Fix off-by-one error in sme_clear_pgd()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Thorsten Blum <[email protected]>
[ Upstream commit cb319926808b1cca522d2087a13205e840beb45b ]
The mapping helpers __sme_map_range_pmd() and __sme_map_range_pte(), and therefore sme_encrypt_kernel(), use exclusive end addresses and stop before vaddr reaches vaddr_end.
However, sme_clear_pgd() treats vaddr_end as inclusive when calculating the last PGD entry to clear. If vaddr_end is PGD-aligned, the first PGD entry outside the range is cleared too.
Use vaddr_end - 1 to calculate the last PGD entry within the range.
--- arch/x86/boot/startup/sme.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/boot/startup/sme.c +1 -1
@@ -97,7 +97,7 @@ static void __init sme_clear_pgd(struct sme_populate_pgd_data *ppd)pgd_t *pgd_p; pgd_start = ppd->vaddr &PGDIR_MASK ; - pgd_end = ppd->vaddr_end &PGDIR_MASK ; + pgd_end = (ppd->vaddr_end -1 ) &PGDIR_MASK ; pgd_size = (((pgd_end - pgd_start) /PGDIR_SIZE ) +1 ) *sizeof (pgd_t);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 458/686 arm64: sdei: Run the event handler on the kernel vectors
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Kiryl Shutsemau (Meta) <[email protected]>
[ Upstream commit 9bf6ee7952c7ee151c30e0fffcfc61b58127c899 ]
With KPTI, VBAR_EL1 holds the trampoline vectors from the return to EL0 until the next exception from EL0 maps the kernel and installs the kernel vectors. The trampoline vectors only handle exceptions from EL0; their current-EL half is zero-filled.
An SDEI event is dispatched regardless of PSTATE.DAIF, so it lands there whenever the CPU is in user space. The SDEI entry trampoline maps the kernel but leaves VBAR_EL1 alone. An exception taken by the handler then executes the zeros, takes an undefined instruction exception to the same vector, and loops there forever. The event never completes and the CPU is lost; RCU stall reports are the first sign of it.
RAS notifications land in user space whenever a task consumes the error, and NMI backtraces land wherever the CPU happens to be. The GHES handler takes no exception on its own, but any exception in the handler path does it: a WARN, a kprobe hit, or a fault fixed up by a _nofault() accessor.
Install the kernel vectors in __sdei_handler() when VBAR_EL1 holds the trampoline vectors, and restore it before returning to firmware. The switch covers irqentry_nmi_enter() and irqentry_nmi_exit() too, as Usama Arif pointed out: their tracepoints and context tracking WARNs can take an exception as well.
The IRQ-like resume into user space must still go through the trampoline to map the kernel. do_sdei_event() takes the interrupted VBAR_EL1 and keeps basing the resume address on it.
--- arch/arm64/include/asm/sdei.h | 3 ++- arch/arm64/kernel/entry-common.c | 21 ++++++++++++++++++++- arch/arm64/kernel/sdei.c | 6 ++++-- 3 files changed, 26 insertions(+), 4 deletions(-)
arch/arm64/include/asm/sdei.h +2 -1
@@ -44,7 +44,8 @@ asmlinkage unsigned long __sdei_handler(struct pt_regs *regs, struct sdei_registered_event *arg);unsigned long do_sdei_event (struct pt_regs *regs, -struct sdei_registered_event *arg); +struct sdei_registered_event *arg, +unsigned long vbar);unsigned long sdei_arch_get_entry_point (int conduit);#define sdei_arch_get_entry_point (x) sdei_arch_get_entry_point(x)
arch/arm64/kernel/entry-common.c +20 -1
@@ -30,6 +30,7 @@#include <asm/stacktrace.h> #include <asm/sysreg.h> #include <asm/system_misc.h> +#include <asm/vectors.h> /* * Handle IRQ/context state management when entering from kernel mode.
@@ -993,6 +994,7 @@ asmlinkage void noinstr __noreturn handle_bad_stack(struct pt_regs *regs) asmlinkage noinstr unsigned long__sdei_handler (struct pt_regs *regs,struct sdei_registered_event *arg) { +unsigned long vbar;irqentry_state_t state;unsigned long ret;
@@ -1018,10 +1020,27 @@ __sdei_handler(struct pt_regs *regs, struct sdei_registered_event *arg) else if (cpu_has_pan()) set_pstate_pan(0); +/* +* With KPTI, VBAR_EL1 holds the trampoline vectors from the return to +* EL0 until the next exception from EL0 maps the kernel. They only +* handle exceptions from EL0: an exception taken here would run their +* empty current-EL half and never come back. Switch to the kernel +* vectors. The IRQ-like resume keeps using the interrupted VBAR, so it +* still goes through the trampoline. +*/ + vbar =read_sysreg (vbar_el1); +if (arm64_kernel_unmapped_at_el0 () && + vbar == (unsigned long )raw_cpu_read (this_cpu_vector)) { +write_sysreg ((unsigned long )vectors, vbar_el1); +isb (); + } + state =irqentry_nmi_enter (regs); - ret =do_sdei_event (regs, arg); + ret =do_sdei_event (regs, arg, vbar);irqentry_nmi_exit (regs, state); +write_sysreg (vbar, vbar_el1); + return ret; }#endif /* CONFIG_ARM_SDE_INTERFACE */
arch/arm64/kernel/sdei.c +4 -2
@@ -204,16 +204,18 @@ unsigned long sdei_arch_get_entry_point(int conduit)* SDEI_EV_HANDLED - success, return to the interrupted context. * SDEI_EV_FAILED - failure, return this error code to firmare. * virtual-address - success, return to this address. +* +* vbar is the interrupted context's VBAR_EL1, for the IRQ-like resume. */ unsigned long __kprobes do_sdei_event (struct pt_regs *regs, -struct sdei_registered_event *arg) +struct sdei_registered_event *arg, +unsigned long vbar) {u32 mode;int i, err =0 ;int clobbered_registers =4 ;u64 elr =read_sysreg (elr_el1);u32 kernel_mode =read_sysreg (CurrentEL) |1 ;/* +SPSel */ -unsigned long vbar =read_sysreg (vbar_el1);if (arm64_kernel_unmapped_at_el0 ()) clobbered_registers++;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 459/686 arm64: sdei: Preserve the interrupted contexts exception registers
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Kiryl Shutsemau (Meta) <[email protected]>
[ Upstream commit 58c1eb84e97701c583605ba2fd553b69afba2245 ]
An SDEI event is dispatched by firmware regardless of PSTATE.DAIF, so it can interrupt the kernel where the exception registers are live:
- exception entry, before kernel_entry has saved ELR_EL1/SPSR_EL1 and before the C handler has read ESR_EL1/FAR_EL1;
- exception return, after kernel_exit has loaded ELR_EL1/SPSR_EL1 and before the ERET.
An IRQ or pseudo-NMI cannot arrive there with PSTATE.I set. Firmware saves only x0-x17, PC and PSTATE around an SDEI event, so a synchronous exception taken by the handler overwrites the interrupted context's ELR, SPSR, ESR and FAR. do_sdei_event() only notices that ELR changed, and warns.
The interrupted context then carries on with the handler's state. A task interrupted on its way into the kernel can be sent SIGILL for the handler's kernel data abort. A task interrupted on its way back to user space ERETs to EL1, at the handler's fixup address, with user registers loaded.
With SDEI delivering NMI backtraces, this happens in normal operation. The handler runs show_regs(), which reads through possibly-NULL pointers with the _nofault() accessors. print_worker_info() faults this way for a kworker that is not running a work item, and a single sysrq-l warned once per such kworker.
Save ELR, SPSR, ESR and FAR in __sdei_handler() before irqentry_nmi_enter(), which can take an exception too, and restore them after irqentry_nmi_exit().
Once they are restored, a nested exception is harmless if its handler is safe in NMI context. That holds for EL1 data aborts on translation, permission and access-flag faults, which never take the mmap lock in NMI context, and for BRK. Warn once, with the syndrome, about any other exception class.
--- arch/arm64/kernel/entry-common.c | 21 ++++++++++++- arch/arm64/kernel/sdei.c | 53 ++++++++++++++++++++++++++------ 2 files changed, 64 insertions(+), 10 deletions(-)
arch/arm64/kernel/entry-common.c +20 -1
@@ -994,7 +994,7 @@ asmlinkage void noinstr __noreturn handle_bad_stack(struct pt_regs *regs) asmlinkage noinstr unsigned long__sdei_handler (struct pt_regs *regs,struct sdei_registered_event *arg) { -unsigned long vbar; +unsigned long elr, spsr, esr, far, vbar;irqentry_state_t state;unsigned long ret;
@@ -1020,6 +1020,17 @@ __sdei_handler(struct pt_regs *regs, struct sdei_registered_event *arg)else if (cpu_has_pan ())set_pstate_pan (0 ); +/* +* Nothing saved the interrupted context's exception registers on the +* way in, and it may be in the middle of exception entry or return +* (SDEI ignores DAIF). Save them before anything can take an exception +* and overwrite them. +*/ + elr =read_sysreg (elr_el1); + spsr =read_sysreg (spsr_el1); + esr =read_sysreg (esr_el1); + far =read_sysreg (far_el1); +/* * With KPTI, VBAR_EL1 holds the trampoline vectors from the return to * EL0 until the next exception from EL0 maps the kernel. They only
@@ -1039,6 +1050,14 @@ __sdei_handler(struct pt_regs *regs, struct sdei_registered_event *arg) ret =do_sdei_event (regs, arg, vbar);irqentry_nmi_exit (regs, state); +/* +* Put them back unconditionally. An unchanged ELR does not rule out a +* nested exception: one may have returned to the same address. +*/ +write_sysreg (elr, elr_el1); +write_sysreg (spsr, spsr_el1); +write_sysreg (esr, esr_el1); +write_sysreg (far, far_el1);write_sysreg (vbar, vbar_el1);return ret;
arch/arm64/kernel/sdei.c +44 -9
74 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 460/686 ata: libata-pmp: disable the SEMB port on Marvell 88SM9705
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Marco Ziliani <[email protected]>
[ Upstream commit 6b67cdb463b006e57f15e3fe4ea03b00f0ac9ee5 ]
The Marvell 88SM9705 is a 1-to-5 SATA port multiplier with one additional SEMB (SATA Enclosure Management Bridge) port [1]. Ports 0-4 are device ports and port 5 is the SEMB. The number of fan-out ports in GSCR[2] is 6 when the SEMB is enabled and 5 when it is not, so on boards without the SEMB there is no link 5 and this quirk does nothing. That includes the common 8-port PCIe cards that pair an 88SE9215 with an 88SM9705, which report 5 ports.
The SEMB port never answers SRST. libata probes it like a device port, and every EH round on the PMP ends in a retry loop that lasts about a minute before EH gives up, then starts over:
ata19.15: Port Multiplier 1.2, 0x1b4b:0x9705 r160, 6 ports, feat 0x1/0x1f ata19.05: hard resetting link
ata19.05: failed to resume link (SControl 0)
ata19.05: softreset failed (1st FIS failed)
ata19.05: hard resetting link
...
ata20.05: reset failed, giving up
Disk discovery waits for this, including disks on other controllers.
libata.force only partly works around it. The "disable" horkage only takes effect after IDENTIFY, which the SEMB link never reaches. "norst" on port 5 stops the retry loop, but the disks still come up about a minute later than with this change (see below).
Treat port 5 the same way as port 4 of the Marvell 88SM4140 and mark the link ATA_LFLAG_DISABLED.
Tested on a Synology DX1222 expansion unit (four 88SM9705 r160 behind a Marvell 88SE9235, passed through to a KVM guest, 6 disks), 7.4-rc1 with and without this change, one boot each:
softreset reset failed, last disk
failed giving up attached
7.4-rc1, no libata.force 60 12 197 s
7.4-rc1, libata.force=N.05:norst 0 0 70 s
7.4-rc1 + this patch, no force 0 0 11 sThe problem was first found on a Synology DX1215 with the same chain, where this change brought the disks up after about 20 s instead of about 200 s, including a disk on a separate AHCI controller.
Each PMP still logs one "failed to resume link (SControl 0)" for port 5 at probe time.
--- drivers/ata/libata-pmp.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
drivers/ata/libata-pmp.c +14 -0
@@ -482,6 +482,20 @@ static void sata_pmp_quirks(struct ata_port *ap)if (link->pmp ==4 ) link->flags |=ATA_LFLAG_DISABLED ; } + }else if (vendor ==0x1b4b && devid ==0x9705 ) { +/* +* Marvell 88SM9705 quirks +* +* 1-to-5 PMP with an extra SEMB port. It reports 6 ports and +* port 5 is the SEMB, which never answers SRST: EH spends about +* a minute per round retrying it, and disk discovery waits for +* that. Seen behind a Marvell 88SE9235 in the Synology DX1215 +* and DX1222. +*/ +ata_for_each_link (link, ap,EDGE ) { +if (link->pmp ==5 ) + link->flags |=ATA_LFLAG_DISABLED ; + } } }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 461/686 x86/mm: Fix global ASID handed out to two processes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Chris Mason <[email protected]>
[ Upstream commit 5cdc3746fa163fb4e8d05fa3cabf46bc6aa7df75 ]
On AMD CPUs with INVLPGB, two live processes can get the same MAX_ASID_AVAILABLE global ASID value. The two then hit each other's TLB entries, so each can read or corrupt the other's memory.
The global ASID space is managed lazily. When a global ASID is freed, its bit is set in the global_asid_freed bitmap. Once the free ASID search reaches the end of the global_asid_used bitmap, a global flush is done to really reclaim the lazily freed global ASIDs.
However, the current code can assign the same global ASID to two different processes, if one process is assigned MAX_ASID_AVAILABLE - 1, another process MAX_ASID_AVAILABLE, and both stick around (keeping their global ASID numbers in use) until the search wraps around again. At that point a third process could also get assigned MAX_ASID_AVAILABLE.
the highest ASID stays in use, so it is not handed out again
last_global_asid stays below it, so no reset
the clear bits run out
find_next_zero_bit() returns MAX_ASID_AVAILABLE
global_asid_available > 0, so the failure is not caught
MAX_ASID_AVAILABLE is handed out as an ASID
A search only looks at the bits below MAX_ASID_AVAILABLE, so it cannot see that this value is in use. The next failed search hands it out again, even if the first process still holds it.
The fix used here is to reset the global ASID space after a failed search, and to search again. If that search fails too, no global ASID is handed out.
The test for !global_asid_available is removed, because use_global_asid() only calls allocate_global_asid() if global_asid_available > 0. The remaining test is for a condition that should be impossible.
[ riel: simplify code, massage changelog and comment ]
--- arch/x86/mm/tlb.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-)
arch/x86/mm/tlb.c +11 -5
@@ -319,13 +319,19 @@ static u16 allocate_global_asid(void)lockdep_assert_held (&global_asid_lock); -/* The previous allocation hit the edge of available address space */ -if (last_global_asid >=MAX_ASID_AVAILABLE -1 ) -reset_global_asid_space (); - asid =find_next_zero_bit (global_asid_used,MAX_ASID_AVAILABLE , last_global_asid); -if (asid >=MAX_ASID_AVAILABLE && !global_asid_available) { +/* +* Nothing is free between last_global_asid and MAX_ASID_AVAILABLE. +* Flush lazy-freed ASIDs and reset the search space. +*/ +if (asid >=MAX_ASID_AVAILABLE ) { +reset_global_asid_space (); + asid =find_next_zero_bit (global_asid_used,MAX_ASID_AVAILABLE , + last_global_asid); + } + +if (asid >=MAX_ASID_AVAILABLE ) {/* This should never happen. */ VM_WARN_ONCE (1 ,"Unable to allocate global ASID despite %d available\n" , global_asid_available);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 462/686 iommu/amd: Force device table to maximum size
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Suravee Suthikulpanit <[email protected]>
commit 6e2213dae78b41976c60133eb10cf99e81916638 upstream.
IOMMU can perform out-of-bounds read of the device table entry (DTE) that is adjacent to the last DTE and falls outside the device table. For example, if the device table can hold 0 to N-1 entries, then the IOMMU can be made to fetch the Nth entry, which falls outside the device table.
The device table is owned by the hypervisor (HV) and is assigned in 4KB pages that are contiguous in system physical address (SPA). If the out-of-bound DTE falls on a guest-owned page, then the guest can exploit this bug to setup malicious table walks to corrupt HV pages and/or bring down the system. Note that this bug does not manifest when the device table size is set to its maximum size of 2MB.
Therefore, force the device table size to the maximum 2MB on affected processors. These are CPU family 0x17 (Zen1/Zen2) through family 0x1a (Zen5/BRH).
This is a mitigation for CVE-2024-21963.
kdump reuses the previous kernel's device table only when the size encoded in the IOMMU device-table register matches pci_seg->dev_table_size. A mixed rollout disagrees: the unpatched kernel uses the IVRS-derived size and the patched kernel uses 2MB, so __reuse_device_table() rejects the table. On SNP-capable IOMMUs that rejection panics the kdump kernel. Kernels that both have this patch agree on 2MB and reuse succeeds. Update the production kernel and the crash kernel together.
--- drivers/iommu/amd/init.c | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-)
drivers/iommu/amd/init.c +24 -3
@@ -1736,6 +1736,21 @@ static int __init init_iommu_from_acpi(sreturn 0 ; } +/* +* Apply workaround for Zen1 to Zen5(BRH) generation of processors. +* References: CVE-2024-21963 +*/ +static bool __init amd_iommu_force_max_dev_table (void ) +{ +if (boot_cpu_data.x86 >=0x17 && boot_cpu_data.x86 <=0x1a ) { +if (cpu_feature_enabled (X86_FEATURE_ZEN6 )) +return false; +else +return true; + } +return false; +} +/* Allocate PCI segment data structure */ static struct amd_iommu_pci_seg *__init alloc_pci_segment (u16 id,struct acpi_table_header *ivrs_base)
@@ -1758,9 +1773,15 @@ static struct amd_iommu_pci_seg *__init pci_seg->last_bdf = last_bdf;DUMP_printk ("PCI segment : 0x%0x, last bdf : 0x%04x\n" , id, last_bdf); - pci_seg->dev_table_size = -max (roundup_pow_of_two ((last_bdf +1 ) *DEV_TABLE_ENTRY_SIZE ), -SZ_4K ); +if (amd_iommu_force_max_dev_table ()) { +pr_info ("Force device table to maximum size\n" ); + pci_seg->dev_table_size =SZ_2M ; + }else { + pci_seg->dev_table_size = +max (roundup_pow_of_two ((last_bdf +1 ) * +DEV_TABLE_ENTRY_SIZE ), +SZ_4K ); + } pci_seg->id = id;init_llist_head (&pci_seg->dev_data_list);
Greg Kroah-Hartman
maintainerPATCH 463/686 Revert "hugetlb: remove VMEMMAP_SYNCHRONIZE_RCU"
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
This reverts commit dba93b8cceb0048071389352fc29dcb0a7fe666f.
--- mm/hugetlb_vmemmap.c | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-)
mm/hugetlb_vmemmap.c +16 -4
@@ -45,6 +45,8 @@ struct vmemmap_remap_walk {#define VMEMMAP_SPLIT_NO_TLB_FLUSH BIT(0)/* Skip the TLB flush when we remap the PTE */ #define VMEMMAP_REMAP_NO_TLB_FLUSH BIT(1) +/* synchronize_rcu() to avoid writes from page_ref_add_unless() */ +#define VMEMMAP_SYNCHRONIZE_RCU BIT(2)unsigned long flags; };
@@ -405,6 +407,9 @@ static int __hugetlb_vmemmap_restore_folio(const struct hstate *h,if (!folio_test_hugetlb_vmemmap_optimized (folio))return 0 ; +if (flags &VMEMMAP_SYNCHRONIZE_RCU ) +synchronize_rcu (); + vmemmap_start = (unsigned long )&folio->page; vmemmap_end = vmemmap_start +hugetlb_vmemmap_size (h);
@@ -437,7 +442,7 @@ static int __hugetlb_vmemmap_restore_folio(const struct hstate *h,*/ int hugetlb_vmemmap_restore_folio (const struct hstate *h,struct folio *folio) { -return __hugetlb_vmemmap_restore_folio (h, folio,0 ); +return __hugetlb_vmemmap_restore_folio (h, folio,VMEMMAP_SYNCHRONIZE_RCU ); }/**
@@ -460,11 +465,14 @@ long hugetlb_vmemmap_restore_folios(const struct hstate *h,struct folio *folio, *t_folio;long restored =0 ;long ret =0 ; -unsigned long flags =VMEMMAP_REMAP_NO_TLB_FLUSH ; +unsigned long flags =VMEMMAP_REMAP_NO_TLB_FLUSH |VMEMMAP_SYNCHRONIZE_RCU ;list_for_each_entry_safe (folio, t_folio, folio_list, lru) {if (folio_test_hugetlb_vmemmap_optimized (folio)) { ret =__hugetlb_vmemmap_restore_folio (h, folio, flags); +/* only need to synchronize_rcu() once for each batch */ + flags &= ~VMEMMAP_SYNCHRONIZE_RCU ; +if (ret)break ; restored++;
@@ -513,6 +521,8 @@ static int __hugetlb_vmemmap_optimize_folio(const struct hstate *h,static_branch_inc (&hugetlb_optimize_vmemmap_key); +if (flags &VMEMMAP_SYNCHRONIZE_RCU ) +synchronize_rcu ();/* * Very Subtle * If VMEMMAP_REMAP_NO_TLB_FLUSH is set, TLB flushing is not performed
@@ -572,7 +582,7 @@ void hugetlb_vmemmap_optimize_folio(const struct hstate *h, struct folio *folio) {LIST_HEAD (vmemmap_pages); -__hugetlb_vmemmap_optimize_folio (h, folio, &vmemmap_pages,0 ); +__hugetlb_vmemmap_optimize_folio (h, folio, &vmemmap_pages,VMEMMAP_SYNCHRONIZE_RCU );free_vmemmap_page_list (&vmemmap_pages); }
@@ -600,7 +610,7 @@ static void __hugetlb_vmemmap_optimize_folios(struct hstate *h,struct folio *folio;int nr_to_optimize;LIST_HEAD (vmemmap_pages); -unsigned long flags =VMEMMAP_REMAP_NO_TLB_FLUSH ; +unsigned long flags =VMEMMAP_REMAP_NO_TLB_FLUSH |VMEMMAP_SYNCHRONIZE_RCU ; nr_to_optimize =0 ;list_for_each_entry (folio, folio_list, lru) {
@@ -654,6 +664,8 @@ static void __hugetlb_vmemmap_optimize_folios(struct hstate *h,int ret; ret =__hugetlb_vmemmap_optimize_folio (h, folio, &vmemmap_pages, flags); +/* only need to synchronize_rcu() once for each batch */ + flags &= ~VMEMMAP_SYNCHRONIZE_RCU ;/* * Pages to be freed may have been accumulated. If we
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 464/686 can: replace ARPHRD_CAN type checks with can_get_ml_priv()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Oliver Hartkopp <[email protected]>
commit 962947b69589881167054bae5accc8abfd5aa4b6 upstream.
Commit 4e096a18867a ("net: introduce CAN specific pointer in the struct net_device") introduced an explicit way to assign the midlayer private pointer (dev->ml_priv) to named users like ML_PRIV_CAN. A valid pointer returned by can_get_ml_priv() therefore identifies a real CAN device.
The referenced commit only converted the j1939 and proc code to this check, while the other parts of the CAN subsystem still rely on dev->type == ARPHRD_CAN.
The TUNSETLINK ioctl allows a down TUN/TAP device to set its hardware type to ARPHRD_CAN while dev->ml_priv remains NULL. Such a repurposed netdevice passes the ARPHRD_CAN checks.
Commit 8aa59e355949 ("can: af_can: fix NULL pointer dereference in can_rx_register()") already made can_rx_register() reject such devices. But can_rx_unregister() still only checks dev->type and dereferences the NULL ml_priv when it walks the receive lists of the device.
CAN_ISOTP reaches this path: isotp_bind() ignores the return values of can_rx_register() and binds the socket anyway. When the socket is released or the device is unregistered, isotp_release() and isotp_notify() remove the filters that have never been registered and trigger the NULL pointer dereference in can_rx_unregister(). This only requires owning a TUN/TAP device or CAP_NET_ADMIN in an unprivileged user namespace.
Convert the remaining ARPHRD_CAN checks in af_can, bcm, gw, isotp and raw to can_get_ml_priv().
[ backport to 6.18: This tree has no can_skb_ext, so only the ARPHRD_CAN
check is removed from the conditions in can_rcv(), canfd_rcv() and canxl_rcv(). Add the <linux/can/can-ml.h> include to raw.c, which upstream got with commit faba5860fcf9 ("can: raw: instantly reject disabled CAN frames"). ]
--- net/can/af_can.c | 12 ++++++------ net/can/bcm.c | 7 ++++--- net/can/gw.c | 7 ++++--- net/can/isotp.c | 5 +++-- net/can/raw.c | 5 +++-- 5 files changed, 20 insertions(+), 16 deletions(-)
net/can/af_can.c +6 -6
@@ -226,7 +226,7 @@ int can_send(struct sk_buff *skb, int loop) goto inval_skb; } -if (unlikely (skb->dev->type !=ARPHRD_CAN )) { +if (unlikely (!can_get_ml_priv (skb->dev))) { err = -EPERM ; goto inval_skb; }
@@ -452,7 +452,7 @@ int can_rx_register(struct net *net, struct net_device *dev, canid_t can_id,/* insert new receiver (dev,canid,mask) -> (func,data) */ -if (dev && (dev->type !=ARPHRD_CAN || !can_get_ml_priv (dev))) +if (dev && !can_get_ml_priv (dev))return -ENODEV ;if (dev && !net_eq (net,dev_net (dev)))
@@ -519,7 +519,7 @@ void can_rx_unregister(struct net *net, struct net_device *dev, canid_t can_id,struct can_rcv_lists_stats *rcv_lists_stats = net->can.rcv_lists_stats;struct can_dev_rcv_lists *dev_rcv_lists; -if (dev && dev->type !=ARPHRD_CAN ) +if (dev && !can_get_ml_priv (dev))return ;if (dev && !net_eq (net,dev_net (dev)))
@@ -685,7 +685,7 @@ static void can_receive(struct sk_buff *skb, struct net_device *dev)static int can_rcv (struct sk_buff *skb,struct net_device *dev,struct packet_type *pt,struct net_device *orig_dev) { -if (unlikely (dev->type !=ARPHRD_CAN || !can_get_ml_priv (dev) || !can_is_can_skb (skb))) { +if (unlikely (!can_get_ml_priv (dev) || !can_is_can_skb (skb))) {pr_warn_once ("PF_CAN: dropped non conform CAN skbuff: dev type %d, len %d\n" , dev->type, skb->len);
@@ -700,7 +700,7 @@ static int can_rcv(struct sk_buff *skb, struct net_device *dev,static int canfd_rcv (struct sk_buff *skb,struct net_device *dev,struct packet_type *pt,struct net_device *orig_dev) { -if (unlikely (dev->type !=ARPHRD_CAN || !can_get_ml_priv (dev) || !can_is_canfd_skb (skb))) { +if (unlikely (!can_get_ml_priv (dev) || !can_is_canfd_skb (skb))) {pr_warn_once ("PF_CAN: dropped non conform CAN FD skbuff: dev type %d, len %d\n" , dev->type, skb->len);
@@ -715,7 +715,7 @@ static int canfd_rcv(struct sk_buff *skb, struct net_device *dev,static int canxl_rcv (struct sk_buff *skb,struct net_device *dev,struct packet_type *pt,struct net_device *orig_dev) { -if (unlikely (dev->type !=ARPHRD_CAN || !can_get_ml_priv (dev) || !can_is_canxl_skb (skb))) { +if (unlikely (!can_get_ml_priv (dev) || !can_is_canxl_skb (skb))) {pr_warn_once ("PF_CAN: dropped non conform CAN XL skbuff: dev type %d, len %d\n" , dev->type, skb->len);
net/can/bcm.c +4 -3
@@ -54,6 +54,7 @@#include <linux/if_arp.h> #include <linux/skbuff.h> #include <linux/can.h> +#include <linux/can/can-ml.h> #include <linux/can/core.h> #include <linux/can/skb.h> #include <linux/can/bcm.h>
@@ -1706,7 +1707,7 @@ static int bcm_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) goto out_release; } -if (dev->type !=ARPHRD_CAN ) { +if (!can_get_ml_priv (dev)) {dev_put (dev); ret = -ENODEV ; goto out_release;
@@ -1854,7 +1855,7 @@ static int bcm_notifier(struct notifier_block *nb, unsigned long msg, {struct net_device *dev =netdev_notifier_info_to_dev (ptr); -if (dev->type !=ARPHRD_CAN ) +if (!can_get_ml_priv (dev))return NOTIFY_DONE ;if (msg !=NETDEV_UNREGISTER && msg !=NETDEV_DOWN )return NOTIFY_DONE ;
@@ -2011,7 +2012,7 @@ static int bcm_connect(struct socket *sock, struct sockaddr *uaddr, int len, ret = -ENODEV ; goto fail; } -if (dev->type !=ARPHRD_CAN ) { +if (!can_get_ml_priv (dev)) {dev_put (dev); ret = -ENODEV ; goto fail;
net/can/gw.c +4 -3
@@ -52,6 +52,7 @@#include <linux/if_arp.h> #include <linux/skbuff.h> #include <linux/can.h> +#include <linux/can/can-ml.h> #include <linux/can/core.h> #include <linux/can/skb.h> #include <linux/can/gw.h>
@@ -603,7 +604,7 @@ static int cgw_notifier(struct notifier_block *nb,struct net_device *dev =netdev_notifier_info_to_dev (ptr);struct net *net =dev_net (dev); -if (dev->type !=ARPHRD_CAN ) +if (!can_get_ml_priv (dev))return NOTIFY_DONE ;if (msg ==NETDEV_UNREGISTER ) {
@@ -1154,7 +1155,7 @@ static int cgw_create_job(struct sk_buff *skb, struct nlmsghdr *nlh,if (!gwj->src.dev) goto out; -if (gwj->src.dev->type !=ARPHRD_CAN ) +if (!can_get_ml_priv (gwj->src.dev)) goto out; gwj->dst.dev =__dev_get_by_index (net, gwj->ccgw.dst_idx);
@@ -1162,7 +1163,7 @@ static int cgw_create_job(struct sk_buff *skb, struct nlmsghdr *nlh,if (!gwj->dst.dev) goto out; -if (gwj->dst.dev->type !=ARPHRD_CAN ) +if (!can_get_ml_priv (gwj->dst.dev)) goto out;/* is sending the skb back to the incoming interface intended? */
net/can/isotp.c +3 -2
@@ -65,6 +65,7 @@#include <linux/if_arp.h> #include <linux/skbuff.h> #include <linux/can.h> +#include <linux/can/can-ml.h> #include <linux/can/core.h> #include <linux/can/skb.h> #include <linux/can/isotp.h>
@@ -1595,7 +1596,7 @@ static int isotp_bind(struct socket *sock, struct sockaddr *uaddr, int len) err = -ENODEV ; goto out; } -if (dev->type !=ARPHRD_CAN ) { +if (!can_get_ml_priv (dev)) { err = -ENODEV ; goto out_put_dev; }
@@ -1895,7 +1896,7 @@ static int isotp_notifier(struct notifier_block *nb, unsigned long msg, {struct net_device *dev =netdev_notifier_info_to_dev (ptr); -if (dev->type !=ARPHRD_CAN ) +if (!can_get_ml_priv (dev))return NOTIFY_DONE ;if (msg !=NETDEV_UNREGISTER && msg !=NETDEV_DOWN )return NOTIFY_DONE ;
net/can/raw.c +3 -2
@@ -49,6 +49,7 @@#include <linux/if_arp.h> #include <linux/skbuff.h> #include <linux/can.h> +#include <linux/can/can-ml.h> #include <linux/can/core.h> #include <linux/can/dev.h> /* for can_is_canxl_dev_mtu() */ #include <linux/can/skb.h>
@@ -343,7 +344,7 @@ static int raw_notifier(struct notifier_block *nb, unsigned long msg, {struct net_device *dev =netdev_notifier_info_to_dev (ptr); -if (dev->type !=ARPHRD_CAN ) +if (!can_get_ml_priv (dev))return NOTIFY_DONE ;if (msg !=NETDEV_UNREGISTER && msg !=NETDEV_DOWN )return NOTIFY_DONE ;
@@ -486,7 +487,7 @@ static int raw_bind(struct socket *sock, struct sockaddr *uaddr, int len) err = -ENODEV ; goto out; } -if (dev->type !=ARPHRD_CAN ) { +if (!can_get_ml_priv (dev)) { err = -ENODEV ; goto out_put_dev; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 465/686 can: protect the receive lists with a per-device lock
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Oliver Hartkopp <[email protected]>
commit 0f3ad9ab40e3dad06d5c0693806e07935ceedbc3 upstream.
The receive lists of a CAN device are located in the device's can_ml_priv and travel with the device when it is moved to another network namespace. But they are protected by the per-netns rcvlists_lock. So can_rx_unregister() needs dev_net(dev) to pick the right lock and silently returns when the passed namespace does not match dev_net(dev) anymore.
isotp_release() and bcm_release() leave their notifier list before they take any lock that serializes against the netdev notifier, which runs under RTNL. When the bound device is moved to another namespace in this window, the notifier skips the socket and the release path has to remove the filters itself. isotp_release() passes the socket's namespace, which does not match dev_net(dev) anymore. bcm_rx_unreg() passes dev_net(dev), which can_rx_unregister() reads again for its check, so a namespace change between both reads makes the check fail as well. In both cases can_rx_unregister() silently returns. As can_rx_register() stores rcv->sk without a reference, the remaining receivers point to the freed socket (isotp) or the freed op (bcm):
BUG: KASAN: use-after-free in isotp_rcv+0x1570/0x24d0 Read of size 1 at addr ffff888118130552 by task isotp_ns_uaf/578 can_rcv_filter+0x4af/0x8c0 can_receive+0x28d/0x3c0 can_rcv+0x2a9/0x310 __netif_receive_skb_one_core+0x21a/0x260 process_backlog+0x210/0x760
Besides this, the lists of a device are protected by the rcvlists_lock of the namespace that is passed in. Callers which pass dev_net(dev) read it at different times, so the same lists may be modified under the locks of different namespaces while the device is moved.
Taking RTNL in these release paths is no option: raw_bind(), raw_setsockopt() and raw_release() already hold RTNL while adding and removing up to CAN_RAW_FILTER_MAX filters per socket, which unprivileged users can trigger repeatedly and which makes RTNL a global bottleneck.
Instead fix the root cause and add a spinlock to struct can_dev_rcv_lists, which protects the receive lists of a CAN device or the 'any' CAN device lists of a namespace. It is initialized in can_set_ml_priv(), which is used by all CAN network devices. With this, can_rx_unregister() finds the subscription independently of the current namespace of the device. The protocols keep the device valid with their tracked references. The per-netns rcvlists_lock only protects the receive list statistics anymore, and CAN_RAW, CAN_BCM and CAN_ISOTP pass the namespace that has been used for can_rx_register().
So isotp_release() and bcm_release() now remove their filters correctly without RTNL, and raw_release(), raw_setsockopt(), raw_bind() and isotp_bind() do not need RTNL anymore and add and remove their filters under lock_sock(). To serialize bind() with NETDEV_UNREGISTER, bind() publishes the device inside the RCU section of its lookup, and raw_notify() and isotp_notify() recheck the bound device under lock_sock(). As RTNL does not keep NETDEV_DOWN out of bind() anymore, bind() checks IFF_UP after publishing the bound device, with a barrier pair against raw_notify() and isotp_notify(), so a down transition during bind() is still reported with ENETDOWN.
[ backport to 6.18: Adapt the can_pernet_init() context to kzalloc() as
this tree has no kzalloc_obj(). ]
--- include/linux/can/can-ml.h | 3 ++ include/net/netns/can.h | 2 +- net/can/af_can.c | 39 +++++++++++------ net/can/bcm.c | 43 +++++------------- net/can/isotp.c | 89 +++++++++++++++++++++++--------------- net/can/raw.c | 88 +++++++++++++++++++++++++++---------- 6 files changed, 160 insertions(+), 104 deletions(-)
include/linux/can/can-ml.h +3 -0
@@ -45,6 +45,7 @@#include <linux/can.h> #include <linux/list.h> #include <linux/netdevice.h> +#include <linux/spinlock.h> #define CAN_SFF_RCV_ARRAY_SZ (1 << CAN_SFF_ID_BITS)#define CAN_EFF_RCV_HASH_BITS 10
@@ -53,6 +54,7 @@enum {RX_ERR ,RX_ALL ,RX_FIL ,RX_INV ,RX_MAX };struct can_dev_rcv_lists { +spinlock_t lock;/* protects the receive lists and entries */ struct hlist_head rx[RX_MAX ];struct hlist_head rx_sff[CAN_SFF_RCV_ARRAY_SZ ];struct hlist_head rx_eff[CAN_EFF_RCV_ARRAY_SZ ];
@@ -74,6 +76,7 @@ static inline struct can_ml_priv *can_get_ml_priv(struct net_device *dev)static inline void can_set_ml_priv (struct net_device *dev,struct can_ml_priv *ml_priv) { +spin_lock_init (&ml_priv->dev_rcv_lists.lock);netdev_set_ml_priv (dev, ml_priv,ML_PRIV_CAN ); }
include/net/netns/can.h +1 -1
@@ -29,7 +29,7 @@ struct netns_can {/* receive filters subscribed for 'all' CAN devices */ struct can_dev_rcv_lists *rx_alldev_list; -spinlock_t rcvlists_lock; +spinlock_t rcvlists_lock;/* protects the rcv_entries(_max) stats */ struct timer_list stattimer;/* timer for statistics update */ struct can_pkg_stats *pkg_stats;struct can_rcv_lists_stats *rcv_lists_stats;
net/can/af_can.c +25 -14
@@ -462,9 +462,10 @@ int can_rx_register(struct net *net, struct net_device *dev, canid_t can_id,if (!rcv)return -ENOMEM ; -spin_lock_bh (&net->can.rcvlists_lock); - dev_rcv_lists =can_dev_rcv_lists_find (net, dev); + +spin_lock_bh (&dev_rcv_lists->lock); + rcv_list =can_rcv_list_find (&can_id, &mask, dev_rcv_lists); rcv->can_id = can_id;
@@ -478,6 +479,9 @@ int can_rx_register(struct net *net, struct net_device *dev, canid_t can_id,hlist_add_head_rcu (&rcv->list, rcv_list); dev_rcv_lists->entries++; +spin_unlock_bh (&dev_rcv_lists->lock); + +spin_lock_bh (&net->can.rcvlists_lock); rcv_lists_stats->rcv_entries++; rcv_lists_stats->rcv_entries_max =max (rcv_lists_stats->rcv_entries_max, rcv_lists_stats->rcv_entries);
@@ -509,6 +513,14 @@ static void can_rx_delete_receiver(struct rcu_head *rp)* * Description: * Removes subscription entry depending on given (subscription) values. +* The receive lists of a CAN device are protected by a per-device lock, +* so the subscription is found even when the device has been moved to +* another network namespace after can_rx_register(). The caller has to +* ensure that @dev stays valid, e.g. by holding a reference to @dev or +* RTNL. @net should be the namespace that has been used for +* can_rx_register(). It selects the 'any' CAN device lists for +* @dev == NULL and is otherwise only used for the receive list +* statistics, which become imprecise when another namespace is passed. */ void can_rx_unregister(struct net *net, struct net_device *dev, canid_t can_id, canid_t mask, void (*func)(struct sk_buff *, void *),
@@ -522,12 +534,10 @@ void can_rx_unregister(struct net *net, struct net_device *dev, canid_t can_id,if (dev && !can_get_ml_priv (dev))return ; -if (dev && !net_eq (net,dev_net (dev))) -return ; + dev_rcv_lists =can_dev_rcv_lists_find (net, dev); -spin_lock_bh (&net->can.rcvlists_lock); +spin_lock_bh (&dev_rcv_lists->lock); - dev_rcv_lists =can_dev_rcv_lists_find (net, dev); rcv_list =can_rcv_list_find (&can_id, &mask, dev_rcv_lists);/* Search the receiver list for the item to delete. This should
@@ -547,26 +557,26 @@ void can_rx_unregister(struct net *net, struct net_device *dev, canid_t can_id,* a warning here. */ if (!rcv) { +spin_unlock_bh (&dev_rcv_lists->lock);pr_warn ("can: receive list entry not found for dev %s, id %03X, mask %03X\n" ,DNAME (dev), can_id, mask); - goto out; +return ; }hlist_del_rcu (&rcv->list); dev_rcv_lists->entries--; +spin_unlock_bh (&dev_rcv_lists->lock); + +spin_lock_bh (&net->can.rcvlists_lock);if (rcv_lists_stats->rcv_entries >0 ) rcv_lists_stats->rcv_entries--; - - out:spin_unlock_bh (&net->can.rcvlists_lock);/* schedule the receiver item for deletion */ -if (rcv) { -if (rcv->sk) -sock_hold (rcv->sk); -call_rcu (&rcv->rcu, can_rx_delete_receiver); - } +if (rcv->sk) +sock_hold (rcv->sk); +call_rcu (&rcv->rcu, can_rx_delete_receiver); }EXPORT_SYMBOL (can_rx_unregister);
@@ -797,6 +807,7 @@ static int can_pernet_init(struct net *net)kzalloc (sizeof (*net->can.rx_alldev_list),GFP_KERNEL );if (!net->can.rx_alldev_list) goto out; +spin_lock_init (&net->can.rx_alldev_list->lock); net->can.pkg_stats =kzalloc (sizeof (*net->can.pkg_stats),GFP_KERNEL );if (!net->can.pkg_stats) goto out_free_rx_alldev_list;
net/can/bcm.c +12 -31
75 lines not on this page · raw message
net/can/isotp.c +54 -35
186 lines not on this page · raw message
net/can/raw.c +65 -23
224 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 466/686 ceph: clamp the inline data length in ceph_fill_inline_data()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Guanglei Zhu <[email protected]>
[ Upstream commit 9c1d14d3b66b3e1dd96ee664c0dd2548f2b77a52 ]
The MDS decides how much inline data to attach to a reply, and the client parses inline_len without any upper bound: ceph_decode_need() only verifies that the message actually carries that many bytes. ceph_fill_inline_data() then copies the data into a single page with no length check, so a malicious or buggy MDS returning more inline data than the page can hold writes past its end.
Clamp the length to PAGE_SIZE so both callers, handle_cap_grant() and fill_inode(), are covered.
--- fs/ceph/addr.c | 6 ++++++ 1 file changed, 6 insertions(+)
fs/ceph/addr.c +6 -0
@@ -2214,6 +2214,12 @@ void ceph_fill_inline_data(struct inode *inode, struct page *locked_page,doutc (cl,"%p %llx.%llx len %zu locked_page %p\n" , inode,ceph_vinop (inode), len, locked_page); +if (len >PAGE_SIZE ) { +pr_warn_ratelimited_client (cl,"oversized inline data %zu\n" , + len); + len =PAGE_SIZE ; + } +if (len >0 ) {void *kaddr =kmap_atomic (page);memcpy (kaddr, data, len);
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 467/686 Revert "mm/page_owner: fix memory leak in page_owner_stack_fops->release()"
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Hamid Nassiby <[email protected]>
This reverts commit 05a8edf607be826738dfc620a17d9d98e8976762, which is commit a76a5ae2c6c6 upstream.
The upstream change is only correct on top of commit 156c0c5d1463 ("mm/page_owner: introduce struct stack_print_ctx"), which first appeared in v6.19. That commit makes page_owner_stack_open() allocate a struct stack_print_ctx through seq_open_private() and moves the stack_list cursor into it, so ->release() must free it with seq_release_private(). 6.18 does not have that commit: page_owner_stack_open() passes a size of 0 to seq_open_private(), so there is nothing to leak, and stack_start()/stack_next() store the current struct stack node directly in m->private.
The upstream commit was backported because it is tagged for stable and carries a Fixes tag for 765973a09803 ("mm,page_owner: display all stacks and their count"), but the leak it fixes only exists since 156c0c5d1463.
seq_release_private() kfree()s m->private. Closing show_stacks before EOF therefore frees a struct stack node that is still linked in stack_list, and the next reader of show_stacks walks into freed memory. On v6.18.60 (x86_64 QEMU, KASAN, page_owner=on), a single 4 KiB read() and close() followed by a full read gives:
BUG: KASAN: slab-use-after-free in stack_print+0x165/0x170 Read of size 8 at addr ff110000062adfc0 by task init/1 ... Allocated by task 1: __kasan_kmalloc+0x7f/0x90 __set_page_owner+0x4a5/0x720 ... Freed by task 1: kfree+0xf8/0x460 seq_release_private+0x58/0x110 full_proxy_release+0xa1/0x130 __fput+0x35c/0xac0 __x64_sys_close+0x79/0xd0 ... The buggy address belongs to the object at ff110000062adfc0 which belongs to the cache kmalloc-16 of size 16
Without KASAN, the same bug panics arm64 hardware running a 6.12.108-based kernel ("head -12 show_stacks; cat show_stacks").
With this revert applied, the QEMU reproducer completes 20 partial-read/full-read cycles without a KASAN report. mm/page_owner.c is unchanged between v6.18.60 and v6.18.62.
Backporting 156c0c5d1463 instead is not proposed: it prepares for the new show_handles and show_stacks_handles debugfs files rather than fixing anything, so reverting the backport is the minimal change for stable.
--- mm/page_owner.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
mm/page_owner.c +1 -1
@@ -936,7 +936,7 @@ static const struct file_operations page_owner_stack_operations = { .open = page_owner_stack_open, .read = seq_read, .llseek = seq_lseek, - .release = seq_release_private, + .release = seq_release, };static int page_owner_threshold_get (void *data,u64 *val)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 468/686 timekeeping: Require permission to set auxiliary clocks
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Daehyeon Ko <[email protected]>
commit 524d95c8a2000cba6cb80a173d76cb746c561244 upstream.
The generic clock_settime() entry point delegates permission checks to each clock-specific callback. aux_clock_set() does not perform one. Once an administrator enables an auxiliary clock, any local process can therefore change the global clock offset.
A test process running as UID and GID 65534 with no effective, permitted, inheritable, or ambient capabilities set CLOCK_AUX0 successfully, and a separate process observed the new value. The same process was denied by clock_adjtime(). An AppArmor profile denying sys_time also blocked CLOCK_REALTIME changes but did not see the auxiliary clock operation.
Call security_settime64() before mutating the auxiliary timekeeper. This matches CLOCK_REALTIME's permission model, enforces initial-user-namespace CAP_SYS_TIME, and gives LSMs the settime hook while preserving authorized clock changes.
--- kernel/time/timekeeping.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/time/timekeeping.c +5 -0
@@ -14,6 +14,7 @@#include <linux/sched.h> #include <linux/sched/loadavg.h> #include <linux/sched/clock.h> +#include <linux/security.h> #include <linux/syscore_ops.h> #include <linux/clocksource.h> #include <linux/jiffies.h>
@@ -2937,11 +2938,15 @@ static int aux_clock_set(const clockid_t id, const struct timespec64 *tnew)struct tk_data *aux_tkd =aux_get_tk_data (id);struct timekeeper *aux_tks;ktime_t tnow, nsecs; +int ret;if (!timespec64_valid_settod (tnew))return -EINVAL ;if (!aux_tkd)return -ENODEV ; + ret =security_settime64 (tnew,NULL ); +if (ret) +return ret; aux_tks = &aux_tkd->shadow_timekeeper;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 469/686 vxlan: Stop rejecting dynamic FDB entries with a nexthop ID
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Ido Schimmel <[email protected]>
[ Upstream commit 7308ef8b4a6779a39f68d053c19b53a5c584a663 ]
Commit 98fc57d16744 ("vxlan: reject dynamic fdb entries that reference a nexthop id") started rejecting FDB entries that point to FDB nexthops unless they are configured as "permanent" or "static". The intent was to prevent such entries from being aged out by vxlan_cleanup(), which runs without RTNL and can therefore race with other VXLAN devices that modify the same per-nexthop FDB list.
However, FRR installs remote MACs that are behind a multihomed Ethernet Segment (EVPN-MH) as dynamic FDB entries that point to an FDB nexthop group. Since the above commit, these entries are rejected and traffic towards the corresponding MACs is flooded to all the remote VTEPs.
These entries are also marked as externally learned ("extern_learn") and are therefore skipped by vxlan_cleanup(), but exempting externally learned entries from the checks is not enough: vxlan_cleanup() reads the state and flags of an entry without the hash lock, so an entry that is concurrently changed from dynamic and externally learned to static can still be aged out.
Instead, remove the checks added by the above commit and make vxlan_cleanup() skip FDB entries that point to FDB nexthops. Such entries can only be configured from user space, cannot be learned and cannot roam, so there is no reason to age them out. The nexthop pointer of an FDB entry is set before the entry is linked and is only cleared after it was unlinked and an RCU grace period has passed, so it can be checked without the hash lock.
Adjust the test cases added by the above commit and add a test case that checks that dynamic FDB entries that point to FDB nexthops are not aged out. Without the fix:
# ./fib_nexthops.sh -t "ipv4_fdb_grp_fcnal ipv6_fdb_grp_fcnal"
IPv4 fdb groups functional
--------------------------
[...]
TEST: Fdb mac add with nexthop group and dynamic state [FAIL] TEST: Fdb mac add with nexthop group and extern_learn [FAIL] TEST: Fdb mac without nexthop group aged out [ OK ] TEST: Fdb mac with nexthop group not aged out [FAIL]
[...]
IPv6 fdb groups functional
--------------------------
[...]
TEST: Fdb mac add with nexthop group and dynamic state [FAIL] TEST: Fdb mac add with nexthop group and extern_learn [FAIL] TEST: Fdb mac without nexthop group aged out [ OK ] TEST: Fdb mac with nexthop group not aged out [FAIL]
[...]
Tests passed: 44
Tests failed: 6
Tests skipped: 0
With the fix:
# ./fib_nexthops.sh -t "ipv4_fdb_grp_fcnal ipv6_fdb_grp_fcnal"
IPv4 fdb groups functional
--------------------------
[...]
TEST: Fdb mac add with nexthop group and dynamic state [ OK ] TEST: Fdb mac add with nexthop group and extern_learn [ OK ] TEST: Fdb mac without nexthop group aged out [ OK ] TEST: Fdb mac with nexthop group not aged out [ OK ]
[...]
IPv6 fdb groups functional
--------------------------
[...]
TEST: Fdb mac add with nexthop group and dynamic state [ OK ] TEST: Fdb mac add with nexthop group and extern_learn [ OK ] TEST: Fdb mac without nexthop group aged out [ OK ] TEST: Fdb mac with nexthop group not aged out [ OK ]
[...]
Tests passed: 50
Tests failed: 0
Tests skipped: 0
--- drivers/net/vxlan/vxlan_core.c | 14 ++------ tools/testing/selftests/net/fib_nexthops.sh | 40 ++++++++++++++------- 2 files changed, 31 insertions(+), 23 deletions(-)
drivers/net/vxlan/vxlan_core.c +3 -11
@@ -997,12 +997,6 @@ static int vxlan_fdb_update_existing(struct vxlan_dev *vxlan,return -EOPNOTSUPP ; } -if (rcu_access_pointer (f->nh) && - !(state & (NUD_PERMANENT |NUD_NOARP ))) { -NL_SET_ERR_MSG (extack,"Cannot make a nexthop fdb dynamic" ); -return -EOPNOTSUPP ; - } -/* Do not allow an externally learned entry to take over an entry added * by the user. */
@@ -1264,11 +1258,6 @@ static int vxlan_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],if (err)return err; -if (nhid && !(ndm->ndm_state & (NUD_PERMANENT |NUD_NOARP ))) { -NL_SET_ERR_MSG (extack,"A nexthop fdb cannot be dynamic" ); -return -EINVAL ; - } -if (vxlan->default_dst.remote_ip.sa.sa_family != ip.sa.sa_family)return -EAFNOSUPPORT ;
@@ -2889,6 +2878,9 @@ static void vxlan_cleanup(struct timer_list *t)if (f->flags &NTF_EXT_LEARNED )continue ; +if (rcu_access_pointer (f->nh)) +continue ; + timeout =READ_ONCE (f->updated) + vxlan->cfg.age_interval *HZ ;if (time_before_eq (timeout, jiffies)) {spin_lock (&vxlan->hash_lock);
tools/testing/selftests/net/fib_nexthops.sh +28 -12
@@ -423,6 +423,14 @@ stop_ip_monitor() return $rc } +fdb_entry_aged() +{ + local mac=$1 + local dev=$2 + + ! $BRIDGE fdb get to $mac dev $dev self &> /dev/null +} + check_nexthop_fdb_support() { $IP nexthop help 2>&1 | grep -q fdb
@@ -527,14 +535,18 @@ ipv6_fdb_grp_fcnal() log_test $? 0 "Fdb mac add with nexthop group and static state" run_cmd "$BRIDGE fdb add 02:02:00:00:00:16 dev vx10 nhid 102 self dynamic" - log_test $? 255 "Fdb mac add with nexthop group and dynamic state" + log_test $? 0 "Fdb mac add with nexthop group and dynamic state" + + run_cmd "$BRIDGE fdb add 02:02:00:00:00:17 dev vx10 nhid 102 self dynamic extern_learn" + log_test $? 0 "Fdb mac add with nexthop group and extern_learn" - run_cmd "$BRIDGE fdb add 02:02:00:00:00:17 dev vx10 nhid 102 self" - run_cmd "$BRIDGE fdb replace 02:02:00:00:00:17 dev vx10 dst 2001:db8:91::11 self dynamic" - log_test $? 255 "Fdb mac replace with nexthop group and dynamic state" + run_cmd "$IP link set dev vx10 up type vxlan ageing 1" + run_cmd "$BRIDGE fdb add 02:02:00:00:00:18 dev vx10 dst 2001:db8:91::11 self dynamic" + slowwait 20 fdb_entry_aged 02:02:00:00:00:18 vx10 + log_test $? 0 "Fdb mac without nexthop group aged out" - run_cmd "$BRIDGE fdb append 02:02:00:00:00:17 dev vx10 dst 2001:db8:91::11 self dynamic" - log_test $? 255 "Fdb mac append with nexthop group and dynamic state" + run_cmd "$BRIDGE fdb get to 02:02:00:00:00:16 dev vx10 self" + log_test $? 0 "Fdb mac with nexthop group not aged out" run_cmd "$IP -6 ro add 2001:db8:101::1/128 nhid 66" log_test $? 2 "Route add with fdb nexthop"
@@ -641,14 +653,18 @@ ipv4_fdb_grp_fcnal() log_test $? 0 "Fdb mac add with nexthop group and static state" run_cmd "$BRIDGE fdb add 02:02:00:00:00:16 dev vx10 nhid 102 self dynamic" - log_test $? 255 "Fdb mac add with nexthop group and dynamic state" + log_test $? 0 "Fdb mac add with nexthop group and dynamic state" + + run_cmd "$BRIDGE fdb add 02:02:00:00:00:17 dev vx10 nhid 102 self dynamic extern_learn" + log_test $? 0 "Fdb mac add with nexthop group and extern_learn" - run_cmd "$BRIDGE fdb add 02:02:00:00:00:17 dev vx10 nhid 102 self" - run_cmd "$BRIDGE fdb replace 02:02:00:00:00:17 dev vx10 dst 10.0.0.3 self dynamic" - log_test $? 255 "Fdb mac replace with nexthop group and dynamic state" + run_cmd "$IP link set dev vx10 up type vxlan ageing 1" + run_cmd "$BRIDGE fdb add 02:02:00:00:00:18 dev vx10 dst 10.0.0.3 self dynamic" + slowwait 20 fdb_entry_aged 02:02:00:00:00:18 vx10 + log_test $? 0 "Fdb mac without nexthop group aged out" - run_cmd "$BRIDGE fdb append 02:02:00:00:00:17 dev vx10 dst 10.0.0.3 self dynamic" - log_test $? 255 "Fdb mac append with nexthop group and dynamic state" + run_cmd "$BRIDGE fdb get to 02:02:00:00:00:16 dev vx10 self" + log_test $? 0 "Fdb mac with nexthop group not aged out" run_cmd "$IP ro add 172.16.0.0/22 nhid 16" log_test $? 2 "Route add with fdb nexthop"
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 470/686 mm/damon/core: move static variable last_nr_regions to damon_ctx
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: SJ Park <[email protected]>
[ Upstream commit 26ae50a0901a44f7d50053f87dc38abd9f9a269c ]
kdamond_split_regions() uses a static variable last_nr_regions, to infer if the region boundaries are too stable. If it looks too stable, it does a more aggressive region split because it might be a fake stability coming from non-aggressive split. Because the variable is static, the inference can be racy and wrong when multiple kdamonds are running in parallel.
The user impact is not critical. No crash, no leak. DAMON's best-effort monitoring accuracy can be degraded when multiple kdamonds are used in parallel and the workload has certain access patterns. Still it is a bug that is better to fix.
Move the variable into the damon_ctx struct to fix the problem.
--- include/linux/damon.h | 6 ++++++ mm/damon/core.c | 5 ++--- 2 files changed, 8 insertions(+), 3 deletions(-)
include/linux/damon.h +6 -0
@@ -804,6 +804,12 @@ struct damon_ctx {struct list_head adaptive_targets;struct list_head schemes; +/* private: */ +/* +* number of regions after last merge. Read kdamond_split_regions() +* for more details. +*/ +unsigned long last_nr_regions; };static inline struct damon_region *damon_next_region (struct damon_region *r)
mm/damon/core.c +2 -3
@@ -2568,7 +2568,6 @@ static void kdamond_split_regions(struct damon_ctx *ctx) {struct damon_target *t;unsigned int nr_regions =0 ; -static unsigned int last_nr_regions;int nr_subregions =2 ;damon_for_each_target (t, ctx)
@@ -2578,14 +2577,14 @@ static void kdamond_split_regions(struct damon_ctx *ctx)return ;/* Maybe the middle of the region has different access frequency */ -if (last_nr_regions == nr_regions && +if (ctx->last_nr_regions == nr_regions && nr_regions < ctx->attrs.max_nr_regions /3 ) nr_subregions =3 ;damon_for_each_target (t, ctx)damon_split_regions_of (t, nr_subregions, ctx->min_sz_region); - last_nr_regions = nr_regions; + ctx->last_nr_regions = nr_regions; }/*
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 471/686 batman-adv: tpmeter: fix u32 truncation of reported bytes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sven Eckelmann <[email protected]>
commit 1025b76d13288a311e8259a0eefde0854fa63c41 upstream.
When more than 4 GB are transferred by the throughput meter, batadv_tp_batctl_notify() will cut of the upper 32 bit of the u64 counter and thus under-report the actual transferred bytes.
The data type of the temporary storage variable must therefore still continue to use u64.
--- net/batman-adv/tp_meter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
net/batman-adv/tp_meter.c +1 -1
@@ -226,9 +226,9 @@ static void batadv_tp_batctl_notify(enum batadv_tp_meter_reason reason, unsigned long start_time, u64 total_sent, u32 cookie) { + u64 total_bytes;u32 test_time;u8 result; -u32 total_bytes;if (!batadv_tp_is_error (reason)) { result =BATADV_TP_REASON_COMPLETE ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 472/686 batman-adv: tt: only transmit local ROAM flag together with DEL
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sven Eckelmann <[email protected]>
commit 10f24f058417024a2c19cb8d88a6a0678a58a21b upstream.
BATADV_TT_CLIENT_ROAM is part of BATADV_TT_REMOTE_MASK but on the wire it only has a defined meaning together with BATADV_TT_CLIENT_DEL: the originator no longer serves the client because it roamed to another node. Such a DEL is only relevant for events (non-full table requests).
An ADD carrying ROAM is processed (by accident) by the receiver like aROAMING_ADV: a newly created global entry is marked as roaming and is excluded from the global CRC. But the sender includes it in its local CRC.
But such a behavior doesn't make sense for non-ROAM_ADV because a new TTVN is meant as announced commit of the local TT table of a node and should therefore not be used to create a temporary (roam) global entry in a node.
At the moment, such an ADD with the BATADV_TT_CLIENT_ROAM flag set can happen due to two mechanisms:
batadv_tt_local_valid() copies all flags of the local entry into a full table response. It is not synchronized with batadv_tt_local_mark_removed(). An entry which was marked as ROAM|PENDING by a ROAMING_ADV is still part of the current TTVN and is sent with the ROAM flag set. The receivers then create a roaming global entry for it and detect a CRC mismatch, which causes them to request the full table again.
The same can happen for an ADD change which is queued for an entry which (still) has the ROAM flag set. For example when only the dynamic WIFI or ISOLA flags were updated.
It is not triggered by batadv_send_other_tt_response() because batadv_tt_global_valid() is already taking care of filtering out BATADV_TT_CLIENT_ROAM entries.
For the two problematic announcement mechanism, only send the ROAM flag of local entries together with a DEL.
This only fixes the ROAM marking of the global entry and the resulting CRC mismatch. When the requester of the full table is the node which sent the ROAMING_ADV, the still announced entry will (independent of the ROAM flag) cause batadv_tt_global_purge_local() to remove the requester's own (new) local entry for the client. This is not addressed here.
--- net/batman-adv/translation-table.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
net/batman-adv/translation-table.c +14 -2
@@ -430,7 +430,6 @@ static void batadv_tt_local_event(struct batadv_priv *bat_priv,if (!tt_change_node)return ; - tt_change_node->change.flags = flags;memset (tt_change_node->change.reserved,0 ,sizeof (tt_change_node->change.reserved));ether_addr_copy (tt_change_node->change.addr, common->addr);
@@ -438,6 +437,15 @@ static void batadv_tt_local_event(struct batadv_priv *bat_priv, del_op_requested = flags &BATADV_TT_CLIENT_DEL ; +/* the ROAM flag is only meaningful for the receiver in combination +* with a DEL. An ADD with ROAM would be interpreted as a roaming +* advertisement +*/ +if (!del_op_requested) + flags &= ~BATADV_TT_CLIENT_ROAM ; + + tt_change_node->change.flags = flags; +/* check for ADD+DEL, DEL+ADD, ADD+ADD or DEL+DEL events */ spin_lock_bh (&bat_priv->tt.changes_list_lock); changes =READ_ONCE (bat_priv->tt.local_changes);
@@ -2691,8 +2699,12 @@ static bool batadv_tt_local_valid(const void *entry_ptr,if (tt_common_entry->flags &BATADV_TT_CLIENT_NEW )return false; +/* the entry is (still) announced. A ROAM flag of an entry which is +* pending to be removed must not be transmitted. Otherwise, the +* receiver would handle it like a roaming advertisement +*/ if (flags) - *flags = tt_common_entry->flags; + *flags = tt_common_entry->flags & ~BATADV_TT_CLIENT_ROAM ;return true; }
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 473/686 batman-adv: tt: clear ROAM flag when re-adding a pending local client
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sven Eckelmann <[email protected]>
commit cc2186d7854785b30d423f5d43757b086b300e55 upstream.
When a ROAMING_ADV is received for an announced local client, batadv_tt_local_mark_removed() sets BATADV_TT_CLIENT_ROAM, queues a DEL|ROAM change and marks the entry as BATADV_TT_CLIENT_PENDING. If the client sends a frame again before the next TTVN commit, batadv_tt_local_add_existing() only clears the PENDING flag and returns early. The ADD cancels the queued DEL, but the entry keeps the ROAM flag:
* batadv_is_my_client() reports the client as not served by this node
* batadv_tt_local_client_is_roaming() reroutes unicast frames for it to the node which sent the ROAMING_ADV
The ROAM flag is only removed with the next frame of the client.
Since BATADV_TT_CLIENT_ROAM is set together with BATADV_TT_CLIENT_PENDING, it has to be cleared also at the same time with BATADV_TT_CLIENT_PENDING when the client roamed back.
--- net/batman-adv/translation-table.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
net/batman-adv/translation-table.c +6 -3
@@ -612,6 +612,7 @@ bool batadv_tt_local_add(struct net_device *mesh_iface, const u8 *addr,int hash_added, table_size, packet_size_max;bool ret = false;bool roamed_back = false; +bool added = false;u8 remote_flags;u32 match_mark;
@@ -638,7 +639,7 @@ bool batadv_tt_local_add(struct net_device *mesh_iface, const u8 *addr,* flag can be reset like it was never enqueued */ tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING ; - goto add_event; + added = true; }if (tt_local->common.flags &BATADV_TT_CLIENT_ROAM ) {
@@ -719,10 +720,12 @@ bool batadv_tt_local_add(struct net_device *mesh_iface, const u8 *addr, goto out; } -add_event: -batadv_tt_local_event (bat_priv, tt_local,BATADV_NO_FLAGS ); + added = true; check_roaming: +if (added) +batadv_tt_local_event (bat_priv, tt_local,BATADV_NO_FLAGS ); +/* Check whether it is a roaming, but don't do anything if the roaming * process has already been handled */
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 474/686 batman-adv: tt: send ROAM_ADV on each roamed back client
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sven Eckelmann <[email protected]>
commit aff4d5d10f2dcb4a9b604e27414dafa1d51b6406 upstream.
When a ROAMING_ADV is received for an announced local client, batadv_roam_tvlv_unicast_handler_v1() creates a global entry with the BATADV_TT_CLIENT_ROAM flag set.
If the client sends a frame again before the next TTVN commit, batadv_tt_local_add_roam() is expected to announce this return via a ROAM_ADV frame. But this doesn't happen because the global entry (created by the first ROAMING_ADV) carries BATADV_TT_CLIENT_ROAM until the new originator announces the client.
Let batadv_tt_local_add_roam() always handle a roamed back client - independent of the ROAM flag of the global entry:
* trigger sending of the ROAM_ADV frame(s)
* remove the (with the roaming) associated global entry
--- net/batman-adv/translation-table.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
net/batman-adv/translation-table.c +2 -1
@@ -729,7 +729,8 @@ bool batadv_tt_local_add(struct net_device *mesh_iface, const u8 *addr,/* Check whether it is a roaming, but don't do anything if the roaming * process has already been handled */ -if (tt_global && !(tt_global->common.flags &BATADV_TT_CLIENT_ROAM )) { +if (tt_global && + (roamed_back || !(tt_global->common.flags &BATADV_TT_CLIENT_ROAM ))) {/* These node are probably going to update their tt table */ head = &tt_global->orig_list;rcu_read_lock ();
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 475/686 batman-adv: tt: ignore ROAM flag of received ADD changes
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sven Eckelmann <[email protected]>
commit c5d68abe6e7f1dbd132a602cb696fe1fff0389eb upstream.
A received TT change (OGM diff or full table response) with the ROAM flag but without DEL is handled by batadv_tt_global_add() like a ROAMING_ADV:
* a newly created global entry gets BATADV_TT_CLIENT_ROAM and is therefore excluded from the global CRC. The sender has it in its local CRC and the receiver has to request the full table again
* batadv_tt_global_purge_local() removes the local entry of the receiver. The receiver's own client is considered as roamed to the sender and frames for it are rerouted
The ROAM flag only has a meaning together with DEL. Drop it on reception to keep it from populating the global table with a temporary ROAMING entry which is not part of the CRC - and therefore causing a CRC mismatch.
--- net/batman-adv/translation-table.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)
net/batman-adv/translation-table.c +12 -3
@@ -3268,20 +3268,29 @@ static void _batadv_tt_update_changes(struct batadv_priv *bat_priv, {int i;int roams; +u8 flags;for (i =0 ; i < tt_num_changes; i++) { -if ((tt_change + i)->flags &BATADV_TT_CLIENT_DEL ) { - roams = (tt_change + i)->flags &BATADV_TT_CLIENT_ROAM ; + flags = (tt_change + i)->flags; + +if (flags &BATADV_TT_CLIENT_DEL ) { + roams = flags &BATADV_TT_CLIENT_ROAM ;batadv_tt_global_del (bat_priv, orig_node, (tt_change + i)->addr,ntohs ((tt_change + i)->vid),"tt removed by changes" , roams); }else { +/* an announced client cannot have roamed away from +* orig_node. Only a ROAMING_ADV is allowed to add a +* global entry with the ROAM flag +*/ + flags &= ~BATADV_TT_CLIENT_ROAM ; +if (!batadv_tt_global_add (bat_priv, orig_node, (tt_change + i)->addr,ntohs ((tt_change + i)->vid), - (tt_change + i)->flags, ttvn)) + flags, ttvn))/* In case of problem while storing a * global_entry, we stop the updating * procedure without committing the
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 476/686 batman-adv: tt: only update flags for TT events
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sven Eckelmann <[email protected]>
commit ad1fd828aa3944efc393b84b0d7c02483f1b5638 upstream.
In the first implementation of the translation table events, it was only possible to announce:
* ADD: new locally detected client
* DEL: disappeared local client
If an ADD event was queued and then a DEL event was queued in the same timeslot, it is valid to destroy both events because nothing actually changed for remode nodes
But with commit 3c4f7ab60cc2 ("batman-adv: improve the TT component to support runtime flag changes") and subsequent changes, it could also happen that there are extra ADD events:
* ADD: _NEW_ locally detected client
* ADD: already existing client with new flags
* DEL: disappeared local client
The first and the last type of event could in theory still be removed together from the (to be announced) events queue. But if the "update flags" ADD is dropped together with the DEL, it would still leave global translation table of a remote node in the incorrect state - believing that the client didn't disappear.
If a detected client was previously announced, a DEL event must only overwrite the "update flags" ADD but the DEL itself must still continue to exist in the (to be anounced) events queue. For now, adjustment of the announced flags is used for everything instead of dropping already queued up events completely.
Similarly, a DEL followed by an ADD caused both entries to be deleted. But the new ADD could announce flags changes which were not yet present for the client before it was marked for DELetion. The new ADD must therefore only overwrite the DEL - but still be kept.
--- net/batman-adv/translation-table.c | 30 ++++++++++-------------------- 1 file changed, 10 insertions(+), 20 deletions(-)
net/batman-adv/translation-table.c +10 -20
@@ -415,6 +415,9 @@ batadv_tt_orig_list_entry_put(struct batadv_tt_orig_list_entry *orig_entry)* @bat_priv: the bat priv with all the mesh interface information * @tt_local_entry: the TT entry involved in the event * @event_flags: flags to store in the event structure +* +* Only a single change per client is queued. It describes the latest state of +* the client and a new event therefore replaces an already queued one. */ static void batadv_tt_local_event(struct batadv_priv *bat_priv, struct batadv_tt_local_entry *tt_local_entry,
@@ -423,7 +426,7 @@ static void batadv_tt_local_event(struct batadv_priv *bat_priv,struct batadv_tt_change_node *tt_change_node, *entry, *safe;struct batadv_tt_common_entry *common = &tt_local_entry->common;u8 flags = common->flags | event_flags; -bool del_op_requested, del_op_entry; +bool del_op_requested;size_t changes; tt_change_node =kmem_cache_alloc (batadv_tt_change_cache,GFP_ATOMIC );
@@ -457,25 +460,12 @@ static void batadv_tt_local_event(struct batadv_priv *bat_priv,if (entry->change.vid != tt_change_node->change.vid)continue ; - del_op_entry = entry->change.flags &BATADV_TT_CLIENT_DEL ; -if (del_op_requested != del_op_entry) { -/* DEL+ADD in the same orig interval have no effect and -* can be removed to avoid silly behaviour on the -* receiver side. The other way around (ADD+DEL) can -* happen in case of roaming of a client still in the -* NEW state. Roaming of NEW clients is now possible due -* to automatically recognition of "temporary" clients -*/ -list_del (&entry->list); -kmem_cache_free (batadv_tt_change_cache, entry); - changes--; - }else { -/* this is a second add or del in the same originator -* interval. It could mean that flags have been changed -* (e.g. double add): update them -*/ - entry->change.flags = flags; - } +/* the other nodes may know the client with different +* flags. A DEL+ADD must therefore still announce the +* current flags and an ADD+DEL must still remove the +* client. ADD+ADD and DEL+DEL only update the flags +*/ + entry->change.flags = flags;kmem_cache_free (batadv_tt_change_cache, tt_change_node); goto update_changes;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 477/686 batman-adv: tt: dont drop local events queued during TVLV update
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Sven Eckelmann <[email protected]>
commit ed7a0dfdd370acb48be7a281df732c1bebcc7f1d upstream.
batadv_tt_tvlv_container_update() read the number of local changes without holding changes_list_lock. batadv_tt_local_event() is not serialized by the commit_lock and can queue new events before the changes_list is flushed:
CPU0 CPU1
batadv_tt_tvlv_container_update()
num = ...local_changes;
batadv_tt_local_event()
list_add_tail(...);
...local_changes++;
spin_lock_bh(&...changes_list_lock);
/* only num events copied but all freed */The additional events were freed without ever being sent. Other nodes will only notice this via a CRC mismatch and must request the full table.
The number of changes and the changes_list must therefore be taken atomically. Events queued afterwards then stay in the tt.changes_list for the next TT round.
The changes can no longer be kept for the next round when the TVLV buffer allocation fails. But they would be sent with a skipped TTVN anyway, so the other nodes have to request the full table in this case either way. The last changeset is only dropped in this case when the TTVN was incremented. Without new changes, it still describes the current TTVN.
Previously, the unconsumed changes caused a retry of the TVLV container update in the next commit round. Since the changes are now consumed, the next round would only take the path without changes and wait for BATADV_TT_OGM_APPEND_MAX rounds before updating the container again. Until then, the outdated container with the previous TTVN would still be announced. The ogm_append_cnt is therefore reset on failure to retry the update in the next OGM interval.
This doesn't make the CRC consistent with the announced changeset. The local table modifications are still not serialized with the commit and batadv_tt_local_transition_new() can still make a client part of the CRC for which the event is only part of the next TT round. Such an inconsistency is detected by the CRC check of the other nodes and solved via a full table request.
--- net/batman-adv/translation-table.c | 61 +++++++++++++++++++++++------- 1 file changed, 48 insertions(+), 13 deletions(-)
net/batman-adv/translation-table.c +48 -13
@@ -978,20 +978,22 @@ batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,* batadv_tt_tvlv_container_update() - update the translation table tvlv * container after local tt changes have been committed * @bat_priv: the bat priv with all the mesh interface information +* @changes_list: list of committed changes which will be consumed +* @tt_diff_entries_num: number of entries in @changes_list */ -static void batadv_tt_tvlv_container_update (struct batadv_priv *bat_priv) +static void batadv_tt_tvlv_container_update (struct batadv_priv *bat_priv, +struct list_head *changes_list, +int tt_diff_entries_num) {struct batadv_tt_change_node *entry, *safe;struct batadv_tvlv_tt_data *tt_data;struct batadv_tvlv_tt_change *tt_change;int tt_diff_len, tt_change_len =0 ; -int tt_diff_entries_num =0 ;int tt_diff_entries_count =0 ;bool drop_changes = false;size_t tt_extra_len =0 ;u16 tvlv_len; - tt_diff_entries_num =READ_ONCE (bat_priv->tt.local_changes); tt_diff_len =batadv_tt_len (tt_diff_entries_num);/* if we have too many changes for one packet don't send any
@@ -1009,19 +1011,39 @@ static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv) tvlv_len =batadv_tt_prepare_tvlv_local_data (bat_priv, &tt_data, &tt_change, &tt_diff_len); -if (!tvlv_len) +if (!tvlv_len) { +/* the changes are lost and the other nodes have to request the +* full table. Don't answer TT requests for the new TTVN with +* the stale changeset of the previous TTVN. Without changes, the +* TTVN was not incremented and the last changeset is still valid +*/ +if (drop_changes || tt_diff_entries_num >0 ) { +list_for_each_entry_safe (entry, safe, changes_list, + list) { +list_del (&entry->list); +kmem_cache_free (batadv_tt_change_cache, entry); + } + +spin_lock_bh (&bat_priv->tt.last_changeset_lock); +kfree (bat_priv->tt.last_changeset); + bat_priv->tt.last_changeset =NULL ; + bat_priv->tt.last_changeset_len =0 ; +spin_unlock_bh (&bat_priv->tt.last_changeset_lock); + } + +/* announce the already committed TTVN in the next OGM interval +* instead of waiting for BATADV_TT_OGM_APPEND_MAX idle rounds +*/ +atomic_set (&bat_priv->tt.ogm_append_cnt,0 );return ; + } tt_data->flags =BATADV_TT_OGM_DIFF ;if (!drop_changes && tt_diff_len ==0 ) goto container_register; -spin_lock_bh (&bat_priv->tt.changes_list_lock); -WRITE_ONCE (bat_priv->tt.local_changes,0 ); - -list_for_each_entry_safe (entry, safe, &bat_priv->tt.changes_list, - list) { +list_for_each_entry_safe (entry, safe, changes_list, list) {if (tt_diff_entries_count < tt_diff_entries_num) { memcpy(tt_change + tt_diff_entries_count, &entry->change,
@@ -1031,7 +1053,6 @@ static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)list_del (&entry->list);kmem_cache_free (batadv_tt_change_cache, entry); } -spin_unlock_bh (&bat_priv->tt.changes_list_lock); tt_extra_len =batadv_tt_len (tt_diff_entries_num - tt_diff_entries_count);
@@ -3695,11 +3716,25 @@ static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)*/ static void batadv_tt_local_commit_changes_nolock (struct batadv_priv *bat_priv) { +LIST_HEAD (changes_list); +int changes_num; +lockdep_assert_held (&bat_priv->tt.commit_lock); -if (READ_ONCE (bat_priv->tt.local_changes) ==0 ) { +/* atomically get the list of changes. The TTVN decision and the +* announced changeset must cover the same events. Events queued +* afterwards stay in the tt.changes_list for the next TT round +*/ +spin_lock_bh (&bat_priv->tt.changes_list_lock); +list_splice_init (&bat_priv->tt.changes_list, &changes_list); + changes_num =READ_ONCE (bat_priv->tt.local_changes); +WRITE_ONCE (bat_priv->tt.local_changes,0 ); +spin_unlock_bh (&bat_priv->tt.changes_list_lock); + +if (changes_num ==0 ) {if (!batadv_atomic_dec_not_zero (&bat_priv->tt.ogm_append_cnt)) -batadv_tt_tvlv_container_update (bat_priv); +batadv_tt_tvlv_container_update (bat_priv, &changes_list, + changes_num);return ; }
@@ -3716,7 +3751,7 @@ static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)/* reset the sending counter */ atomic_set (&bat_priv->tt.ogm_append_cnt,BATADV_TT_OGM_APPEND_MAX ); -batadv_tt_tvlv_container_update (bat_priv); +batadv_tt_tvlv_container_update (bat_priv, &changes_list, changes_num); }/**
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 478/686 can: raw, isotp: copy socket options outside of lock_sock()
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Oliver Hartkopp <[email protected]>
commit 43c973a0887d3d7b2ee0a446603c97bf0f38c58e upstream.
The CAN_RAW and CAN_ISOTP specific socket options are copied from and to user space while holding lock_sock(). A copy that faults or stalls, e.g. on a userfaultfd or FUSE backed mapping, holds lock_sock() for its whole duration.
raw_notify() and isotp_notify() take lock_sock() of a socket that is bound to the vanishing device while holding RTNL. As the CAN_RAW options can also be changed on a bound socket, a stalled copy can block RTNL on an unregistration or namespace change of the bound device. Before "can: protect the receive lists with a per-device lock", raw_setsockopt() even held RTNL itself during the copy. CAN_ISOTP only copies its options for unbound sockets, which isotp_notify() skips without taking lock_sock().
Keep the user space copies out of the locked sections: Check the option name and length and copy the option values, including the CAN_RAW_FILTER filters, to kernel memory before lock_sock(). raw_setsockopt_locked() and isotp_setsockopt_locked() get the copied values directly and drop their now redundant length checks and copies. As a side effect, a failing copy can not leave partially overwritten options behind anymore. In raw_getsockopt() duplicate the filters under lock_sock() and copy them to user space after release_sock().
As the option name and length are now checked before lock_sock(), the order of the checks in isotp_setsockopt() and accordingly the order of the returned error values changes. 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() are not affected by this patch.
[ backport to 6.18: raw_getsockopt() uses copy_to_user() and put_user()
instead of the getsockopt_iter interface in this tree. Duplicate the filters under lock_sock() and copy them with copy_to_user() after release_sock(). Also move the put_user() of the needed filter space for -ERANGE behind release_sock(), which upstream writes to the kernel side opt->optlen. ]
--- net/can/isotp.c | 100 ++++++++++++++----------- net/can/raw.c | 193 ++++++++++++++++++++++++++---------------------- 2 files changed, 160 insertions(+), 133 deletions(-)
net/can/isotp.c +57 -43
@@ -1687,8 +1687,8 @@ static int isotp_getname(struct socket *sock, struct sockaddr *uaddr, int peer)return ISOTP_MIN_NAMELEN ; } -static int isotp_setsockopt_locked (struct socket *sock,int level,int optname, -sockptr_t optval,unsigned int optlen) +static int isotp_setsockopt_locked (struct socket *sock,int optname, +const void *val) {struct sock *sk = sock->sk;struct isotp_sock *so =isotp_sk (sk);
@@ -1699,11 +1699,7 @@ static int isotp_setsockopt_locked(struct socket *sock, int level, int optname,switch (optname) {case CAN_ISOTP_OPTS : -if (optlen !=sizeof (struct can_isotp_options )) -return -EINVAL ; - -if (copy_from_sockptr (&so->opt, optval, optlen)) -return -EFAULT ; +memcpy (&so->opt, val,sizeof (so->opt));/* no separate rx_ext_address is given => use ext_address */ if (!(so->opt.flags &CAN_ISOTP_RX_EXT_ADDR ))
@@ -1728,55 +1724,37 @@ static int isotp_setsockopt_locked(struct socket *sock, int level, int optname,break ;case CAN_ISOTP_RECV_FC : -if (optlen !=sizeof (struct can_isotp_fc_options )) -return -EINVAL ; - -if (copy_from_sockptr (&so->rxfc, optval, optlen)) -return -EFAULT ; +memcpy (&so->rxfc, val,sizeof (so->rxfc));break ;case CAN_ISOTP_TX_STMIN : -if (optlen !=sizeof (u32)) -return -EINVAL ; - -if (copy_from_sockptr (&so->force_tx_stmin, optval, optlen)) -return -EFAULT ; + so->force_tx_stmin = *(const u32 *)val;break ;case CAN_ISOTP_RX_STMIN : -if (optlen !=sizeof (u32)) -return -EINVAL ; - -if (copy_from_sockptr (&so->force_rx_stmin, optval, optlen)) -return -EFAULT ; + so->force_rx_stmin = *(const u32 *)val;break ; -case CAN_ISOTP_LL_OPTS : -if (optlen ==sizeof (struct can_isotp_ll_options )) { -struct can_isotp_ll_options ll; - -if (copy_from_sockptr (&ll, optval, optlen)) -return -EFAULT ; +case CAN_ISOTP_LL_OPTS : { +const struct can_isotp_ll_options *ll = val; -/* check for correct ISO 11898-1 DLC data length */ -if (ll.tx_dl !=padlen (ll.tx_dl)) -return -EINVAL ; +/* check for correct ISO 11898-1 DLC data length */ +if (ll->tx_dl !=padlen (ll->tx_dl)) +return -EINVAL ; -if (ll.mtu !=CAN_MTU && ll.mtu !=CANFD_MTU ) -return -EINVAL ; +if (ll->mtu !=CAN_MTU && ll->mtu !=CANFD_MTU ) +return -EINVAL ; -if (ll.mtu ==CAN_MTU && - (ll.tx_dl >CAN_MAX_DLEN || ll.tx_flags !=0 )) -return -EINVAL ; +if (ll->mtu ==CAN_MTU && + (ll->tx_dl >CAN_MAX_DLEN || ll->tx_flags !=0 )) +return -EINVAL ; -memcpy (&so->ll, &ll,sizeof (ll)); +memcpy (&so->ll, ll,sizeof (*ll)); -/* set ll_dl for tx path to similar place as for rx */ - so->tx.ll_dl = ll.tx_dl; - }else { -return -EINVAL ; - } +/* set ll_dl for tx path to similar place as for rx */ + so->tx.ll_dl = ll->tx_dl;break ; + }default : ret = -ENOPROTOOPT ;
@@ -1790,13 +1768,49 @@ static int isotp_setsockopt(struct socket *sock, int level, int optname, {struct sock *sk = sock->sk; +union { +struct can_isotp_options opt; +struct can_isotp_fc_options rxfc; +struct can_isotp_ll_options ll; +u32 stmin; + } val; +unsigned int size;int ret;if (level !=SOL_CAN_ISOTP )return -EINVAL ; +/* copy the option values from user space before lock_sock() */ +switch (optname) { +case CAN_ISOTP_OPTS : + size =sizeof (val.opt); +break ; + +case CAN_ISOTP_RECV_FC : + size =sizeof (val.rxfc); +break ; + +case CAN_ISOTP_TX_STMIN : +case CAN_ISOTP_RX_STMIN : + size =sizeof (val.stmin); +break ; + +case CAN_ISOTP_LL_OPTS : + size =sizeof (val.ll); +break ; + +default : +return -ENOPROTOOPT ; + } + +if (optlen != size) +return -EINVAL ; + +if (copy_from_sockptr (&val, optval, size)) +return -EFAULT ; +lock_sock (sk); - ret =isotp_setsockopt_locked (sock, level, optname, optval, optlen); + ret =isotp_setsockopt_locked (sock, optname, &val);release_sock (sk);return ret; }
net/can/raw.c +103 -90
300 lines not on this page · raw message
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 479/686 sched_ext: Reset runnable_at when a task leaves its scheduler
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Michal Blaszczyk <[email protected]>
[ Upstream commit 993e8fbfecbbf284b9644c6f10741b28fb914094 ]
The watchdog measures how long a task has been waiting from p->scx.runnable_at, which set_task_runnable() resets when the task becomes runnable after it last ran. ops_dequeue() never asks for a reset, as the dequeue of a waiting task is temporary, e.g. for a migration or an attribute change.
Leaving the scheduler isn't temporary. A task which is switched out of SCHED_EXT while it's waiting keeps its runnable_at. When it's switched back and becomes runnable, its wait appears to have started before it left, and the time it spent in another class counts towards the timeout. If the watchdog checks before the task runs, it aborts the scheduler:
sched_ext: class_switch_stall: runner[418] failed to run for 3.010s
Here, the task waited for a few milliseconds before it was switched to SCHED_OTHER, slept outside of SCHED_EXT for three seconds, and was charged for all of it as soon as it woke up on SCHED_EXT again.
The same happens when scx_sub_enable_workfn() hands a waiting task over to a new sub-scheduler, which can then be blamed for time the task waited under the parent. scx_rehome_task() isn't affected, as it moves the task through SCX_TASK_INIT, which resets runnable_at. The stale runnable_at also skews the default core-sched ordering in scx_prio_less().
Reset runnable_at in scx_disable_task(), when the task leaves the control of its scheduler.
--- kernel/sched/ext.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)
kernel/sched/ext.c +13 -1
@@ -1438,7 +1438,11 @@ static void ops_dequeue(struct rq *rq, struct task_struct *p, u64 deq_flags)struct scx_sched *sch = scx_root;unsigned long opss; -/* dequeue is always temporary, don't reset runnable_at */ +/* +* Don't reset runnable_at. If @p is waiting, the wait continues across +* temporary dequeues, e.g. for a migration or an attribute change. +* scx_disable_task() ends it if @p leaves its scheduler. +*/ clr_task_runnable (p, false);/* acquire ensures that we see the preceding updates on QUEUED */
@@ -2959,6 +2963,14 @@ static void scx_disable_task(struct task_struct *p)if (SCX_HAS_OP (sch, disable))SCX_CALL_OP_TASK (sch,SCX_KF_REST , disable, rq, p);scx_set_task_state (p,SCX_TASK_READY ); + +/* +* If @p is runnable but not running, its wait started at runnable_at, +* which ops_dequeue() didn't reset. Leaving @sch ends the wait. Reset +* runnable_at the next time @p is enqueued on SCX, so that the watchdog +* doesn't count the time @p spends elsewhere. +*/ + p->scx.flags |=SCX_TASK_RESET_RUNNABLE_AT ; }static void scx_exit_task (struct task_struct *p)
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 480/686 ata: libata-scsi: reject data-in commands with a data-out buffer
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Zhao Gongyi <[email protected]>
[ Upstream commit a4845f077415ef32fe672c841e2fc58ae9e28273 ]
SG_IO can submit a data-in SCSI command with DMA_TO_DEVICE. The scatterlist can then contain pages pinned without write access. ata_scsi_rbuf_fill() writes simulated replies to that scatterlist; in the reported case, the copy tried to write the shared zero page and faulted in the kernel.
The same mismatch can affect SG_IO commands translated by libata. ZBC IN and GET PHYSICAL ELEMENT STATUS completion handlers can modify the receive buffer even if the drive aborts the command. For ATAPI, the successful INQUIRY completion also rewrites the buffer in atapi_fixup_inquiry().
Reject these mismatched commands before the buffer is written or the command is issued. Report ABORTED COMMAND / DATA IN BUFFER ERROR because the CDB itself can be valid; the supplied transfer direction is wrong.
Backport notes: Use the older five-argument ata_scsi_set_sense() interface and spell DATA IN BUFFER ERROR as ASC/ASCQ 0x4b/0x0a.
--- drivers/ata/libata-scsi.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
drivers/ata/libata-scsi.c +25 -0
@@ -1977,6 +1977,18 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,if (xlat_func (qc)) goto done; +/* +* A data-out request may contain pages pinned without write access. +* Reject a translated data-in command before issuing it, since its +* completion handler may write to the buffer even if the device fails. +*/ +if (unlikely (cmd->sc_data_direction ==DMA_TO_DEVICE && +ata_is_data (qc->tf.protocol) && + !(qc->tf.flags &ATA_TFLAG_WRITE ))) { +ata_scsi_set_sense (dev, cmd,ABORTED_COMMAND ,0x4b ,0x0a ); + goto done; + } +return ata_scsi_qc_issue (ap, qc); done:
@@ -2008,6 +2020,12 @@ static void ata_scsi_rbuf_fill(struct ata_device *dev, struct scsi_cmnd *cmd,unsigned long flags;unsigned int len; +/* A data-out request may contain pages pinned without write access. */ +if (cmd->sc_data_direction ==DMA_TO_DEVICE ) { +ata_scsi_set_sense (dev, cmd,ABORTED_COMMAND ,0x4b ,0x0a ); +return ; + } +spin_lock_irqsave (&ata_scsi_rbuf_lock, flags);memset (ata_scsi_rbuf,0 ,ATA_SCSI_RBUF_SIZE );
@@ -3065,6 +3083,13 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc) qc->complete_fn = atapi_qc_complete; +/* atapi_fixup_inquiry() writes to the buffer on successful completion. */ +if (scmd->sc_data_direction ==DMA_TO_DEVICE && + scmd->cmnd[0 ] ==INQUIRY ) { +ata_scsi_set_sense (dev, scmd,ABORTED_COMMAND ,0x4b ,0x0a ); +return 1 ; + } + qc->tf.flags |=ATA_TFLAG_ISADDR |ATA_TFLAG_DEVICE ;if (scmd->sc_data_direction ==DMA_TO_DEVICE ) { qc->tf.flags |=ATA_TFLAG_WRITE ;
Signature · 1 line
2.53.0
Greg Kroah-Hartman
maintainerPATCH 481/686 powerpc/bpf: fix buffer overflow in JIT for large BPF programs
In reply to Greg Kroah-Hartman6.18-stable review patch. If anyone has any objections, please let me know.
------------------
From: Abhishek Dubey <[email protected]>
[ Upstream commit 78ce55b7913a78e1687306668e078b86bc6508ee ]
During size calculation in pass-0, exit_addr is 0 since addrs[fp->len] is not yet populated. bpf_jit_emit_exit_insn() treats a zero exit_addr as in-range and skips bpf_jit_build_epilogue(), so the alternate inline epilogue instructions are not counted in alloclen.
In later passes, if the real exit_addr falls outside the 32MB branch range, the full inline epilogue is emitted into the already-allocated buffer, writing past its end and corrupting adjacent memory.
Fix by ensuring exit_addr is non-zero before treating it as in-range, so pass-0 always falls through to bpf_jit_build_epilogue() and conservatively accounts for all epilogue instructions in alloclen. Also range check alt_exit_addr directly in the else-if condition.
Since exit_addr handling now falls through to the epilogue, two related issues in bpf_int_jit_compile() must also be addressed:
1. Reset cgctx.alt_exit_addr before the second size-calculation pass. Without this, a stale alt_exit_addr from the first pass causes the second pass to emit a single jump instead of the full epilogue, undercounting alloclen and reintroducing the overflow.
2. Recompute addrs[fp->len] at the end of each code-generation pass. The larger pass-0 body can shrink in later passes as out-of-range exits settle into in-range jumps; a stale addrs[fp->len] would leave exit branches targeting past the real (shrunken) epilogue.
Because shrinkage in a later pass can move the epilogue offset, the fixed two-pass loop is no longer sufficient: an exit that was out of range in an earlier pass may fall in range once the epilogue offset shrinks, shrinking the body further and overwriting the start of the epilogue. Convert the code-generation loop to iterate until the program size converges, bounded by CODEGEN_MAX_PASSES, and fail the JIT if it does not converge.
--- arch/powerpc/net/bpf_jit.h | 7 +++++++ arch/powerpc/net/bpf_jit_comp.c | 35 +++++++++++++++++++++++++-------- 2 files changed, 34 insertions(+), 8 deletions(-)
arch/powerpc/net/bpf_jit.h +7 -0
@@ -14,6 +14,13 @@#include <asm/ppc-opcode.h> #include <linux/build_bug.h> +/* +* We need at least 2 passes for proper code generation, and may need +* additional passes if code size changes between passes. +*/ +#define CODEGEN_MIN_PASSES 2 +#define CODEGEN_MAX_PASSES 3 +#ifdef CONFIG_PPC64_ELF_ABI_V1 #define FUNCTION_DESCR_SIZE 24#else
arch/powerpc/net/bpf_jit_comp.c +27 -8
@@ -99,11 +99,10 @@ void bpf_jit_build_fentry_stubs(u32 *image, struct codegen_context *ctx)int bpf_jit_emit_exit_insn (u32 *image,struct codegen_context *ctx,int tmp_reg,long exit_addr) { -if (!exit_addr ||is_offset_in_branch_range (exit_addr - (ctx->idx *4 ))) { +if (exit_addr &&is_offset_in_branch_range (exit_addr - (long )(ctx->idx *4 ))) {PPC_JMP (exit_addr); - }else if (ctx->alt_exit_addr) { -if (WARN_ON (!is_offset_in_branch_range ((long )ctx->alt_exit_addr - (ctx->idx *4 )))) -return -1 ; + }else if (ctx->alt_exit_addr &&is_offset_in_branch_range ( + (long )(ctx->alt_exit_addr) - (long )(ctx->idx *4 ))) {PPC_JMP (ctx->alt_exit_addr); }else { ctx->alt_exit_addr = ctx->idx *4 ;
@@ -223,6 +222,7 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp)*/ if (cgctx.seen &SEEN_TAILCALL || !is_offset_in_branch_range ((long )cgctx.idx *4 )) { cgctx.idx =0 ; + cgctx.alt_exit_addr =0 ;if (bpf_jit_build_body (fp,NULL ,NULL , &cgctx, addrs,0 , false)) { fp = org_fp; goto out_addrs;
@@ -259,10 +259,13 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) code_base = (u32 *)(image +FUNCTION_DESCR_SIZE ); fcode_base = (u32 *)(fimage +FUNCTION_DESCR_SIZE ); -/* Code generation passes 1-2 */ -for (pass =1 ; pass <3 ; pass++) { +/* Code generation passes 1-2+, loop until program size converges. */ +for (pass =1 ; pass <=CODEGEN_MAX_PASSES ; pass++) { +u32 prev_proglen = proglen; +/* Now build the prologue, body code & epilogue for real. */ cgctx.idx =0 ; + cgctx.exentry_idx =0 ; cgctx.alt_exit_addr =0 ;bpf_jit_build_prologue (code_base, &cgctx); if (bpf_jit_build_body(fp, code_base, fcode_base, &cgctx, addrs, pass,
@@ -272,11 +275,27 @@ struct bpf_prog *bpf_int_jit_compile(struct bpf_prog *fp) fp = org_fp; goto out_addrs; } + addrs[fp->len] = cgctx.idx *4 ;bpf_jit_build_epilogue (code_base, &cgctx); + proglen = cgctx.idx *4 ; +if (bpf_jit_enable >1 )pr_info ("Pass %d: shrink = %d, seen = 0x%x\n" , pass, - proglen - (cgctx.idx *4 ), cgctx.seen); + prev_proglen - proglen, cgctx.seen); + +/* Check if program size has converged, but ensure minimum passes */ +if (pass >=CODEGEN_MIN_PASSES && proglen == prev_proglen) +break ; + +if (pass ==CODEGEN_MAX_PASSES && proglen != prev_proglen) { +pr_err ("BPF JIT: Program did not converge after %d passes\n" , +CODEGEN_MAX_PASSES ); +bpf_arch_text_copy (&fhdr->size, &hdr->size,sizeof (hdr->size)); +bpf_jit_binary_pack_free (fhdr, hdr); + fp = org_fp; + goto out_addrs; + } }if (bpf_jit_enable >1 )
@@ -336,7 +355,7 @@ int bpf_add_extable_entry(struct bpf_prog *fp, u32 *image, u32 *fimage, int passu32 *fixup;/* Populate extable entries only in the last pass */ -if (pass !=2 ) +if (pass <CODEGEN_MIN_PASSES )return 0 ; if (!fp->aux->extable ||
Signature · 1 line
2.53.0